diff --git "a/data/dataset_Pathogens.csv" "b/data/dataset_Pathogens.csv" new file mode 100644--- /dev/null +++ "b/data/dataset_Pathogens.csv" @@ -0,0 +1,71920 @@ +"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language" +"Pathogens","pat-s/pathogen-modeling","exec-drake.R",".R","945","30","## make targets + +r_make(r_args = list(show = TRUE)) + +# visualize + +r_vis_drake_graph(group = ""stage"", clusters = c(""data"", ""task"", ""learner"", + ""mlr_settings"", + ""prediction""), + targets_only = TRUE, show_output_files = FALSE) +# see outdated + +r_outdated(r_args = list(show = TRUE)) + +# Misc +r_predict_runtime(r_args = list(show = TRUE)) + +r_predict_workers() + + +# Manually ---------------------------------------------------------------- + +make(plan, verbose = 2, targets = c(""maps_debugging_diplodia_no_temp""), + cache_log_file = ""log/cache_log.txt"", + console_log_file = ""log/drake.log"", + lazy_load = ""promise"", caching = ""worker"", + memory_strategy = ""memory"", + template = list(log_file = ""log/worker%a.log"", n_cpus= 5, memory = 20000), + garbage_collection = TRUE, jobs = 2, parallelism = ""clustermq"") +","R" +"Pathogens","pat-s/pathogen-modeling","tic.R",".R","77","2","do_package_checks(error_on = ""error"", args = c(""--no-tests"", ""--no-manual"")) +","R" +"Pathogens","pat-s/pathogen-modeling","LICENSE.md",".md","1074","22","# MIT License + +Copyright (c) 2019 Patrick Schratz + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the ""Software""), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +","Markdown" +"Pathogens","pat-s/pathogen-modeling","_drake.R",".R","3358","83","# Plans ----------------------------------------------------------- +source(""code/99-packages.R"") +sourceDirectory(""R/"") + +data_plan = code_to_plan(""code/01-data/data.R"") +task_plan = code_to_plan(""code/01-data/task.R"") +learners_plan = code_to_plan(""code/02-mlr-settings/learner.R"") +resampling_plan = code_to_plan(""code/02-mlr-settings/resampling.R"") +param_set_plan = code_to_plan(""code/02-mlr-settings/param-set.R"") +tune_ctrl_plan = code_to_plan(""code/02-mlr-settings/tune_ctrl_mbo.R"") +tuning_wrapper_plan = code_to_plan(""code/02-mlr-settings/tuning.R"") +source(""code/03-benchmark/aggregate-results.R"") +source(""code/03-benchmark/benchmark.R"") +source(""code/04-prediction/prediction.R"") +visualization_plan = code_to_plan(""code/05-visualization/vis-partitions.R"") +dataset_tables_plan = code_to_plan(""code/05-visualization/create_dataset_tables.R"") +source(""code/06-reports.R"") + +source(""https://raw.githubusercontent.com/mlr-org/mlr-extralearner/master/R/RLearner_classif_gam.R"") + +# grouping for visualization +data_plan$stage = ""data"" +task_plan$stage = ""data"" +learners_plan$stage = ""learner"" +resampling_plan$stage = ""mlr_settings"" +param_set_plan$stage = ""mlr_settings"" +tune_ctrl_plan$stage = ""mlr_settings"" +tuning_wrapper_plan$stage = ""learner"" +benchmark_plan$stage = ""benchmark"" +bmr_aggr_path_resamp_plan$stage = ""benchmark"" +bmr_aggr_model_resamp_plan$stage = ""benchmark"" +no_extract_plan$stage = ""benchmark"" +bm_all_pathogens_plan$stage = ""benchmark"" +prediction_prob_plan$stage = ""prediction"" +prediction_maps_plan$stage = ""prediction"" +reports_plan$stage = ""reports"" +visualization_plan$stage = ""visualization"" +dataset_tables_plan$stage = ""visualization"" + +# Combine all ------------------------------------------------------------- + +plan = bind_plans(data_plan, task_plan, learners_plan, resampling_plan, + param_set_plan, tune_ctrl_plan, tuning_wrapper_plan, + + bmr_aggr_path_resamp_plan, + bmr_aggr_model_resamp_plan, + bm_all_pathogens_plan, + no_extract_plan, + benchmark_plan, + + prediction_prob_plan, + prediction_maps_plan, + reports_plan, + visualization_plan, + dataset_tables_plan) + +plan %<>% mutate(stage = as.factor(stage)) + +options(clustermq.scheduler = ""slurm"", + clustermq.template = ""~/papers/2018-model-comparison/slurm_clustermq.tmpl"") + + +### Show log in console +# watch -n .1 tail -n 40 ~/git/pathogen-modeling/drake.log + +drake_config(plan, + verbose = 2, + targets = c(""pathogen_maps_debugging"", ""prediction_pathogens""), + lazy_load = ""promise"", + console_log_file = ""log/drake.log"", + caching = ""worker"", + template = list(log_file = ""log/worker%a.log"", n_cpus = 16, memory = 60000, + job_name = ""paper1""), + prework = list(quote(set.seed(1, ""L'Ecuyer-CMRG"")), + quote(future::plan(future.callr::callr, workers = 10)), + quote(parallelStart( + mode = ""multicore"", cpus = ignore(16), level = ""mlr.resample"" + )) + ), + garbage_collection = TRUE, jobs = 3, parallelism = ""clustermq"", + lock_envir = FALSE, keep_going = TRUE +) +","R" +"Pathogens","pat-s/pathogen-modeling","inst/rsync-jupiter.sh",".sh","2660","50","#! /bin/bash + +######## +# LIFE +######## + +# `pathogen-prediction-maps` --------------- copy pathogen infection prediction PNG maps to LIFE +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/docs/figure/prediction-pathogens.Rmd/prediction-map* \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/www/life-healthy-forest/action-B1-spatial-mapping/pathogen-infection-maps/ + +# `pathogen_prediction_report` ------------ copy pathogen infection report to LIFE +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/pathogens-prediction.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/www/life-healthy-forest/action-B1-spatial-mapping/ + +# `benchmark_all_pathogens`-------- copy benchmark report all pathogens to LIFE +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/pathogens-performance.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/www/life-healthy-forest/action-B1-spatial-mapping/ + +######## +# paper ""2018-model-comparison"" +######## + +# `benchmark_diplodia` ----------- copy benchmark report DIPLODIA to patrick +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/pathogens-performance-diplodia.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/patrick/2018-model-comparison/ + +# `visualize_partitions` -------------- copy visualization of partitions to patrick +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/visualize-partitions.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/patrick/2018-model-comparison/ + +# `vis_opt_paths` -------------- copy visualization of optimization paths to patrick + +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/vis-opt-paths.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/patrick/2018-model-comparison/ + +# `vis_tuning_effects` -------------- copy visualization of tuning effects to patrick +rsync -rlptDvzog --chown=www-data:www-data --fake-super \ + /mnt/cluster/home/patrick/papers/2018-model-comparison/analysis/rmd/vis-tuning-effects.html \ + -e ssh patrick@jupiter.geogr.uni-jena.de:/home/patrick/2018-model-comparison/ + +# rsync -rlptDvzog --chown=www-data:www-data --fake-super \ +# /mnt/geoinf_web/bi28yuv/LIFE-Healthy-Forest/* \ +# -e ssh patrick@jupiter.geogr.uni-jena.de:/home/www/life-healthy-forest/action-A2-predictor-database/ +","Shell" +"Pathogens","pat-s/pathogen-modeling","inst/99-funs.R",".R","1250","37","##### my.pairs env +the.col.hist <- ""cyan"" + + +panel.hist <- function(x, col.hist=the.col.hist, + cex.cor=NULL,digits=NULL,col=NULL,pch=NULL,cex=NULL,...) +{ + dummy <- is.character(cex.cor) | is.numeric(digits) | is.character(cex) | is.character(pch) | is.character(col) + usr <- par(""usr""); on.exit(par(usr)) + par(usr = c(usr[1:2], 0, 1.5) ) + h <- hist(x, plot = FALSE) + breaks <- h$breaks; nB <- length(breaks) + y <- h$counts; y <- y/max(y) + rect(breaks[-nB], 0, breaks[-1], y, col=col.hist, ...) +} + +panel.cor <- function(x, y, digits=2, prefix="""", cex.cor=NULL, + col.hist=NULL, + col=NULL,pch=NULL,cex=NULL,...) +{ + dummy <- is.character(col.hist) | is.character(cex) | is.character(pch) | is.character(col) + usr <- par(""usr""); on.exit(par(usr)) + par(usr = c(0, 1, 0, 1)) + r <- abs(cor(x, y, use=""pairwise.complete.obs"")) + txt <- format(c(r, 0.123456789), digits=digits)[1] + txt <- paste(prefix, txt, sep="""") + if (is.null(cex.cor)) cex.cor <- 0.8/strwidth(txt) + #text(0.5, 0.5, txt, cex = cex.cor * r) + text(0.5, 0.5, txt, cex = cex.cor) +} + +my_pairs <- function( x, ... ) +{ + pairs( x, ..., + upper.panel=panel.smooth, lower.panel=panel.cor, diag.panel=panel.hist ) +} +","R" +"Pathogens","pat-s/pathogen-modeling","inst/atlas-climatico-new.R",".R","1634","40","library(magrittr) +library(readr) +library(raster) +library(sf) +library(dplyr) +pr_1km_CAPV_Arakil <- read.table(file = ""data/02-pr/pr/pr_1km_CAPV_Arakil.csv"", sep = "","", dec = ""."", header = TRUE) + +test = tidyr::gather(pr_1km_CAPV_Arakil, ""coord_id"", ""p_sum"", -YYYYMMDD, factor_key = F) %>% + #dplyr::filter(coord_id != ""X22512"") %>% + dplyr::rename(date = YYYYMMDD) %>% + dplyr::mutate(date = as.character(date)) %>% + dplyr::mutate(date = lubridate::as_date(date)) %>% + dplyr::filter(date > ""2000-01-01"") %>% + dplyr::mutate(coord_id = stringr::str_remove(coord_id, ""X"")) %>% + dplyr::mutate(month = lubridate::month(date)) %>% # create month column (includes all years) + dplyr::group_by(month, coord_id) %>% + dplyr::summarise_at(""p_sum"", mean) # get the summarised p_sum for the respective grouping + +coordinates = readr::read_table2(""data/01_grid_1km_cuencas/grid_1km_cuencas_etrs89/stations_Arakil_etrs89.txt"", + col_type = readr::cols(station_id = col_character())) + +df_bind = dplyr::left_join(test, coordinates, by = c(""coord_id"" = ""station_id"")) + +df_bind %<>% + dplyr::rename(x = UTMXetrs89) %>% + dplyr::rename(y = UTMYetrs89) %>% + dplyr::mutate(month = as.factor(as.character(month))) %>% + dplyr::select(x, y, p_sum, month) + +#df_month = split(df_bind, df_bind$month, drop = FALSE) + +x = df_bind %>% group_split(month, keep = FALSE) + +x = map(x, ~ as.data.frame(.x, xy = TRUE)) + +x_st = map(x, ~ st_as_sf(.x, coords = c(""x"", ""y""), crs = 25830)) +x_sp = map(x_st, ~ as(.x, ""Spatial"")) +x_spdf = map(x_sp, ~ SpatialPixelsDataFrame(.x, tolerance = 0.973816, .x@data)) +x_ras = map(x_spdf, ~ raster(.x)) +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/learner.R",".R","50","2","#' @param learner Learner from [mlr::makeLearner] +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/url.R",".R","52","2","#' @param url URL to download from (usually Zenodo) +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/task.R",".R","24","2","#' @param task mlr task +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/param_set.R",".R","34","2","#' @param param_set mlr Param Set +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/tune_ctrl.R",".R","44","2","#' @param tune_ctrl mrl tune control object +","R" +"Pathogens","pat-s/pathogen-modeling","man-roxygen/resampling.R",".R","36","2","#' @param resampling mlr resampling +","R" +"Pathogens","pat-s/pathogen-modeling","packrat/init.R",".R","8406","227","local({ + + ## Helper function to get the path to the library directory for a + ## given packrat project. + getPackratLibDir <- function(projDir = NULL) { + path <- file.path(""packrat"", ""lib"", R.version$platform, getRversion()) + + if (!is.null(projDir)) { + + ## Strip trailing slashes if necessary + projDir <- sub(""/+$"", """", projDir) + + ## Only prepend path if different from current working dir + if (!identical(normalizePath(projDir), normalizePath(getwd()))) + path <- file.path(projDir, path) + } + + path + } + + ## Ensure that we set the packrat library directory relative to the + ## project directory. Normally, this should be the working directory, + ## but we also use '.rs.getProjectDirectory()' if necessary (e.g. we're + ## rebuilding a project while within a separate directory) + libDir <- if (exists("".rs.getProjectDirectory"")) + getPackratLibDir(.rs.getProjectDirectory()) + else + getPackratLibDir() + + ## Unload packrat in case it's loaded -- this ensures packrat _must_ be + ## loaded from the private library. Note that `requireNamespace` will + ## succeed if the package is already loaded, regardless of lib.loc! + if (""packrat"" %in% loadedNamespaces()) + try(unloadNamespace(""packrat""), silent = TRUE) + + if (suppressWarnings(requireNamespace(""packrat"", quietly = TRUE, lib.loc = libDir))) { + + # Check 'print.banner.on.startup' -- when NA and RStudio, don't print + print.banner <- packrat::get_opts(""print.banner.on.startup"") + if (print.banner == ""auto"" && is.na(Sys.getenv(""RSTUDIO"", unset = NA))) { + print.banner <- TRUE + } else { + print.banner <- FALSE + } + return(packrat::on(print.banner = print.banner)) + } + + ## Escape hatch to allow RStudio to handle bootstrapping. This + ## enables RStudio to provide print output when automagically + ## restoring a project from a bundle on load. + if (!is.na(Sys.getenv(""RSTUDIO"", unset = NA)) && + is.na(Sys.getenv(""RSTUDIO_PACKRAT_BOOTSTRAP"", unset = NA))) { + Sys.setenv(""RSTUDIO_PACKRAT_BOOTSTRAP"" = ""1"") + setHook(""rstudio.sessionInit"", function(...) { + # Ensure that, on sourcing 'packrat/init.R', we are + # within the project root directory + if (exists("".rs.getProjectDirectory"")) { + owd <- getwd() + setwd(.rs.getProjectDirectory()) + on.exit(setwd(owd), add = TRUE) + } + source(""packrat/init.R"") + }) + return(invisible(NULL)) + } + + ## Bootstrapping -- only performed in interactive contexts, + ## or when explicitly asked for on the command line + if (interactive() || ""--bootstrap-packrat"" %in% commandArgs(TRUE)) { + + needsRestore <- ""--bootstrap-packrat"" %in% commandArgs(TRUE) + + message(""Packrat is not installed in the local library -- "", + ""attempting to bootstrap an installation..."") + + ## We need utils for the following to succeed -- there are calls to functions + ## in 'restore' that are contained within utils. utils gets loaded at the + ## end of start-up anyhow, so this should be fine + library(""utils"", character.only = TRUE) + + ## Install packrat into local project library + packratSrcPath <- list.files(full.names = TRUE, + file.path(""packrat"", ""src"", ""packrat"") + ) + + ## No packrat tarballs available locally -- try some other means of installation + if (!length(packratSrcPath)) { + + message(""> No source tarball of packrat available locally"") + + ## There are no packrat sources available -- try using a version of + ## packrat installed in the user library to bootstrap + if (requireNamespace(""packrat"", quietly = TRUE) && packageVersion(""packrat"") >= ""0.2.0.99"") { + message(""> Using user-library packrat ("", + packageVersion(""packrat""), + "") to bootstrap this project"") + } + + ## Couldn't find a user-local packrat -- try finding and using devtools + ## to install + else if (requireNamespace(""devtools"", quietly = TRUE)) { + message(""> Attempting to use devtools::install_github to install "", + ""a temporary version of packrat"") + library(stats) ## for setNames + devtools::install_github(""rstudio/packrat"") + } + + ## Try downloading packrat from CRAN if available + else if (""packrat"" %in% rownames(available.packages())) { + message(""> Installing packrat from CRAN"") + install.packages(""packrat"") + } + + ## Fail -- couldn't find an appropriate means of installing packrat + else { + stop(""Could not automatically bootstrap packrat -- try running "", + ""\""'install.packages('devtools'); devtools::install_github('rstudio/packrat')\"""", + ""and restarting R to bootstrap packrat."") + } + + # Restore the project, unload the temporary packrat, and load the private packrat + if (needsRestore) + packrat::restore(prompt = FALSE, restart = TRUE) + + ## This code path only reached if we didn't restart earlier + unloadNamespace(""packrat"") + requireNamespace(""packrat"", lib.loc = libDir, quietly = TRUE) + return(packrat::on()) + + } + + ## Multiple packrat tarballs available locally -- try to choose one + ## TODO: read lock file and infer most appropriate from there; low priority because + ## after bootstrapping packrat a restore should do the right thing + if (length(packratSrcPath) > 1) { + warning(""Multiple versions of packrat available in the source directory;"", + ""using packrat source:\n- "", shQuote(packratSrcPath)) + packratSrcPath <- packratSrcPath[[1]] + } + + + lib <- file.path(""packrat"", ""lib"", R.version$platform, getRversion()) + if (!file.exists(lib)) { + dir.create(lib, recursive = TRUE) + } + + message(""> Installing packrat into project private library:"") + message(""- "", shQuote(lib)) + + surround <- function(x, with) { + if (!length(x)) return(character()) + paste0(with, x, with) + } + + + ## Invoke install.packages() in clean R session + peq <- function(x, y) paste(x, y, sep = "" = "") + installArgs <- c( + peq(""pkgs"", surround(packratSrcPath, with = ""'"")), + peq(""lib"", surround(lib, with = ""'"")), + peq(""repos"", ""NULL""), + peq(""type"", surround(""source"", with = ""'"")) + ) + + fmt <- ""utils::install.packages(%s)"" + installCmd <- sprintf(fmt, paste(installArgs, collapse = "", "")) + + ## Write script to file (avoid issues with command line quoting + ## on R 3.4.3) + installFile <- tempfile(""packrat-bootstrap"", fileext = "".R"") + writeLines(installCmd, con = installFile) + on.exit(unlink(installFile), add = TRUE) + + fullCmd <- paste( + surround(file.path(R.home(""bin""), ""R""), with = ""\""""), + ""--vanilla"", + ""--slave"", + ""-f"", + surround(installFile, with = ""\"""") + ) + system(fullCmd) + + ## Tag the installed packrat so we know it's managed by packrat + ## TODO: should this be taking information from the lockfile? this is a bit awkward + ## because we're taking an un-annotated packrat source tarball and simply assuming it's now + ## an 'installed from source' version + + ## -- InstallAgent -- ## + installAgent <- ""InstallAgent: packrat 0.5.0"" + + ## -- InstallSource -- ## + installSource <- ""InstallSource: source"" + + packratDescPath <- file.path(lib, ""packrat"", ""DESCRIPTION"") + DESCRIPTION <- readLines(packratDescPath) + DESCRIPTION <- c(DESCRIPTION, installAgent, installSource) + cat(DESCRIPTION, file = packratDescPath, sep = ""\n"") + + # Otherwise, continue on as normal + message(""> Attaching packrat"") + library(""packrat"", character.only = TRUE, lib.loc = lib) + + message(""> Restoring library"") + if (needsRestore) + packrat::restore(prompt = FALSE, restart = FALSE) + + # If the environment allows us to restart, do so with a call to restore + restart <- getOption(""restart"") + if (!is.null(restart)) { + message(""> Packrat bootstrap successfully completed. "", + ""Restarting R and entering packrat mode..."") + return(restart()) + } + + # Callers (source-erers) can define this hidden variable to make sure we don't enter packrat mode + # Primarily useful for testing + if (!exists("".__DONT_ENTER_PACKRAT_MODE__."") && interactive()) { + message(""> Packrat bootstrap successfully completed. Entering packrat mode..."") + packrat::on() + } + + Sys.unsetenv(""RSTUDIO_PACKRAT_BOOTSTRAP"") + + } + +}) +","R" +"Pathogens","pat-s/pathogen-modeling","code/06-reports.R",".R","713","18","reports_plan = drake_plan( + + benchmark_diplodia = wflow_publish(knitr_in(""analysis/benchmark-diplodia.Rmd""), view = FALSE), + + benchmark_pathogens = wflow_publish(knitr_in(""analysis/benchmark-pathogens.Rmd""), view = FALSE), + + prediction_pathogens = wflow_publish(knitr_in(""analysis/prediction-pathogens.Rmd""), view = FALSE), + + pathogen_maps_debugging = wflow_publish(knitr_in(""analysis/pathogen-maps-debugging.Rmd""), view = FALSE), + + vis_partitions = wflow_publish(knitr_in(""analysis/vis-partitions.Rmd""), view = FALSE), + + vis_opt_paths = wflow_publish(knitr_in(""analysis/vis-opt-paths.Rmd""), view = FALSE), + + vis_tuning_effects = wflow_publish(knitr_in(""analysis/vis-tuning-effects.Rmd""), view = FALSE) + +) +","R" +"Pathogens","pat-s/pathogen-modeling","code/99-packages.R",".R","1993","42","suppressPackageStartupMessages(library(drake)) +suppressPackageStartupMessages(library(mlr)) +suppressPackageStartupMessages(library(magrittr)) +suppressPackageStartupMessages(library(mlrMBO)) +suppressPackageStartupMessages(library(purrr)) +suppressPackageStartupMessages(library(parallelMap)) +suppressPackageStartupMessages(library(sf)) +suppressPackageStartupMessages(library(dplyr)) +suppressPackageStartupMessages(library(lwgeom)) +suppressPackageStartupMessages(library(forcats)) +suppressPackageStartupMessages(library(tibble)) +suppressPackageStartupMessages(library(rgdal)) +suppressPackageStartupMessages(library(viridis)) +suppressPackageStartupMessages(library(rasterVis)) +suppressPackageStartupMessages(library(lattice)) +suppressPackageStartupMessages(library(latticeExtra)) +suppressPackageStartupMessages(library(glue)) +suppressPackageStartupMessages(library(RSAGA)) +suppressPackageStartupMessages(library(stringr)) +suppressPackageStartupMessages(library(GSIF)) +suppressPackageStartupMessages(library(sp)) +suppressPackageStartupMessages(library(R.utils)) +suppressPackageStartupMessages(library(curl)) +suppressPackageStartupMessages(library(fs)) +suppressPackageStartupMessages(library(rgenoud)) +suppressPackageStartupMessages(library(stringr)) +suppressPackageStartupMessages(library(ggplot2)) +suppressPackageStartupMessages(library(ggspatial)) +suppressPackageStartupMessages(library(clustermq)) +suppressPackageStartupMessages(library(ggsci)) +suppressPackageStartupMessages(library(furrr)) +suppressPackageStartupMessages(library(future.callr)) +suppressPackageStartupMessages(library(ggpubr)) +suppressPackageStartupMessages(library(hrbrthemes)) +suppressPackageStartupMessages(library(cowplot)) +suppressPackageStartupMessages(library(reporttools)) +suppressPackageStartupMessages(library(ggrepel)) +suppressPackageStartupMessages(library(ggExtra)) +suppressPackageStartupMessages(library(kableExtra)) +suppressPackageStartupMessages(library(here)) +suppressPackageStartupMessages(library(workflowr)) +","R" +"Pathogens","pat-s/pathogen-modeling","code/04-prediction/prediction.R",".R","11567","244","args_pred = tibble(task = rlang::syms(c(""tasks_pred_no_ph"", + ""tasks_pred_no_ph"", + ""tasks_pred_no_ph"", + ""tasks_pred_no_ph"", + ""tasks_pred_no_ph"", + + ""diplodia_task_dummy_prediction_no_temp"", + ""diplodia_task_dummy_prediction_no_precip"", + ""diplodia_task_dummy_prediction_no_hail"", + ""diplodia_task_dummy_prediction_no_ph"", + ""diplodia_task_dummy_prediction_no_soil"", + ""diplodia_task_dummy_prediction_no_lithology"", + ""diplodia_task_dummy_prediction_no_slope"", + ""diplodia_task_dummy_prediction_no_pisr"", + + ""diplodia_task_dummy_prediction_no_ph"", + ""fusarium_task_dummy_prediction_no_ph"", + ""armillaria_task_dummy_no_ph"", + ""heterobasidion_task_dummy_no_ph"", + ""tasks_pred_no_ph"")), + learner = c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_kknn"", + ""lrn_glm"", + + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + ""lrn_rf"", # debugging tasks + + ""lrn_gam_diplodia_pred_no_ph"", + ""lrn_gam_fusarium_pred_no_ph"", + ""lrn_gam_armillaria_pred_no_ph"", + ""lrn_gam_heterobasidion_pred_no_ph"", + ""lrn_brt""), + resampling = rlang::syms(rep(""spcv_inner_fiveF"", 18)), + param_set = rlang::syms(c(""ps_rf"", + ""ps_svm"", + ""ps_xgboost"", + ""ps_kknn"", + ""NULL"", + + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + ""ps_rf"", # debugging tasks + + ""ps_gam_diplodia_fusarium_pred"", + ""ps_gam_diplodia_fusarium_pred"", + ""ps_gam_armillaria_heterobasidion"", + ""ps_gam_armillaria_heterobasidion"", + ""ps_brt"")), + tune_ctrl = rlang::syms(c(""tune_ctrl_rf_100"", + ""tune_ctrl_svm_100"", + ""tune_ctrl_xgboost_100"", + ""tune_ctrl_kknn_100"", + ""NULL"", + + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + ""tune_ctrl_rf_100"", # debugging tasks + + ""tune_ctrl_gam_100_diplodia_fusarium_pred"", + ""tune_ctrl_gam_100_diplodia_fusarium_pred"", + ""tune_ctrl_gam_100_armillaria_heterobasidion"", + ""tune_ctrl_gam_100_armillaria_heterobasidion"", + ""tune_ctrl_brt_100"")), + prediction_data = c(rep(rlang::syms(""pred_data_no_ph""), 5), + + rlang::syms(""pred_data_no_temp""), + rlang::syms(""pred_data_no_precip""), + rlang::syms(""pred_data_no_hail""), + rlang::syms(""pred_data_no_ph""), + rlang::syms(""pred_data_no_soil""), + rlang::syms(""pred_data_no_lithology""), + rlang::syms(""pred_data_no_slope""), + rlang::syms(""pred_data_no_pisr""), + + rep(rlang::syms(""pred_data_no_ph""), 5)), + prediction_grid = rep(rlang::syms(""temperature_mean""), 18), + desc_resampling = c(""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/no tuning"", + + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + ""spatial/spatial"", # debugging tasks + + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"") +) +args_pred$id = suppressWarnings(paste0(""prediction_"", str_split(args_pred$learner, ""_"", simplify = TRUE)[, 2])) +args_pred$learner = rlang::syms(args_pred$learner) + +args_pred[6, ""id""] = ""prediction_debugging_diplodia_no_temp"" +args_pred[7, ""id""] = ""prediction_debugging_diplodia_no_precip"" +args_pred[8, ""id""] = ""prediction_debugging_diplodia_no_hail"" +args_pred[9, ""id""] = ""prediction_debugging_diplodia_no_ph"" +args_pred[10, ""id""] = ""prediction_debugging_diplodia_no_soil"" +args_pred[11, ""id""] = ""prediction_debugging_diplodia_no_lithology"" +args_pred[12, ""id""] = ""prediction_debugging_diplodia_no_slope"" +args_pred[13, ""id""] = ""prediction_debugging_diplodia_no_pisr"" + +args_pred[14, ""id""] = ""prediction_gam_diplodia_no_ph"" +args_pred[15, ""id""] = ""prediction_gam_fusarium_no_ph"" +args_pred[16, ""id""] = ""prediction_gam_armillaria_no_ph"" +args_pred[17, ""id""] = ""prediction_gam_heterobasidion_no_ph"" + +prediction_prob_plan = map_plan(args_pred, prediction_custom, trace = FALSE) + + +# prediction maps --------------------------------------------------------- + +args_pred = tibble(prediction_raster = c(""prediction_glm"", + + ""prediction_gam_diplodia_no_ph"", + ""prediction_gam_fusarium_no_ph"", + ""prediction_gam_armillaria_no_ph"", + ""prediction_gam_heterobasidion_no_ph"", + + ""prediction_svm"", + + ""prediction_rf"", + + ""prediction_kknn"", + + ""prediction_xgboost"", + + ""prediction_brt"", + + ""prediction_debugging_diplodia_no_temp"", + ""prediction_debugging_diplodia_no_precip"", + ""prediction_debugging_diplodia_no_hail"", + ""prediction_debugging_diplodia_no_ph"", + ""prediction_debugging_diplodia_no_soil"", + ""prediction_debugging_diplodia_no_lithology"", + ""prediction_debugging_diplodia_no_slope"", + ""prediction_debugging_diplodia_no_pisr"" +), +model_name = c(""glm"", + + ""gam"", + ""gam"", + ""gam"", + ""gam"", + + ""svm"", + + ""rf"", + + ""kknn"", + + ""xgboost"", + + ""brt"", + + ""rf"", + ""rf"", + ""rf"", + ""rf"", + ""rf"", + ""rf"", + ""rf"", + ""rf"" +), +benchmark_object = c(""bm_sp_non_glm"", + + ""bm_sp_sp_diplodia_gam"", + ""bm_sp_sp_fusarium_gam"", + ""bm_sp_sp_armillaria_gam"", + ""bm_sp_sp_heterobasidion_gam"", + + ""no_extract_bm_sp_sp_svm"", + ""no_extract_bm_sp_sp_rf"", + ""no_extract_bm_sp_sp_kknn"", + ""no_extract_bm_sp_sp_xgboost"", + ""no_extract_bm_sp_sp_brt"", + + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"", # debugging + ""no_extract_bm_sp_sp_brt"" # debugging +), +resampling = c(# glm + ""spatial/no tuning"", + + # gam + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + ""spatial/spatial"", + + ""NA"", # debugging + ""NA"", # debugging + ""NA"", # debugging + ""NA"", # debugging + ""NA"", # debugging + ""NA"", # debugging + ""NA"", # debugging + ""NA"") # debugging +) + +args_pred$id = suppressWarnings(paste0(""maps_"", gsub(""prediction_"", """", args_pred$prediction_raster))) +args_pred$prediction_raster = rlang::syms(args_pred$prediction_raster) +args_pred$benchmark_object = rlang::syms(args_pred$benchmark_object) + +prediction_maps_plan = map_plan(args_pred, create_prediction_map, trace = FALSE) + +rm(list=ls(pattern=""args_pred"")) +","R" +"Pathogens","pat-s/pathogen-modeling","code/01-data/task.R",".R","8428","170"," +# tasks all predictors ---------------------------------------------------- + +heterobasidion_task_dummy <- task_custom(heterobasidion_data, + ""heterobasidion"", ""heterobasi"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE +) + +armillaria_task_dummy <- task_custom(armillaria_data, + ""armillaria"", ""armillaria"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE +) + +diplodia_task_dummy <- task_custom(diplodia_data, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = TRUE +) + +diplodia_task <- task_custom(diplodia_data, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = FALSE +) + +fusarium_task_dummy <- task_custom(fusarium_data, + ""fusarium"", ""fus01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = TRUE +) + +diplodia_task_dummy_prediction <- task_custom_prediction(diplodia_data, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +fusarium_task_dummy_prediction <- task_custom_prediction(fusarium_data, + ""fusarium"", ""fus01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +# tasks no ph ------------------------------------------------------------- + + +heterobasidion_task_dummy_no_ph <- task_custom(heterobasidion_data_no_ph, + ""heterobasidion"", ""heterobasi"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE +) + +armillaria_task_dummy_no_ph <- task_custom(armillaria_data_no_ph, + ""armillaria"", ""armillaria"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE +) + +diplodia_task_dummy_no_ph <- task_custom(diplodia_data_no_ph, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = TRUE +) + +diplodia_task_no_ph <- task_custom(diplodia_data_no_ph, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = FALSE +) + +fusarium_task_dummy_no_ph <- task_custom(fusarium_data_no_ph, + ""fusarium"", ""fus01"", + dummy_features = c(""lithology"", ""soil"", ""year""), + dummy.factors = TRUE +) + +diplodia_task_dummy_prediction_no_ph <- task_custom_prediction(diplodia_data_no_ph, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +fusarium_task_dummy_prediction_no_ph <- task_custom_prediction(fusarium_data_no_ph, + ""fusarium"", ""fus01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +# Debugging tasks --------------------------------------------------------- + +# We can't put them into a list because each one needs its own prediction task + +diplodia_task_dummy_prediction_no_temp <- task_custom_prediction(diplodia_data_no_temp, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_precip <- task_custom_prediction(diplodia_data_no_precip, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_hail <- task_custom_prediction(diplodia_data_no_hail, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_soil <- task_custom_prediction(diplodia_data_no_soil, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_lithology <- task_custom_prediction(diplodia_data_no_lithology, + ""diplodia"", ""diplo01"", + dummy_features = c(""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_slope <- task_custom_prediction(diplodia_data_no_slope, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +diplodia_task_dummy_prediction_no_pisr <- task_custom_prediction(diplodia_data_no_pisr, + ""diplodia"", ""diplo01"", + dummy_features = c(""lithology"", ""soil""), + dummy.factors = TRUE, + remove.vars = TRUE +) + +# Combined tasks --------------------------------------------------------- + +tasks <- list( + armillaria_task_dummy, + heterobasidion_task_dummy, + diplodia_task_dummy, + fusarium_task_dummy +) + +tasks_pred <- list( + armillaria_task_dummy, + heterobasidion_task_dummy, + diplodia_task_dummy_prediction, + fusarium_task_dummy_prediction +) + +tasks_pred_no_ph <- list( + armillaria_task_dummy_no_ph, + heterobasidion_task_dummy_no_ph, + diplodia_task_dummy_prediction_no_ph, + fusarium_task_dummy_prediction_no_ph +) +","R" +"Pathogens","pat-s/pathogen-modeling","code/01-data/data.R",".R","18326","279","# data with ph ----------------------------------------------------------- + +armillaria_data = extract_variables(""https://zenodo.org/record/2621996/files/heterobasidion-armillaria.gpkg"", + study_area = data_basque, drop_vars = ""heterobasi"", + response = ""armillaria"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = FALSE) +heterobasidion_data = extract_variables(""https://zenodo.org/record/2621996/files/heterobasidion-armillaria.gpkg"", + study_area = data_basque, drop_vars = ""armillaria"", + response = ""heterobasi"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = FALSE) +fusarium_data = extract_variables(""https://zenodo.org/record/2621996/files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""diplo01"", + response = ""fus01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE) +diplodia_data = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE) + +# data without ph --------------------------------------------------------- + +armillaria_data_no_ph = extract_variables(""https://zenodo.org/record/2621996/files/heterobasidion-armillaria.gpkg"", + study_area = data_basque, drop_vars = ""heterobasi"", + response = ""armillaria"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = FALSE, + remove_pred = ""ph"") +diplodia_data_no_ph = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""ph"") +fusarium_data_no_ph = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""diplo01"", + response = ""fus01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""ph"") +heterobasidion_data_no_ph = extract_variables(""https://zenodo.org/record/2621996/files/heterobasidion-armillaria.gpkg"", + study_area = data_basque, drop_vars = ""armillaria"", + response = ""heterobasi"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = FALSE, + remove_pred = ""ph"") + + +# debugging data ---------------------------------------------------------- + + +# data with extracted temp, precip and pisr +diplodia_data_no_temp = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""temp"") + +# data with extracted temp, precip and pisr +diplodia_data_no_precip = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""precip"") + +# data with extracted temp, precip and pisr +diplodia_data_no_hail = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""hail_probability"") + +# data with extracted temp, precip and pisr +diplodia_data_no_soil = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""soil"") + +# data with extracted temp, precip and pisr +diplodia_data_no_lithology = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""lithology"") + +# data with extracted temp, precip and pisr +diplodia_data_no_slope = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""slope_degrees"") + +# data with extracted temp, precip and pisr +diplodia_data_no_pisr = extract_variables(""https://zenodo.org/record/2621996//files/diplodia-fusarium.gpkg"", + study_area = data_basque, drop_vars = ""fus01"", + response = ""diplo01"", + soil = soil, lithology = lithology, slope = slope, + temperature = temperature_mean, ph = ph, + hail = hail_raw, precipitation = precipitation_sum, + pisr = pisr, elevation = elevation, age = TRUE, + remove_pred = ""pisr"") + +# Raw Data preprocessing ------------------------------------------------------------ + +data_basque = st_read(""https://zenodo.org/record/2621996/files/study-area.gpkg"", + quiet = TRUE) + +dem_raw = dem_download(""https://zenodo.org/record/2621996/files/dem.zip"") +slope = slope_processing(data = dem_raw) +elevation = elevation_preprocessing(data = dem_raw) + +temperature_mean = temperature_preprocessing(atlas_climatico = atlas_climatico) +precipitation_sum = precipitation_preprocessing(atlas_climatico = atlas_climatico) +pisr = pisr_preprocessing(atlas_climatico = atlas_climatico) + +lithology_raw = lithology_download(url = ""https://zenodo.org/record/2621996/files/lithology.zip"") +lithology = lithology_preprocessing(lithology_raw) + +soil_raw = soil_download(""https://zenodo.org/record/2621996/files/soil.tif"") +soil = soil_preprocessing(data = soil_raw, + study_area = data_basque) + +# we cannot make ph public unfortunately so we load it locally from the repo +ph = ph_preprocessing(data = ""data/ph/"", study_area = data_basque) + +atlas_climatico_raw = atlas_climatico_download(""https://zenodo.org/record/2621996/files/atlas-climatico.zip"") +atlas_climatico = atlas_climatico_preprocessing(data = atlas_climatico_raw, + study_area = data_basque) + +hail_raw = hail_download(url = ""https://zenodo.org/record/2621996/files/hail-probability.tif"") + +# Prediction data --------------------------------------------------------- + +pred_data = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil"") + ) + +pred_data_no_temp = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""temp"") + +pred_data_no_precip = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""precip"") + +pred_data_no_soil = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology""), + drop_var = ""soil"") + +pred_data_no_ph = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""ph"") + +pred_data_no_lithology = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""soil""), + drop_var = ""lithology"") + +pred_data_no_hail = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""hail_probability"") + +pred_data_no_slope = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""slope_degrees"") + +pred_data_no_pisr = create_prediction_data(temperature = temperature_mean, + precipitation = precipitation_sum, + pisr = pisr, + elevation = elevation, + soil = soil, + slope = slope, + lithology = lithology, + hail = hail_raw, + ph = ph, + dummy_features = c(""lithology"", ""soil""), + drop_var = ""pisr"") +","R" +"Pathogens","pat-s/pathogen-modeling","code/02-mlr-settings/learner.R",".R","34128","594","# Random Forest ----------------------------------------------------------- + +lrn_rf <- makeLearner( + ""classif.ranger"", + predict.type = ""prob"" +) + +# xgboost ----------------------------------------------------------------- + +lrn_xgboost <- makeLearner( + ""classif.xgboost"", + predict.type = ""prob"" +) + +# SVM --------------------------------------------------------------------- + +# lrn_svm <- makeLearner( +# ""classif.svm"", +# predict.type = ""prob"", +# kernel = ""rbfdot"", +# scaled = FALSE +# ) + +lrn_svm <- makeLearner( + ""classif.svm"", + predict.type = ""prob"", + scale = FALSE +) + +# KNN --------------------------------------------------------------------- + +lrn_kknn <- makeLearner(""classif.kknn"", + predict.type = ""prob"", + kernel = ""rectangular"" +) + +# BRT --------------------------------------------------------------------- + +lrn_brt <- makeLearner(""classif.gbm"", + predict.type = ""prob"", + distribution = ""bernoulli"" +) + +# GAM --------------------------------------------------------------------- + +lrn_gam_diplodia_perf <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" + +) + +lrn_gam_diplodia_perf_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" + +) + +# ""pred"" without variable and ""year"" +lrn_gam_diplodia_pred <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_diplodia_pred_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_fusarium_perf <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + +lrn_gam_fusarium_perf_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + +# ""pred"" without variable and ""year"" +lrn_gam_fusarium_pred <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_fusarium_pred_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_armillaria_perf <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + +lrn_gam_armillaria_perf_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + + +# ""pred"" without variable and ""year"" +lrn_gam_armillaria_pred <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_armillaria_pred_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_heterobasidion_perf <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + +lrn_gam_heterobasidion_perf_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"" +) + +# ""pred"" without variable and ""year"" +lrn_gam_heterobasidion_pred <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth"" +) + +lrn_gam_heterobasidion_pred_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth"" +) + + + +lrn_gam_diplodia_perf_non <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 7) +) + +lrn_gam_diplodia_perf_non_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""diplo01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 6) +) + + +lrn_gam_fusarium_perf_non <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 6) +) + +lrn_gam_fusarium_perf_non_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""fus01 ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(age, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + + soil.pronounced.accumulation.of.organic.matter.in.the.mineral.topsoil + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 6) +) + + + +lrn_gam_armillaria_perf_non <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 6) +) + +lrn_gam_armillaria_perf_non_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""armillaria ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 5) +) + + +lrn_gam_heterobasidion_perf_non <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + s(ph, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 6) +) + +lrn_gam_heterobasidion_perf_non_no_ph <- makeLearner(""classif.gam"", + family = ""binomial"", + binomial.link = ""logit"", + predict.type = ""prob"", + method = ""GCV.Cp"", + fix.factors.prediction = TRUE, + formula = ""heterobasi ~ s(temp, k = 15) + s(precip, k = 15) + s(pisr, k = 15) + + s(slope_degrees, k = 15) + s(hail_probability, k = 15) + + + lithology.clastic.sedimentary.rock + + lithology.biological.sedimentary.rock + + lithology.chemical.sedimentary.rock + + lithology.magmatic.rock + + + soil.soils.with.little.or.no.profile.differentiation + soil.soils.with.limitations.to.root.growth + + + year.2010 + + year.2011 + + year.2012"", + sp = rep(0, 5) +) + +# GLM --------------------------------------------------------------------- + +lrn_glm <- makeLearner(""classif.binomial"", + link = ""logit"", + predict.type = ""prob"", + fix.factors.prediction = TRUE +) +","R" +"Pathogens","pat-s/pathogen-modeling","code/02-mlr-settings/tune_ctrl_mbo.R",".R","873","18","# tune_ctrl_rf_50 = tune_ctrl_mbo_30n_20it(ps_rf) +# tune_ctrl_svm_50 = tune_ctrl_mbo_30n_20it(ps_svm) +# tune_ctrl_xgboost_50 = tune_ctrl_mbo_30n_20it(ps_xgboost) +# tune_ctrl_kknn_50 = tune_ctrl_mbo_30n_20it(ps_kknn) +# tune_ctrl_brt_50 = tune_ctrl_mbo_30n_20it(ps_brt) +# tune_ctrl_gam_50 = tune_ctrl_mbo_30n_20it(ps_gam) + +tune_ctrl_rf_100 = tune_ctrl_mbo_30n_70it(ps_rf) +tune_ctrl_svm_100 = tune_ctrl_mbo_30n_70it(ps_svm) +tune_ctrl_xgboost_100 = tune_ctrl_mbo_30n_70it(ps_xgboost) +tune_ctrl_kknn_100 = tune_ctrl_mbo_30n_70it(ps_kknn) +tune_ctrl_brt_100 = tune_ctrl_mbo_30n_70it(ps_brt) + + +tune_ctrl_gam_100_diplodia_fusarium = tune_ctrl_mbo_30n_70it(ps_gam_diplodia_fusarium) +tune_ctrl_gam_100_diplodia_fusarium_pred = tune_ctrl_mbo_30n_70it(ps_gam_diplodia_fusarium_pred) +tune_ctrl_gam_100_armillaria_heterobasidion = tune_ctrl_mbo_30n_70it(ps_gam_armillaria_heterobasidion) +","R" +"Pathogens","pat-s/pathogen-modeling","code/02-mlr-settings/param-set.R",".R","2732","68","# Random Forest ----------------------------------------------------------- + +ps_rf <- makeParamSet( + makeIntegerParam(""mtry"", lower = 1, upper = 9), + makeIntegerParam(""min.node.size"", lower = 1, upper = 10), + makeNumericParam(""sample.fraction"", lower = 0.2, upper = 0.9) +) + +# xgboost ----------------------------------------------------------------- + +# ps_xgboost = makeParamSet( +# makeIntegerParam(""nrounds"", lower = 10, upper = 600), +# makeNumericParam(""colsample_bytree"", lower = 0.3, upper = 0.7), +# makeNumericParam(""subsample"", lower = 0.25, upper = 1), +# makeIntegerParam(""max_depth"", lower = 1, upper = 10), +# makeNumericParam(""gamma"", lower = 0, upper = 10), +# makeNumericParam(""eta"", lower = 0.001, upper = 0.6), +# makeNumericParam(""min_child_weight"", lower = 0, upper = 20) +# ) + +ps_xgboost = makeParamSet( + makeNumericParam(""eta"", lower = 0.01, upper = 0.2), + makeNumericParam(""gamma"", lower = -7, upper = 6, trafo = function(x) 2^x), + makeIntegerParam(""max_depth"", lower = 3, upper = 20), + makeNumericParam(""colsample_bytree"", lower = 0.5, upper = 1), + makeNumericParam(""colsample_bylevel"", lower = 0.5, upper = 1), + makeNumericParam(""lambda"", lower = -10, upper = 10, trafo = function(x) 2^x), + makeNumericParam(""alpha"", lower = -10, upper = 10, trafo = function(x) 2^x), + makeNumericParam(""subsample"", lower = 0.5, upper = 1) +) + +# SVM --------------------------------------------------------------------- + +ps_svm = makeParamSet( + makeNumericParam(""cost"", lower = -5, upper = 12, + trafo = function(x) 2 ^ x), + makeNumericParam(""gamma"", lower = -12, upper = 3, + trafo = function(x) 2 ^ x) +) + +# KNN --------------------------------------------------------------------- + +ps_kknn <- makeParamSet( + makeIntegerParam(""k"", lower = 1, upper = 100), + makeIntegerParam(""distance"", lower = 1, upper = 100), + makeDiscreteParam(""kernel"", values = c(""rectangular"", ""triangular"", ""epanechnikov"", ""triweight"", ""cos"", ""inv"", ""gaussian"", ""rank"", ""optimal"")) +) + +# BRT --------------------------------------------------------------------- + +ps_brt <- makeParamSet( + makeIntegerParam(""n.trees"", lower = 100, upper = 10000), + makeNumericParam(""shrinkage"", lower = 0.005, upper = 0.2), + makeIntegerParam(""interaction.depth"", lower = 1, upper = 10) +) + +# GAM --------------------------------------------------------------------- + +ps_gam_armillaria_heterobasidion <- makeParamSet( + makeNumericVectorParam(""sp"", len = 5, lower = 0, upper = 500000) +) +ps_gam_diplodia_fusarium <- makeParamSet( + makeNumericVectorParam(""sp"", len = 6, lower = 0, upper = 500000) +) +ps_gam_diplodia_fusarium_pred <- makeParamSet( + makeNumericVectorParam(""sp"", len = 5, lower = 0, upper = 500000) +) +","R" +"Pathogens","pat-s/pathogen-modeling","code/02-mlr-settings/tuning.R",".R","2441","32","wrapper_rf_sp = tuning_wrapper_custom(lrn_rf, ps_rf, spcv_inner_fiveF, tune_ctrl_rf_100) + +wrapper_svm_sp = tuning_wrapper_custom(lrn_svm, ps_svm, spcv_inner_fiveF, tune_ctrl_svm_100) + +wrapper_kknn_sp = tuning_wrapper_custom(lrn_kknn, ps_kknn, spcv_inner_fiveF, tune_ctrl_kknn_100) + +wrapper_xgboost_sp = tuning_wrapper_custom(lrn_xgboost, ps_xgboost, spcv_inner_fiveF, tune_ctrl_xgboost_100) + +wrapper_brt_sp = tuning_wrapper_custom(lrn_brt, ps_brt, spcv_inner_fiveF, tune_ctrl_brt_100) + +wrapper_gam_diplodia_perf_sp = tuning_wrapper_custom(lrn_gam_diplodia_perf_no_ph, ps_gam_diplodia_fusarium, spcv_inner_fiveF, tune_ctrl_gam_100_diplodia_fusarium) +wrapper_gam_fusarium_perf_sp = tuning_wrapper_custom(lrn_gam_fusarium_perf_no_ph, ps_gam_diplodia_fusarium, spcv_inner_fiveF, tune_ctrl_gam_100_diplodia_fusarium) +wrapper_gam_armillaria_perf_sp = tuning_wrapper_custom(lrn_gam_armillaria_perf_no_ph, ps_gam_armillaria_heterobasidion, spcv_inner_fiveF, tune_ctrl_gam_100_armillaria_heterobasidion) +wrapper_gam_heterobasidion_perf_sp = tuning_wrapper_custom(lrn_gam_heterobasidion_perf_no_ph, ps_gam_armillaria_heterobasidion, spcv_inner_fiveF, tune_ctrl_gam_100_armillaria_heterobasidion) + +# Non-spatial ------------------------------------------------------------- + +wrapper_rf_nsp = tuning_wrapper_custom(lrn_rf, ps_rf, cv_inner_fiveF, tune_ctrl_rf_100) + +wrapper_svm_nsp = tuning_wrapper_custom(lrn_svm, ps_svm, cv_inner_fiveF, tune_ctrl_svm_100) + +wrapper_kknn_nsp = tuning_wrapper_custom(lrn_kknn, ps_kknn, cv_inner_fiveF, tune_ctrl_kknn_100) + +wrapper_xgboost_nsp = tuning_wrapper_custom(lrn_xgboost, ps_xgboost, cv_inner_fiveF, tune_ctrl_xgboost_100) + +wrapper_brt_nsp = tuning_wrapper_custom(lrn_brt, ps_brt, cv_inner_fiveF, tune_ctrl_brt_100) + +wrapper_gam_diplodia_perf_nsp = tuning_wrapper_custom(lrn_gam_diplodia_perf_no_ph, ps_gam_diplodia_fusarium, cv_inner_fiveF, tune_ctrl_gam_100_diplodia_fusarium) +wrapper_gam_fusarium_perf_nsp = tuning_wrapper_custom(lrn_gam_fusarium_perf_no_ph, ps_gam_diplodia_fusarium, cv_inner_fiveF, tune_ctrl_gam_100_diplodia_fusarium) +wrapper_gam_armillaria_perf_nsp = tuning_wrapper_custom(lrn_gam_armillaria_perf_no_ph, ps_gam_armillaria_heterobasidion, cv_inner_fiveF, tune_ctrl_gam_100_armillaria_heterobasidion) +wrapper_gam_heterobasidion_perf_nsp = tuning_wrapper_custom(lrn_gam_heterobasidion_perf_no_ph, ps_gam_armillaria_heterobasidion, cv_inner_fiveF, tune_ctrl_gam_100_armillaria_heterobasidion) +","R" +"Pathogens","pat-s/pathogen-modeling","code/02-mlr-settings/resampling.R",".R","415","8","spcv_inner_fiveF <- makeResampleDesc(""SpCV"", iters = 5, fixed = FALSE) +spcv_outer_fiveF_hundredR <- makeResampleDesc(""SpRepCV"", folds = 5, reps = 100, + fixed = FALSE) + +cv_inner_fiveF <- makeResampleDesc(""CV"", iters = 5, fixed = FALSE) +cv_outer_fiveF_hundredR <- makeResampleDesc(""RepCV"", folds = 5, reps = 100, + fixed = FALSE) +","R" +"Pathogens","pat-s/pathogen-modeling","code/07-paper/submission/3/Changelog.md",".md","732","15","(This file tracks changes between submission 2 and submission 3. It may not include all changes since it was not added right from the start.) + +# Changes + +- Add Zenodo research compendium link + +- Add section 5.3 ""Outlook"" + +- Add section 5.2.6 ""The effect of overoptimistic performance estimates on ecological decision making"" + +- Update hyperparameter range from BRT + +- Move appendices into Research compendium + +- Change title from ""*Crucial but often neglected: The important role of spatial autocorrelation in hyperparameter tuning and predictive performance of machine-learning algorithms for spatial data.*"" to ""*Hyperparameter tuning and performance assessment of statistical and machine-learning algorithms using spatial data.*""","Markdown" +"Pathogens","pat-s/pathogen-modeling","code/07-paper/submission/2/latex-source-files/copy-figures.R",".R","2950","49","library(fs) + +# Figure 1 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/01_data/study_area.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/study_area.pdf"", + overwrite = TRUE) +# Figure 2 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/01_data/cross-validation_farbig.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/cross-validation_farbig.pdf"", + overwrite = TRUE) +# Figure 3 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/01_data/spcv_nspcv_folds.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/spcv_nspcv_folds.pdf"", + overwrite = TRUE) +# Figure 4 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/opt-paths-RF-sp-vs-nsp.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/opt-paths-RF-sp-vs-nsp.pdf"", + overwrite = TRUE) +# Figure 5 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/tuning_effects_all_models_mbo.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/tuning_effects_all_models_mbo.pdf"", + overwrite = TRUE) +# Figure 6 +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/cv_boxplots_final_brier.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/cv_boxplots_final_brier.pdf"", + overwrite = TRUE) +# Appendix A +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/tuning_effects_appendix_mbo.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/tuning_effects_appendix_mbo.pdf"", + overwrite = TRUE) +# Appendix B +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/opt-paths-BRT.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/opt-paths-BRT.pdf"", + overwrite = TRUE) + +# Appendix C +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/opt-paths-GAM.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/opt-paths-GAM.pdf"", + overwrite = TRUE) + +# Appendix D +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/opt-paths-KNN.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/opt-paths-KNN.pdf"", + overwrite = TRUE) +# Appendix E +file_copy(""/home/patrick/PhD/papers/01_model_comparison/04_figures/02_results/opt-paths-SVM.pdf"", + ""/home/patrick/PhD/papers/01_model_comparison/02_writing/submission/2/latex-source-files/opt-paths-SVM.pdf"", + overwrite = TRUE) +","R" +"Pathogens","pat-s/pathogen-modeling","code/03-benchmark/benchmark.R",".R","24075","331","# combining all benchmark calls into a single plan +# see https://ropenscilabs.github.io/drake-manual/plans.html#map_plan + +# sp/sp ------------------------------------------------------------------- + +args_bm_sp_sp_armillaria = tibble(task = rlang::syms(""armillaria_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_sp"", + ""wrapper_svm_sp"", + ""wrapper_xgboost_sp"", + ""wrapper_brt_sp"", + ""wrapper_kknn_sp"", + ""wrapper_gam_armillaria_perf_sp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_sp_armillaria$learner = rlang::syms(args_bm_sp_sp_armillaria$learner) +args_bm_sp_sp_armillaria$id = suppressWarnings(paste0(""bm_sp_sp_armillaria_"", str_split(args_bm_sp_sp_armillaria$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_sp_diplodia = tibble(task = rlang::syms(""diplodia_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_sp"", + ""wrapper_svm_sp"", + ""wrapper_xgboost_sp"", + ""wrapper_brt_sp"", + ""wrapper_kknn_sp"", + ""wrapper_gam_diplodia_perf_sp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_sp_diplodia$learner = rlang::syms(args_bm_sp_sp_diplodia$learner) +args_bm_sp_sp_diplodia$id = suppressWarnings(paste0(""bm_sp_sp_diplodia_"", str_split(args_bm_sp_sp_diplodia$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_sp_fusarium = tibble(task = rlang::syms(""fusarium_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_sp"", + ""wrapper_svm_sp"", + ""wrapper_xgboost_sp"", + ""wrapper_brt_sp"", + ""wrapper_kknn_sp"", + ""wrapper_gam_fusarium_perf_sp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_sp_fusarium$learner = rlang::syms(args_bm_sp_sp_fusarium$learner) +args_bm_sp_sp_fusarium$id = suppressWarnings(paste0(""bm_sp_sp_fusarium_"", str_split(args_bm_sp_sp_fusarium$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_sp_heterobasidion = tibble(task = rlang::syms(""heterobasidion_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_sp"", + ""wrapper_svm_sp"", + ""wrapper_xgboost_sp"", + ""wrapper_brt_sp"", + ""wrapper_kknn_sp"", + ""wrapper_gam_heterobasidion_perf_sp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_sp_heterobasidion$learner = rlang::syms(args_bm_sp_sp_heterobasidion$learner) +args_bm_sp_sp_heterobasidion$id = suppressWarnings(paste0(""bm_sp_sp_heterobasidion_"", str_split(args_bm_sp_sp_heterobasidion$learner, ""_"", + simplify = TRUE)[, 2])) + + +# sp/nsp ------------------------------------------------------------------ + +args_bm_sp_nsp_armillaria = tibble(task = rlang::syms(""armillaria_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_armillaria_perf_nsp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_nsp_armillaria$learner = rlang::syms(args_bm_sp_nsp_armillaria$learner) +args_bm_sp_nsp_armillaria$id = suppressWarnings(paste0(""bm_sp_nsp_armillaria_"", str_split(args_bm_sp_nsp_armillaria$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_nsp_diplodia = tibble(task = rlang::syms(""diplodia_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_diplodia_perf_nsp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_nsp_diplodia$learner = rlang::syms(args_bm_sp_nsp_diplodia$learner) +args_bm_sp_nsp_diplodia$id = suppressWarnings(paste0(""bm_sp_nsp_diplodia_"", str_split(args_bm_sp_nsp_diplodia$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_nsp_fusarium = tibble(task = rlang::syms(""fusarium_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_fusarium_perf_nsp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_nsp_fusarium$learner = rlang::syms(args_bm_sp_nsp_fusarium$learner) +args_bm_sp_nsp_fusarium$id = suppressWarnings(paste0(""bm_sp_nsp_fusarium_"", str_split(args_bm_sp_nsp_fusarium$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_nsp_heterobasidion = tibble(task = rlang::syms(""heterobasidion_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_heterobasidion_perf_nsp"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 6))) +args_bm_sp_nsp_heterobasidion$learner = rlang::syms(args_bm_sp_nsp_heterobasidion$learner) +args_bm_sp_nsp_heterobasidion$id = suppressWarnings(paste0(""bm_sp_nsp_heterobasidion_"", str_split(args_bm_sp_nsp_heterobasidion$learner, ""_"", + simplify = TRUE)[, 2])) + + +# sp/non ------------------------------------------------------------------ + +args_bm_sp_non_armillaria = tibble(task = rlang::syms(""armillaria_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_armillaria_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 7))) +args_bm_sp_non_armillaria$learner = rlang::syms(args_bm_sp_non_armillaria$learner) +args_bm_sp_non_armillaria$id = suppressWarnings(paste0(""bm_sp_non_armillaria_"", str_split(args_bm_sp_non_armillaria$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_non_diplodia = tibble(task = ""diplodia_task_dummy_no_ph"", + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_diplodia_perf_non_no_ph"" + )), + resampling = rep(""spcv_outer_fiveF_hundredR"", 7)) +# manual add - only temporary +args_bm_sp_non_diplodia[8,1] = ""test_diplodia_task"" +args_bm_sp_non_diplodia[8,2] = ""lrn_glm"" +args_bm_sp_non_diplodia[8,3] = ""spcv_outer_fiveF_hundredR"" + +args_bm_sp_non_diplodia$task = rlang::syms(args_bm_sp_non_diplodia$task) +args_bm_sp_non_diplodia$learner = rlang::syms(args_bm_sp_non_diplodia$learner) +args_bm_sp_non_diplodia$resampling = rlang::syms(args_bm_sp_non_diplodia$resampling) +args_bm_sp_non_diplodia$id = suppressWarnings(paste0(""bm_sp_non_diplodia_"", str_split(args_bm_sp_non_diplodia$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_non_diplodia[8,4] = ""bm_sp_non_diplodia_glm_old"" + + +args_bm_sp_non_fusarium = tibble(task = rlang::syms(""fusarium_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_fusarium_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 7))) +args_bm_sp_non_fusarium$learner = rlang::syms(args_bm_sp_non_fusarium$learner) +args_bm_sp_non_fusarium$id = suppressWarnings(paste0(""bm_sp_non_fusarium_"", str_split(args_bm_sp_non_fusarium$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_sp_non_heterobasidion = tibble(task = rlang::syms(""heterobasidion_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_heterobasidion_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""spcv_outer_fiveF_hundredR"", 7))) +args_bm_sp_non_heterobasidion$learner = rlang::syms(args_bm_sp_non_heterobasidion$learner) +args_bm_sp_non_heterobasidion$id = suppressWarnings(paste0(""bm_sp_non_heterobasidion_"", str_split(args_bm_sp_non_heterobasidion$learner, ""_"", + simplify = TRUE)[, 2])) + +# nsp/nsp ------------------------------------------------------------------ + +args_bm_nsp_nsp_armillaria = tibble(task = rlang::syms(""armillaria_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_armillaria_perf_nsp"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 6))) +args_bm_nsp_nsp_armillaria$learner = rlang::syms(args_bm_nsp_nsp_armillaria$learner) +args_bm_nsp_nsp_armillaria$id = suppressWarnings(paste0(""bm_nsp_nsp_armillaria_"", str_split(args_bm_nsp_nsp_armillaria$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_nsp_diplodia = tibble(task = rlang::syms(""diplodia_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_diplodia_perf_nsp"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 6))) +args_bm_nsp_nsp_diplodia$learner = rlang::syms(args_bm_nsp_nsp_diplodia$learner) +args_bm_nsp_nsp_diplodia$id = suppressWarnings(paste0(""bm_nsp_nsp_diplodia_"", str_split(args_bm_nsp_nsp_diplodia$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_nsp_fusarium = tibble(task = rlang::syms(""fusarium_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_fusarium_perf_nsp"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 6))) +args_bm_nsp_nsp_fusarium$learner = rlang::syms(args_bm_nsp_nsp_fusarium$learner) +args_bm_nsp_nsp_fusarium$id = suppressWarnings(paste0(""bm_nsp_nsp_fusarium_"", str_split(args_bm_nsp_nsp_fusarium$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_nsp_heterobasidion = tibble(task = rlang::syms(""heterobasidion_task_dummy_no_ph""), + learner = c(c(""wrapper_rf_nsp"", + ""wrapper_svm_nsp"", + ""wrapper_xgboost_nsp"", + ""wrapper_brt_nsp"", + ""wrapper_kknn_nsp"", + ""wrapper_gam_heterobasidion_perf_nsp"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 6))) +args_bm_nsp_nsp_heterobasidion$learner = rlang::syms(args_bm_nsp_nsp_heterobasidion$learner) +args_bm_nsp_nsp_heterobasidion$id = suppressWarnings(paste0(""bm_nsp_nsp_heterobasidion_"", str_split(args_bm_nsp_nsp_heterobasidion$learner, ""_"", + simplify = TRUE)[, 2])) + +# nsp/non ------------------------------------------------------------------ + +args_bm_nsp_non_armillaria = tibble(task = rlang::syms(""armillaria_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_armillaria_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 7))) +args_bm_nsp_non_armillaria$learner = rlang::syms(args_bm_nsp_non_armillaria$learner) +args_bm_nsp_non_armillaria$id = suppressWarnings(paste0(""bm_nsp_non_armillaria_"", str_split(args_bm_nsp_non_armillaria$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_non_diplodia = tibble(task = rlang::syms(""diplodia_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_diplodia_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 7))) +args_bm_nsp_non_diplodia$learner = rlang::syms(args_bm_nsp_non_diplodia$learner) +args_bm_nsp_non_diplodia$id = suppressWarnings(paste0(""bm_nsp_non_diplodia_"", str_split(args_bm_nsp_non_diplodia$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_non_fusarium = tibble(task = rlang::syms(""fusarium_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_fusarium_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 7))) +args_bm_nsp_non_fusarium$learner = rlang::syms(args_bm_nsp_non_fusarium$learner) +args_bm_nsp_non_fusarium$id = suppressWarnings(paste0(""bm_nsp_non_fusarium_"", str_split(args_bm_nsp_non_fusarium$learner, ""_"", + simplify = TRUE)[, 2])) + +args_bm_nsp_non_heterobasidion = tibble(task = rlang::syms(""heterobasidion_task_dummy_no_ph""), + learner = c(c(""lrn_rf"", + ""lrn_svm"", + ""lrn_xgboost"", + ""lrn_brt"", + ""lrn_kknn"", + ""lrn_glm"", + ""lrn_gam_heterobasidion_perf_non_no_ph"" + )), + resampling = rlang::syms(rep(""cv_outer_fiveF_hundredR"", 7))) +args_bm_nsp_non_heterobasidion$learner = rlang::syms(args_bm_nsp_non_heterobasidion$learner) +args_bm_nsp_non_heterobasidion$id = suppressWarnings(paste0(""bm_nsp_non_heterobasidion_"", str_split(args_bm_nsp_non_heterobasidion$learner, ""_"", + simplify = TRUE)[, 2])) + +# combine ----------------------------------------------------------------- + +benchmark_sp_sp_armillaria = map_plan(args_bm_sp_sp_armillaria, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_sp_diplodia = map_plan(args_bm_sp_sp_diplodia, benchmark_custom_no_pred_no_models, trace = FALSE) +benchmark_sp_sp_fusarium = map_plan(args_bm_sp_sp_fusarium, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_sp_heterobasidion = map_plan(args_bm_sp_sp_heterobasidion, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) + +benchmark_sp_nsp_armillaria = map_plan(args_bm_sp_nsp_armillaria, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_nsp_diplodia = map_plan(args_bm_sp_nsp_diplodia, benchmark_custom_no_pred_no_models, trace = FALSE) +benchmark_sp_nsp_fusarium = map_plan(args_bm_sp_nsp_fusarium, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_nsp_heterobasidion = map_plan(args_bm_sp_nsp_heterobasidion, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) + +benchmark_sp_non_armillaria = map_plan(args_bm_sp_non_armillaria, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_non_diplodia = map_plan(args_bm_sp_non_diplodia, benchmark_custom_no_pred_no_models, trace = FALSE) +benchmark_sp_non_fusarium = map_plan(args_bm_sp_non_fusarium, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_sp_non_heterobasidion = map_plan(args_bm_sp_non_heterobasidion, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) + +benchmark_nsp_nsp_armillaria = map_plan(args_bm_nsp_nsp_armillaria, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_nsp_nsp_diplodia = map_plan(args_bm_nsp_nsp_diplodia, benchmark_custom_no_pred_no_models, trace = FALSE) +benchmark_nsp_nsp_fusarium = map_plan(args_bm_nsp_nsp_fusarium, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_nsp_nsp_heterobasidion = map_plan(args_bm_nsp_nsp_heterobasidion, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) + +benchmark_nsp_non_armillaria = map_plan(args_bm_nsp_non_armillaria, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_nsp_non_diplodia = map_plan(args_bm_nsp_non_diplodia, benchmark_custom_no_pred_no_models, trace = FALSE) +benchmark_nsp_non_fusarium = map_plan(args_bm_nsp_non_fusarium, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) +benchmark_nsp_non_heterobasidion = map_plan(args_bm_nsp_non_heterobasidion, benchmark_custom_no_extract_no_pred_no_models, trace = FALSE) + +benchmark_plan = bind_plans(benchmark_sp_sp_armillaria, benchmark_sp_sp_diplodia, benchmark_sp_sp_fusarium, benchmark_sp_sp_heterobasidion, + benchmark_sp_nsp_armillaria, benchmark_sp_nsp_diplodia, benchmark_sp_nsp_fusarium, benchmark_sp_nsp_heterobasidion, + benchmark_sp_non_armillaria, benchmark_sp_non_diplodia, benchmark_sp_non_fusarium, benchmark_sp_non_heterobasidion, + benchmark_nsp_nsp_armillaria, benchmark_nsp_nsp_diplodia, benchmark_nsp_nsp_fusarium, benchmark_nsp_nsp_heterobasidion, + benchmark_nsp_non_armillaria, benchmark_nsp_non_diplodia, benchmark_nsp_non_fusarium, benchmark_nsp_non_heterobasidion +) + +rm(list=ls(pattern=""args_"")) +rm(list=ls(pattern=""benchmark_nsp"")) +rm(list=ls(pattern=""benchmark_sp"")) +","R" +"Pathogens","pat-s/pathogen-modeling","code/03-benchmark/aggregate-results.R",".R","16737","214"," +# Aggregate by pathogen + resampling -------------------------------------- + +bmr_aggr_path_resamp_plan = drake_plan(bm_sp_sp_diplodia = mergeBenchmarkResults(list(bm_sp_sp_diplodia_gam, + bm_sp_sp_diplodia_kknn, bm_sp_sp_diplodia_rf, + bm_sp_sp_diplodia_svm, bm_sp_sp_diplodia_brt)), + bm_sp_sp_diplodia2 = mergeBenchmarkResults(list(bm_sp_sp_diplodia_gam, + bm_sp_sp_diplodia_kknn, bm_sp_sp_diplodia_rf, + bm_sp_sp_diplodia_svm, bm_sp_sp_diplodia_brt, + bm_sp_sp_diplodia_xgboost)), + + bm_sp_nsp_diplodia = mergeBenchmarkResults(list(bm_sp_nsp_diplodia_gam, + bm_sp_nsp_diplodia_kknn, bm_sp_nsp_diplodia_rf, + bm_sp_nsp_diplodia_svm, bm_sp_nsp_diplodia_brt)), + + bm_sp_nsp_diplodia2 = mergeBenchmarkResults(list(bm_sp_nsp_diplodia_gam, + bm_sp_nsp_diplodia_kknn, bm_sp_nsp_diplodia_rf, + bm_sp_nsp_diplodia_svm, bm_sp_nsp_diplodia_brt, + bm_sp_nsp_diplodia_xgboost)), + + bm_nsp_nsp_diplodia = mergeBenchmarkResults(list(bm_nsp_nsp_diplodia_gam, + bm_nsp_nsp_diplodia_kknn, bm_nsp_nsp_diplodia_rf, + bm_nsp_nsp_diplodia_svm, bm_nsp_nsp_diplodia_brt)), + + bm_nsp_nsp_diplodia2 = mergeBenchmarkResults(list(bm_nsp_nsp_diplodia_gam, + bm_nsp_nsp_diplodia_kknn, bm_nsp_nsp_diplodia_rf, + bm_nsp_nsp_diplodia_svm, bm_nsp_nsp_diplodia_brt, + bm_nsp_nsp_diplodia_xgboost)), + + bm_sp_non_diplodia = mergeBenchmarkResults(list(bm_sp_non_diplodia_gam, bm_sp_non_diplodia_glm, + bm_sp_non_diplodia_kknn, bm_sp_non_diplodia_rf, + bm_sp_non_diplodia_svm, bm_sp_non_diplodia_brt)), + + bm_sp_non_diplodia2 = mergeBenchmarkResults(list(bm_sp_non_diplodia_gam, bm_sp_non_diplodia_glm, + bm_sp_non_diplodia_kknn, bm_sp_non_diplodia_rf, + bm_sp_non_diplodia_svm, bm_sp_non_diplodia_brt, + bm_sp_non_diplodia_xgboost)), + + bm_nsp_non_diplodia = mergeBenchmarkResults(list(bm_nsp_non_diplodia_gam, bm_nsp_non_diplodia_glm, + bm_nsp_non_diplodia_kknn, bm_nsp_non_diplodia_rf, + bm_nsp_non_diplodia_svm, bm_nsp_non_diplodia_brt)), + + bm_nsp_non_diplodia2 = mergeBenchmarkResults(list(bm_nsp_non_diplodia_gam, bm_nsp_non_diplodia_glm, + bm_nsp_non_diplodia_kknn, bm_nsp_non_diplodia_rf, + bm_nsp_non_diplodia_svm, bm_nsp_non_diplodia_brt, + bm_nsp_non_diplodia_xgboost)), + + bm_sp_sp_armillaria = mergeBenchmarkResults(list(bm_sp_sp_armillaria_gam, + bm_sp_sp_armillaria_kknn, bm_sp_sp_armillaria_rf, + bm_sp_sp_armillaria_svm, bm_sp_sp_armillaria_brt, + bm_sp_sp_armillaria_xgboost + )), + + bm_sp_nsp_armillaria = mergeBenchmarkResults(list(bm_sp_nsp_armillaria_gam, + bm_sp_nsp_armillaria_kknn, bm_sp_nsp_armillaria_rf, + bm_sp_nsp_armillaria_svm, bm_sp_nsp_armillaria_brt, + bm_sp_nsp_armillaria_xgboost)), + + bm_nsp_nsp_armillaria = mergeBenchmarkResults(list(bm_nsp_nsp_armillaria_gam, + bm_nsp_nsp_armillaria_kknn, bm_nsp_nsp_armillaria_rf, + bm_nsp_nsp_armillaria_svm, bm_nsp_nsp_armillaria_brt, + bm_nsp_nsp_armillaria_xgboost)), + + bm_sp_non_armillaria = mergeBenchmarkResults(list(bm_sp_non_armillaria_gam, bm_sp_non_armillaria_glm, + bm_sp_non_armillaria_kknn, bm_sp_non_armillaria_rf, + bm_sp_non_armillaria_svm, bm_sp_non_armillaria_brt, + bm_sp_non_armillaria_xgboost)), + + bm_nsp_non_armillaria = mergeBenchmarkResults(list(bm_nsp_non_armillaria_gam, bm_nsp_non_armillaria_glm, + bm_nsp_non_armillaria_kknn, bm_nsp_non_armillaria_rf, + bm_nsp_non_armillaria_svm, bm_nsp_non_armillaria_brt, + bm_nsp_non_armillaria_xgboost)), + + bm_sp_sp_fusarium = mergeBenchmarkResults(list(bm_sp_sp_fusarium_gam, + bm_sp_sp_fusarium_kknn, bm_sp_sp_fusarium_rf, + bm_sp_sp_fusarium_svm, bm_sp_sp_fusarium_brt, + bm_sp_sp_fusarium_xgboost)), + + bm_sp_nsp_fusarium = mergeBenchmarkResults(list(bm_sp_nsp_fusarium_gam, + bm_sp_nsp_fusarium_kknn, bm_sp_nsp_fusarium_rf, + bm_sp_nsp_fusarium_svm, bm_sp_nsp_fusarium_brt, + bm_sp_nsp_fusarium_xgboost)), + + bm_nsp_nsp_fusarium = mergeBenchmarkResults(list(bm_nsp_nsp_fusarium_gam, + bm_nsp_nsp_fusarium_kknn, bm_nsp_nsp_fusarium_rf, + bm_nsp_nsp_fusarium_svm, bm_nsp_nsp_fusarium_brt, + bm_nsp_nsp_fusarium_xgboost)), + + bm_sp_non_fusarium = mergeBenchmarkResults(list(bm_sp_non_fusarium_gam, bm_sp_non_fusarium_glm, + bm_sp_non_fusarium_kknn, bm_sp_non_fusarium_rf, + bm_sp_non_fusarium_svm, bm_sp_non_fusarium_brt, + bm_sp_non_fusarium_xgboost)), + + bm_nsp_non_fusarium = mergeBenchmarkResults(list(bm_nsp_non_fusarium_gam, bm_nsp_non_fusarium_glm, + bm_nsp_non_fusarium_kknn, bm_nsp_non_fusarium_rf, + bm_nsp_non_fusarium_svm, bm_nsp_non_fusarium_brt, + bm_nsp_non_fusarium_xgboost)), + + bm_sp_sp_heterobasidion = mergeBenchmarkResults(list(bm_sp_sp_heterobasidion_gam, + bm_sp_sp_heterobasidion_kknn, bm_sp_sp_heterobasidion_rf, + bm_sp_sp_heterobasidion_svm, bm_sp_sp_heterobasidion_brt, + bm_sp_sp_heterobasidion_xgboost)), + + bm_sp_nsp_heterobasidion = mergeBenchmarkResults(list(bm_sp_nsp_heterobasidion_gam, + bm_sp_nsp_heterobasidion_kknn, bm_sp_nsp_heterobasidion_rf, + bm_sp_nsp_heterobasidion_svm, bm_sp_nsp_heterobasidion_brt, + bm_sp_nsp_heterobasidion_xgboost)), + + bm_nsp_nsp_heterobasidion = mergeBenchmarkResults(list(bm_nsp_nsp_heterobasidion_gam, + bm_nsp_nsp_heterobasidion_kknn, bm_nsp_nsp_heterobasidion_rf, + bm_nsp_nsp_heterobasidion_svm, bm_nsp_nsp_heterobasidion_brt, + bm_nsp_nsp_heterobasidion_xgboost)), + + bm_sp_non_heterobasidion = mergeBenchmarkResults(list(bm_sp_non_heterobasidion_gam, bm_sp_non_heterobasidion_glm, + bm_sp_non_heterobasidion_kknn, bm_sp_non_heterobasidion_rf, + bm_sp_non_heterobasidion_svm, bm_sp_non_heterobasidion_brt, + bm_sp_non_heterobasidion_xgboost)), + + bm_nsp_non_heterobasidion = mergeBenchmarkResults(list(bm_nsp_non_heterobasidion_gam, bm_nsp_non_heterobasidion_glm, + bm_nsp_non_heterobasidion_kknn, bm_nsp_non_heterobasidion_rf, + bm_nsp_non_heterobasidion_svm, bm_nsp_non_heterobasidion_brt, + bm_nsp_non_heterobasidion_xgboost)) +) + +# Aggregate by model + resampling -------------------------------------- + +bmr_aggr_model_resamp_plan = drake_plan( + + bm_sp_sp_svm = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_svm, bm_sp_sp_diplodia_svm, + bm_sp_sp_fusarium_svm, bm_sp_sp_heterobasidion_svm + )), + bm_sp_sp_rf = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_rf, bm_sp_sp_diplodia_rf, + bm_sp_sp_fusarium_rf, bm_sp_sp_heterobasidion_rf + )), + bm_sp_sp_kknn = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_kknn, bm_sp_sp_diplodia_kknn, + bm_sp_sp_fusarium_kknn, bm_sp_sp_heterobasidion_kknn + )), + bm_sp_sp_brt = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_brt, bm_sp_sp_diplodia_brt, + bm_sp_sp_fusarium_brt, bm_sp_sp_heterobasidion_brt + )), + bm_sp_sp_xgboost = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_xgboost, + bm_sp_sp_diplodia_xgboost, + bm_sp_sp_fusarium_xgboost, + bm_sp_sp_heterobasidion_xgboost + )), + bm_sp_sp_gam = mergeBenchmarkResults(list( + bm_sp_sp_armillaria_gam, + bm_sp_sp_diplodia_gam, + bm_sp_sp_fusarium_gam, + bm_sp_sp_heterobasidion_gam + )), + bm_sp_non_glm = mergeBenchmarkResults(list( + bm_sp_non_armillaria_glm, + bm_sp_non_diplodia_glm, + bm_sp_non_fusarium_glm, + bm_sp_non_heterobasidion_glm + )) + +) + + +# Remove ""extract"" slot from BM objects ----------------------------------- + +no_extract_plan = drake_plan( + no_extract = target( + remove_extract(bm_result), + transform = cross(bm_result = c(bm_sp_sp_diplodia, bm_sp_nsp_diplodia, + bm_nsp_nsp_diplodia, bm_sp_non_diplodia, + bm_nsp_non_diplodia, + + bm_sp_sp_diplodia2, bm_sp_nsp_diplodia2, + bm_nsp_nsp_diplodia2, bm_sp_non_diplodia2, + bm_nsp_non_diplodia2, + + bm_sp_sp_armillaria, bm_sp_nsp_armillaria, + bm_nsp_nsp_armillaria, bm_sp_non_armillaria, + bm_nsp_non_armillaria, + + bm_sp_sp_fusarium, bm_sp_nsp_fusarium, + bm_nsp_nsp_fusarium, bm_sp_non_fusarium, + bm_nsp_non_fusarium, + + bm_sp_sp_heterobasidion, bm_sp_nsp_heterobasidion, + bm_nsp_nsp_heterobasidion, bm_sp_non_heterobasidion, + bm_nsp_non_heterobasidion, + + bm_sp_sp_gam, bm_sp_sp_svm, bm_sp_sp_brt, + bm_sp_sp_rf, bm_sp_sp_xgboost, bm_sp_sp_kknn)) + ) +) + +# Aggregate by pathogen + model + resampling -------------------------------------- + +bm_all_pathogens_plan = drake_plan( + bm_all_pathogens_sp_sp = mergeBenchmarkResults(list(no_extract_bm_sp_sp_diplodia2, + no_extract_bm_sp_sp_armillaria, + no_extract_bm_sp_sp_fusarium, + no_extract_bm_sp_sp_heterobasidion)), + bm_all_pathogens_sp_nsp = mergeBenchmarkResults(list(no_extract_bm_sp_nsp_diplodia2, no_extract_bm_sp_nsp_armillaria, + no_extract_bm_sp_nsp_fusarium, no_extract_bm_sp_nsp_heterobasidion)), + bm_all_pathogens_nsp_nsp = mergeBenchmarkResults(list(no_extract_bm_nsp_nsp_diplodia2, no_extract_bm_nsp_nsp_armillaria, + no_extract_bm_nsp_nsp_fusarium, no_extract_bm_nsp_nsp_heterobasidion)), + bm_all_pathogens_sp_non = mergeBenchmarkResults(list(no_extract_bm_sp_non_diplodia2, no_extract_bm_sp_non_armillaria, + no_extract_bm_sp_non_fusarium, no_extract_bm_sp_non_heterobasidion)), + bm_all_pathogens_nsp_non = mergeBenchmarkResults(list(no_extract_bm_nsp_non_diplodia2, no_extract_bm_nsp_non_armillaria, + no_extract_bm_nsp_non_fusarium, no_extract_bm_nsp_non_heterobasidion)) +) + +","R" +"Pathogens","pat-s/pathogen-modeling","code/05-visualization/vis-partitions.R",".R","298","7","plot_partitions = vis_partitions(diplodia_data, bm_sp_non_diplodia_glm, bm_nsp_non_diplodia_glm) + +img_plot_partitions = save_plot_custom(plot_partitions, ""analysis/figures/spcv_nspcv_folds.png"", + ncol = 3, nrow = 4) + +img_plot_opt_paths = save_plot_opt_paths() +","R" +"Pathogens","pat-s/pathogen-modeling","code/05-visualization/create_dataset_tables.R",".R","628","11","diplodia_table_continuous = create_dataset_tables(diplodia_data, + stats = c(""n"", ""min"", ""q1"", + ""median"", ""mean"", + ""q3"", ""max"", + ""iqr"", ""na""), + type = ""continuous"") + +diplodia_table_nominal = create_dataset_tables(diplodia_data, + type = ""nominal"", + drop_vars = ) +","R" +"Pathogens","pat-s/pathogen-modeling","R/data-functions.R",".R","33380","996","#' @title Create a [mlr::task] for performance estimation +#' +#' @param data [data.frame] +#' @param name ID of the task +#' @param target Response of the task +#' @param dummy_features (logical) Whether factor levels should be dummy encoded +#' @param dummy.factors Which factor levels should be dummy encoded +#' +#' @details Differs to [task_custom_prediction] in that it includes variables +#' that are not available for prediction + +task_custom <- function(data, name, target, dummy_features, + dummy.factors = FALSE) { + + + coordinates <- data[, c(""x"", ""y"")] + + data %<>% + st_as_sf(coords = c(""x"", ""y"")) %>% + st_set_geometry(NULL) + + # for some reason we need to remove the geom column twice?! + if (!is.null(data$geometry)) { + data$geometry = NULL + } + + if (isTRUE(dummy.factors)) { + data %<>% createDummyFeatures( + target = target, + cols = dummy_features, + method = ""reference"" + ) + } + + task <- makeClassifTask( + id = name, data = data, + target = target, positive = ""1"", + coordinates = coordinates + ) + + return(task) +} + +#' @title Create a [mlr::task] for performance estimation +#' +#' @param data [data.frame] +#' @param name ID of the task +#' @param target Response of the task +#' @param dummy_features (logical) Whether factor levels should be dummy encoded +#' @param dummy.factors Which factor levels should be dummy encoded +#' +#' @details Differs to [task_custom] in that it removes variables +#' that are not available for prediction +task_custom_prediction <- function(data, name, target, dummy_features, + dummy.factors = FALSE, remove.vars = FALSE) { + task <- task_custom( + data = data, name = name, target = target, + dummy_features = dummy_features, dummy.factors = dummy.factors + ) + + if (all(c(""year"", ""age"") %in% colnames(task$env$data)) && isTRUE(remove.vars)) { + df <- task$env$data %>% + dplyr::select(-year, -age) + } + + task <- makeClassifTask( + id = name, data = df, + target = target, positive = ""1"", + coordinates = task$coordinates + ) + return(task) +} + +#' @title Create prediction data +#' +#' @param temperature Temperature data (mean) +#' @param precipitation Precipitation data (sum) +#' @param pisr Potential incoming solar radiation (as a fraction of its mean) +#' @param slope Slope (in degrees) +#' @param elevation Elevation in meters +#' @param soil Soil type +#' @param lithology Lithology type +#' @param hail Probability of hail damage at trees +#' @param ph pH value of soil +#' @param drop_var Whether a variable should be dropped right before returning. +#' +#' @details `drop_var` is used for debugging purposes. If one variable is being +#' left out in the model, we also need to leave it out in the pred data. +create_prediction_data <- function(temperature, precipitation, pisr, slope, + elevation, soil, lithology, hail, ph, + drop_var = NULL, dummy_features = NULL) { + + # Its a square around the Basque Country. + # This prevents error for the subsequent raster `extract` calls that may result + # in NAs if the rasters does not exceed the dimensions of the extracting area. + + # ## Prediction raster grid + # + # Now create a 200 x 200 point grid using a dummy raster that represents the study area shape. + # + # !! This is temporarly overwritten by an import of the below created file which has already the extracted ltihology information inisde. + # This intersection was created in ArcGIS as R did not finish in one day. + # Runtime in ArcGIS: < 1 min. + # QGIS did not even start.. + # + pred_grid <- as(temperature, ""SpatialPixelsDataFrame"") + pred_grid = st_as_sf(pred_grid) + + # Precipitation + + pred_grid$precip <- + precipitation %>% + raster::extract(pred_grid) + + # Temperature + + pred_grid %<>% + dplyr::rename(temp = layer) + + # PISR + + pred_grid$pisr <- + pisr %>% + raster::extract(pred_grid) + + # Slope + + pred_grid$slope_degrees <- + slope %>% + raster::extract(pred_grid) + + # Lithology + + pred_grid %<>% st_join(lithology) + + pred_grid %<>% + dplyr::rename(lithology = COD_LITOLO) %>% + mutate(lithology = as.factor(lithology)) %>% + mutate(lithology = fct_recode(lithology, + NULL = ""00"", # water bodies + ""surface deposits"" = ""01"", + ""clastic sedimentary rock"" = ""02"", + ""clastic sedimentary rock"" = ""03"", + ""biological sedimentary rock"" = ""04"", + ""clastic sedimentary rock"" = ""08"", + ""biological sedimentary rock"" = ""09"", + ""biological sedimentary rock"" = ""10"", + ""chemical sedimentary rock"" = ""11"", + ""chemical sedimentary rock"" = ""12"", + ""magmatic rock"" = ""13"", + ""magmatic rock"" = ""14"", + ""chemical sedimentary rock"" = ""15"", + ""biological sedimentary rock"" = ""16"", + ""biological sedimentary rock"" = ""17"", + ""chemical sedimentary rock"" = ""18"", + ""clastic sedimentary rock"" = ""19"", + ""magmatic rock"" = ""20"", + ""magmatic rock"" = ""22"", + ""magmatic rock"" = ""23"", + ""magmatic rock"" = ""24"" + )) + + + # Soil + + pred_grid$soil <- + soil %>% + raster::extract(pred_grid) + + soil_legend <- as_tibble(GSIF::soil.legends$TAXNWRB) + + pred_grid %<>% + left_join(soil_legend, by = c(""soil"" = ""Number"")) %>% + dplyr::select(-one_of(""Shortened_name"", ""Group"", ""COLOR"", ""soil"")) %>% + dplyr::rename(soil = Generic) %>% + mutate(soil = as.factor(soil)) + + pred_grid %<>% + mutate(soil = fct_recode(soil, + ""soils with limitations to root growth"" = ""Leptosols"", + ""soils with limitations to root growth"" = ""Cryosols"", + ""soils with limitations to root growth"" = ""Vertisols"", + ""soils with limitations to root growth"" = ""Solonetz"", + ""soils with limitations to root growth"" = ""Solonchaks"", + ""soils with clay-enriched subsoil"" = ""Luvisols"", + ""soils with clay-enriched subsoil"" = ""Lixisols"", + ""soils with clay-enriched subsoil"" = ""Acrisols"", + # ""soils with clay-enriched subsoil"" = ""Retisols"", + ""soils with clay-enriched subsoil"" = ""Alisols"", + ""organic soil"" = ""Histosols"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Kastanozems"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Chernozems"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Phaeozems"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Umbrisols"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Gypsisols"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Durisols"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Calcisols"", + ""soils distinguished by Fe/Al chemistry"" = ""Gleysols"", + ""soils distinguished by Fe/Al chemistry"" = ""Podzols"", + ""soils distinguished by Fe/Al chemistry"" = ""Plinthosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Planosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Nitisols"", + ""soils distinguished by Fe/Al chemistry"" = ""Andosols"", + ""soils with little or no profile differentiation"" = ""Fluvisols"", + ""soils with little or no profile differentiation"" = ""Cambisols"", + ""soils with little or no profile differentiation"" = ""Arenosols"", + ""soils with little or no profile differentiation"" = ""Regosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Ferralsols"", + ""soils distinguished by Fe/Al chemistry"" = ""Stagnosols"" + )) + + # Hail + + pred_grid$hail_probability <- + hail %>% + raster::extract(pred_grid) + + # Elevation + + pred_grid$elevation <- + elevation %>% + raster::extract(pred_grid) + + # ph + + pred_grid$ph <- + ph %>% + raster::extract(pred_grid) + + #' Make prediction data.frame + + pred_grid %<>% + st_set_geometry(NULL) + pred_grid$x <- NULL + pred_grid$y <- NULL + pred_grid$index_1 <- NULL + + if (!is.null(dummy_features)) { + pred_grid %<>% createDummyFeatures( + # target = ""heterobasidion"", + cols = dummy_features + ) + } + + pred_grid %<>% + na.omit() + + if (!is.null(drop_var)) { + pred_grid %<>% + dplyr::select(-!!drop_var) + } + + return(pred_grid) +} + +#' @title Impute age values of trees +#' +#' @param data [data.frame] containing a variable named ""age"" +age_imp_preprocessing = function(data) { + data %<>% + filter(!is.na(age)) + + # We trimmed age > 40 to reduce influence of outliers. + + data %<>% + mutate(age = as.numeric(levels(age)[age])) %>% + mutate(age = replace(age, age > 40, 40)) + + res <- test_age_imputation(data$x, data$y, data$age) + summary(res) + + # qplot(res$obs, res$imput) + geom_abline() + hrbrthemes::theme_ipsum_rc() + # cor(res$obs, res$imput, use = ""complete"") + + data$age <- age_imputation(data$x, data$y, + data$age, print = TRUE) + return(data) +} + +#' @title Download hail data +#' @template url +hail_download = function(url) { + + dir_create(""data/hail"") + + if (!file.exists(""data/hail/hail.tif"")) { + curl_download(path, + destfile = ""data/hail/hail.tif"", quiet = FALSE) + } + + hail <- raster(""data/hail/hail.tif"") + + return(hail) + +} + +#' @title Preprocessing of precipitation data +#' @param atlas_climatico Preprocessed Atlas Climatico data +precipitation_preprocessing = function(atlas_climatico) { + + # Atlas climatico is a prerequisite for the following task + # However we do not want to do run it every time + # by specifying it as an unused argument we trigger is as a drake dependency + + # ## Precipitation + # + # Raw data: Precipitation rasters for month july and august in `.tif`´format in CRS 32630. + # + # Workflow: Get files by pattern and stack files. + # Add precipitation of month july and august and write raster to disk. + # Extract precipitation at each observation. + # + # Modified data: Total july and august precipitation raster in `.tif` format in CRS 32630. + + precip = list.files(""data/atlas-climatico/unzip"", + ""pluvio.*(julio|agosto|septiembre)_av.tif$"", + full.names = TRUE + ) %>% + stack() %>% + calc(function(x) { + sum(x) / 10 + }) + + return(precip) +} + +#' @title Preprocessing of PISR data +#' @param atlas_climatico Preprocessed Atlas Climatico data +pisr_preprocessing = function(atlas_climatico) { + + # Atlas climatico is a prerequisite for the following task + # However we do not want to do run it every time + # by specifying it as an unused argument we trigger is as a drake dependency) + + # ## PISR + # + # Raw data: PISR rasters for month july to september in `.tif`´format in CRS 32630. + # + # Workflow: Get files by pattern and stack files. + # Add pisr of july to september and convert to the relative fraction of its mean (mean = 8065.952 kW/m^2). + # Write raster to disk and extract pisr at each observation. + # + # Modified data: PISR raster in `.tif` format in CRS 32630. + # + + + psir_sum_raster <- + list.files(""data/atlas-climatico/unzip"", + ""radiacion.*(julio|agosto|septiembre)_av.tif$"", + full.names = TRUE + ) %>% + stack() %>% + sum() + + psir_sum_raster %<>% + calc(function(x) { + x / cellStats(psir_sum_raster, stat = mean, na.rm = TRUE) - 1 + }) + + return(psir_sum_raster) +} + +#' @title Preprocessing of temperature data +#' @param atlas_climatico Preprocessed Atlas Climatico data +temperature_preprocessing = function(atlas_climatico) { + + # Atlas climatico is a prerequisite for the following task + # However we do not want to do run it every time + # by specifying it as an unused argument we trigger is as a drake dependency + + # ## Temperature + # + # Raw data: Temperature rasters for month march to september in `.tif`´format in CRS 32630. + # + # Workflow: Get files by pattern and stack files. + # Calculate mean temperature of month march to september and write raster to disk. + # Extract mean summer temperature at each observation. + # + # Modified data: Mean summer temperature raster in `.tif` format in CRS 32630. + + temperature_mean = list.files(""data/atlas-climatico/unzip"", + ""termo.*(marzo|abril|mayo|junio|julio|agosto|septiembre)_av.tif$"", + full.names = TRUE + ) %>% + stack() %>% + calc(function(x) { + mean(x) / 10 + }) + + return(temperature_mean) +} + +#' @title Download Atlas Climatico data +#' @template url +atlas_climatico_download = function(url) { + + dir_create(""data/atlas-climatico"") + + if (!file.exists(""data/atlas-climatico/mn_de.zip"")) { + curl_download(path, + destfile = glue(tempdir(), ""/atlas-climatico.zip""), quiet = FALSE) + unzip(glue(tempdir(), ""/atlas-climatico.zip""), exdir = ""data/atlas-climatico"") + } + + files = c(""^mt.*_av.zip$"", ""^rad.*_av.zip$"", ""^pl.*_av.zip$"") %>% # , ""^rad.*_av.zip$"", ""^pl.*_av.zip$"" + map(function(x) list.files( + path = ""data/atlas-climatico"", + pattern = x, + full.names = TRUE + )) + + return(files) + +} + +#' @title Preprocessing of Atlas Climatico data +#' @param data Downloaded Atlas Climatico data +atlas_climatico_preprocessing = function(data, + study_area) { + + # ## Atlas Climatico + # + # Raw data: Zipped raster files of temperature, pisr and precipitation in `.txt` format in CRS 23030. + # + # Workflow: Unzip files specified by pattern. + # Remove unused `.gif` and `.htm` files. + # Reproject study area to CRS 23030 to crop and mask raster files. + # Reproject raster files to CRS 32630. + # Write raster files to disk. + # Remove unused `.txt` files + # + # Mod data: Temperature, pisr and precipitation rasters in `.tif` format in CRS 32630 for each month. + # + + data %>% + unlist() %>% + walk(unzip, exdir = ""data/atlas-climatico/unzip"") + + list.files(""data/atlas-climatico/unzip"", + pattern = ""*.(gif|htm)$"", + full.names = TRUE + ) %>% + walk(file.remove) + + study_area_23030 <- + study_area %>% + st_transform(23030) %>% + as(""Spatial"") + + txt_files <- list.files(""data/atlas-climatico/unzip"", + pattern = "".txt$"", + full.names = TRUE + ) + + file_names <- map(txt_files, function(x) sub(""txt"", x, replacement = ""tif"")) %>% + unlist() + + out = map(txt_files, raster, crs = CRS(""+init=epsg:23030"")) %>% + map(crop, y = study_area_23030) %>% + map(mask, mask = study_area_23030) %>% + map(projectRaster, crs = CRS(""+init=epsg:32630"")) %>% + walk2(file_names, writeRaster, overwrite = TRUE) + + return(out) + +} + +#' @title Download lithology data +#' @template url +lithology_download = function(url) { + + dir_create(""data/lithology"") + + if (!file.exists(""data/lithology/CT_LITOLOGICO_25000_ETRS89.shp"")) { + curl_download(url, + destfile = glue(tempdir(), ""/lithology.zip""), quiet = FALSE) + unzip(glue(tempdir(), ""/lithology.zip""), exdir = ""data/lithology"") + } + + lithology = st_read(""data/lithology/CT_LITOLOGICO_25000_ETRS89.shp"", quiet = TRUE) %>% + st_set_crs(25830) %>% + st_transform(32630) %>% + dplyr::select(COD_LITOLO) + + return(lithology) + +} + +#' @title Preprocessing of lithology data +#' @param data Downloaded lithology data +lithology_preprocessing = function(data) { + + # Raw data: Polygon shapefile with lithology units in CRS 25830. + # + # Workflow: Read shapefile and reproject to CRS 32630. + # Extract column with lithology unit id. + # Make lithology sf object valid and extract at each observation the lithology unit id. + # Aggregate lithology units to common lithology classes. + # + # Output: Aggregated lithology units. + # + # + # curl_download(path, + # destfile = glue(tempdir(), ""/lithology.zip""), quiet = FALSE) + # unzip(glue(tempdir(), ""/lithology.zip""), exdir = glue(tempdir(), ""/lithology"")) + # + # st_read(glue(tempdir(), ""/lithology/CT_LITOLOGICO_25000_ETRS89.shp""), quiet = TRUE) %>% + # st_set_crs(25830) %>% + # st_transform(32630) %>% + # dplyr::select(COD_LITOLO) -> lithology_sp + + data %<>% + st_make_valid() %>% + st_cast(""POLYGON"") + + return(data) + +} + +#' @title Preprocessing of elevation data +#' @param data Downloaded elevation data +elevation_preprocessing = function(data) { + + # Raw data: Zipped 5m lidar DEM in CRS 3042 in `.tif` format. + # + # Workflow: Reprojection on CRS 32630. Extraction of the elevation values for each observation. + # + # Mod data: DEM with 5m resolution in `.tif` format in CRS 32630. + + dem = raster(data) %>% + projectRaster(crs = CRS(""+init=epsg:32630""), method = ""bilinear"") %>% + writeRaster(""data/dem/dem.tif"", overwrite = TRUE) + + return(dem) +} + +#' @title Preprocessing of pH data +#' @param data Downloaded pH data +ph_preprocessing = function(data, + study_area) { + + data = new(""GDALReadOnlyDataset"", data) %>% + asSGDF_GROD() %>% + raster() + + crs(data) <- CRS(""+init=epsg:3035"") + + study_area_3035 <- + study_area %>% + st_transform(3035) %>% + as(""Spatial"") + + data %<>% + crop(study_area_3035) %>% + mask(study_area_3035) %>% + projectRaster(crs = CRS(""+init=epsg:32630""), method = ""bilinear"") %>% + writeRaster(""data/ph/ph.tif"", overwrite = TRUE) + + return(data) +} + +#' @title Download soil data +#' @template url +soil_download = function(url) { + + dir_create(""data/soil"") + + curl_download(url, + destfile = ""data/soil/soil.tif"", quiet = FALSE) + + soil = raster(""data/soil/soil.tif"") + + return(soil) +} + +#' @title Preprocessing of soil data +#' @param data Downloaded soil data +#' @param study_area Geopackage of study area +soil_preprocessing = function(data, study_area) { + + # ## Soil + # + # Raw data: Soil raster with 250m resolution in `.tif`format in CRS 4326 (Hengl 2017, http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0169748). + # + # Workflow: Reproject study area to CRS 4326. + # Crop soil raster with study area and reproject to CRS 23030. + # Extraction of the soil value for each record. + # Left join with soil database from GSIF package to get actual soil name. + # Remove unused columns and factor soil name. + # + # Output: Soil raster with 250 m resolution in `.tif` format in CRS 23030. + # + + study_area_4326 <- + study_area %>% + st_transform(4326) %>% + as(""Spatial"") + + soil_ras = data %>% + crop(study_area_4326) %>% + mask(study_area_4326) %>% + projectRaster(crs = CRS(""+init=epsg:32630""), method = ""ngb"") + + return(soil_ras) + +} + +#' @title Download DEM +#' @template url +dem_download = function(url) { + + dir_create(""data/dem"") + + if (!file.exists(""data/dem/mdt_2013_5m.tif"")) { + curl_download(url, + destfile = glue(tempdir(), ""/dem.zip""), quiet = FALSE) + unzip(glue(tempdir(), ""/dem.zip""), exdir = ""data/dem"") + } + + dem = raster(""data/dem/mdt_2013_5m.tif"") # just to detect errors + dem = ""data/dem/mdt_2013_5m.tif"" + + return(dem) + +} + +#' @title Preprocessing of slope data +#' @param data Downloaded DEM data +slope_processing = function(data) { + + # ## Slope + # + # Raw data: Reprojected DEM with 5m resolution in `.tif` format in CRS 32630. + # + # Workflow: Calculation of the slope with the RSAGA package. + # Conversion of the resulting `.sgrd` to `.tif`. + # Extraction of the slope values for each record. + # + # Mod data: Slope raster in degrees with 5m resolution in `.tif` format in CRS 32630. + # + dir_create(""data/slope"") + + env = rsaga.env() + + rsaga.slope.asp.curv( + in.dem = ""data/dem/mdt_2013_5m.tif"", + out.slope = glue(tempdir(), ""/slope_5m""), + unit.slope = ""degrees"", env = env + ) + + rsaga.geoprocessor( + lib = ""io_gdal"", module = 2, env = env, + param = list( + GRIDS = glue(tempdir(), ""/slope_5m.sgrd""), + FILE = ""data/slope/slope_5m.tif"" + ) + ) + + slope = raster(""data/slope/slope_5m.tif"") + + return(slope) + +} + +#' @title Modification of raw data +#' @param data Raw input data +#' @param drop_vars Variable to remove from the data +#' @param response Variable that will be the response of the task later +#' +#' @details The following modifications are handled in this function: +#' - Transformation of variable names to lowercase +#' - Wiggling of coordinates so that they are ""unique"" in a spatial sense +#' - Custom replacement of specific variables using expert knowledge +#' - Removal of points with no coordinate information +#' - Filtering of observations to a certain tree species +mod_raw_data = function(data, drop_vars, response) { + + +### Reason why the data is already transformed: We had to map variable ph to the +### data because we were not allowed to put the raw data on Zenodo due to +### license issues. To conduct a proper `raster::extract` call we transformed +### the data already. + # data %<>% + # st_transform(32630) + + ## Change column names to lowercase + colnames(data) <- + data %>% + colnames() %>% + tolower() + + # ## Wiggle coordinates + # Some coordinates are not unique, so we have to wiggle them a little bit + # + # + if (response == ""diplo01"" | response == ""fus01"") { + set.seed(1234) + data$x <- data$x + rnorm(nrow(data)) / 10 + data$y <- data$y + rnorm(nrow(data)) / 10 + } + + if (!is.null(drop_vars)) { + # drop second response + data %<>% + dplyr::select(-!!drop_vars) + } + + if (response == ""diplo01"") { + + # Process `year` variable to end up with only years. + + # The two missing entries we added for observation `785` and `836` are + # based on statements from the person who collected the data. + + data %<>% + mutate(year = fct_recode(date, ""NA"" = ""-"", + ""NA"" = """")) + + data$year %<>% + str_replace_all(""-"",""/"") %>% + str_extract_all('\\d+') %>% + vapply(function(x) paste(x[3], collapse = '/'), character(1)) + + data %<>% + mutate(year = replace(year, id == 785, 2009)) %>% + mutate(year = replace(year, id == 836, 2009)) + + # We only analyze tree type ""Pinus radiata"" in this work. + data %<>% + filter(host == ""Pinus radiata"") + + } + + # drop points with no coordinate information + data = data[!st_is_empty(data), ] + + return(data) +} + +#' @title Extract variables to in-situ data +#' @param data Input [data.frame] containing in-situ points. Here a Geopackage +#' file downloaded directly from Zenodo. +#' @param temperature Temperature data (mean) +#' @param precipitation Precipitation data (sum) +#' @param pisr Potential incoming solar radiation (as a fraction of its mean) +#' @param slope Slope (in degrees) +#' @param elevation Elevation in meters +#' @param soil Soil type +#' @param lithology Lithology type +#' @param hail Probability of hail damage at trees +#' @param ph pH value of soil +#' @param study_area study area +#' @param response Name of the response variable +#' @param drop_vars A vector of variables to drop +#' @param age (logical) Whether ""age imputation"" should be performed +#' @param remove_pred Remove variables right before returning the data. +#' +#' @details This function extract all variables to the data points. +#' Variables ""temperature"", ""precipitation"" and ""pisr"" already existed in the +#' dataset and were not extracted to the points. +#' `remove_pred` is used to debug rectangular artifacts in the prediction maps +#' (by fittign a model without variable X, we check which variables causes the +#' trouble) +#' +#' @seealso [extract_variables_v2] +extract_variables <- function(data, temperature, precipitation, pisr, slope, + elevation, soil, lithology, hail, ph, study_area, + response, drop_vars = NULL, age = FALSE, + remove_pred = NULL) { + + data_in = st_read(data, quiet = TRUE) + + data_in = mod_raw_data(data_in, drop_vars = drop_vars, response = response) + + # Elevation + + data_in$elevation <- + elevation %>% + raster::extract(data_in) + + # Slope + + data_in$slope_degrees <- + slope %>% + raster::extract(data_in) + + # Soil + + data_in$soil <- + soil %>% + raster::extract(data_in) + + # data(""soil.legends"") + soil_legend <- as_tibble(GSIF::soil.legends$TAXNWRB) + + data_in %<>% + left_join(soil_legend, by = c(""soil"" = ""Number"")) %>% + dplyr::select(-one_of(""Shortened_name"", ""Group"", ""COLOR"", ""soil"")) %>% + dplyr::rename(soil = Generic) %>% + mutate(soil = as.factor(soil)) + + data_in %<>% + mutate(soil = fct_recode(soil, + ""soils with limitations to root growth"" = ""Leptosols"", + ""soils with limitations to root growth"" = ""Cryosols"", + ""soils with limitations to root growth"" = ""Vertisols"", + ""soils with clay-enriched subsoil"" = ""Luvisols"", + ""soils with clay-enriched subsoil"" = ""Lixisols"", + ""soils with clay-enriched subsoil"" = ""Acrisols"", + ""organic soil"" = ""Histosols"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Kastanozems"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Chernozems"", + ""pronounced accumulation of organic matter in the mineral topsoil"" = ""Phaeozems"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Gypsisols"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Durisols"", + ""accumulation of moderately soluble salts or non-saline substances"" = ""Calcisols"", + ""soils distinguished by Fe/Al chemistry"" = ""Gleysols"", + ""soils distinguished by Fe/Al chemistry"" = ""Podzols"", + ""soils distinguished by Fe/Al chemistry"" = ""Plinthosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Planosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Nitisols"", + ""soils with little or no profile differentiation"" = ""Fluvisols"", + ""soils with little or no profile differentiation"" = ""Cambisols"", + ""soils with little or no profile differentiation"" = ""Arenosols"", + ""soils with little or no profile differentiation"" = ""Regosols"", + ""soils distinguished by Fe/Al chemistry"" = ""Ferralsols"" + )) + + # ph + ### Reason why ph is not extracted from the raw data: We were not allowed to + ### put the raw data on Zenodo due to license issues. + + # data_in$ph <- + # ph %>% + # raster::extract(data_in) + + # Lithology + + data_in %<>% st_join(lithology) + + data_in %<>% + dplyr::rename(lithology = COD_LITOLO) %>% + mutate(lithology = as.factor(lithology)) %>% + mutate(lithology = fct_recode(lithology, + ""surface deposits"" = ""01"", + ""clastic sedimentary rock"" = ""02"", + ""clastic sedimentary rock"" = ""03"", + ""biological sedimentary rock"" = ""04"", + ""clastic sedimentary rock"" = ""08"", + ""biological sedimentary rock"" = ""09"", + ""biological sedimentary rock"" = ""10"", + ""chemical sedimentary rock"" = ""11"", + ""chemical sedimentary rock"" = ""12"", + ""magmatic rock"" = ""13"", + ""magmatic rock"" = ""14"", + ""chemical sedimentary rock"" = ""15"", + ""biological sedimentary rock"" = ""16"", + ""biological sedimentary rock"" = ""17"", + ""chemical sedimentary rock"" = ""18"", + ""clastic sedimentary rock"" = ""19"", + ""magmatic rock"" = ""20"", + ""magmatic rock"" = ""22"", + ""magmatic rock"" = ""23"", + ""magmatic rock"" = ""24"" + )) + + + # Hail + + data_in$hail_probability <- + hail %>% + raster::extract(data_in) + + if (response == ""heterobasi"" | response == ""armillaria"") { + data_in$temp <- + temperature %>% + raster::extract(data_in) + } else { + + # the geom column needs to be removed, otherwise `rowMeans()` will faill + st_geometry(data_in) = NULL + # temperature is already in the dataset + data_in %>% + dplyr::select(ttmarav, ttabrav, ttmayav, ttjunav, ttjulav, ttagoav, ttsepav) %>% + dplyr::mutate_if(is.integer, as.numeric) %>% + rowMeans() %>% + divide_by(10) -> data_in$temp + } + + if (response == ""heterobasi"" | response == ""armillaria"") { + data_in$pisr <- + pisr %>% + raster::extract(data_in) + } else { + + # PISR is already in the dataset + data_in %>% + dplyr::select(rjulav, ragoav, rsepav) %>% + rowSums %>% + divide_by(mean(.)) - 1 -> data_in$pisr + } + + if (response == ""heterobasi"" | response == ""armillaria"") { + data_in$precip <- + precipitation %>% + raster::extract(data_in) + } else { + + # precip is already in the dataset + data_in %>% + dplyr::select(pjuliav, pagosav, pseptav) %>% + dplyr::mutate_if(is.integer, as.numeric) %>% + rowSums() %>% + divide_by(10) -> data_in$precip + } + + + # Age + + if (isTRUE(age)) { + data_in = age_imp_preprocessing(data = data_in) + } + + # year + if (""date"" %in% colnames(data_in)) { + # The two missing entries we added for observation `785` and `836` are based on statements from the person who collected the data. + + data_in %<>% + mutate(year = fct_recode(date, ""NA"" = ""-"", + ""NA"" = """")) + + data_in$year %<>% + str_replace_all(""-"",""/"") %>% + str_extract_all('\\d+') %>% + vapply(function(x) paste(x[3], collapse = '/'), character(1)) + + data_in %<>% + mutate(year = replace(year, id == 785, 2009)) %>% + mutate(year = replace(year, id == 836, 2009)) %>% + mutate(year = as.factor(year)) + + } + + # select vars + if (all(c(""year"", ""age"") %in% colnames(data_in))) { + data_in %<>% + dplyr::select(!!response, temp, precip, + hail_probability, ph, soil, + lithology, slope_degrees, pisr, + x, y, year, age) + } else { + data_in %<>% + dplyr::select(!!response, temp, precip, + hail_probability, ph, soil, + lithology, slope_degrees, pisr, + x, y) + } + # Remove NAs + + # # Remove samples with NAs + # Examine datasets for missing values. Remove sample 12 from heterobasi data set because lithology is missing + # and remove sample 11, 13, 14, 15, 22, 23, 25, 26, 27 and 28 from armillaria data set because elevation and/or lithology is missing. + + data_in %<>% + na.omit() %>% + as.data.frame() %>% + droplevels() + + # target as factor + # https://stackoverflow.com/questions/49942453/piping-dplyr-mutate-with-unknown-variable-name?noredirect=1&lq=1 + # # sollte eigentlich funktionieren, aber klappt manchmal iwie einfach nicht. + # vllt NSE != drake, aber alles unklar. Kostet zu viel Zeit um es zum laufen zu kriegen + # daher der ""unschöne"" if() workaround + # data_in %<>% + # mutate(!!quo_name(as.name(response)) := as.factor(!!as.name(response))) + + if (response == ""armillaria"") { + data_in$armillaria = as.factor(as.character(data_in$armillaria)) + } else if (response == ""heterobasi"") { + data_in$heterobasi = as.factor(as.character(data_in$heterobasi)) + } else if (response == ""diplo01"") { + data_in$diplo01 = as.factor(as.character(data_in$diplo01)) + } else if (response == ""fus01"") { + data_in$fus01 = as.factor(as.character(data_in$fus01)) + } + + # optional remove certain features + # Reason: Debugging artifacts in prediction maps + if (!is.null(remove_pred)) { + data_in[[remove_pred]] = NULL + } + + return(data_in) +} + +","R" +"Pathogens","pat-s/pathogen-modeling","R/prediction-functions.R",".R","7483","209","#' @title Predict infection state of pathogens +#' @param ... mlr task objects +#' @template learner +#' @template param_set +#' @template tune_ctrl +#' @template resampling +#' @param prediction_data List of prediction data.frame(s) +#' @param prediction_grid Raster Grid to which the prediction should be mapped to +#' @param desc_resampling Resampling description +#' +#' @details `prediction_data` is a list of Tasks. If the learner ID has a +#' pathogen in its name, e.g. GAM has, then the prediction will only be done +#' for this task. Otherwise, prediction will be done for all supplied tasks. + +prediction_custom <- function(..., learner, param_set, tune_ctrl, resampling, + prediction_data, prediction_grid, + desc_resampling) { + configureMlr(on.learner.error = ""warn"", on.error.dump = TRUE) + + # browser() + # # check if a supplied learner has one of the following keywords in its name + # # if yes, we need to subset `tasks_pred` to the specific task + # if (any(map_lgl(c(""diplodia"", ""fusarium"", ""armillaria"", ""heterobasidion""), ~ + # grepl(.x, deparse(substitute(learner)))))) { + # str_deparse(substitute(lrn_gam_fusarium_pred)) + # + # # subset the specific task + # tasks = list(tasks_pred[[which(map_lgl(c(""diplodia"", ""fusarium"", ""armillaria"", ""heterobasidion""), ~ + # grepl(.x, deparse(substitute(learner)))))]]) + # } else { + # tasks = list(...) + # } + tasks <- list(...) + + # unlist if a list of multiple tasks was supplied + if (any(class(tasks[[1]][[1]]) %in% ""Task"")) { + tasks <- unlist(tasks, recursive = FALSE) + } + + # Tune all models --------------------------------------------------------- + + if (learner$id != ""classif.binomial"") { + learner_tuned <- map(tasks, ~ { + + # multicore mode does not work with dranke and mlrMBO + parallelStop() + # parallelStart( + # mode = ""socket"", level = ""mlrMBO.feval"", cpus = 30 + # ) + # parallelStartSocket(cpus = 30L) + set.seed(12345) + tuned <- tuneParams(learner, + task = .x, resampling = resampling, + par.set = param_set, control = tune_ctrl, + show.info = TRUE, measure = list(brier) + ) + # parallelStop() + return(tuned) + }) + } else { + learner_tuned <- learner + } + # Train all models --------------------------------------------------------- + + if (learner$id != ""classif.binomial"") { + learner_tuned %<>% imap(~ setHyperPars(learner, + par.vals = learner_tuned[[.y]]$x + )) + fit <- map2(learner_tuned, tasks, ~ train(.x, .y)) + } else { + fit <- map(tasks, ~ train(learner_tuned, .x)) + } + + # Create predictions --------------------------------------------------- + + fit <- map(fit, ~.x) + + # if (fit$learner.model == ""xgboost"") { + # fit <- fit[tasks[[1]]$learner.model$feature_names] + # } + + predictions <- map(fit, ~ predict(.x, newdata = prediction_data)) + + # this object contains the coordinates that we need to attach to the predictions + prediction_grid <- as(prediction_grid, ""SpatialPixelsDataFrame"") + prediction_grid <- st_as_sf(prediction_grid) + coords <- as.data.frame(st_coordinates(prediction_grid)) + colnames(coords) <- c(""x"", ""y"") + # we need to make sure that the rownames of `coords` mirror the ones from `df_basque ` + rownames(coords) <- rownames(prediction_grid) + rm(prediction_grid) + + # # Visualize all predictors + # + + rasters <- imap(predictions, ~ { + + # we join the predictions and coordinates based on the rownames of both objects + pred_xy_xg <- left_join(rownames_to_column(.x$data), + rownames_to_column(coords), + by = ""rowname"" + ) + + pred_xy_xg <- SpatialPixelsDataFrame( + points = pred_xy_xg[, c(""x"", ""y"")], + data = as.data.frame(pred_xy_xg[, ""prob.1""]), + proj4string = CRS(""+proj=utm +zone=30 +datum=WGS84 +units=m +no_defs"") + ) + names(pred_xy_xg) <- ""probability"" + + raster_xg <- projectRaster(raster(pred_xy_xg), + crs = ""+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs "" + ) + + dir_create(""data/prediction"") + dir_create(""data/prediction/raster"") + + if (desc_resampling == ""spatial/spatial"") { + desc_resampling <- ""sp_sp"" + } else if (desc_resampling == ""spatial/no tuning"") { + desc_resampling <- ""sp_non"" + } else if (desc_resampling == ""spatial/non-spatial"") { + desc_resampling <- ""sp_nsp"" + } else if (desc_resampling == ""non-spatial/non-spatial"") { + desc_resampling <- ""nsp_nsp"" + } else if (desc_resampling == ""non-spatial/no tuning"") { + desc_resampling <- ""nsp_non"" + } + + if (learner$id != ""classif.binomial"") { + # write out raster + writeRaster(raster_xg, glue(""data/prediction/raster/prediction-{.x$task.desc$id}-{learner_tuned[[.y]]$id}-{desc_resampling}.tif""), + overwrite = TRUE + ) + } else { + writeRaster(raster_xg, glue(""data/prediction/raster/prediction-{.x$task.desc$id}-{learner_tuned$id}-{desc_resampling}.tif""), + overwrite = TRUE + ) + } + return(raster_xg) + }) + rasters <- set_names(rasters, map_chr(tasks, ~ .x$task.desc$id)) + return(rasters) +} + +#' @title Create spatial maps from predicted data +#' @param prediction_raster List of predicted raster layers from +#' [prediction_custom]. +#' @param model_name Algorithm name +#' @param benchmark_object mlr benchmark object containing performance of all +#' tasks that are present in `prediction_raster` +#' @param Resampling String with the resampling description that should appear +#' on the map +create_prediction_map <- function(prediction_raster, model_name, benchmark_object, + resampling) { + if (resampling == ""spatial/spatial"") { + resampling_file <- ""sp_sp"" + } else if (resampling == ""spatial/no tuning"") { + resampling_file <- ""sp_non"" + } else if (resampling == ""spatial/non-spatial"") { + resampling_file <- ""sp_nsp"" + } else if (resampling == ""non-spatial/non-spatial"") { + resampling_file <- ""nsp_nsp"" + } else if (resampling == ""non-spatial/no tuning"") { + resampling_file <- ""nsp_non"" + } + + # account for missing armillaria object for xgboost + if (model_name == ""xgboost"") { + prediction_raster[[1]] <- NULL + } + + out_maps <- imap(prediction_raster, ~ { + + # set info fields for debugging models to NA + if (is.na(resampling)) { + score <- NA + } else { + score <- getBMRAggrPerformances(benchmark_object, as.df = TRUE) %>% + dplyr::filter(task.id == .y) %>% + dplyr::select(brier.test.mean) %>% + pull() + } + + plot <- ggplot() + + annotation_map_tile(zoomin = -1, type = ""cartolight"", progress = ""none"") + + layer_spatial(.x, aes(fill = stat(band1))) + + # scale_alpha_continuous(na.value = 0) + + scale_fill_viridis_c(na.value = NA, name = ""Probability of\n infection"", + limits = c(0, 1)) + + # spatial-aware automagic scale bar + annotation_scale(location = ""tl"") + + # spatial-aware automagic north arrow + annotation_north_arrow(location = ""br"", which_north = ""true"") + + theme_pubr(legend = ""right"") + + theme( + legend.key.size = unit(2, ""line""), + plot.margin = margin(1.5, 0, 1, 0) + ) + + labs(caption = glue( + ""Pathogen: {tools::toTitleCase(.y)}, Algorithm: {toupper(model_name)},"", + "" Spatial resolution: 200 m + Performance: {round(score, 4)} (Brier), Resampling: {resampling}"" + )) + + return(plot) + }) +} +","R" +"Pathogens","pat-s/pathogen-modeling","R/helper-functions.R",".R","3206","100","##### my.pairs env +the.col.hist <- ""cyan"" + + +panel.hist <- function(x, col.hist=the.col.hist, + cex.cor=NULL,digits=NULL,col=NULL,pch=NULL,cex=NULL,...) +{ + dummy <- is.character(cex.cor) | is.numeric(digits) | is.character(cex) | is.character(pch) | is.character(col) + usr <- par(""usr""); on.exit(par(usr)) + par(usr = c(usr[1:2], 0, 1.5) ) + h <- hist(x, plot = FALSE) + breaks <- h$breaks; nB <- length(breaks) + y <- h$counts; y <- y/max(y) + rect(breaks[-nB], 0, breaks[-1], y, col=col.hist, ...) +} + +panel.cor <- function(x, y, digits=2, prefix="""", cex.cor=NULL, + col.hist=NULL, + col=NULL,pch=NULL,cex=NULL,...) +{ + dummy <- is.character(col.hist) | is.character(cex) | is.character(pch) | is.character(col) + usr <- par(""usr""); on.exit(par(usr)) + par(usr = c(0, 1, 0, 1)) + r <- abs(cor(x, y, use=""pairwise.complete.obs"")) + txt <- format(c(r, 0.123456789), digits=digits)[1] + txt <- paste(prefix, txt, sep="""") + if (is.null(cex.cor)) cex.cor <- 0.8/strwidth(txt) + #text(0.5, 0.5, txt, cex = cex.cor * r) + text(0.5, 0.5, txt, cex = cex.cor) +} + +my_pairs <- function( x, ... ) +{ + pairs( x, ..., + upper.panel=panel.smooth, lower.panel=panel.cor, diag.panel=panel.hist ) +} + +#' @title Imputation of age values +#' @param x X coordinate +#' @param y Y coordinate +#' @param age Age value +#' +#' @details This function imputes age values of trees assuming that a tree is +#' very likely to have the same age as the tree it is surrounded by. +age_imputation <- function(x, y, age, print = TRUE) { + wh <- which(is.na(age)) + N.na <- length(wh) + set.seed(1234) + for (i in wh) { + di <- sqrt((x - x[i])^2 + (y - y[i])^2) + wh.nn <- which(di < 50 & !is.na(age)) + if (length(wh.nn) < 5) + wh.nn <- which(di < 100 & !is.na(age)) + if (length(wh.nn) < 5) + wh.nn <- which(di < 200 & !is.na(age)) + if (length(wh.nn) < 5) + wh.nn <- which(di < 300 & !is.na(age)) + if (length(wh.nn) < 5) + wh.nn <- which(di < 400 & !is.na(age)) + if (length(wh.nn) > 0) + age[i] = sample( age[wh.nn], size=1 ) + age[i] <- median(age[wh.nn]) + } + if (print) cat(""\nImputed"", N.na - sum(is.na(age)), ""age values.\n\n"") + return(age) +} + +test_age_imputation <- function(x, y, age) { + sel <- !is.na(age) + x <- x[sel] + y <- y[sel] + age <- age[sel] + res <- rep(NA, length(age)) + for (i in 1:length(res)) { + temp.age <- age + temp.age[i] <- NA + temp.age <- age_imputation(x, y, temp.age, print=FALSE) + res[i] <- temp.age[i] + } + return(data.frame(obs = age,imput = res)) +} + +#' @title remove_extract +#' @description Removes the extract column of a `mlr` BenchmarkResult object +#' @param bm_result BenchmarkResult object +#' +#' @details Typically, tuning results are stored in this slot. Combining many benchmark +#' results can lead to a huge object. For visualizing the performance, the +#' object can be shrinked with this function. +remove_extract = function(bm_result) { + + bm_result[[""results""]] = map(bm_result[[""results""]], ~ + { + map(.x, function(y) list_modify(y, extract = NULL)) + }) + + return(bm_result) +} + +","R" +"Pathogens","pat-s/pathogen-modeling","R/benchmark-functions.R",".R","1101","48","#' @title mlr::benchmark() wrapper +#' +#' @template task +#' @template learner +#' @template resampling +#' @export + +benchmark_custom_no_extract_no_pred_no_models <- function(task, learner, resampling) { + + set.seed(12345, ""L'Ecuyer-CMRG"") + + bmr <- benchmark(learner, task, + models = FALSE, + keep.pred = TRUE, + keep.extract = FALSE, + resampling = resampling, + show.info = TRUE, + measures = list(brier, timetrain) + ) + + parallelStop() + return(bmr) +} + +#' @title mlr::benchmark() wrapper +#' +#' @template task +#' @template learner +#' @template resampling +#' @export + +benchmark_custom_no_pred_no_models <- function(task, learner, resampling) { + + set.seed(12345, ""L'Ecuyer-CMRG"") + + bmr <- benchmark(learner, task, + models = FALSE, + keep.pred = TRUE, + keep.extract = TRUE, + resampling = resampling, + show.info = TRUE, + measures = list(brier, timetrain) + ) + + parallelStop() + return(bmr) +} +","R" +"Pathogens","pat-s/pathogen-modeling","R/mlr-functions.R",".R","1222","40","#' @title mlr tuning wrapper +#' @template learner +#' @template param_set +#' @template resampling +#' @template tune_ctrl +tuning_wrapper_custom <- function(lrn, param_set, resampling, tune_ctrl) { + + wrapper <- makeTuneWrapper( + lrn, + resampling = resampling, par.set = param_set, + control = tune_ctrl, show.info = FALSE, + measures = list(brier) + ) + return(wrapper) +} + +#' @title mlrMBO 30n 20 iterations tuning setting +#' @template param_set +tune_ctrl_mbo_30n_20it = function(param_set) { + makeTuneControlMBO( + mbo.control = makeMBOControl(propose.points = 1L, + on.surrogate.error = ""warn"") %>% + setMBOControlTermination(iters = 20L) %>% + setMBOControlInfill(crit = crit.ei), + mbo.design = generateDesign(n = 30, par.set = param_set) + ) +} + +#' @title mlrMBO 30n 70 iterations tuning setting +#' @template param_set +tune_ctrl_mbo_30n_70it = function(param_set) { + makeTuneControlMBO( + mbo.control = makeMBOControl(propose.points = 1L, + on.surrogate.error = ""warn"") %>% + setMBOControlTermination(iters = 70L) %>% + setMBOControlInfill(crit = crit.ei), + mbo.design = generateDesign(n = 30, par.set = param_set) + ) +} +","R" +"Pathogens","pat-s/pathogen-modeling","R/visualization.R",".R","7551","207","#' @title Visualization of partitions used in benchmarking +#' @param resampling_sp A benchmark/resampling object with a spatial resampling +#' @param resampling_nsp A benchmark/resampling object with a non-spatial resampling + +vis_partitions = function(data, resampling_sp, resampling_nsp) { + coordinates <- data[, c(""x"", ""y"")] + data$geometry <- NULL + data$x = NULL + data$y = NULL + + + task_spatial <- makeClassifTask(id = ""pathogen_data"", data = data, + target = ""diplo01"", positive = ""1"", + coordinates = coordinates) + + plist <- createSpatialResamplingPlots(task_spatial, list(""CV"" = resampling_nsp$results$diplodia$classif.binomial, + ""SpCV"" = resampling_sp$results$diplodia$classif.binomial), + crs = 32630, repetitions = 1, point.size = 1.5, + y.axis.breaks = c(42.8, 43.2), + x.axis.breaks = c(-2, -3), + axis.text.size = 18) + + sp <- plot_grid(plist[[""Plots""]][[1]], plist[[""Plots""]][[2]], + plist[[""Plots""]][[3]], ncol = 3, nrow = 1, + labels = plist[[""Labels""]][1:3], label_size = 18) + sp2 <- plot_grid(plist[[""Plots""]][[4]], plist[[""Plots""]][[5]], NULL, + ncol = 3, nrow = 1, labels = plist[[""Labels""]][4:5], + label_size = 18) + + nsp <- plot_grid(plist[[""Plots""]][[6]], plist[[""Plots""]][[7]], + plist[[""Plots""]][[8]], ncol = 3, nrow = 1, + labels = plist[[""Labels""]][6:8], + label_size = 18) + nsp2 <- plot_grid(plist[[""Plots""]][[9]], plist[[""Plots""]][[10]], NULL, + ncol = 3, nrow = 1, labels = plist[[""Labels""]][9:10], + label_size = 18) + + final_plot <- plot_grid(sp, sp2, nsp, nsp2, ncol = 1) + + return(final_plot) + +} + +#' @title Visualization of optimization paths +#' @param models List of Benchmark/Resample results +#' @param n_folds Number of folds to visualize (e.g. 1-5) +vis_opt_path = function(models) { + + opt_path_list = map(models, function(.i) + imap( + .i$extract[1:5], + ~getOptPathY(.x$opt.path) %>% + as_tibble() %>% + mutate(iter = 1:length(value)) %>% + mutate(value = cummin(value)) %>% + mutate(fold_id = glue(""Fold {.y}"")) + ) %>% + bind_rows() + ) + + opt_path_plot = imap(opt_path_list, ~ + ggline(.x, + x = ""iter"", + y = ""value"", + plot_type = ""l"", + title = """", + ylab = ""Brier score"", + xlab = ""Iteration"", + numeric.x.axis = T, + point.size = 0.03, facet.by = ""fold_id"" + ) + + ggtitle(.y) + + geom_vline(xintercept = 30, linetype = ""dashed"") + + theme(axis.title.y = + element_text(margin = margin(t = 0, r = 20, + b = 0, l = 0))) + + facet_wrap(~fold_id, scales = ""free"") # we use the ggplot2 version here as we can specify `scales` which is not possible in the ggpubr argument + ) +} + +#' @title Visualization of tuning effects +#' @param models List of Benchmark/Resample results +#' @param model_name Name of algorithm for title +#' @param resampling String specifying the resample setting +#' @param hyperparam String of 2L specyfying the hyperparamters to compare +#' @param xlim x-axis limits +#' @param ylim y-axis limits +#' @param default Default hyperparameter settings (x and y). A red cross will +#' denote the default settings in the plot. +vis_tuning_effects = function(models, model_name, resampling, hyperparameter, + xlim, ylim, default) { + + + plot_list = pmap(list(x = models, y = model_name, z = hyperparameter, + xlim = xlim, ylim = ylim, default = default), + function(x, y, z, xlim, ylim, default) { + + hyperpar_effect <- generateHyperParsEffectData(x, partial.dep = TRUE) + + # find best combinations by folds + hyperpar_effect$data %<>% + group_by(nested_cv_run) %>% + filter(brier.test.mean == min(brier.test.mean, na.rm = TRUE)) %>% + ungroup() %>% + mutate(nested_cv_run = as.factor(nested_cv_run)) + + plot = ggplot(hyperpar_effect$data, aes_string(x = z[1], y = z[2], + label = ""nested_cv_run"")) + + geom_point(alpha = 0.1) + + geom_point(aes(x = default[1], y = default[2]), shape = 4, + color = ""red"", size = 3) + # default values for num.trees and mtry + coord_cartesian( + ylim = ylim, + xlim = xlim + ) + + labs( + title = glue(""{y} ({resampling})""), + subtitle = glue(""{z[1]} and {z[2]}"") + ) + + geom_label_repel( + data = subset( + hyperpar_effect$data, + as.integer(nested_cv_run) <= 5), + min.segment.length = unit(0, ""lines"")) + + #scale_y_continuous(breaks = seq(1, 11, 2), labels = seq(1, 11, 2)) + + theme_pubr() + + theme( + axis.text = element_text(size = 12), + plot.margin = unit(c(0.25, 0.2, 0.5, 0.2), ""cm""), + axis.title.y = element_text(angle = -90, vjust = 1) + ) + + if (y == ""SVM"") { + plot = plot + + labs( + x = bquote(2^{ + cost + }), + y = bquote(2^{ + gamma + }) + ) + } + + plot_marg <- ggMarginal(plot, + type = ""density"", + fill = ""transparent"", size = 20 + ) + }) + +} + + + +#' @title Save plot and convert to pdf +#' @param plot A ggplot2 plot +#' @param path The path where to save the plot (including filename) +#' @param nrow number of rows +#' @param ncol number of columns +#' +#' @details Same behaviour as [cowplot::save_plot] +save_plot_custom = function(plot, path, nrow, ncol) { + + save_plot(file_out(path), + plot, ncol = ncol, nrow = nrow) + + system(""cd analysis/figures && exec ls -1 *.png | + parallel convert '{}' '{.}.pdf'"") + +} + +#' @title Create continuos and nominal LaTeX tables from dataset +#' @param data [data.frame] +#' @param type Options: ""continuous"" or ""nominal"" +create_dataset_tables = function(data, type = ""continuous"", drop_vars = NULL, + stats = NULL) { + + if (is.null(stats)) { + stats = c(""n"", ""min"", ""q1"", ""median"", ""mean"", ""q3"", ""max"", + ""s"", ""iqr"", ""na"") + } + + if (!is.null(drop_vars)) { + data %<>% + dplyr::select(-!!drop_vars) + } + + if (type == ""continuous"") { + + table = tableContinuous(data[, sapply(data, is.numeric)], + longtable = FALSE, cumsum = FALSE, + cap = ""Summary of numerical predictor variables"", + label = ""table:descriptive_summary_numeric"", + stats = stats) + + } else if (type == ""nominal"") { + table = tableNominal(data[, !sapply(data, is.numeric)], + longtable = FALSE, cumsum = FALSE, + cap = ""Summary of nominal predictor variables"", + label = ""table:descriptive_summary_non_numeric"", + stats = stats) + } + + return(table) + +} +","R" +"Pathogens","pat-s/pathogen-modeling","reviews/review1-reviewer1.md",".md","12332","97","# Reviewer #1: Revision of ""Performance evaluation and hyperparameter tuning of statistical and machine-learning models using spatial data"" + +In this study, the authors analyze the effect of spatial cross-validation strategies and the effect of spatial hyperparameter tuning for several parametric and non-parametric algorithms. The comparisons are performed at the example of a prediction task aiming at the classification of a forest disease. + +The paper is highly relevant for the predictive modelling community due to the widely underestimated problem of overfitting in spatial prediction tasks. I read it with highest interest and recommend it for publication after the issues and questions listed below are clarified. In summary, my major concerns are that the objectives and hypotheses of this study are not made very clear which remains a problem throughout the manuscript. Also the key challenges in spatial ML applications that have motivated this study are not well elaborated in the text. Finally some of the conclusions are not supported by the results of this study. + +I hope the authors of the manuscript find the revisions helpful. I'm looking forward to read the revised version of this manuscript. + +----------------------------------- + +# MAJOR COMMENTS + +1) Clearly state your objectives and hypotheses. It remains unclear what exactly should be achieved or explored with this study. For example it is unclear why you use different ML algorithms. I assume your objective is to compare the effect of hyperparameter tuning for several algorithms. What is your hypothesis in this case? I assume it is that different algorithms have a different sensitivity to spatial hyperparameter tuning and to spatial vs non spatial CV in general? I suggest you use bullet points to explicitly highlight each of your aims (i.e. sensitivity to hyperparameter tuning, spatial vs non spatial cross validation, comparison of the sensitivity to tuning between algorithms, nonparametric vs parametric) and the corresponding hypothesis. + +2) The description of the case study needs a bit more detail and a short but clear summary of  Iturritxa et al. I suggest including a first subsection in chapter 2, called something like ""Summary of the prediction task"" where you clearly explain the aim and setting of this project. It further remains unclear how you assume that your newly chosen predictors matter (why is hail damage or soil type important to map tree infection?). From a technical perspective: How does spatial autocorrelation becomes present in this example?  + +3) Clearly explain the challenges of ML based spatial mapping in the introduction. Especially the problem of spatial autocorrelation. This is the crucial problem leading to your idea to test the effect of hyperparameter tuning and hence it deserves a proper description. Also make clear what the problem with a ""standard cross validation"" is in comparison to spatial CV (e.g. why does it lead to overoptimistic results?). Why does this problem leads to the need of spatial hyperparameter tuning? Without making these points clear it is hard to understand the relevance of your findings. + +4) The structure of the manuscript is confusing in some parts. I suggest leaving the long description of the algorithms out (page 14-16) as this can be easily referred to. This would help reducing the content to the essential parts. page 14 paragraph 3.4 needs to be partly shifted forwards in the manuscript. You already mentioned quite a few R packages earlier on, so it makes sense to mention right at the start of your methods chapter what software environment you're using. The discussion includes a lot of side-discussions (e.g. model interpretability, variable selection,moothness of the predictions). I strongly recommend to stick to the plot of your study rather than go into discussions about what else might be relevant. + +5) The conclusions do not always fit to the data. It is unclear why you recommend to use spatial partitioning for hyperparameter tuning of spatial data when the results indicate no major effect of spatial vs non-spatial hyperparameter tuning. In the same context you write that e.g. mtry needs to be tuned in a spatial way even though the performance remains the same. You justify this by the finding that the mtry values are not identical between spatial and non spatial tuning. However, the performance is the same so what effect does it have? To approach this you could compare the differences in the maps of predicted probabilities of the model using the spatially tuned hyperparameters with the non spatially tuned model. Are there patterns that indicate that the way of tuning makes a difference? Are there even differences that are beyond randomness? If not I think it is more appropriate to conclude that contrary to your hypothesis spatial hyperparameter tuning didn't make a +difference in your case study. +On the other hand, some important results are not highlighted in the conclusions, e.g. that the risk of overoptimistic model results in the case of non spatial CV is present for all algorithms. Please clearly align your aims/hypotheses with your conclusions (see also the first major comment). + +6) I think figure 6 points on an interesting finding that you did not mention: apparently the choice of the algorithm is more important than spatial vs non spatial hyperparameter tuning, while regardless of the algorithm, a spatial cross validation is crucial. Consider including this finding. + +7) The usage of mtry = 1 is interesting. It means that RF has no chance to skip uninformative predictors. All predictors are forced to be used even if they are just random noise. Is this desirable?  + +8) Is it a fair comparison if you set arbitrary values as a default for the ""no tuning"" models? Can you justify the choice of your default values? + +9) It is unclear why you include GAM and GLM in your study when your main focus is on hyperparameter tuning. I see two options here. Either make explicitly clear why you include them in your study and also explicitly discuss what you learned from the outcome of these two models. Or drop them completely from your manuscript which I think might be appropriate as they don't have hyperparameters to tune which however in the current version seems to be the focus of the manuscript. + +----------------------------------- + +# MINOR COMMENTS + +1) throughout the manuscript: make sure that it's always clear that the results of the non-spatial CV are not a valid indicator for model performance because it does not validate the performance to predict beyond the neighborhood of training locations. + +2) The title of the manuscript is not very clear. Both, machine learning algorithms as well as parametric models can be referred to as ""statistical"". I recommend to either call it ""parametric and machine-learning models"" or just ""spatial predictive models"". Further, it might make sense to change the wording to ""performance evaluation and sensitivity to hyperparameter tuning"" rather than just naming the key words. + +3) page 1, line 45-48: I think these are two things that need to be separated: We need cross-validation methods to evaluate the model performance and to obtain non-biased performance estimates. Hyperparameter tuning is important to receive robust or biased-reduced models but we're not performing tuning studies to obtain performance estimates. This should be separated by language. + +4) page 2, line 3-5: As you submit to ecological modelling it is rather of interest where statistical learning is used in the context of ecology. + +5) page 2, first paragraph: I recommend shifting the plot: First start with the motivation from a ecological perspective (""Spatial predictions are of great importance..."") which leads to your introduction to the case study (page 3 lines 21-31) as a typical spatial mapping example. The case study is currently poorly linked. Continue with the methodological approaches to face the challenges that exist with such modelling tasks (spatial autocorrelation, complex relationships etc). + +6) page 2 in the abstract: I suggest changing this paragraph to something like this: ""Results show that GAM and RF (AUROC estimates 0.705) outperform all other methods in predictive accuracy. The AUROC differences between the bias-reduced (spatial cross-validation) and overoptimistic (non-spatial cross-validation) performance estimates of the GAM and RF are 0.167 (24 %) and 0.213 (30 %), respectively. Though the sensitivity to hyperparameter tuning differed between the ML algorithms, there were in most cases no significant differences between spatial and non-spatial partitioning for hyperparameter tuning."" + +7) page 4, line 56: define ""bias reduced"". When is a model biased in this context? + +8) page 4, line 65: Here is an explanation missing why not only model performance but also the hyperparameters might need to be assessed using spatial resampling. + +9) page 4, line 72: Include a line break + +10) Page 5 line 88: You mention the problem of uneven distribution in the dataset. How do you deal with this in your analysis? + +11) Page 6, lines 92-95: Are the climatic variables long-term averages? + +12) Page 7, lines 122-124: Shift this to the discussion  + +13) Page 8, line 167: How are spatially disjoint subsets determined? + +14) page 17 line 355 and Figure 4: You say that SVM shows the highest tuning effects. But in Fig. 4 it looks like the effect is even higher for BRT. +I also wonder how WKNN can be better without tuning? Is there a lot of randomness in the models? In general, how is it possible that the performance sometimes decreases with tuning iterations (e.g. BRT at 300 iterations or SVM at 50 iterations). Maybe providing standard error bars might help in assessing the relevance of small differences. + +15) Page 20, line 383-388: I agree that hyperparameter tuning is expensive in computation time. You use a comparably small dataset but if large datasets are used it is nearly impossible to perform a such extensive tuning study. I think it is worth mentioning that in this respect, RF might be the algorithm of choice because it is insensitive to tuning especially to the way of tuning (spatial/non spatial) and shows a high performance. + +16) Page 23, line 445-446: Please explain: What are the consequences if predictors that profit from autocorrelation are chosen. + +17) Page 24 line 465. I think that spatial cross validation is not only recommended but necessary if we have strong autocorrelation and our sampling locations are not evenly distributed + +18) Page 24 line 465. It seems like a reference is missing here. + +19) Page 25, line 516:521: That's dangerous. We know that it is not acceptable to judge spatial models by a random CV. Please make clear that the high AUROC is not meaningful. + +20) page 26 lines 533-536: What does it mean? You cannot judge models by their performance metrics? The meaning does not become clear here. + +22) page 27 line 580: 0.05 does not seem to be much of a difference. Is it even significant? Anyway, I suggest leaving this out because your aim was not to improve this prediction by introducing new predictors (at least you never mentioned that this is your aim) but to study the sensitivity of cross validation and hyperparameter tuning so your conclusions should strongly focus on this. + +23) Page 27 line 576: "" all machine learning models outperformed parametric models in terms of predictive accuracy with RF and GAM showing the best results."" That's a contradiction. Earlier on you classified GAM as parametric model. + +24) As you submit to ecological modelling, please conclude what is the relevance of your study for spatial modelling in an ecological context. + + +----------------------------------- + + +# TABLES AND FIGURES + +1) Table 1: Include the default values that you used for the non-tuning models + +2) Table 2 is redundant. All information are presented in a more intuitive way in fig.6. Could you leave table 2 out? + +3) Figure 3: explain the abbreviations RepCV and SpRepCv in the figure caption. Change the color explanation so that it becomes clear which color is training and which one is test, e.g.  ""Blue dots represent the respective training samples and yellow dots represent the respective test samples"" + +4) figure 5: Please change the label of the x axis so that it's not upside down +","Markdown" +"Pathogens","pat-s/pathogen-modeling","reviews/review2-reviewer1.md",".md","2490","27","# Reviewer #1: Second Revision of the manuscript ""Crucial but often neglected: The important role of spatial autocorrelation in hyperparameter tuning and predictive performance for spatial data."" + +Thank you very much for putting the effort in improving the manuscript. It has improved a lot and is very clear and structured now. I only have some minor comments: + +# Introduction: +* Remove references from the abstract as this is not necessary +* line 5/6: Remove the ""the"" before soil science in accodance to the other examples. And I would prefer to leave the ""of course"" out. Sounds somehow misplaced +* Is landslide modelling necessarily an ecological application? Why not mention a few biotic and abiotic examples like species distribution modelling but also modelling of e.g. plant or soil properties, plant diseases etc… +* line 10/11: include a link here, e.g something like ""One typical example for a spatial prediction approach in ecology is the detection of fungi infection on Monterey pines (Iturritxa et al., 2014)…. +* Line 72: Rewrite ""good performance results"" to ""robust performance results"" +* Main objectives: I think the brackets around the hypotheses are not necessary as the hypotheses are an important part of the introduction. + +# Data and methods: +* line 106: change ""used new predictors"" to ""introduced further predictors"" +* Line 107: Make clear what the response variable is. It's not ""Diplodia sapinea"" but it's ""trees infected by Diplodia sapinea or not"" +* Line 113: What do you mean by number(11)? +* Line 124 and also from 137 on: don't refer to the internal name of the variable if not necessary. Better: ""Iturritxa et al. (2014) showed that the presence or absence of hail damage..."" +* Line 137: approx instead of ca. + +# Discussion: +* Section 5.2.4. This sounds like the validation is very arbitrary. How is it possible that a algorithm is the best with AUC but worst with Brier. What is the reason for that and why is Brier more reliable? + +Last but not least, the title: +* I think the title is misleading because it contradicts with the findings of the study. Yes Spatial CV is necessary for estimating the predictive performance but your results have shown that spatial hyperparameter tuning doesn't have an effect compared to non-hyperparameter tuning. So apparently it's not as crucial as claimed in the title. Maybe a question mark at the end of the title might solve the issue? + +Please also check the manuscript again for spelling and grammatical errors. +","Markdown" +"Pathogens","pat-s/pathogen-modeling","tests/testthat.R",".R","78","5","library(testthat) +library(pathogen.modeling) + +test_check(""pathogen.modeling"") +","R" +"Pathogens","sejmodha/MiscScripts","AlphaFold2_test.ipynb",".ipynb","4105494","1016","{ + ""nbformat"": 4, + ""nbformat_minor"": 0, + ""metadata"": { + ""accelerator"": ""GPU"", + ""colab"": { + ""provenance"": [], + ""gpuType"": ""A100"", + ""include_colab_link"": true + }, + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.8.10"" + } + }, + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""id"": ""view-in-github"", + ""colab_type"": ""text"" + }, + ""source"": [ + ""\""Open"" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""id"": ""G4yBrceuFbf3"" + }, + ""source"": [ + ""\n"", + ""\n"", + ""##ColabFold v1.5.5: AlphaFold2 using MMseqs2\n"", + ""\n"", + ""Easy to use protein structure and complex prediction using [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2) and [Alphafold2-multimer](https://www.biorxiv.org/content/10.1101/2021.10.04.463034v1). Sequence alignments/templates are generated through [MMseqs2](mmseqs.com) and [HHsearch](https://github.com/soedinglab/hh-suite). For more details, see bottom of the notebook, checkout the [ColabFold GitHub](https://github.com/sokrypton/ColabFold) and [Nature Protocols](https://www.nature.com/articles/s41596-024-01060-5).\n"", + ""\n"", + ""Old versions: [v1.4](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.4.0/AlphaFold2.ipynb), [v1.5.1](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.1/AlphaFold2.ipynb), [v1.5.2](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.2/AlphaFold2.ipynb), [v1.5.3-patch](https://colab.research.google.com/github/sokrypton/ColabFold/blob/56c72044c7d51a311ca99b953a71e552fdc042e1/AlphaFold2.ipynb)\n"", + ""\n"", + ""[Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all.\n"", + ""*Nature Methods*, 2022](https://www.nature.com/articles/s41592-022-01488-1)"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""id"": ""kOblAo-xetgx"", + ""cellView"": ""form"", + ""outputId"": ""24e89218-3ce9-4045-e920-1cdab1aec1e7"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"" + } + }, + ""source"": [ + ""#@title Input protein sequence(s), then hit `Runtime` -> `Run all`\n"", + ""from google.colab import files\n"", + ""import os\n"", + ""import re\n"", + ""import hashlib\n"", + ""import random\n"", + ""\n"", + ""from sys import version_info\n"", + ""python_version = f\""{version_info.major}.{version_info.minor}\""\n"", + ""\n"", + ""def add_hash(x,y):\n"", + "" return x+\""_\""+hashlib.sha1(y.encode()).hexdigest()[:5]\n"", + ""\n"", + ""query_sequence = 'MGPGPSRAPRAPRLMLCALALMVAAGGCVVSAFNLDTRFLVVKEAGNPGSLFGYSVALHRQTERQQRYLLLAGAPRELAVPDGYTNRTGAVYLCPLTAHKDDCERMNITVKNDPGHHIIEDMWLGVTVASQGPAGRVLVCAHRYTQVLWSGSEDQRRMVGKCYVRGNDLELDSSDDWQTYHNEMCNSNTDYLETGMCQLGTSGGFTQNTVYFGAPGAYNWKGNSYMIQRKEWDLSEYSYKDPEDQGNLYIGYTMQVGSFILHPKNITIVTGAPRHRHMGAVFLLSQEAGGDLRRRQVLEGSQVGAYFGSAIALADLNNDGWQDLLVGAPYYFERKEEVGGAIYVFMNQAGTSFPAHPSLLLHGPSGSAFGLSVASIGDINQDGFQDIAVGAPFEGLGKVYIYHSSSKGLLRQPQQVIHGEKLGLPGLATFGYSLSGQMDVDENFYPDLLVGSLSDHIVLLRARPVINIVHKTLVPRPAVLDPALCTATSCVQVELCFAYNQSAGNPNYRRNITLAYTLEADRDRRPPRLRFAGSESAVFHGFFSMPEMRCQKLELLLMDNLRDKLRPIIISMNYSLPLRMPDRPRLGLRSLDAYPILNQAQALENHTEVQFQKECGPDNKCESNLQMRAAFVSEQQQKLSRLQYSRDVRKLLLSINVTNTRTSERSGEDAHEALLTLVVPPALLLSSVRPPGACQANETIFCELGNPFKRNQRMELLIAFEVIGVTLHTRDLQVQLQLSTSSHQDNLWPMILTLLVDYTLQTSLSMVNHRLQSFFGGTVMGESGMKTVEDVGSPLKYEFQVGPMGEGLVGLGTLVLGLEWPYEVSNGKWLLYPTEITVHGNGSWPCRPPGDLINPLNLTLSDPGDRPSSPQRRRRQLDPGGGQGPPPVTLAAAKKAKSETVLTCATGRAHCVWLECPIPDAPVVTNVTVKARVWNSTFIEDYRDFDRVRVNGWATLFLRTSIPTINMENKTTWFSVDIDSELVEELPAEIELWLVLVAVGAGLLLLGLIILLLWKCGFFKRARTRALYEAKRQKAEMKSQPSETERLTDDY:MRRAVVSSSPPPSYESVMAQATLEVPFVPPRYMAPTEGRNSIRYSELAPQYDTTRVYLVDNKSADIASLNYQNDHSNFLTTVVQNNDFTPAEASTQTINFDERSRWGGDLKTILHTNMPNVNEYMFTSKFKARVMVSRKHPEGVVETDLSQDKLEYEWFEFTLPEGNFSETMTIDLMNNAILENYLQVGRQNGVLESDIGVKFDSRNFKLGWDPVTKLVMPGVYTYEAFHPDVVLLPGCGVDFTESRLSNLLGIRKKQPFQEGFRIMYEDLEGGNIPALLDVPKYLESKKKVEDETKNAAAATADTTTRGDTFATPAQETAADKKVEVLPIEKDESGRSYNLIQGTHDTLYRSWYLSYTYGDPEKGVQSWTLLTTPDVTCGAEQVYWSLPDLMQDPVTFRSTQQVSNYPVVGAELMPFRAKSFYNDLAVYSQLIRSYTSLTHVFNRFPDNQILCRPPAPTITTVSENVPALTDHGTLPLRSSIRGVQRVTVTDARRRTCPYVYKALGIVAPRVLSSRTF' #@param {type:\""string\""}\n"", + ""#@markdown - Use `:` to specify inter-protein chainbreaks for **modeling complexes** (supports homo- and hetro-oligomers). For example **PI...SK:PI...SK** for a homodimer\n"", + ""jobname = 'P26006_ A4ZKL2' #@param {type:\""string\""}\n"", + ""# number of models to use\n"", + ""num_relax = 0 #@param [0, 1, 5] {type:\""raw\""}\n"", + ""#@markdown - specify how many of the top ranked structures to relax using amber\n"", + ""template_mode = \""none\"" #@param [\""none\"", \""pdb100\"",\""custom\""]\n"", + ""#@markdown - `none` = no template information is used. `pdb100` = detect templates in pdb100 (see [notes](#pdb100)). `custom` - upload and search own templates (PDB or mmCIF format, see [notes](#custom_templates))\n"", + ""\n"", + ""use_amber = num_relax > 0\n"", + ""\n"", + ""# remove whitespaces\n"", + ""query_sequence = \""\"".join(query_sequence.split())\n"", + ""\n"", + ""basejobname = \""\"".join(jobname.split())\n"", + ""basejobname = re.sub(r'\\W+', '', basejobname)\n"", + ""jobname = add_hash(basejobname, query_sequence)\n"", + ""\n"", + ""# check if directory with jobname exists\n"", + ""def check(folder):\n"", + "" if os.path.exists(folder):\n"", + "" return False\n"", + "" else:\n"", + "" return True\n"", + ""if not check(jobname):\n"", + "" n = 0\n"", + "" while not check(f\""{jobname}_{n}\""): n += 1\n"", + "" jobname = f\""{jobname}_{n}\""\n"", + ""\n"", + ""# make directory to save results\n"", + ""os.makedirs(jobname, exist_ok=True)\n"", + ""\n"", + ""# save queries\n"", + ""queries_path = os.path.join(jobname, f\""{jobname}.csv\"")\n"", + ""with open(queries_path, \""w\"") as text_file:\n"", + "" text_file.write(f\""id,sequence\\n{jobname},{query_sequence}\"")\n"", + ""\n"", + ""if template_mode == \""pdb100\"":\n"", + "" use_templates = True\n"", + "" custom_template_path = None\n"", + ""elif template_mode == \""custom\"":\n"", + "" custom_template_path = os.path.join(jobname,f\""template\"")\n"", + "" os.makedirs(custom_template_path, exist_ok=True)\n"", + "" uploaded = files.upload()\n"", + "" use_templates = True\n"", + "" for fn in uploaded.keys():\n"", + "" os.rename(fn,os.path.join(custom_template_path,fn))\n"", + ""else:\n"", + "" custom_template_path = None\n"", + "" use_templates = False\n"", + ""\n"", + ""print(\""jobname\"",jobname)\n"", + ""print(\""sequence\"",query_sequence)\n"", + ""print(\""length\"",len(query_sequence.replace(\"":\"",\""\"")))"" + ], + ""execution_count"": 10, + ""outputs"": [ + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""jobname P26006_A4ZKL2_d86b4\n"", + ""sequence MGPGPSRAPRAPRLMLCALALMVAAGGCVVSAFNLDTRFLVVKEAGNPGSLFGYSVALHRQTERQQRYLLLAGAPRELAVPDGYTNRTGAVYLCPLTAHKDDCERMNITVKNDPGHHIIEDMWLGVTVASQGPAGRVLVCAHRYTQVLWSGSEDQRRMVGKCYVRGNDLELDSSDDWQTYHNEMCNSNTDYLETGMCQLGTSGGFTQNTVYFGAPGAYNWKGNSYMIQRKEWDLSEYSYKDPEDQGNLYIGYTMQVGSFILHPKNITIVTGAPRHRHMGAVFLLSQEAGGDLRRRQVLEGSQVGAYFGSAIALADLNNDGWQDLLVGAPYYFERKEEVGGAIYVFMNQAGTSFPAHPSLLLHGPSGSAFGLSVASIGDINQDGFQDIAVGAPFEGLGKVYIYHSSSKGLLRQPQQVIHGEKLGLPGLATFGYSLSGQMDVDENFYPDLLVGSLSDHIVLLRARPVINIVHKTLVPRPAVLDPALCTATSCVQVELCFAYNQSAGNPNYRRNITLAYTLEADRDRRPPRLRFAGSESAVFHGFFSMPEMRCQKLELLLMDNLRDKLRPIIISMNYSLPLRMPDRPRLGLRSLDAYPILNQAQALENHTEVQFQKECGPDNKCESNLQMRAAFVSEQQQKLSRLQYSRDVRKLLLSINVTNTRTSERSGEDAHEALLTLVVPPALLLSSVRPPGACQANETIFCELGNPFKRNQRMELLIAFEVIGVTLHTRDLQVQLQLSTSSHQDNLWPMILTLLVDYTLQTSLSMVNHRLQSFFGGTVMGESGMKTVEDVGSPLKYEFQVGPMGEGLVGLGTLVLGLEWPYEVSNGKWLLYPTEITVHGNGSWPCRPPGDLINPLNLTLSDPGDRPSSPQRRRRQLDPGGGQGPPPVTLAAAKKAKSETVLTCATGRAHCVWLECPIPDAPVVTNVTVKARVWNSTFIEDYRDFDRVRVNGWATLFLRTSIPTINMENKTTWFSVDIDSELVEELPAEIELWLVLVAVGAGLLLLGLIILLLWKCGFFKRARTRALYEAKRQKAEMKSQPSETERLTDDY:MRRAVVSSSPPPSYESVMAQATLEVPFVPPRYMAPTEGRNSIRYSELAPQYDTTRVYLVDNKSADIASLNYQNDHSNFLTTVVQNNDFTPAEASTQTINFDERSRWGGDLKTILHTNMPNVNEYMFTSKFKARVMVSRKHPEGVVETDLSQDKLEYEWFEFTLPEGNFSETMTIDLMNNAILENYLQVGRQNGVLESDIGVKFDSRNFKLGWDPVTKLVMPGVYTYEAFHPDVVLLPGCGVDFTESRLSNLLGIRKKQPFQEGFRIMYEDLEGGNIPALLDVPKYLESKKKVEDETKNAAAATADTTTRGDTFATPAQETAADKKVEVLPIEKDESGRSYNLIQGTHDTLYRSWYLSYTYGDPEKGVQSWTLLTTPDVTCGAEQVYWSLPDLMQDPVTFRSTQQVSNYPVVGAELMPFRAKSFYNDLAVYSQLIRSYTSLTHVFNRFPDNQILCRPPAPTITTVSENVPALTDHGTLPLRSSIRGVQRVTVTDARRRTCPYVYKALGIVAPRVLSSRTF\n"", + ""length 1570\n"" + ] + } + ] + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""#@title Install dependencies\n"", + ""%%time\n"", + ""import os\n"", + ""USE_AMBER = use_amber\n"", + ""USE_TEMPLATES = use_templates\n"", + ""PYTHON_VERSION = python_version\n"", + ""\n"", + ""if not os.path.isfile(\""COLABFOLD_READY\""):\n"", + "" print(\""installing colabfold...\"")\n"", + "" os.system(\""pip install -q --no-warn-conflicts 'colabfold[alphafold-minus-jax] @ git+https://github.com/sokrypton/ColabFold'\"")\n"", + "" if os.environ.get('TPU_NAME', False) != False:\n"", + "" os.system(\""pip uninstall -y jax jaxlib\"")\n"", + "" os.system(\""pip install --no-warn-conflicts --upgrade dm-haiku==0.0.10 'jax[cuda12_pip]'==0.3.25 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html\"")\n"", + "" os.system(\""ln -s /usr/local/lib/python3.*/dist-packages/colabfold colabfold\"")\n"", + "" os.system(\""ln -s /usr/local/lib/python3.*/dist-packages/alphafold alphafold\"")\n"", + "" os.system(\""touch COLABFOLD_READY\"")\n"", + ""\n"", + ""if USE_AMBER or USE_TEMPLATES:\n"", + "" if not os.path.isfile(\""CONDA_READY\""):\n"", + "" print(\""installing conda...\"")\n"", + "" os.system(\""wget -qnc https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh\"")\n"", + "" os.system(\""bash Miniforge3-Linux-x86_64.sh -bfp /usr/local\"")\n"", + "" os.system(\""mamba config --set auto_update_conda false\"")\n"", + "" os.system(\""touch CONDA_READY\"")\n"", + ""\n"", + ""if USE_TEMPLATES and not os.path.isfile(\""HH_READY\"") and USE_AMBER and not os.path.isfile(\""AMBER_READY\""):\n"", + "" print(\""installing hhsuite and amber...\"")\n"", + "" os.system(f\""mamba install -y -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0 openmm=8.0.0 python='{PYTHON_VERSION}' pdbfixer\"")\n"", + "" os.system(\""touch HH_READY\"")\n"", + "" os.system(\""touch AMBER_READY\"")\n"", + ""else:\n"", + "" if USE_TEMPLATES and not os.path.isfile(\""HH_READY\""):\n"", + "" print(\""installing hhsuite...\"")\n"", + "" os.system(f\""mamba install -y -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0 python='{PYTHON_VERSION}'\"")\n"", + "" os.system(\""touch HH_READY\"")\n"", + "" if USE_AMBER and not os.path.isfile(\""AMBER_READY\""):\n"", + "" print(\""installing amber...\"")\n"", + "" os.system(f\""mamba install -y -c conda-forge openmm=8.0.0 python='{PYTHON_VERSION}' pdbfixer\"")\n"", + "" os.system(\""touch AMBER_READY\"")"" + ], + ""metadata"": { + ""cellView"": ""form"", + ""id"": ""AzIKiDiCaHAn"", + ""outputId"": ""af15448b-8f59-4ac8-c915-804a224b820f"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"" + } + }, + ""execution_count"": 12, + ""outputs"": [ + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""CPU times: user 113 µs, sys: 0 ns, total: 113 µs\n"", + ""Wall time: 96.8 µs\n"" + ] + } + ] + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""#@markdown ### MSA options (custom MSA upload, single sequence, pairing mode)\n"", + ""msa_mode = \""mmseqs2_uniref_env\"" #@param [\""mmseqs2_uniref_env\"", \""mmseqs2_uniref\"",\""single_sequence\"",\""custom\""]\n"", + ""pair_mode = \""unpaired\"" #@param [\""unpaired_paired\"",\""paired\"",\""unpaired\""] {type:\""string\""}\n"", + ""#@markdown - \""unpaired_paired\"" = pair sequences from same species + unpaired MSA, \""unpaired\"" = seperate MSA for each chain, \""paired\"" - only use paired sequences.\n"", + ""\n"", + ""# decide which a3m to use\n"", + ""if \""mmseqs2\"" in msa_mode:\n"", + "" a3m_file = os.path.join(jobname,f\""{jobname}.a3m\"")\n"", + ""\n"", + ""elif msa_mode == \""custom\"":\n"", + "" a3m_file = os.path.join(jobname,f\""{jobname}.custom.a3m\"")\n"", + "" if not os.path.isfile(a3m_file):\n"", + "" custom_msa_dict = files.upload()\n"", + "" custom_msa = list(custom_msa_dict.keys())[0]\n"", + "" header = 0\n"", + "" import fileinput\n"", + "" for line in fileinput.FileInput(custom_msa,inplace=1):\n"", + "" if line.startswith(\"">\""):\n"", + "" header = header + 1\n"", + "" if not line.rstrip():\n"", + "" continue\n"", + "" if line.startswith(\"">\"") == False and header == 1:\n"", + "" query_sequence = line.rstrip()\n"", + "" print(line, end='')\n"", + ""\n"", + "" os.rename(custom_msa, a3m_file)\n"", + "" queries_path=a3m_file\n"", + "" print(f\""moving {custom_msa} to {a3m_file}\"")\n"", + ""\n"", + ""else:\n"", + "" a3m_file = os.path.join(jobname,f\""{jobname}.single_sequence.a3m\"")\n"", + "" with open(a3m_file, \""w\"") as text_file:\n"", + "" text_file.write(\"">1\\n%s\"" % query_sequence)"" + ], + ""metadata"": { + ""cellView"": ""form"", + ""id"": ""C2_sh2uAonJH"" + }, + ""execution_count"": 13, + ""outputs"": [] + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""#@markdown ### Advanced settings\n"", + ""model_type = \""auto\"" #@param [\""auto\"", \""alphafold2_ptm\"", \""alphafold2_multimer_v1\"", \""alphafold2_multimer_v2\"", \""alphafold2_multimer_v3\"", \""deepfold_v1\"", \""alphafold2\""]\n"", + ""#@markdown - if `auto` selected, will use `alphafold2_ptm` for monomer prediction and `alphafold2_multimer_v3` for complex prediction.\n"", + ""#@markdown Any of the mode_types can be used (regardless if input is monomer or complex).\n"", + ""num_recycles = \""3\"" #@param [\""auto\"", \""0\"", \""1\"", \""3\"", \""6\"", \""12\"", \""24\"", \""48\""]\n"", + ""#@markdown - if `auto` selected, will use `num_recycles=20` if `model_type=alphafold2_multimer_v3`, else `num_recycles=3` .\n"", + ""recycle_early_stop_tolerance = \""auto\"" #@param [\""auto\"", \""0.0\"", \""0.5\"", \""1.0\""]\n"", + ""#@markdown - if `auto` selected, will use `tol=0.5` if `model_type=alphafold2_multimer_v3` else `tol=0.0`.\n"", + ""relax_max_iterations = 200 #@param [0, 200, 2000] {type:\""raw\""}\n"", + ""#@markdown - max amber relax iterations, `0` = unlimited (AlphaFold2 default, can take very long)\n"", + ""pairing_strategy = \""greedy\"" #@param [\""greedy\"", \""complete\""] {type:\""string\""}\n"", + ""#@markdown - `greedy` = pair any taxonomically matching subsets, `complete` = all sequences have to match in one line.\n"", + ""calc_extra_ptm = False #@param {type:\""boolean\""}\n"", + ""#@markdown - return pairwise chain iptm/actifptm\n"", + ""\n"", + ""#@markdown #### Sample settings\n"", + ""#@markdown - enable dropouts and increase number of seeds to sample predictions from uncertainty of the model.\n"", + ""#@markdown - decrease `max_msa` to increase uncertainity\n"", + ""max_msa = \""auto\"" #@param [\""auto\"", \""512:1024\"", \""256:512\"", \""64:128\"", \""32:64\"", \""16:32\""]\n"", + ""num_seeds = 1 #@param [1,2,4,8,16] {type:\""raw\""}\n"", + ""use_dropout = False #@param {type:\""boolean\""}\n"", + ""\n"", + ""num_recycles = None if num_recycles == \""auto\"" else int(num_recycles)\n"", + ""recycle_early_stop_tolerance = None if recycle_early_stop_tolerance == \""auto\"" else float(recycle_early_stop_tolerance)\n"", + ""if max_msa == \""auto\"": max_msa = None\n"", + ""\n"", + ""#@markdown #### Save settings\n"", + ""save_all = False #@param {type:\""boolean\""}\n"", + ""save_recycles = False #@param {type:\""boolean\""}\n"", + ""save_to_google_drive = False #@param {type:\""boolean\""}\n"", + ""#@markdown - if the save_to_google_drive option was selected, the result zip will be uploaded to your Google Drive\n"", + ""dpi = 200 #@param {type:\""integer\""}\n"", + ""#@markdown - set dpi for image resolution\n"", + ""\n"", + ""if save_to_google_drive:\n"", + "" from pydrive2.drive import GoogleDrive\n"", + "" from pydrive2.auth import GoogleAuth\n"", + "" from google.colab import auth\n"", + "" from oauth2client.client import GoogleCredentials\n"", + "" auth.authenticate_user()\n"", + "" gauth = GoogleAuth()\n"", + "" gauth.credentials = GoogleCredentials.get_application_default()\n"", + "" drive = GoogleDrive(gauth)\n"", + "" print(\""You are logged into Google Drive and are good to go!\"")\n"", + ""\n"", + ""#@markdown Don't forget to hit `Runtime` -> `Run all` after updating the form."" + ], + ""metadata"": { + ""cellView"": ""form"", + ""id"": ""ADDuaolKmjGW"" + }, + ""execution_count"": 14, + ""outputs"": [] + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""#@title Run Prediction\n"", + ""display_images = True #@param {type:\""boolean\""}\n"", + ""\n"", + ""import sys\n"", + ""import warnings\n"", + ""warnings.simplefilter(action='ignore', category=FutureWarning)\n"", + ""from Bio import BiopythonDeprecationWarning\n"", + ""warnings.simplefilter(action='ignore', category=BiopythonDeprecationWarning)\n"", + ""from pathlib import Path\n"", + ""from colabfold.download import download_alphafold_params, default_data_dir\n"", + ""from colabfold.utils import setup_logging\n"", + ""from colabfold.batch import get_queries, run, set_model_type\n"", + ""from colabfold.plot import plot_msa_v2\n"", + ""\n"", + ""import os\n"", + ""import numpy as np\n"", + ""try:\n"", + "" K80_chk = os.popen('nvidia-smi | grep \""Tesla K80\"" | wc -l').read()\n"", + ""except:\n"", + "" K80_chk = \""0\""\n"", + "" pass\n"", + ""if \""1\"" in K80_chk:\n"", + "" print(\""WARNING: found GPU Tesla K80: limited to total length < 1000\"")\n"", + "" if \""TF_FORCE_UNIFIED_MEMORY\"" in os.environ:\n"", + "" del os.environ[\""TF_FORCE_UNIFIED_MEMORY\""]\n"", + "" if \""XLA_PYTHON_CLIENT_MEM_FRACTION\"" in os.environ:\n"", + "" del os.environ[\""XLA_PYTHON_CLIENT_MEM_FRACTION\""]\n"", + ""\n"", + ""from colabfold.colabfold import plot_protein\n"", + ""from pathlib import Path\n"", + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""# For some reason we need that to get pdbfixer to import\n"", + ""if use_amber and f\""/usr/local/lib/python{python_version}/site-packages/\"" not in sys.path:\n"", + "" sys.path.insert(0, f\""/usr/local/lib/python{python_version}/site-packages/\"")\n"", + ""\n"", + ""def input_features_callback(input_features):\n"", + "" if display_images:\n"", + "" plot_msa_v2(input_features)\n"", + "" plt.show()\n"", + "" plt.close()\n"", + ""\n"", + ""def prediction_callback(protein_obj, length,\n"", + "" prediction_result, input_features, mode):\n"", + "" model_name, relaxed = mode\n"", + "" if not relaxed:\n"", + "" if display_images:\n"", + "" fig = plot_protein(protein_obj, Ls=length, dpi=150)\n"", + "" plt.show()\n"", + "" plt.close()\n"", + ""\n"", + ""result_dir = jobname\n"", + ""log_filename = os.path.join(jobname,\""log.txt\"")\n"", + ""setup_logging(Path(log_filename))\n"", + ""\n"", + ""queries, is_complex = get_queries(queries_path)\n"", + ""model_type = set_model_type(is_complex, model_type)\n"", + ""\n"", + ""if \""multimer\"" in model_type and max_msa is not None:\n"", + "" use_cluster_profile = False\n"", + ""else:\n"", + "" use_cluster_profile = True\n"", + ""\n"", + ""download_alphafold_params(model_type, Path(\"".\""))\n"", + ""results = run(\n"", + "" queries=queries,\n"", + "" result_dir=result_dir,\n"", + "" use_templates=use_templates,\n"", + "" custom_template_path=custom_template_path,\n"", + "" num_relax=num_relax,\n"", + "" msa_mode=msa_mode,\n"", + "" model_type=model_type,\n"", + "" num_models=5,\n"", + "" num_recycles=num_recycles,\n"", + "" relax_max_iterations=relax_max_iterations,\n"", + "" recycle_early_stop_tolerance=recycle_early_stop_tolerance,\n"", + "" num_seeds=num_seeds,\n"", + "" use_dropout=use_dropout,\n"", + "" model_order=[1,2,3,4,5],\n"", + "" is_complex=is_complex,\n"", + "" data_dir=Path(\"".\""),\n"", + "" keep_existing_results=False,\n"", + "" rank_by=\""auto\"",\n"", + "" pair_mode=pair_mode,\n"", + "" pairing_strategy=pairing_strategy,\n"", + "" stop_at_score=float(100),\n"", + "" prediction_callback=prediction_callback,\n"", + "" dpi=dpi,\n"", + "" zip_results=False,\n"", + "" save_all=save_all,\n"", + "" max_msa=max_msa,\n"", + "" use_cluster_profile=use_cluster_profile,\n"", + "" input_features_callback=input_features_callback,\n"", + "" save_recycles=save_recycles,\n"", + "" user_agent=\""colabfold/google-colab-main\"",\n"", + "" calc_extra_ptm=calc_extra_ptm,\n"", + "")\n"", + ""results_zip = f\""{jobname}.result.zip\""\n"", + ""os.system(f\""zip -r {results_zip} {jobname}\"")"" + ], + ""metadata"": { + ""cellView"": ""form"", + ""id"": ""mbaIO9pWjaN0"", + ""outputId"": ""c6917cb5-6ddc-4f46-9128-2800e91d9db0"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"", + ""height"": 1000 + } + }, + ""execution_count"": 15, + ""outputs"": [ + { + ""output_type"": ""stream"", + ""name"": ""stderr"", + ""text"": [ + ""Downloading alphafold2_multimer_v3 weights to .: 100%|██████████| 3.82G/3.82G [00:19<00:00, 211MB/s]\n"" + ] + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 13:45:07,061 Running on GPU\n"", + ""2025-03-05 13:45:07,064 Found 5 citations for tools or databases\n"", + ""2025-03-05 13:45:07,064 Query 1/1: P26006_A4ZKL2_d86b4 (length 1570)\n"" + ] + }, + { + ""output_type"": ""stream"", + ""name"": ""stderr"", + ""text"": [ + ""COMPLETE: 100%|██████████| 300/300 [elapsed: 00:03 remaining: 00:00]\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 13:45:15,733 Setting max_seq=508, max_extra_seq=1739\n"", + ""2025-03-05 13:47:56,737 alphafold2_multimer_v3_model_1_seed_000 recycle=0 pLDDT=69.4 pTM=0.482 ipTM=0.198\n"", + ""2025-03-05 13:49:05,571 alphafold2_multimer_v3_model_1_seed_000 recycle=1 pLDDT=70.1 pTM=0.458 ipTM=0.195 tol=15.2\n"", + ""2025-03-05 13:50:14,476 alphafold2_multimer_v3_model_1_seed_000 recycle=2 pLDDT=70.7 pTM=0.442 ipTM=0.183 tol=12.5\n"", + ""2025-03-05 13:51:23,315 alphafold2_multimer_v3_model_1_seed_000 recycle=3 pLDDT=72.8 pTM=0.436 ipTM=0.19 tol=15.3\n"", + ""2025-03-05 13:51:23,318 alphafold2_multimer_v3_model_1_seed_000 took 362.9s (3 recycles)\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 13:52:35,185 alphafold2_multimer_v3_model_2_seed_000 recycle=0 pLDDT=70.9 pTM=0.492 ipTM=0.221\n"", + ""2025-03-05 13:53:43,941 alphafold2_multimer_v3_model_2_seed_000 recycle=1 pLDDT=72.3 pTM=0.495 ipTM=0.221 tol=8.53\n"", + ""2025-03-05 13:54:52,748 alphafold2_multimer_v3_model_2_seed_000 recycle=2 pLDDT=73.6 pTM=0.493 ipTM=0.216 tol=5.91\n"", + ""2025-03-05 13:56:01,512 alphafold2_multimer_v3_model_2_seed_000 recycle=3 pLDDT=77.3 pTM=0.48 ipTM=0.208 tol=5.96\n"", + ""2025-03-05 13:56:01,514 alphafold2_multimer_v3_model_2_seed_000 took 275.1s (3 recycles)\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 13:57:13,238 alphafold2_multimer_v3_model_3_seed_000 recycle=0 pLDDT=69 pTM=0.472 ipTM=0.207\n"", + ""2025-03-05 13:58:22,243 alphafold2_multimer_v3_model_3_seed_000 recycle=1 pLDDT=69.9 pTM=0.467 ipTM=0.207 tol=13.8\n"", + ""2025-03-05 13:59:30,954 alphafold2_multimer_v3_model_3_seed_000 recycle=2 pLDDT=69.6 pTM=0.456 ipTM=0.208 tol=38.7\n"", + ""2025-03-05 14:00:39,616 alphafold2_multimer_v3_model_3_seed_000 recycle=3 pLDDT=73.7 pTM=0.447 ipTM=0.198 tol=7.23\n"", + ""2025-03-05 14:00:39,619 alphafold2_multimer_v3_model_3_seed_000 took 275.4s (3 recycles)\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 14:01:51,374 alphafold2_multimer_v3_model_4_seed_000 recycle=0 pLDDT=69.8 pTM=0.475 ipTM=0.209\n"", + ""2025-03-05 14:03:00,504 alphafold2_multimer_v3_model_4_seed_000 recycle=1 pLDDT=71.4 pTM=0.464 ipTM=0.188 tol=15.2\n"", + ""2025-03-05 14:04:09,601 alphafold2_multimer_v3_model_4_seed_000 recycle=2 pLDDT=72.5 pTM=0.473 ipTM=0.21 tol=15.1\n"", + ""2025-03-05 14:05:18,537 alphafold2_multimer_v3_model_4_seed_000 recycle=3 pLDDT=76.8 pTM=0.473 ipTM=0.211 tol=12\n"", + ""2025-03-05 14:05:18,539 alphafold2_multimer_v3_model_4_seed_000 took 276.3s (3 recycles)\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 14:06:30,261 alphafold2_multimer_v3_model_5_seed_000 recycle=0 pLDDT=68.4 pTM=0.477 ipTM=0.23\n"", + ""2025-03-05 14:07:39,309 alphafold2_multimer_v3_model_5_seed_000 recycle=1 pLDDT=69.7 pTM=0.465 ipTM=0.204 tol=12.7\n"", + ""2025-03-05 14:08:48,252 alphafold2_multimer_v3_model_5_seed_000 recycle=2 pLDDT=72.6 pTM=0.456 ipTM=0.182 tol=21\n"", + ""2025-03-05 14:09:57,139 alphafold2_multimer_v3_model_5_seed_000 recycle=3 pLDDT=73.8 pTM=0.455 ipTM=0.176 tol=12.1\n"", + ""2025-03-05 14:09:57,141 alphafold2_multimer_v3_model_5_seed_000 took 275.9s (3 recycles)\n"" + ] + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + }, + { + ""output_type"": ""stream"", + ""name"": ""stdout"", + ""text"": [ + ""2025-03-05 14:09:59,868 reranking models by 'multimer' metric\n"", + ""2025-03-05 14:09:59,869 rank_001_alphafold2_multimer_v3_model_4_seed_000 pLDDT=76.8 pTM=0.473 ipTM=0.211\n"", + ""2025-03-05 14:09:59,869 rank_002_alphafold2_multimer_v3_model_2_seed_000 pLDDT=77.3 pTM=0.48 ipTM=0.208\n"", + ""2025-03-05 14:09:59,869 rank_003_alphafold2_multimer_v3_model_3_seed_000 pLDDT=73.7 pTM=0.447 ipTM=0.198\n"", + ""2025-03-05 14:09:59,869 rank_004_alphafold2_multimer_v3_model_1_seed_000 pLDDT=72.8 pTM=0.436 ipTM=0.19\n"", + ""2025-03-05 14:09:59,869 rank_005_alphafold2_multimer_v3_model_5_seed_000 pLDDT=73.8 pTM=0.455 ipTM=0.176\n"", + ""2025-03-05 14:10:06,825 Done\n"" + ] + }, + { + ""output_type"": ""execute_result"", + ""data"": { + ""text/plain"": [ + ""0"" + ] + }, + ""metadata"": {}, + ""execution_count"": 15 + } + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""id"": ""KK7X9T44pWb7"", + ""outputId"": ""fb87bf36-8adb-4ec3-8254-d99838d69196"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"", + ""height"": 542 + } + }, + ""source"": [ + ""#@title Display 3D structure {run: \""auto\""}\n"", + ""import py3Dmol\n"", + ""import glob\n"", + ""import matplotlib.pyplot as plt\n"", + ""from colabfold.colabfold import plot_plddt_legend\n"", + ""from colabfold.colabfold import pymol_color_list, alphabet_list\n"", + ""rank_num = 1 #@param [\""1\"", \""2\"", \""3\"", \""4\"", \""5\""] {type:\""raw\""}\n"", + ""color = \""lDDT\"" #@param [\""chain\"", \""lDDT\"", \""rainbow\""]\n"", + ""show_sidechains = False #@param {type:\""boolean\""}\n"", + ""show_mainchains = False #@param {type:\""boolean\""}\n"", + ""\n"", + ""tag = results[\""rank\""][0][rank_num - 1]\n"", + ""jobname_prefix = \"".custom\"" if msa_mode == \""custom\"" else \""\""\n"", + ""pdb_filename = f\""{jobname}/{jobname}{jobname_prefix}_unrelaxed_{tag}.pdb\""\n"", + ""pdb_file = glob.glob(pdb_filename)\n"", + ""\n"", + ""def show_pdb(rank_num=1, show_sidechains=False, show_mainchains=False, color=\""lDDT\""):\n"", + "" model_name = f\""rank_{rank_num}\""\n"", + "" view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n"", + "" view.addModel(open(pdb_file[0],'r').read(),'pdb')\n"", + ""\n"", + "" if color == \""lDDT\"":\n"", + "" view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':50,'max':90}}})\n"", + "" elif color == \""rainbow\"":\n"", + "" view.setStyle({'cartoon': {'color':'spectrum'}})\n"", + "" elif color == \""chain\"":\n"", + "" chains = len(queries[0][1]) + 1 if is_complex else 1\n"", + "" for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n"", + "" view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n"", + ""\n"", + "" if show_sidechains:\n"", + "" BB = ['C','O','N']\n"", + "" view.addStyle({'and':[{'resn':[\""GLY\"",\""PRO\""],'invert':True},{'atom':BB,'invert':True}]},\n"", + "" {'stick':{'colorscheme':f\""WhiteCarbon\"",'radius':0.3}})\n"", + "" view.addStyle({'and':[{'resn':\""GLY\""},{'atom':'CA'}]},\n"", + "" {'sphere':{'colorscheme':f\""WhiteCarbon\"",'radius':0.3}})\n"", + "" view.addStyle({'and':[{'resn':\""PRO\""},{'atom':['C','O'],'invert':True}]},\n"", + "" {'stick':{'colorscheme':f\""WhiteCarbon\"",'radius':0.3}})\n"", + "" if show_mainchains:\n"", + "" BB = ['C','O','N','CA']\n"", + "" view.addStyle({'atom':BB},{'stick':{'colorscheme':f\""WhiteCarbon\"",'radius':0.3}})\n"", + ""\n"", + "" view.zoomTo()\n"", + "" return view\n"", + ""\n"", + ""show_pdb(rank_num, show_sidechains, show_mainchains, color).show()\n"", + ""if color == \""lDDT\"":\n"", + "" plot_plddt_legend().show()"" + ], + ""execution_count"": 24, + ""outputs"": [ + { + ""output_type"": ""display_data"", + ""data"": { + ""application/3dmoljs_load.v0"": ""
\n

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n
\n"", + ""text/html"": [ + ""
\n"", + ""

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n"", + ""
\n"", + """" + ] + }, + ""metadata"": {} + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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\n"" + }, + ""metadata"": {} + } + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""id"": ""11l8k--10q0C"", + ""cellView"": ""form"", + ""outputId"": ""279a5b9a-4489-49f7-a1c5-6ffba7ab43e9"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"", + ""height"": 1000 + } + }, + ""source"": [ + ""#@title Plots {run: \""auto\""}\n"", + ""from IPython.display import display, HTML\n"", + ""import base64\n"", + ""from html import escape\n"", + ""\n"", + ""# see: https://stackoverflow.com/a/53688522\n"", + ""def image_to_data_url(filename):\n"", + "" ext = filename.split('.')[-1]\n"", + "" prefix = f'data:image/{ext};base64,'\n"", + "" with open(filename, 'rb') as f:\n"", + "" img = f.read()\n"", + "" return prefix + base64.b64encode(img).decode('utf-8')\n"", + ""\n"", + ""pae = \""\""\n"", + ""pae_file = os.path.join(jobname,f\""{jobname}{jobname_prefix}_pae.png\"")\n"", + ""if os.path.isfile(pae_file):\n"", + "" pae = image_to_data_url(pae_file)\n"", + ""cov = image_to_data_url(os.path.join(jobname,f\""{jobname}{jobname_prefix}_coverage.png\""))\n"", + ""plddt = image_to_data_url(os.path.join(jobname,f\""{jobname}{jobname_prefix}_plddt.png\""))\n"", + ""display(HTML(f\""\""\""\n"", + ""\n"", + ""
\n"", + ""

Plots for {escape(jobname)}

\n"", + "" { '' if pae == '' else '' }\n"", + "" \n"", + "" \n"", + ""
\n"", + ""\""\""\""))"" + ], + ""execution_count"": 20, + ""outputs"": [ + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + """" + ], + ""text/html"": [ + ""\n"", + ""\n"", + ""
\n"", + ""

Plots for P26006_A4ZKL2_d86b4

\n"", + "" \n"", + "" \n"", + "" \n"", + ""
\n"" + ] + }, + ""metadata"": {} + } + ] + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""#@title Package and download results\n"", + ""#@markdown If you are having issues downloading the result archive, try disabling your adblocker and run this cell again. If that fails click on the little folder icon to the left, navigate to file: `jobname.result.zip`, right-click and select \\\""Download\\\"" (see [screenshot](https://pbs.twimg.com/media/E6wRW2lWUAEOuoe?format=jpg&name=small)).\n"", + ""\n"", + ""if msa_mode == \""custom\"":\n"", + "" print(\""Don't forget to cite your custom MSA generation method.\"")\n"", + ""\n"", + ""files.download(f\""{jobname}.result.zip\"")\n"", + ""\n"", + ""if save_to_google_drive == True and drive:\n"", + "" uploaded = drive.CreateFile({'title': f\""{jobname}.result.zip\""})\n"", + "" uploaded.SetContentFile(f\""{jobname}.result.zip\"")\n"", + "" uploaded.Upload()\n"", + "" print(f\""Uploaded {jobname}.result.zip to Google Drive with ID {uploaded.get('id')}\"")"" + ], + ""metadata"": { + ""cellView"": ""form"", + ""id"": ""R_AH6JSXaeb2"", + ""outputId"": ""ed04bc58-19cb-485d-937f-46ff73862760"", + ""colab"": { + ""base_uri"": ""https://localhost:8080/"", + ""height"": 17 + } + }, + ""execution_count"": 21, + ""outputs"": [ + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + """" + ], + ""application/javascript"": [ + ""\n"", + "" async function download(id, filename, size) {\n"", + "" if (!google.colab.kernel.accessAllowed) {\n"", + "" return;\n"", + "" }\n"", + "" const div = document.createElement('div');\n"", + "" const label = document.createElement('label');\n"", + "" label.textContent = `Downloading \""${filename}\"": `;\n"", + "" div.appendChild(label);\n"", + "" const progress = document.createElement('progress');\n"", + "" progress.max = size;\n"", + "" div.appendChild(progress);\n"", + "" document.body.appendChild(div);\n"", + ""\n"", + "" const buffers = [];\n"", + "" let downloaded = 0;\n"", + ""\n"", + "" const channel = await google.colab.kernel.comms.open(id);\n"", + "" // Send a message to notify the kernel that we're ready.\n"", + "" channel.send({})\n"", + ""\n"", + "" for await (const message of channel.messages) {\n"", + "" // Send a message to notify the kernel that we're ready.\n"", + "" channel.send({})\n"", + "" if (message.buffers) {\n"", + "" for (const buffer of message.buffers) {\n"", + "" buffers.push(buffer);\n"", + "" downloaded += buffer.byteLength;\n"", + "" progress.value = downloaded;\n"", + "" }\n"", + "" }\n"", + "" }\n"", + "" const blob = new Blob(buffers, {type: 'application/binary'});\n"", + "" const a = document.createElement('a');\n"", + "" a.href = window.URL.createObjectURL(blob);\n"", + "" a.download = filename;\n"", + "" div.appendChild(a);\n"", + "" a.click();\n"", + "" div.remove();\n"", + "" }\n"", + "" "" + ] + }, + ""metadata"": {} + }, + { + ""output_type"": ""display_data"", + ""data"": { + ""text/plain"": [ + """" + ], + ""application/javascript"": [ + ""download(\""download_a1936868-cb27-4b32-ac5d-c571ff875c85\"", \""P26006_A4ZKL2_d86b4.result.zip\"", 33448374)"" + ] + }, + ""metadata"": {} + } + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""id"": ""UGUBLzB3C6WN"", + ""pycharm"": { + ""name"": ""#%% md\n"" + } + }, + ""source"": [ + ""# Instructions \n"", + ""For detailed instructions, tips and tricks, see recently published paper at [Nature Protocols](https://www.nature.com/articles/s41596-024-01060-5)\n"", + ""\n"", + ""**Quick start**\n"", + ""1. Paste your protein sequence(s) in the input field.\n"", + ""2. Press \""Runtime\"" -> \""Run all\"".\n"", + ""3. The pipeline consists of 5 steps. The currently running step is indicated by a circle with a stop sign next to it.\n"", + ""\n"", + ""**Result zip file contents**\n"", + ""\n"", + ""1. PDB formatted structures sorted by avg. pLDDT and complexes are sorted by pTMscore. (unrelaxed and relaxed if `use_amber` is enabled).\n"", + ""2. Plots of the model quality.\n"", + ""3. Plots of the MSA coverage.\n"", + ""4. Parameter log file.\n"", + ""5. A3M formatted input MSA.\n"", + ""6. A `predicted_aligned_error_v1.json` using [AlphaFold-DB's format](https://alphafold.ebi.ac.uk/faq#faq-7) and a `scores.json` for each model which contains an array (list of lists) for PAE, a list with the average pLDDT and the pTMscore.\n"", + ""7. BibTeX file with citations for all used tools and databases.\n"", + ""\n"", + ""At the end of the job a download modal box will pop up with a `jobname.result.zip` file. Additionally, if the `save_to_google_drive` option was selected, the `jobname.result.zip` will be uploaded to your Google Drive.\n"", + ""\n"", + ""**MSA generation for complexes**\n"", + ""\n"", + ""For the complex prediction we use unpaired and paired MSAs. Unpaired MSA is generated the same way as for the protein structures prediction by searching the UniRef100 and environmental sequences three iterations each.\n"", + ""\n"", + ""The paired MSA is generated by searching the UniRef100 database and pairing the best hits sharing the same NCBI taxonomic identifier (=species or sub-species). We only pair sequences if all of the query sequences are present for the respective taxonomic identifier.\n"", + ""\n"", + ""**Using a custom MSA as input**\n"", + ""\n"", + ""To predict the structure with a custom MSA (A3M formatted): (1) Change the `msa_mode`: to \""custom\"", (2) Wait for an upload box to appear at the end of the \""MSA options ...\"" box. Upload your A3M. The first fasta entry of the A3M must be the query sequence without gaps.\n"", + ""\n"", + ""It is also possilbe to proide custom MSAs for complex predictions. Read more about the format [here](https://github.com/sokrypton/ColabFold/issues/76).\n"", + ""\n"", + ""As an alternative for MSA generation the [HHblits Toolkit server](https://toolkit.tuebingen.mpg.de/tools/hhblits) can be used. After submitting your query, click \""Query Template MSA\"" -> \""Download Full A3M\"". Download the A3M file and upload it in this notebook.\n"", + ""\n"", + ""**PDB100** \n"", + ""\n"", + ""As of 23/06/08, we have transitioned from using the PDB70 to a 100% clustered PDB, the PDB100. The construction methodology of PDB100 differs from that of PDB70.\n"", + ""\n"", + ""The PDB70 was constructed by running each PDB70 representative sequence through [HHblits](https://github.com/soedinglab/hh-suite) against the [Uniclust30](https://uniclust.mmseqs.com/). On the other hand, the PDB100 is built by searching each PDB100 representative structure with [Foldseek](https://github.com/steineggerlab/foldseek) against the [AlphaFold Database](https://alphafold.ebi.ac.uk).\n"", + ""\n"", + ""To maintain compatibility with older Notebook versions and local installations, the generated files and API responses will continue to be named \""PDB70\"", even though we're now using the PDB100.\n"", + ""\n"", + ""**Using custom templates** \n"", + ""\n"", + ""To predict the structure with a custom template (PDB or mmCIF formatted): (1) change the `template_mode` to \""custom\"" in the execute cell and (2) wait for an upload box to appear at the end of the \""Input Protein\"" box. Select and upload your templates (multiple choices are possible).\n"", + ""\n"", + ""* Templates must follow the four letter PDB naming with lower case letters.\n"", + ""\n"", + ""* Templates in mmCIF format must contain `_entity_poly_seq`. An error is thrown if this field is not present. The field `_pdbx_audit_revision_history.revision_date` is automatically generated if it is not present.\n"", + ""\n"", + ""* Templates in PDB format are automatically converted to the mmCIF format. `_entity_poly_seq` and `_pdbx_audit_revision_history.revision_date` are automatically generated.\n"", + ""\n"", + ""If you encounter problems, please report them to this [issue](https://github.com/sokrypton/ColabFold/issues/177).\n"", + ""\n"", + ""**Comparison to the full AlphaFold2 and AlphaFold2 Colab**\n"", + ""\n"", + ""This notebook replaces the homology detection and MSA pairing of AlphaFold2 with MMseqs2. For a comparison against the [AlphaFold2 Colab](https://colab.research.google.com/github/deepmind/alphafold/blob/main/notebooks/AlphaFold.ipynb) and the full [AlphaFold2](https://github.com/deepmind/alphafold) system read our [paper](https://www.nature.com/articles/s41592-022-01488-1).\n"", + ""\n"", + ""**Troubleshooting**\n"", + ""* Check that the runtime type is set to GPU at \""Runtime\"" -> \""Change runtime type\"".\n"", + ""* Try to restart the session \""Runtime\"" -> \""Factory reset runtime\"".\n"", + ""* Check your input sequence.\n"", + ""\n"", + ""**Known issues**\n"", + ""* Google Colab assigns different types of GPUs with varying amount of memory. Some might not have enough memory to predict the structure for a long sequence.\n"", + ""* Your browser can block the pop-up for downloading the result file. You can choose the `save_to_google_drive` option to upload to Google Drive instead or manually download the result file: Click on the little folder icon to the left, navigate to file: `jobname.result.zip`, right-click and select \\\""Download\\\"" (see [screenshot](https://pbs.twimg.com/media/E6wRW2lWUAEOuoe?format=jpg&name=small)).\n"", + ""\n"", + ""**Limitations**\n"", + ""* Computing resources: Our MMseqs2 API can handle ~20-50k requests per day.\n"", + ""* MSAs: MMseqs2 is very precise and sensitive but might find less hits compared to HHblits/HMMer searched against BFD or MGnify.\n"", + ""* We recommend to additionally use the full [AlphaFold2 pipeline](https://github.com/deepmind/alphafold).\n"", + ""\n"", + ""**Description of the plots**\n"", + ""* **Number of sequences per position** - We want to see at least 30 sequences per position, for best performance, ideally 100 sequences.\n"", + ""* **Predicted lDDT per position** - model confidence (out of 100) at each position. The higher the better.\n"", + ""* **Predicted Alignment Error** - For homooligomers, this could be a useful metric to assess how confident the model is about the interface. The lower the better.\n"", + ""\n"", + ""**Bugs**\n"", + ""- If you encounter any bugs, please report the issue to https://github.com/sokrypton/ColabFold/issues\n"", + ""\n"", + ""**License**\n"", + ""\n"", + ""The source code of ColabFold is licensed under [MIT](https://raw.githubusercontent.com/sokrypton/ColabFold/main/LICENSE). Additionally, this notebook uses the AlphaFold2 source code and its parameters licensed under [Apache 2.0](https://raw.githubusercontent.com/deepmind/alphafold/main/LICENSE) and [CC BY 4.0](https://creativecommons.org/licenses/by-sa/4.0/) respectively. Read more about the AlphaFold license [here](https://github.com/deepmind/alphafold).\n"", + ""\n"", + ""**Acknowledgments**\n"", + ""- We thank the AlphaFold team for developing an excellent model and open sourcing the software.\n"", + ""\n"", + ""- [KOBIC](https://kobic.re.kr) and [Söding Lab](https://www.mpinat.mpg.de/soeding) for providing the computational resources for the MMseqs2 MSA server.\n"", + ""\n"", + ""- Richard Evans for helping to benchmark the ColabFold's Alphafold-multimer support.\n"", + ""\n"", + ""- [David Koes](https://github.com/dkoes) for his awesome [py3Dmol](https://3dmol.csb.pitt.edu/) plugin, without whom these notebooks would be quite boring!\n"", + ""\n"", + ""- Do-Yoon Kim for creating the ColabFold logo.\n"", + ""\n"", + ""- A colab by Sergey Ovchinnikov ([@sokrypton](https://twitter.com/sokrypton)), Milot Mirdita ([@milot_mirdita](https://twitter.com/milot_mirdita)) and Martin Steinegger ([@thesteinegger](https://twitter.com/thesteinegger)).\n"" + ] + } + ] +}","Unknown" +"Pathogens","sejmodha/MiscScripts","UpdateKrakenDatabases.py",".py","7031","158","#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""""" +This script takes an optional command-line argument which can be specified as the target location where the data should be downloaded and saved. +By default, all files are downloaded in the present working directory.  +@author: sejalmodha +"""""" +#import OS module to use os methods and functions +import os +import subprocess +import sys +import re +# you'll see this alias in documentation, examples, etc. +import pandas as pd +#import biopython SeqIO +from Bio import SeqIO + +#set present working directory +if len(sys.argv) > 1: + cwd = sys.argv[1] +else: + cwd=os.getcwd() +#os.chdir(pwd) + +print(cwd) + +#get the current working directory +os.chdir(cwd) +print(os.getcwd()) +#function to process ftp url file that is created from assembly files +def process_url_file(inputurlfile): + url_file=open(inputurlfile,'r') + file_suffix=r'genomic.gbff.gz' + for line in url_file: + url=line.rstrip('\n').split(',') + ftp_url= url[0]+'/'+url[1]+'_'+url[2]+'_'+file_suffix + #print(new_url) + print(""Downloading""+ ftp_url) + #Download the files in the gbff format + subprocess.call(""wget ""+ftp_url,shell=True) + #unzip the files + subprocess.call(""gunzip *.gz"",shell=True) + return + +#function to download bacterial sequences +def download_bacterial_genomes(outfile='outfile.txt'): + assembly_summary_file=r'ftp://ftp.ncbi.nlm.nih.gov/genomes/refseq/bacteria/assembly_summary.txt' + if os.path.exists('assembly_summary.txt'): + os.remove('assembly_summary.txt') + #Download the file using wget sysyem call + subprocess.call(""wget ""+assembly_summary_file, shell=True) + #Reformat the file to pandas-friendly format + subprocess.call(""sed -i '1d' assembly_summary.txt"",shell=True) + subprocess.call(""sed -i 's/^# //' assembly_summary.txt"", shell=True) + #Read the file as a dataframe - using read_table + #Use read_table if the column separator is tab + assembly_sum = pd.read_table('assembly_summary.txt',dtype='unicode') + #filter the dataframe and save the URLs of the complete genomes in a new file + my_df=assembly_sum[(assembly_sum['version_status'] == 'latest') & + (assembly_sum['assembly_level']=='Complete Genome') + ] + my_df=my_df[['ftp_path','assembly_accession','asm_name']] + #output_file.write + my_df.to_csv(outfile,mode='w',index=False,header=None) + process_url_file(outfile) + return + +#function to download reference genomes +#this function downloads latest version human reference genome by default +def download_refseq_genome(taxid=9606,outfile='refseq_genome.txt'): + assembly_summary_file=""ftp://ftp.ncbi.nih.gov/genomes/refseq/assembly_summary_refseq.txt"" + if os.path.exists('assembly_summary_refseq.txt'): + os.remove('assembly_summary_refseq.txt') + #Download the file using wget sysyem call + subprocess.call(""wget ""+assembly_summary_file, shell=True) + #Reformat the file to pandas-friendly format + subprocess.call(""sed -i '1d' assembly_summary_refseq.txt"",shell=True) + subprocess.call(""sed -i 's/^# //' assembly_summary_refseq.txt"", shell=True) + #Read the file as a dataframe - using read_table + #Use read_table if the column separator is tab + assembly_sum = pd.read_csv('assembly_summary_refseq.txt', sep='\t', dtype='unicode') + my_df=assembly_sum[(assembly_sum['taxid'] == taxid) & + ((assembly_sum['refseq_category'] == 'reference genome') | + (assembly_sum['refseq_category'] == 'representative genome') + )] + my_df=my_df[['ftp_path','assembly_accession','asm_name']] + #Process the newly created file and download genomes from NCBI website + my_df.to_csv(outfile,mode='w',index=False,header=None) + process_url_file(outfile) + return + +#format genbank files to generate kraken-friendly formatted fasta files +def get_fasta_in_kraken_format(outfile_fasta='sequences.fa'): + output=open(outfile_fasta,'w') + for file_name in os.listdir(cwd): + if file_name.endswith('.gbff'): + records = SeqIO.parse(file_name, ""genbank"") + for seq_record in records: + seq_id=seq_record.id + seq=seq_record.seq + for feature in seq_record.features: + if 'source' in feature.type: + print(feature.qualifiers) + taxid=''.join(feature.qualifiers['db_xref']) + taxid=re.sub(r'.*taxon:','kraken:taxid|',taxid) + print(''.join(taxid)) + outseq="">""+seq_id+""|""+taxid+""\n""+str(seq)+""\n"" + output.write(outseq) + os.remove(file_name) + output.close() + return + +print('Downloading human genome'+'\n') +#change argument in the following function if you want to download other reference genomes +#taxonomy ID 9606 (human) should be replaced with taxonomy ID of genome of interest +download_refseq_genome(9606,'human_genome_url.txt') +print('Converting sequences to kraken input format'+'\n') +get_fasta_in_kraken_format('human_genome.fa') + +#print('Downloading rat genome'+'\n') +#download_refseq_genome(10116,'rat_genome_url.txt') +#print('Converting sequences to kraken input format'+'\n') +#get_fasta_in_kraken_format('rat_genome.fa') + +print('Downloading bacterial genomes'+'\n') +download_bacterial_genomes('bacterial_complete_genome_url.txt') +print('Converting sequences to kraken input format'+'\n') +get_fasta_in_kraken_format('bacterial_genomes.fa') + +print('Downloading viral genomes'+'\n') +subprocess.call('wget ftp://ftp.ncbi.nlm.nih.gov/refseq/release/viral/viral.*.genomic.gbff.gz',shell=True) +subprocess.call('gunzip *.gz',shell=True) +print('Converting sequences to kraken input format'+'\n') +get_fasta_in_kraken_format('viral_genomes.fa') + +print('Downloading archaeal genomes'+'\n') +subprocess.call('wget ftp://ftp.ncbi.nlm.nih.gov/refseq/release/archaea/archaea.*.genomic.gbff.gz',shell=True) +subprocess.call('gunzip *.gz',shell=True) +print('Converting sequences to kraken input format'+'\n') +get_fasta_in_kraken_format('archaeal_genomes.fa') + +print('Downloading plasmid sequences'+'\n') +subprocess.call('wget ftp://ftp.ncbi.nlm.nih.gov/refseq/release/plasmid/plasmid.*.genomic.gbff.gz', shell=True) +subprocess.call('gunzip *.gz',shell=True) +print('Converting sequences to kraken input format'+'\n') +get_fasta_in_kraken_format('plasmids_genomes.fa') + +#Set name for the krakendb directory +krakendb='HumanVirusBacteria' +subprocess.call('kraken-build --download-taxonomy --db '+krakendb, shell=True) +print('Running Kraken DB build for '+krakendb+'\n') +print('This might take a while '+'\n') +for fasta_file in os.listdir(cwd): + if fasta_file.endswith('.fa') or fasta_file.endswith('.fasta'): + print (fasta_file) + subprocess.call('kraken-build --add-to-library '+fasta_file +' --db '+krakendb,shell=True) +subprocess.call('kraken-build --build --db '+krakendb+' --threads 12',shell=True) +","Python" +"Pathogens","sejmodha/MiscScripts","reorderHCMVContig.py",".py","2697","77","#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""""" +Created on Fri Sep 7 15:56:17 2018 + +@author: sejalmodha +"""""" +import argparse +from Bio import Seq,SeqIO +from pyfaidx import Fasta +from pymummer import nucmer + +#Define all commandline arguments +parser = argparse.ArgumentParser(description='This script runs mummer using python') +parser.add_argument('-q','--query', help='Input query genome fasta file name with one sequence',required=True) +parser.add_argument('-r','--reference',help='Input reference fasta file', required=True) +parser.add_argument('-c','--coordinates',help='Output coordinates file name',required=True) +parser.add_argument('-i','--minidentity',help='Minimum percent identity for filtering results',required=True) +parser.add_argument('-o','--output',help='Output file in fasta format',required=True) +parser.add_argument('-n','--header',help='Header name for output fasta format',required=False) +args = parser.parse_args() + +#function to check input file format - fasta +def checkFormat(file): + #print(file) + inputfile=open(file,'r') + fasta=SeqIO.parse(inputfile,'fasta') + return any(fasta) + +if checkFormat(args.query) == False: + print('Error: Please ensure that QUERY (-q) file is in fasta format') + exit() +if checkFormat(args.reference) == False: + print('Error: Please ensure that REFERENCE (-r) file is in fasta format') + exit() +#check if valid parameter is provided for identity value +if args.minidentity.isdigit() ==False: + print('Error: Identity (-i) threshold must be a numeric value') + exit() +#Set a default header if user-defined header name is absent +if args.header == None: + args.header='reordered_contig' +print(args.header) + +#Save query file in faidx index +contigfile=Fasta(args.query) + +#run nucmer program and filter the coords output file +runner = nucmer.Runner(args.reference,args.query,args.coordinates,min_id=args.minidentity,coords_header=False) +runner.run() + +#open output files +coordsfile=open(args.coordinates) +outfile=open(args.output,'w') + +#reorder the sequences based on the reference genome coordinates +reordered='' +#print(contigfile[0].name) +for line in coordsfile: + fields=line.replace('[BEGIN]','').rstrip('\n').split('\t')[:-1] + #print(fields) + start=int(fields[2]) + end=int(fields[3]) + contigid=''.join((fields[-1:])) + print(str(start)+'\t'+str(end)+'\t'+contigid) + if start > end: + segment=Seq.Seq(contigfile[contigid][end:start].seq).reverse_complement() + #print(segment) + else: + segment=contigfile[contigid][start:end].seq + reordered=reordered+segment +outfile.write('>'+args.header+'\n'+str(reordered)) + + +#close output files +outfile.close() +coordsfile.close()","Python" +"Pathogens","sanger-pathogens/gff3toembl","paper.md",".md","1765","31","--- +title: 'GFF3toEMBL: Preparing annotated assemblies for submission to EMBL' +tags: + - bioinformatics + - annotation + - EMBL +authors: + - name: Andrew J. Page + orcid: 0000-0001-6919-6062 + affiliation: Pathogen Informatics, Wellcome Trust Sanger Institute + - name: Sascha Steinbiss + orcid: 0000-0002-2151-0574 + affiliation: Pathogen Informatics, Wellcome Trust Sanger Institute + - name: Ben Taylor + affiliation: Pathogen Informatics, Wellcome Trust Sanger Institute + - name: Torsten Seemann + orcid: 0000-0001-6046-610X + affiliation: University of Melbourne + - name: Jacqueline A. Keane + orcid: 0000-0002-2021-1863 + affiliation: Pathogen Informatics, Wellcome Trust Sanger Institute + +date: 19 Sept 2016 +bibliography: paper.bib +--- + +# Summary +An essential part of open reproducible research in genomics is the deposition of annotated de novo assembled genomes in public archives such as EMBL/GenBank [@BLAXTER2016]. The interfaces provided by the major archives do not allow for data to be easily submitted on a large scale without substantial prior knowledge on the part of the submitter. This has lead to a situation where less than 15% of all sequenced bacteria have corresponding public assemblies. We address this by providing GFF3toEMBL, which converts the output of the most commonly used automatic annotation tool, Prokka [@SEEMANN2014], and converts it to a format suitable for submission to EMBL. Built on the GenomeTools annotation processing library [@GREMME2013], GFF3toEMBL is robust, fast, memory efficient and well tested, and has been used to submit more than 30% of all annotated genomes in EMBL/GenBank [@PAGE2016]. It is a small, but essential missing step in making genomic research more open and reproducible. + +# References +","Markdown" +"Pathogens","sanger-pathogens/gff3toembl","setup.py",".py","958","31","import os +import glob +import multiprocessing +from setuptools import setup, find_packages + +def read(fname): + return open(os.path.join(os.path.dirname(__file__), fname)).read() + +setup( + name='gff3toembl', + version='1.1.4', + description='Convert a GFF3 file to EMBL format for submission', + long_description=read('README.md'), + packages = find_packages(), + author='Andrew J. Page', + author_email='ap13@sanger.ac.uk', + url='https://github.com/sanger-pathogens/gff3toembl', + scripts=glob.glob('scripts/*'), + test_suite='nose.collector', + install_requires=['six'], + tests_require=['nose >= 1.3', 'mock'], + license='GPLv3', + classifiers=[ + ""License :: OSI Approved :: GNU General Public License (GPLv3)"", + ""Programming Language :: Python"", + ""Development Status :: 4 - Beta"", + ""Intended Audience :: Science/Research"", + ""Topic :: Scientific/Engineering :: Bio-Informatics"", + ], +) +","Python" +"Pathogens","sanger-pathogens/gff3toembl","CHANGELOG.md",".md","12224","187","# Change Log + +## [Unreleased](https://github.com/sanger-pathogens/gff3toembl/tree/HEAD) + +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.1.4...HEAD) + +**Closed issues:** + +- Installation and running problems [\#74](https://github.com/sanger-pathogens/gff3toembl/issues/74) +- mac brew install does not work. [\#63](https://github.com/sanger-pathogens/gff3toembl/issues/63) + +**Merged pull requests:** + +- fix readme and add to codecov [\#75](https://github.com/sanger-pathogens/gff3toembl/pull/75) ([ssjunnebo](https://github.com/ssjunnebo)) +- using six for urllib.parse for support of python 3 [\#73](https://github.com/sanger-pathogens/gff3toembl/pull/73) ([sachalau](https://github.com/sachalau)) +- update LICENSE and AUTHORS [\#72](https://github.com/sanger-pathogens/gff3toembl/pull/72) ([ssjunnebo](https://github.com/ssjunnebo)) + +## [v1.1.4](https://github.com/sanger-pathogens/gff3toembl/tree/v1.1.4) (2016-11-11) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.1.3...v1.1.4) + +**Merged pull requests:** + +- Include XX line between features \(FT\) and sequence \(SQ\) [\#70](https://github.com/sanger-pathogens/gff3toembl/pull/70) ([peterjc](https://github.com/peterjc)) +- Unescape percent encoding from GFF3, then line wrap [\#69](https://github.com/sanger-pathogens/gff3toembl/pull/69) ([peterjc](https://github.com/peterjc)) + +## [v1.1.3](https://github.com/sanger-pathogens/gff3toembl/tree/v1.1.3) (2016-11-10) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.1.2...v1.1.3) + +**Merged pull requests:** + +- More wrapping tests; Fix ignored test [\#68](https://github.com/sanger-pathogens/gff3toembl/pull/68) ([peterjc](https://github.com/peterjc)) + +## [v1.1.2](https://github.com/sanger-pathogens/gff3toembl/tree/v1.1.2) (2016-11-10) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.1.1...v1.1.2) + +**Closed issues:** + +- Sequence header SQ line can exceed 80 characters [\#65](https://github.com/sanger-pathogens/gff3toembl/issues/65) + +**Merged pull requests:** + +- EMBL files wrap at 80 characters, not 79 [\#67](https://github.com/sanger-pathogens/gff3toembl/pull/67) ([peterjc](https://github.com/peterjc)) + +## [v1.1.1](https://github.com/sanger-pathogens/gff3toembl/tree/v1.1.1) (2016-11-09) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.1.0...v1.1.1) + +**Closed issues:** + +- Change PROKKA to Prokka in repo description [\#64](https://github.com/sanger-pathogens/gff3toembl/issues/64) +- linuxbrew recipe needs updating [\#62](https://github.com/sanger-pathogens/gff3toembl/issues/62) + +**Merged pull requests:** + +- Sq exceeds 80 [\#66](https://github.com/sanger-pathogens/gff3toembl/pull/66) ([andrewjpage](https://github.com/andrewjpage)) + +## [v1.1.0](https://github.com/sanger-pathogens/gff3toembl/tree/v1.1.0) (2016-09-21) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.9...v1.1.0) + +**Implemented enhancements:** + +- I have added this to my brew repo \(updated to 1.0.9\) [\#59](https://github.com/sanger-pathogens/gff3toembl/issues/59) + +**Fixed bugs:** + +- Failure to install on Biolinux [\#38](https://github.com/sanger-pathogens/gff3toembl/issues/38) + +**Merged pull requests:** + +- fix typos [\#61](https://github.com/sanger-pathogens/gff3toembl/pull/61) ([satta](https://github.com/satta)) +- Docker file [\#60](https://github.com/sanger-pathogens/gff3toembl/pull/60) ([andrewjpage](https://github.com/andrewjpage)) + +## [v1.0.9](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.9) (2016-05-24) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.8...v1.0.9) + +**Merged pull requests:** + +- check codon start is a number [\#57](https://github.com/sanger-pathogens/gff3toembl/pull/57) ([andrewjpage](https://github.com/andrewjpage)) + +## [v1.0.8](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.8) (2016-05-23) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.6...v1.0.8) + +**Merged pull requests:** + +- Remove colour tag [\#56](https://github.com/sanger-pathogens/gff3toembl/pull/56) ([andrewjpage](https://github.com/andrewjpage)) +- Remove double quoting [\#55](https://github.com/sanger-pathogens/gff3toembl/pull/55) ([andrewjpage](https://github.com/andrewjpage)) +- Break on hyphen [\#54](https://github.com/sanger-pathogens/gff3toembl/pull/54) ([andrewjpage](https://github.com/andrewjpage)) + +## [v1.0.6](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.6) (2016-05-06) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.5...v1.0.6) + +## [v1.0.5](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.5) (2016-05-03) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.3...v1.0.5) + +**Implemented enhancements:** + +- Format for listing authors not defined [\#45](https://github.com/sanger-pathogens/gff3toembl/issues/45) + +**Fixed bugs:** + +- Should unescape %2C in GFF column 9 as comma in EMBL [\#50](https://github.com/sanger-pathogens/gff3toembl/issues/50) +- Document versions of Python supported [\#42](https://github.com/sanger-pathogens/gff3toembl/issues/42) + +**Merged pull requests:** + +- Avoid breaking long words in product attributes [\#53](https://github.com/sanger-pathogens/gff3toembl/pull/53) ([peterjc](https://github.com/peterjc)) +- Un-escape %2C to comma etc for GFF3 to EMBL [\#52](https://github.com/sanger-pathogens/gff3toembl/pull/52) ([peterjc](https://github.com/peterjc)) +- Ec dash [\#49](https://github.com/sanger-pathogens/gff3toembl/pull/49) ([andrewjpage](https://github.com/andrewjpage)) + +## [v1.0.3](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.3) (2015-12-10) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.2...v1.0.3) + +**Fixed bugs:** + +- Long author lists break instead of line wrapping [\#46](https://github.com/sanger-pathogens/gff3toembl/issues/46) + +**Merged pull requests:** + +- Make publication arguments a little more explicit [\#48](https://github.com/sanger-pathogens/gff3toembl/pull/48) ([peterjc](https://github.com/peterjc)) + +## [v1.0.2](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.2) (2015-12-10) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.1...v1.0.2) + +**Closed issues:** + +- self.assertItemsEqual is Python 2.7 only [\#43](https://github.com/sanger-pathogens/gff3toembl/issues/43) +- Non-standard indentation of Python code [\#41](https://github.com/sanger-pathogens/gff3toembl/issues/41) +- Python 3 support [\#40](https://github.com/sanger-pathogens/gff3toembl/issues/40) + +**Merged pull requests:** + +- Wrap publication lines [\#47](https://github.com/sanger-pathogens/gff3toembl/pull/47) ([andrewjpage](https://github.com/andrewjpage)) +- Add note that it only works on Python 2.7 [\#44](https://github.com/sanger-pathogens/gff3toembl/pull/44) ([bewt85](https://github.com/bewt85)) +- Use Python 3 ready exception, print, etc [\#39](https://github.com/sanger-pathogens/gff3toembl/pull/39) ([peterjc](https://github.com/peterjc)) + +## [v1.0.1](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.1) (2015-09-02) +[Full Changelog](https://github.com/sanger-pathogens/gff3toembl/compare/v1.0.0...v1.0.1) + +**Closed issues:** + +- v1.0.0 vs v1.0 [\#36](https://github.com/sanger-pathogens/gff3toembl/issues/36) + +**Merged pull requests:** + +- Complete genome naming [\#37](https://github.com/sanger-pathogens/gff3toembl/pull/37) ([andrewjpage](https://github.com/andrewjpage)) +- README.md: Fix a spelling mistake gff3toemble [\#35](https://github.com/sanger-pathogens/gff3toembl/pull/35) ([sjackman](https://github.com/sjackman)) + +## [v1.0.0](https://github.com/sanger-pathogens/gff3toembl/tree/v1.0.0) (2015-07-13) +**Closed issues:** + +- OSX and dlylib [\#33](https://github.com/sanger-pathogens/gff3toembl/issues/33) +- Does this cope with Prokka GFF3 files ok? [\#23](https://github.com/sanger-pathogens/gff3toembl/issues/23) + +**Merged pull requests:** + +- Add TravisCI Support \(and fix setup.py\) [\#34](https://github.com/sanger-pathogens/gff3toembl/pull/34) ([bewt85](https://github.com/bewt85)) +- case insensitive hypo search [\#32](https://github.com/sanger-pathogens/gff3toembl/pull/32) ([andrewjpage](https://github.com/andrewjpage)) +- get the version of the script with --version [\#31](https://github.com/sanger-pathogens/gff3toembl/pull/31) ([andrewjpage](https://github.com/andrewjpage)) +- Empty product hypo protein [\#30](https://github.com/sanger-pathogens/gff3toembl/pull/30) ([andrewjpage](https://github.com/andrewjpage)) +- Update README and version [\#29](https://github.com/sanger-pathogens/gff3toembl/pull/29) ([bewt85](https://github.com/bewt85)) +- gff3toembl on Mac OS X [\#28](https://github.com/sanger-pathogens/gff3toembl/pull/28) ([satta](https://github.com/satta)) +- Add usage example to readme [\#26](https://github.com/sanger-pathogens/gff3toembl/pull/26) ([bewt85](https://github.com/bewt85)) +- Default ""publication"" to include today's date [\#25](https://github.com/sanger-pathogens/gff3toembl/pull/25) ([bewt85](https://github.com/bewt85)) +- Refactor / rewrite / remove convert.py [\#24](https://github.com/sanger-pathogens/gff3toembl/pull/24) ([bewt85](https://github.com/bewt85)) +- Duplicate entries [\#22](https://github.com/sanger-pathogens/gff3toembl/pull/22) ([andrewjpage](https://github.com/andrewjpage)) +- intermediate gff prefix to suffic [\#21](https://github.com/sanger-pathogens/gff3toembl/pull/21) ([andrewjpage](https://github.com/andrewjpage)) +- sort and tidy gff files with GT [\#20](https://github.com/sanger-pathogens/gff3toembl/pull/20) ([andrewjpage](https://github.com/andrewjpage)) +- Revert rna feature translate [\#19](https://github.com/sanger-pathogens/gff3toembl/pull/19) ([andrewjpage](https://github.com/andrewjpage)) +- No trans table for rna [\#18](https://github.com/sanger-pathogens/gff3toembl/pull/18) ([andrewjpage](https://github.com/andrewjpage)) +- Convert type for 16s [\#17](https://github.com/sanger-pathogens/gff3toembl/pull/17) ([andrewjpage](https://github.com/andrewjpage)) +- Unknown function [\#16](https://github.com/sanger-pathogens/gff3toembl/pull/16) ([andrewjpage](https://github.com/andrewjpage)) +- replace unknown with uncharacterised [\#15](https://github.com/sanger-pathogens/gff3toembl/pull/15) ([andrewjpage](https://github.com/andrewjpage)) +- extra dot [\#14](https://github.com/sanger-pathogens/gff3toembl/pull/14) ([andrewjpage](https://github.com/andrewjpage)) +- passes java validator [\#13](https://github.com/sanger-pathogens/gff3toembl/pull/13) ([andrewjpage](https://github.com/andrewjpage)) +- Update format [\#12](https://github.com/sanger-pathogens/gff3toembl/pull/12) ([andrewjpage](https://github.com/andrewjpage)) +- version [\#11](https://github.com/sanger-pathogens/gff3toembl/pull/11) ([andrewjpage](https://github.com/andrewjpage)) +- Made EC number values unique [\#10](https://github.com/sanger-pathogens/gff3toembl/pull/10) ([aslett1](https://github.com/aslett1)) +- Create Chromosome.txt file [\#9](https://github.com/sanger-pathogens/gff3toembl/pull/9) ([andrewjpage](https://github.com/andrewjpage)) +- update version [\#8](https://github.com/sanger-pathogens/gff3toembl/pull/8) ([andrewjpage](https://github.com/andrewjpage)) +- Add chrom name to source [\#7](https://github.com/sanger-pathogens/gff3toembl/pull/7) ([andrewjpage](https://github.com/andrewjpage)) +- Split lines on words, fix headers and references [\#6](https://github.com/sanger-pathogens/gff3toembl/pull/6) ([andrewjpage](https://github.com/andrewjpage)) +- fix input param names [\#5](https://github.com/sanger-pathogens/gff3toembl/pull/5) ([andrewjpage](https://github.com/andrewjpage)) +- convert inference to db\_xref [\#4](https://github.com/sanger-pathogens/gff3toembl/pull/4) ([andrewjpage](https://github.com/andrewjpage)) +- rename script [\#3](https://github.com/sanger-pathogens/gff3toembl/pull/3) ([andrewjpage](https://github.com/andrewjpage)) +- Working script for converting [\#2](https://github.com/sanger-pathogens/gff3toembl/pull/2) ([andrewjpage](https://github.com/andrewjpage)) +- initial working version [\#1](https://github.com/sanger-pathogens/gff3toembl/pull/1) ([andrewjpage](https://github.com/andrewjpage)) + +","Markdown" +"Pathogens","sanger-pathogens/gff3toembl","install_dependencies.sh",".sh","1932","95","#!/bin/bash + +set -x +set -e + +start_dir=$(pwd) + +GENOMETOOLS_VERSION=""1.5.5"" + +GENOMETOOLS_DOWNLOAD_URL=""https://github.com/genometools/genometools/archive/v${GENOMETOOLS_VERSION}.tar.gz"" + +# Make an install location +if [ ! -d 'build' ]; then + mkdir build +fi +cd build +build_dir=$(pwd) + +# DOWNLOAD ALL THE THINGS +download () { + url=$1 + download_location=$2 + + if [ -e $download_location ]; then + echo ""Skipping download of $url, $download_location already exists"" + else + echo ""Downloading $url to $download_location"" + wget $url -O $download_location + fi +} + +download $GENOMETOOLS_DOWNLOAD_URL ""genometools-${GENOMETOOLS_VERSION}.tgz"" + +# Update dependencies +if [ ""$TRAVIS"" = 'true' ]; then + echo ""Using Travis's apt plugin"" +else + sudo apt-get update -q + sudo apt-get install -y -q g++ \ + python-dev +fi + +# Build all the things +cd $build_dir + +## GenomeTools +genometools_dir=$(pwd)/genometools-${GENOMETOOLS_VERSION} +if [ ! -d $genometools_dir ]; then + tar xzf genometools-${GENOMETOOLS_VERSION}.tgz +fi +cd $genometools_dir +if [ -e ""${genometools_dir}/bin/gt"" ]; then + echo ""Already built GenomeTools; skipping build"" +else + make cairo=no +fi + +cd $build_dir + +# Setup environment variables +update_path () { + new_dir=$1 + export PATH=${PATH:-$new_dir} + if [[ ! ""$PATH"" =~ (^|:)""${new_dir}""(:|$) ]]; then + export PATH=${new_dir}:${PATH} + fi +} + +update_path ${genometools_dir}/bin + +update_python_path () { + new_dir=$1 + export PYTHONPATH=${PYTHONPATH:-$new_dir} + if [[ ! ""$PYTHONPATH"" =~ (^|:)""${new_dir}""(:|$) ]]; then + export PYTHONPATH=${new_dir}:${PYTHONPATH} + fi +} + +update_python_path ${genometools_dir}/gtpython + +update_ld_path () { + new_dir=$1 + export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:-$new_dir} + if [[ ! ""$LD_LIBRARY_PATH"" =~ (^|:)""${new_dir}""(:|$) ]]; then + export LD_LIBRARY_PATH=${new_dir}:${LD_LIBRARY_PATH} + fi +} + +update_ld_path ${genometools_dir}/lib + +cd $start_dir + +set +x +set +e +","Shell" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/__init__.py",".py","0","0","","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/EMBLConverter.py",".py","1946","42","import gff3toembl +from gt import CustomVisitor +from gff3toembl.EMBLContig import EMBLContig + +class EMBLConverter(CustomVisitor): + + def __init__(self, locus_tag=None, translation_table=11): + CustomVisitor.__init__(self) + self.contigs = {} + self.locus_tag = locus_tag + self.translation_table = translation_table + + def visit_feature_node(self, feature_node): + sequence_id = feature_node.get_seqid() + contig = self.contigs.get(sequence_id) + if contig: # contig already exists, just try and update it + contig.add_feature(sequence_id = sequence_id, feature_type = feature_node.get_type(), start = feature_node.get_start(), + end = feature_node.get_end(), strand = feature_node.get_strand(), + feature_attributes = feature_node.attribs, + locus_tag = self.locus_tag, translation_table = self.translation_table) + else: + contig = EMBLContig() + successfully_added_feature = contig.add_feature(sequence_id = sequence_id, feature_type = feature_node.get_type(), start = feature_node.get_start(), + end = feature_node.get_end(), strand = feature_node.get_strand(), + feature_attributes = feature_node.attribs, + locus_tag = self.locus_tag, translation_table = self.translation_table) + if successfully_added_feature: + self.contigs[sequence_id] = contig + else: + pass # discard the contig because we didn't add a feature so it is empty + + def visit_region_node(self, region_node): + pass # for now + + def visit_comment_node(self, comment_node): + pass # for now + + def visit_sequence_node(self, sequence_node): + sequence_id = sequence_node.get_description() + contig = self.contigs.setdefault(sequence_id, EMBLContig()) + contig.add_sequence(sequence_node.get_sequence()) +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/VisitorStream.py",".py","356","16","import sys +from gt import CustomStream + +class VisitorStream(CustomStream): + + def __init__(self, instream, visitor): + CustomStream.__init__(self) + self.instream = instream + self.visitor = visitor + + def next(self): + node = self.instream.next_tree() + if node: + node.accept(self.visitor) + return node +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/EMBLWriter.py",".py","4237","100","import sys +import subprocess +from gt import GFF3InStream +import os +import re + +from gff3toembl.EMBLConverter import EMBLConverter +from gff3toembl.VisitorStream import VisitorStream + +class EMBLWriter(object): + + def __init__(self, gff3_file, organism, taxonid, project, description, authors, title, publication, genome_type, classification, output_filename, locus_tag = None, translation_table = 11, chromosome_list = None): + self.locus_tag = locus_tag + self.translation_table = translation_table + self.conv = EMBLConverter(locus_tag, translation_table) + self.gff3_file = gff3_file + self.organism = organism + self.taxonid = taxonid + self.project = project + self.authors = authors + self.title = title + self.publication = publication + self.genome_type = genome_type + self.classification = classification + self.output_filename = output_filename + self.chromosome_list = chromosome_list + self.fixed_gff_file = str(self.gff3_file)+""_fixed.gff"" + + def create_output_file(self, organism, taxonid, project, authors, title, publication, genome_type, classification): + target = open(self.output_filename, 'w') + for sequence_identifier, contig in sorted(self.conv.contigs.items()): + contig.add_header( + authors = authors, + classification = classification, + genome_type = genome_type, + organism = organism, + project = project, + publication = publication, + sequence_identifier = sequence_identifier, + sequence_length = contig.sequence.length, + sequence_name = sequence_identifier, + taxon_id = taxonid, + title = title, + ) + target.write(contig.format()) + target.write(""//\n"") + target.close() + + def create_chromosome_list(self, chromosome_list_filename, embl_filename): + if chromosome_list_filename == None: + return + if not os.path.exists(embl_filename): + return + + embl_file = open(embl_filename, 'r') + chromosome_list_file = open(chromosome_list_filename, 'w') + object_accessions = [] + object_sizes = [] + + for embl_line in embl_file.readlines(): + sequence_size_match = re.search(""; (\d+) BP."", embl_line) + if sequence_size_match != None and sequence_size_match.group(1): + object_sizes.append(int(sequence_size_match.group(1))) + m = re.match(""AC \* _(\w+)"", embl_line) + if m != None and m.group(1): + object_accessions.append(m.group(1)) + + for index, object_accession in enumerate(object_accessions): + chromosome_name = str((index+1)) + # TODO make it work for more than just Bacteria + chromosome_type = ""Chromosome"" + + chr_name_search = re.search(""chr"", object_accession) + if chr_name_search != None and chr_name_search.group(): + chromosome_type = ""Chromosome"" + elif index > 0 and object_sizes[index] < 1000000: + chromosome_type = ""Plasmid"" + chromosome_list_file.write(object_accession + ""\t"" + chromosome_name + ""\t"" + chromosome_type + ""\n"") + + def sort_and_tidy_gff_file(self): + try: + subprocess.check_call(""gt gff3 -force -sort -retainids -tidy -o ""+str(self.fixed_gff_file)+"" ""+str(self.gff3_file), shell=True) + except: + sys.exit(""Failed to sort and tidy gff file with GT"") + + def parse_and_run(self): + self.sort_and_tidy_gff_file() + ins = GFF3InStream(self.fixed_gff_file) + vs = VisitorStream(ins, self.conv) + try: + while (vs.next_tree()): + pass + except Exception as e: + print(e) + exit(1) + self.create_output_file(self.organism, self.taxonid, self.project, self.authors, self.title, self.publication, self.genome_type, self.classification) + self.create_chromosome_list(self.chromosome_list, self.output_filename) + os.remove(self.fixed_gff_file) + +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/EMBLContig.py",".py","19185","453","import re +from textwrap import TextWrapper +from six.moves.urllib.parse import unquote as gff3_unescape + +class EMBLContig(object): + def __init__(self): + self.header = None + self.features = {} + self.sequence = None + + def format(self): + try: + header = self.header.format() + except AttributeError: + raise ValueError(""Could not format contig, no header data found"") + feature_strings = [feature.format() for feature in self.sorted_features()] + features = """".join(feature_strings) + try: + sequence = self.sequence.format() + except AttributeError: + raise ValueError(""Could not format contig, no sequence data found"") + formatted_string = header + features + sequence + header_features_formatted_string = header + features + line_lengths = map(len, header_features_formatted_string.split('\n')) + maximum_line_length = max(line_lengths) + if maximum_line_length > 80: + raise ValueError(""Could not format contig, a line exceeded 80 characters in length"") + return formatted_string + + def add_header(self, **kwargs): + if self.header != None: + raise ValueError(""Contig already has header data"") + header = EMBLHeader(**kwargs) + self.header = header + + def add_feature(self, sequence_id, **kwargs): + feature = EMBLFeature(**kwargs) + unique_feature_reference = ""{}_{}_{}_{}"".format(sequence_id, feature.feature_type, feature.start, feature.end) + if unique_feature_reference in self.features: + # we're already seen a feature in this region so don't add another + return False + elif feature.format() == None: + # some feature types should be ignored; format() returns None in these cases + return False + else: + self.features[unique_feature_reference] = feature + return True + + def add_sequence(self, sequence_string): + if self.sequence != None: + raise ValueError(""Contig already has sequence data"") + sequence = EMBLSequence(sequence_string) + self.sequence = sequence + + def sorted_features(self): + # Features should be sorted by start and then by end irrespective of strand + def sort_key(feature): + return (feature.start, feature.end) + return sorted(self.features.values(), key=sort_key) + +class EMBLFeature(object): + inference_to_db_xref_map = { + 'similar to AA sequence:UniProtKB': 'UniProtKB/Swiss-Prot', + 'protein motif:Pfam': 'PFAM', + 'protein motif:CLUSTERS': ""CDD"", + 'protein motif:Cdd': ""CDD"", + 'protein motif:TIGRFAMs': ""TIGRFAM"" + } + + def __init__(self, feature_type, start, end, strand, feature_attributes, + locus_tag=None, translation_table=11): + # Picks a feature builder and builds the feature + # Most features are built with a default but some are either a little different or + # should just be ignored + feature_builder = self.pick_feature_builder(feature_type) + feature_builder(feature_type=feature_type, start=start, end=end, strand=strand, + feature_attributes=feature_attributes, locus_tag=locus_tag, + translation_table=translation_table) + + def pick_feature_builder(self, feature_type): + feature_builders = { + 'CDS': self.create_CDS_feature, + 'source': self.create_source_feature, + 'ncRNA': self.create_empty_feature + } + return feature_builders.get(feature_type, self.create_default_feature) + + def create_default_feature(self, feature_type, start, end, strand, feature_attributes, locus_tag, translation_table): + self.feature_type = feature_type + self.start = start + self.end = end + self.strand = strand + self.locus_tag = locus_tag + self.translation_table = translation_table + self.attributes = [] + for attribute_key, attribute_value in feature_attributes.items(): + attribute_creator = self.lookup_attribute_creator(attribute_key) + new_attributes = attribute_creator(attribute_key, attribute_value) + self.attributes += new_attributes + + def create_CDS_feature(self, **kwargs): + self.create_default_feature(**kwargs) + self.attributes += self.create_translation_table_attributes('transl_table', self.translation_table) + + def create_source_feature(self, feature_type, start, end, strand, feature_attributes, locus_tag, translation_table): + self.feature_type = feature_type + self.start = start + self.end = end + self.strand = strand + self.locus_tag = locus_tag + self.translation_table = translation_table + + organism = feature_attributes['organism'] + db_xref = feature_attributes['db_xref'] + note = feature_attributes['note'] + + # We hard code the order and composition of attributes for source features + # Source features are only created as part of the header + self.attributes = [(""organism"", organism), (""mol_type"", ""genomic DNA""), (""db_xref"", db_xref), (""note"", note)] + + def create_empty_feature(self, **kwargs): + # Some features should be ignored. This is how this is done + self.format = lambda: None + + def format(self): + coordinates = self.format_coordinates(self.start, self.end, self.strand) + header_string = ""FT {feature_type: <16}{coordinates}"".format( feature_type=self.feature_type, + coordinates=coordinates) + attribute_strings = [header_string] + for attribute_key,attribute_value in self.attributes: + attribute_strings.append(self.format_attribute(attribute_key, attribute_value)) + + return '\n'.join(attribute_strings) + '\n' + + def format_attribute(self, key, value): + # Looks up a formatter for an attribute and formats the attribute + # Some attributes are formatted a little differently + # Also un-escapes the GFF3 mandated percent encoding here + formatter = self.lookup_attribute_formatter(key) + return formatter(key, gff3_unescape(str(value))) + + def lookup_attribute_formatter(self, attribute_type): + formatters = { + 'transl_table': self.number_attribute_formatter, + 'product': self.product_attribute_formatter, + 'codon_start': self.number_attribute_formatter, + + } + return formatters.get(attribute_type, self.default_attribute_formatter) + + def number_attribute_formatter(self, key, value): + # transl_table attributes do not have their values in quotes + wrapper = TextWrapper() + wrapper.initial_indent='FT ' + wrapper.subsequent_indent='FT ' + wrapper.width=80 # can use 80 characters plus the new line + attribute_text_template='/{attribute_key}={attribute_value}' + attribute_text=attribute_text_template.format(attribute_key=key, attribute_value=value) + return wrapper.fill(attribute_text) + + def product_attribute_formatter(self, key, value): + # Products can include very long enzyme names which we don't want to break + wrapper = TextWrapper() + wrapper.initial_indent='FT ' + wrapper.subsequent_indent='FT ' + wrapper.width=80 # can use 80 characters plus the new line + wrapper.break_on_hyphens=True + attribute_text_template='/{attribute_key}=""{attribute_value}""' + attribute_text=attribute_text_template.format(attribute_key=key, attribute_value=value) + return wrapper.fill(attribute_text) + + def default_attribute_formatter(self, key, value): + wrapper = TextWrapper() + wrapper.initial_indent='FT ' + wrapper.subsequent_indent='FT ' + wrapper.width=80 # can use 80 characters plus the new line + attribute_text_template='/{attribute_key}=""{attribute_value}""' + attribute_text=attribute_text_template.format(attribute_key=key, attribute_value=value) + return wrapper.fill(attribute_text) + + def format_coordinates(self, start, end, strand): + if strand == '-': + return ""complement({start}..{end})"".format(start=start, end=end) + else: + return ""{start}..{end}"".format(start=start, end=end) + + def lookup_attribute_creator(self, attribute_key): + # These functions take attributes and reformat them into a list + # of (key, values) which are later formatted into strings by other + # methods. There is quite a lot of variation between these such as + # whether to keep more than one value for a given attribute type. + attribute_creator_table = { + 'product': self.create_product_attributes, + 'locus_tag': self.create_locus_tag_attributes, + 'eC_number': self.create_EC_number_attributes, + 'inference': self.create_inference_attributes, + 'protein_id': self.ignore_attributes, + 'ID': self.ignore_attributes, + 'codon_start': self.create_number_attributes, + 'colour': self.ignore_attributes + } + return attribute_creator_table.get(attribute_key, self.create_default_attributes) + + def create_number_attributes(self, attribute_key, attribute_value): + def strip_quotes(value): + return value.strip('""') + def remove_empty_strings(value): + return value != '' + attribute_values = attribute_value.split(',') + attribute_values = map(strip_quotes, attribute_values) + attribute_values = list(filter(remove_empty_strings, attribute_values)) + if len(attribute_values) > 0: + first_attribute_value = attribute_values[0] + else: + return [] + try: + first_attribute_value = int(first_attribute_value) + except TypeError: + first_attribute_value = 0 + return [(attribute_key, first_attribute_value)] + + def create_default_attributes(self, attribute_key, attribute_value): + def strip_quotes(value): + return value.strip('""') + def remove_empty_strings(value): + return value != '' + attribute_values = attribute_value.split(',') + attribute_values = map(strip_quotes, attribute_values) + attribute_values = list(filter(remove_empty_strings, attribute_values)) + if len(attribute_values) > 0: + first_attribute_value = attribute_values[0] + else: + return [] + return [(attribute_key, first_attribute_value)] + + def create_product_attributes(self, attribute_key, attribute_value): + def remove_hypotheticals(value): + return 'hypothetical protein' not in value.lower() + def replace_unknown_with_uncharacterised(value): + return value.replace(""nknown"",""ncharacterised"") + def strip_quotes(value): + return value.strip('""') + def remove_empty_strings(value): + return value != '' + # attribute_value may be a comma deliminated list of values + # only some of which might be valid + attribute_values = attribute_value.split(',') + attribute_values = map(strip_quotes, attribute_values) + attribute_values = filter(remove_hypotheticals, attribute_values) + attribute_values = map(replace_unknown_with_uncharacterised, attribute_values) + attribute_values = list(filter(remove_empty_strings, attribute_values)) + chosen_value = attribute_values[0] if len(attribute_values) > 0 else 'Uncharacterised protein' + return [('product', chosen_value)] + + def create_locus_tag_attributes(self, attribute_key, attribute_value): + if self.locus_tag == None: + return [('locus_tag', attribute_value.strip('""'))] + else: + attribute_value_suffix = attribute_value.split('_')[-1] + return [('locus_tag', ""{}_{}"".format(self.locus_tag, attribute_value_suffix.strip('""')))] + + def create_EC_number_attributes(self, attribute_key, attribute_value): + attribute_values = attribute_value.split(',') + def deduplicate_values(values): + return list(set(values)) + def strip_quotes(value): + return value.strip('""') + attribute_values = deduplicate_values(attribute_values) + attribute_values = map(strip_quotes, attribute_values) + + def remove_invalidnumber(value): + return re.match(""^[\d]+\.[\d-]+\.[\d-]+\.[\d-]+$"", value) + + attribute_values = filter(remove_invalidnumber, attribute_values) + + return [('EC_number', value) for value in attribute_values] + + def create_inference_attributes(self, attribute_key, attribute_value): + def strip_quotes(value): + return value.strip('""') + attribute_values = attribute_value.split(',') + attribute_values = map(strip_quotes, attribute_values) + attributes = [] + for value in attribute_values: + if self.should_convert_to_db_xref(value): + attributes.append(('db_xref', self.convert_to_db_xref(value))) + else: + attributes.append(('inference', value)) + return attributes + + def ignore_attributes(self, attribute_key, attribute_value): + return [] + + def should_convert_to_db_xref(self, attribute_value): + for search_text in self.inference_to_db_xref_map: + if search_text in attribute_value: + return True + return False + + def convert_to_db_xref(self, attribute_value): + for search_text, replacement_text in self.inference_to_db_xref_map.items(): + if search_text in attribute_value: + return attribute_value.replace(search_text, replacement_text) + raise ValueError(""Failed to convert inference attribute '%s' to db_xref"" % attribute_value) + + def create_translation_table_attributes(self, attribute_key, attribute_value): + return [('transl_table', attribute_value)] + +class EMBLHeader(object): + def __init__(self, + authors=""Pathogen Genomics"", + classification=""UNC"", + genome_type=""circular"", + organism=None, + project="""", + publication=""Unpublished"", + sequence_identifier="""", + sequence_length="""", + sequence_name=None, + taxon_id=None, + title=""Draft assembly annotated with Prokka"", + ): + self.authors=authors + self.classification=classification + self.genome_type=genome_type + self.organism=organism + self.project=project + self.publication=publication + self.sequence_identifier=self.remove_non_word_characters(sequence_identifier) + self.sequence_length=sequence_length + self.sequence_name=sequence_name + self.taxon_id=taxon_id + self.title=title + + source_attributes = self.build_source_attributes(organism, taxon_id, sequence_name) + self.source_feature = EMBLFeature(feature_type='source', start=1, end=sequence_length, + strand='+', feature_attributes=source_attributes) + self.header_template = """"""\ +ID XXX; XXX; {genome_type}; genomic DNA; STD; {classification}; {sequence_length} BP. +XX +AC XXX; +XX +AC * _{sequence_identifier} +XX +{project_line} +XX +DE XXX; +XX +RN [1] +{publication_authors} +{publication_title} +{publication_name} +XX +FH Key Location/Qualifiers +FH +"""""" + + def header_attribute_formatter(self, key, header_text, quote_character, final_character): + wrapper = TextWrapper() + wrapper.initial_indent=key + ' ' + wrapper.subsequent_indent=key + ' ' + wrapper.width=80 # can use 80 characters plus the new line + attribute_text_template='{attribute_quote_character}{attribute_header_text}{attribute_quote_character}{attribute_final_character}' + attribute_text=attribute_text_template.format(attribute_header_text = header_text, + attribute_quote_character = quote_character, + attribute_final_character = final_character) + return wrapper.fill(attribute_text) + + def remove_non_word_characters(self, sequence_identifier): + return re.sub(r'\W+', '', sequence_identifier) + + def format(self): + project_line = self.header_attribute_formatter(""PR"", ""Project:"" + self.project, '', ';' ) + publication_authors = self.header_attribute_formatter(""RA"", self.authors,'',';' ) + publication_title = self.header_attribute_formatter(""RT"", self.title,'""',';' ) + publication_name = self.header_attribute_formatter(""RL"", self.publication,'','.' ) + return self.header_template.format(project_line = project_line, + publication_authors = publication_authors, + publication_title = publication_title, + publication_name = publication_name, **self.__dict__) + self.source_feature.format() + + def build_source_attributes(self, organism, taxon_id, sequence_name): + def empty_string_if_none(value): + return value if value else '' + organism = empty_string_if_none(organism) + taxon_id = empty_string_if_none(taxon_id) + sequence_name = empty_string_if_none(sequence_name) + return {""organism"": organism, ""db_xref"": ""taxon:{}"".format(taxon_id), ""note"": sequence_name} + +class EMBLSequence(object): + + def __init__(self, sequence_string): + nucleotide_counts = self.calculate_nucleotide_counts(sequence_string) + self.header = self.format_header(nucleotide_counts) + self.body = self.format_sequence_body(sequence_string) + self.length = len(sequence_string) + + def format(self): + return self.header + '\n' + self.body + + def calculate_nucleotide_counts(self, sequence): + sequence = sequence.lower() + counts = {} + counts['a'] = sequence.count('a') + counts['c'] = sequence.count('c') + counts['g'] = sequence.count('g') + counts['t'] = sequence.count('t') + count_of_acgt = sum(counts.values()) + counts['other'] = len(sequence) - count_of_acgt + return counts + + def format_header(self, nucleotide_counts): + # The SQ line can exceed 80 characters + template = ""XX\nSQ Sequence {total} BP; {a} A; {c} C; {g} G; {t} T; {other} other;"" + total_counts = sum(nucleotide_counts.values()) + nucleotide_counts['total'] = total_counts + return template.format(**nucleotide_counts) + + def format_sequence_body(self, sequence_string): + sequence_string = sequence_string.lower() + lines = self.split_sequence(sequence_string) + def format_a_line(line): + # a line looks like: + # ([""1234567890"", ""12345"", '', '', '', ''], 15) + # and should look like + # "" 1234567890 12345 15"" + blocks_of_sequence, end_of_line = line + format_arguments = blocks_of_sequence + [end_of_line] + return "" {:<10} {:<10} {:<10} {:<10} {:<10} {:<10} {:>9}"".format(*format_arguments) + formatted_lines = map(format_a_line, lines) + return '\n'.join(formatted_lines) + '\n' + + def split_line_of_sequence(self, line_of_sequence): + # Turns ""123456789012345"" into [""1234567890"", ""12345"", '', '', '', ''] + splits = [] + line_breaks = range(0, 60, 10) + for line_break in line_breaks: + split = line_of_sequence[line_break:line_break+10] + splits.append(split) + return splits + + def split_sequence(self, sequence_string): + splits = [] + sequence_length = len(sequence_string) + for start_of_line in range(0, sequence_length, 60): + # might not actually be the end of the line if the line isn't long enough + end_of_line = start_of_line + 60 + line_of_sequence = sequence_string[start_of_line:end_of_line] + length_of_line = len(line_of_sequence) + end_of_line = start_of_line + length_of_line # actually end of the line + splits.append((self.split_line_of_sequence(line_of_sequence), end_of_line)) + return splits +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/tests/EMBLConverter_test.py",".py","3646","79","import unittest +import mock +from gff3toembl.EMBLConverter import EMBLConverter +from gff3toembl.EMBLContig import EMBLContig + +class TestEMBLConverter(unittest.TestCase): + + def mock_feature_node(self, seqid, feature_type, start, end, strand, attributes): + mock_methods = { + 'get_seqid.return_value': seqid, + 'get_type.return_value': feature_type, + 'get_start.return_value': start, + 'get_end.return_value': end, + 'get_strand.return_value': strand + } + return mock.Mock(attribs={'attribute_key': attributes}, **mock_methods) + + @mock.patch('gff3toembl.EMBLContig.EMBLFeature') + def test_visit_features_node_feature_ignored(self, embl_feature_mock): + converter = EMBLConverter(None) + + feature_node = self.mock_feature_node(1, 'ignored_type', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = None + converter.visit_feature_node(feature_node) + self.assertEqual(converter.contigs, {}) + + @mock.patch('gff3toembl.EMBLContig.EMBLFeature') + def test_visit_features_node_feature_included(self, embl_feature_mock): + converter = EMBLConverter(None) + + feature_node = self.mock_feature_node(1, 'type_1', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = 'Feature_string' + converter.visit_feature_node(feature_node) + self.assertEqual(converter.contigs.keys(), [1]) + self.assertIsInstance(converter.contigs[1], EMBLContig) + + @mock.patch('gff3toembl.EMBLContig.EMBLFeature') + def test_visit_features_node_one_feature_included_one_ignored(self, embl_feature_mock): + converter = EMBLConverter(None) + + feature_node = self.mock_feature_node(1, 'type_1', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = 'Feature_string' + converter.visit_feature_node(feature_node) + + feature_node = self.mock_feature_node(2, 'ignored_type', 101, 200, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = None + converter.visit_feature_node(feature_node) + self.assertEqual(converter.contigs.keys(), [1]) + self.assertIsInstance(converter.contigs[1], EMBLContig) + + @mock.patch('gff3toembl.EMBLContig.EMBLFeature') + def test_visit_features_node_two_different_features(self, embl_feature_mock): + converter = EMBLConverter(None) + + feature_node = self.mock_feature_node(1, 'type_1', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = 'Feature_string' + converter.visit_feature_node(feature_node) + + feature_node = self.mock_feature_node(2, 'type_2', 101, 200, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = ""Another_feature_string"" + converter.visit_feature_node(feature_node) + self.assertEqual(converter.contigs.keys(), [1, 2]) + self.assertIsInstance(converter.contigs[1], EMBLContig) + self.assertIsInstance(converter.contigs[2], EMBLContig) + + @mock.patch('gff3toembl.EMBLContig.EMBLFeature') + def test_visit_features_node_repeated_features(self, embl_feature_mock): + converter = EMBLConverter(None) + + feature_node = self.mock_feature_node(1, 'type_1', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = 'Feature_string' + converter.visit_feature_node(feature_node) + + feature_node = self.mock_feature_node(1, 'type_1', 1, 100, '', {'attr_k1': 'attr_v1'}) + embl_feature_mock.return_value.format.return_value = 'Feature_string' + converter.visit_feature_node(feature_node) + self.assertEqual(converter.contigs.keys(), [1]) + self.assertIsInstance(converter.contigs[1], EMBLContig) +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/tests/EMBLContig_test.py",".py","44656","1039","import unittest +from mock import MagicMock, patch +from gff3toembl.EMBLContig import EMBLContig, EMBLHeader, EMBLFeature, EMBLSequence + + +class TestEMBLContig(unittest.TestCase): + + def create_blank_bit_of_contig(self): + contig_mock = MagicMock() + contig_mock.format.return_value = """" + return contig_mock + + def test_format(self): + contig = EMBLContig() + header_mock = MagicMock() + feature_mock_1 = MagicMock() + feature_mock_2 = MagicMock() + sequence_mock = MagicMock() + header_mock.format.return_value = ""Header\n"" + feature_mock_1.format.return_value = ""Feature 1\n"" + feature_mock_1.start = 0 + feature_mock_2.format.return_value = ""Feature 2\n"" + feature_mock_2.start = 100 + sequence_mock.format.return_value = ""Sequence\n"" + contig.header = header_mock + contig.features = {1: feature_mock_1, 2: feature_mock_2} + contig.sequence = sequence_mock + calculated_string = contig.format() + expected_string = """"""\ +Header +Feature 1 +Feature 2 +Sequence +"""""" + self.assertEqual(calculated_string, expected_string) + + def test_add_feature(self): + contig = EMBLContig() + contig.add_feature( + sequence_id = 1, + feature_type = 'tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + self.assertEqual(len(contig.features), 1) + + def test_add_duplicate_feature(self): + contig = EMBLContig() + contig.add_feature( + sequence_id = 1, + feature_type = 'tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + contig.add_feature( + sequence_id = 1, + feature_type = 'tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + self.assertEqual(len(contig.features), 1) + + @patch('gff3toembl.EMBLContig.EMBLFeature') + def test_add_ignored_feature(self, feature_mock): + contig = EMBLContig() + feature_mock.return_value.format.side_effect = lambda: None + contig.add_feature( + sequence_id = 1, + feature_type = 'tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + self.assertEquals(contig.features, {}) + + def test_format_no_features(self): + contig = EMBLContig() + contig.header = self.create_blank_bit_of_contig() + contig.sequence = self.create_blank_bit_of_contig() + self.assertEquals(contig.format(), '') + + def test_get_sorted_features(self): + # Must be able to get a list of features sorted by (start, end) irrespective of strand + contig = EMBLContig() + feature_1 = MagicMock() + feature_1.start = 100 + feature_1.end = 200 + feature_2 = MagicMock() + feature_2.start = 1100 + feature_2.end = 1200 + + contig.features = {1: feature_1, 2: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_2, 1: feature_1} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_1, 1: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + def test_get_sorted_features_2(self): + # Must be able to get a list of features sorted by (start, end) irrespective of strand + contig = EMBLContig() + feature_1 = MagicMock() + feature_1.start = 100 + feature_1.end = 2000 + feature_2 = MagicMock() + feature_2.start = 1100 + feature_2.end = 1200 + + contig.features = {1: feature_1, 2: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_2, 1: feature_1} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_1, 1: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + def test_get_sorted_features_3(self): + # Must be able to get a list of features sorted by (start, end) irrespective of strand + contig = EMBLContig() + feature_1 = MagicMock() + feature_1.start = 100 + feature_1.end = 1500 + feature_2 = MagicMock() + feature_2.start = 1100 + feature_2.end = 2000 + + contig.features = {1: feature_1, 2: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_2, 1: feature_1} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + contig.features = {2: feature_1, 1: feature_2} + expected_features = [feature_1, feature_2] + self.assertEquals(contig.sorted_features(), expected_features) + + def test_add_sequence(self): + contig = EMBLContig() + contig.header = self.create_blank_bit_of_contig() + contig.features['feature_1'] = self.create_blank_bit_of_contig() + contig.add_sequence('AAAACCCGGTNN') + self.assertIsInstance(contig.sequence, EMBLSequence) + self.assertRaises(ValueError, contig.add_sequence, 'AAAACCCGGTNN') + + def test_format_no_sequence(self): + contig = EMBLContig() + contig.header = self.create_blank_bit_of_contig() + contig.features['feature_1'] = self.create_blank_bit_of_contig() + self.assertEqual(contig.sequence, None) + self.assertRaises(ValueError, contig.format) + + def test_add_header(self): + contig = EMBLContig() + contig.features['feature_1'] = self.create_blank_bit_of_contig() + contig.sequence = self.create_blank_bit_of_contig() + header_details = { + ""authors"": ""John Doe"", + ""classification"": ""UNC"", + ""genome_type"": ""circular"", + ""organism"": ""My organism"", + ""project"": ""PRJ1234"", + ""publication"": ""Unpublished"", + ""sequence_identifier"": ""**contig123"", + ""sequence_length"": 8, + ""sequence_name"": ""chromX"", + ""taxon_id"": 5678, + ""title"": ""My title"" + } + contig.add_header(**header_details) + self.assertIsInstance(contig.header, EMBLHeader) + with self.assertRaises(ValueError): + contig.add_header(**header_details) + + def test_format_no_header(self): + contig = EMBLContig() + contig.features['feature_1'] = self.create_blank_bit_of_contig() + contig.sequence = self.create_blank_bit_of_contig() + self.assertEqual(contig.header, None) + self.assertRaises(ValueError, contig.format) + +class TestEMBLHeader(unittest.TestCase): + + def test_initialize_header_object(self): + header = EMBLHeader( + authors=""John Doe"", + classification=""UNC"", + genome_type=""circular"", + organism=""My organism"", + project=""PRJ1234"", + publication=""Unpublished"", + sequence_identifier=""**contig123"", + sequence_length=8, + sequence_name=""chromX"", + taxon_id=5678, + title=""My title"" + ) + + self.assertEqual(header.authors, ""John Doe"") + self.assertEqual(header.classification, ""UNC"") + self.assertEqual(header.genome_type, ""circular"") + self.assertEqual(header.organism, ""My organism"") + self.assertEqual(header.project, ""PRJ1234"") + self.assertEqual(header.publication, ""Unpublished"") + self.assertEqual(header.sequence_identifier, ""contig123"") # Removed non-word characters + self.assertEqual(header.sequence_length, 8) + self.assertEqual(header.sequence_name, ""chromX"") + self.assertEqual(header.taxon_id, 5678) + self.assertEqual(header.title, ""My title"") + self.assertIsInstance(header.source_feature, EMBLFeature) + + def test_remove_non_word_characters(self): + header = EMBLHeader() + test_cases = [ + ('foo', 'foo'), + ('#foo', 'foo'), + ('#fo!o', 'foo'), + ('fo#o', 'foo'), + ('foo##', 'foo'), + (""*!#foo"", 'foo') + ] + for test_string, expected_result in test_cases: + self.assertEqual(header.remove_non_word_characters(test_string), expected_result) + + def test_format(self): + header = EMBLHeader() + + header.authors=""John Doe"" + header.classification=""UNC"" + header.genome_type=""circular"" + header.organism=""My organism"" + header.project=""PRJ1234"" + header.publication=""Unpublished"" + header.sequence_identifier=""contig123"" + header.sequence_length=1234 + header.sequence_name=""chromX"" + header.taxon_id=5678 + header.title=""My title"" + source_attributes = {""organism"": ""My organism"", ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + header.source_feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + expected_header = """"""\ +ID XXX; XXX; circular; genomic DNA; STD; UNC; 1234 BP. +XX +AC XXX; +XX +AC * _contig123 +XX +PR Project:PRJ1234; +XX +DE XXX; +XX +RN [1] +RA John Doe; +RT ""My title""; +RL Unpublished. +XX +FH Key Location/Qualifiers +FH +FT source 1..1234 +FT /organism=""My organism"" +FT /mol_type=""genomic DNA"" +FT /db_xref=""taxon:5678"" +FT /note=""chromX"" +"""""" + calculated_header = header.format() + for calculated_line,expected_line in zip(calculated_header.split('\n'), expected_header.split('\n')): + self.assertEqual(calculated_line, expected_line) + self.assertEqual(len(calculated_header), len(expected_header)) + + + + + def test_format_long_organism_name(self): + header = EMBLHeader() + + header.authors=""John Doe"" + header.classification=""UNC"" + header.genome_type=""circular"" + header.organism=""reeeeeeeeeeeeeeaaaaaaaaaaaaaallllllllllyyyyyyyyyyyyyyyyyyyy_long_name"" + header.project=""PRJ1234"" + header.publication=""Unpublished"" + header.sequence_identifier=""contig123"" + header.sequence_length=1234 + header.sequence_name=""chromX"" + header.taxon_id=5678 + header.title=""My title"" + source_attributes = {""organism"": header.organism, ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + header.source_feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + expected_header = """"""\ +ID XXX; XXX; circular; genomic DNA; STD; UNC; 1234 BP. +XX +AC XXX; +XX +AC * _contig123 +XX +PR Project:PRJ1234; +XX +DE XXX; +XX +RN [1] +RA John Doe; +RT ""My title""; +RL Unpublished. +XX +FH Key Location/Qualifiers +FH +FT source 1..1234 +FT /organism=""reeeeeeeeeeeeeeaaaaaaaaaaaaaallllllllllyyyyyyyyy +FT yyyyyyyyyyy_long_name"" +FT /mol_type=""genomic DNA"" +FT /db_xref=""taxon:5678"" +FT /note=""chromX"" +"""""" + + calculated_header = header.format() + for calculated_line,expected_line in zip(calculated_header.split('\n'), expected_header.split('\n')): + self.assertEqual(calculated_line, expected_line) + self.assertEqual(len(calculated_header), len(expected_header)) + + + def test_format_long_publication(self): + header = EMBLHeader() + + header.authors=""Jagger M., Richards K., Watts C., Wood R., Jones B., Stewart I., Wyman B., Taylor M."" + header.classification=""UNC"" + header.genome_type=""circular"" + header.organism=""organism"" + header.project=""PRJ1234"" + header.publication=""The Rolling Stones, 12 X 5, The Rolling Stones No. 2, Out of Our Heads, Aftermath, Between the Buttons, Their Satanic Majesties Request, Beggars Banquet"" + header.sequence_identifier=""contig123"" + header.sequence_length=1234 + header.sequence_name=""chromX"" + header.taxon_id=5678 + header.title=""Let It Bleed, Sticky Fingers, Exile on Main St., Goats Head Soup, It's Only Rock 'n Roll, Black and Blue, Some Girls, Emotional Rescue, Tattoo You, Undercover"" + source_attributes = {""organism"": header.organism, ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + header.source_feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + expected_header = """"""\ +ID XXX; XXX; circular; genomic DNA; STD; UNC; 1234 BP. +XX +AC XXX; +XX +AC * _contig123 +XX +PR Project:PRJ1234; +XX +DE XXX; +XX +RN [1] +RA Jagger M., Richards K., Watts C., Wood R., Jones B., Stewart I., Wyman B., +RA Taylor M.; +RT ""Let It Bleed, Sticky Fingers, Exile on Main St., Goats Head Soup, It's +RT Only Rock 'n Roll, Black and Blue, Some Girls, Emotional Rescue, Tattoo +RT You, Undercover""; +RL The Rolling Stones, 12 X 5, The Rolling Stones No. 2, Out of Our Heads, +RL Aftermath, Between the Buttons, Their Satanic Majesties Request, Beggars +RL Banquet. +XX +FH Key Location/Qualifiers +FH +FT source 1..1234 +FT /organism=""organism"" +FT /mol_type=""genomic DNA"" +FT /db_xref=""taxon:5678"" +FT /note=""chromX"" +"""""" + + calculated_header = header.format() + for calculated_line,expected_line in zip(calculated_header.split('\n'), expected_header.split('\n')): + self.assertEqual(calculated_line, expected_line) + self.assertEqual(len(calculated_header), len(expected_header)) + + def test_build_source_attributes(self): + header = EMBLHeader() + calculated_attributes=header.build_source_attributes(organism=""an organism"", taxon_id=""TAX_ID"", sequence_name=""sequence_name"") + expected_attributes = {""organism"": ""an organism"", ""db_xref"": ""taxon:TAX_ID"", ""note"": ""sequence_name""} + self.assertEqual(calculated_attributes, expected_attributes) + + +class TestEMBLFeature(unittest.TestCase): + + def create_uninitialized_feature(self): + # In most cases I don't want tests to run the __init__ + # This creates an otherwise identical EMBLFeature object + return EMBLFeature.__new__(EMBLFeature) + + def test_initializer(self): + feature = EMBLFeature( + feature_type='tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + self.assertEqual(feature.feature_type, 'tRNA') + self.assertEqual(feature.start, 100) + self.assertEqual(feature.end, 200) + self.assertEqual(feature.strand, '+') + self.assertEqual(feature.locus_tag, None) + self.assertEqual(feature.translation_table, 11) + + expected_attributes = [('some_attribute', 'ABC')] + self.assertItemsEqual(feature.attributes, expected_attributes) + + def test_initializer_for_ignored_features(self): + feature = EMBLFeature( + feature_type='ncRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' } + ) + self.assertEqual(feature.format(), None) + + def test_format(self): + feature = self.create_uninitialized_feature() + feature.feature_type = ""feature_type"" + feature.start = 1 + feature.end = 10 + feature.strand = '' + feature.attributes = [ + (""attributeA"", ""foo""), + (""attributeB"", 'bar'), + (""attributeB"", 'baz') + ] + calculated_string = feature.format() + expected_string = """"""\ +FT feature_type 1..10 +FT /attributeA=""foo"" +FT /attributeB=""bar"" +FT /attributeB=""baz"" +"""""" + + for calculated_line,expected_line in zip(calculated_string.split('\n'), expected_string.split('\n')): + self.assertEqual(calculated_line, expected_line) + self.assertEqual(len(calculated_string), len(expected_string)) + + def test_pick_feature_builder(self): + feature = self.create_uninitialized_feature() + self.assertEqual(feature.pick_feature_builder('CDS'), feature.create_CDS_feature) + self.assertEqual(feature.pick_feature_builder('source'), feature.create_source_feature) + self.assertEqual(feature.pick_feature_builder('ncRNA'), feature.create_empty_feature) + self.assertEqual(feature.pick_feature_builder('other'), feature.create_default_feature) + + def test_create_empty_feature(self): + feature = self.create_uninitialized_feature() + feature.create_empty_feature( + feature_type='ncRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' }, + locus_tag = None, + translation_table = 11 + ) + self.assertEqual(feature.format(), None) + + def test_create_default_feature(self): + feature = self.create_uninitialized_feature() + feature.create_default_feature( + feature_type='tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' }, + locus_tag = None, + translation_table = 11 + ) + self.assertEqual(feature.feature_type, 'tRNA') + self.assertEqual(feature.start, 100) + self.assertEqual(feature.end, 200) + self.assertEqual(feature.strand, '+') + self.assertEqual(feature.locus_tag, None) + self.assertEqual(feature.translation_table, 11) + + expected_attributes = [('some_attribute', 'ABC')] + self.assertItemsEqual(feature.attributes, expected_attributes) + + def test_create_default_feature_with_locus_tag(self): + feature = self.create_uninitialized_feature() + feature.create_default_feature( + feature_type='tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC', 'locus_tag': 'XYZ_123'}, + locus_tag = 'A_LOCUS_TAG', + translation_table = 11 + ) + self.assertEqual(feature.feature_type, 'tRNA') + self.assertEqual(feature.start, 100) + self.assertEqual(feature.end, 200) + self.assertEqual(feature.strand, '+') + self.assertEqual(feature.locus_tag, 'A_LOCUS_TAG') + self.assertEqual(feature.translation_table, 11) + + expected_attributes = [('some_attribute', 'ABC'), ('locus_tag', 'A_LOCUS_TAG_123')] + self.assertItemsEqual(feature.attributes, expected_attributes) + + def test_create_CDS_feature(self): + feature = self.create_uninitialized_feature() + feature.create_CDS_feature( + feature_type='tRNA', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'some_attribute': 'ABC' }, + locus_tag = None, + translation_table = 11 + ) + self.assertEqual(feature.feature_type, 'tRNA') + self.assertEqual(feature.start, 100) + self.assertEqual(feature.end, 200) + self.assertEqual(feature.strand, '+') + self.assertEqual(feature.locus_tag, None) + self.assertEqual(feature.translation_table, 11) + + expected_attributes = [('some_attribute', 'ABC'), ('transl_table', 11)] + self.assertItemsEqual(feature.attributes, expected_attributes) + + def test_create_feature_with_quotes(self): + feature = self.create_uninitialized_feature() + feature.create_CDS_feature( + feature_type='CDS', + start = 100, + end = 200, + strand = '+', + feature_attributes = {'gene': '""dnaA""', 'codon_start': '""1""','colour': '""9""', 'locus_tag': '""ABC_001""' }, + locus_tag = None, + translation_table = 11 + ) + expected_attributes = [('gene', 'dnaA'),('codon_start', 1), ('locus_tag', 'ABC_001'), ('transl_table', 11)] + self.assertItemsEqual(feature.attributes, expected_attributes) + + def test_create_source_feature(self): + feature = self.create_uninitialized_feature() + feature.create_source_feature( + feature_type='source', + start = 1, + end = 1234, + strand = '+', + feature_attributes = {""organism"": ""My organism"", ""db_xref"": ""taxon:5678"", ""note"": ""chromX""}, + locus_tag = None, + translation_table = 11 + ) + self.assertEqual(feature.feature_type, 'source') + self.assertEqual(feature.start, 1) + self.assertEqual(feature.end, 1234) + self.assertEqual(feature.strand, '+') + self.assertEqual(feature.locus_tag, None) + self.assertEqual(feature.translation_table, 11) + + # Source attributes should have their attributes in this order. We therefore use assertEqual not assertItemsEqual + expected_attributes = [(""organism"", ""My organism""), (""mol_type"", ""genomic DNA""), (""db_xref"", ""taxon:5678""), (""note"", ""chromX"")] + self.assertEqual(feature.attributes, expected_attributes) + + def test_format_attribute(self): + feature = self.create_uninitialized_feature() + calculated_string = feature.format_attribute('attributeA', 'foo') + expected_string = 'FT /attributeA=""foo""' + self.assertEqual(calculated_string, expected_string) + + calculated_string = feature.format_attribute('transl_table', 11) + expected_string = 'FT /transl_table=11' + self.assertEqual(calculated_string, expected_string) + + def test_lookup_attribute_formatter(self): + feature = self.create_uninitialized_feature() + formatter = feature.lookup_attribute_formatter('attributeA') + self.assertEqual(formatter, feature.default_attribute_formatter) + + feature = self.create_uninitialized_feature() + formatter = feature.lookup_attribute_formatter('transl_table') + self.assertEqual(formatter, feature.number_attribute_formatter) + + def test_number_attribute_formatter(self): + feature = self.create_uninitialized_feature() + calculated_string = feature.number_attribute_formatter('transl_table', 11) + expected_string = 'FT /transl_table=11' + self.assertEqual(calculated_string, expected_string) + + def test_format_multiline_attribute(self): + feature = self.create_uninitialized_feature() + long_attribute = 'abc efg hij klm nop qrs tuvw xyz abc efg hij klm nop qrs tuvw xyz' + calculated_string = feature.format_attribute('product', long_attribute) + expected_string = """"""\ +FT /product=""abc efg hij klm nop qrs tuvw xyz abc efg hij klm +FT nop qrs tuvw xyz""\ +"""""" + self.assertEqual(calculated_string, expected_string) + + long_attribute = """"""\ +abc efg hij klm nop qrs tuvw xyz abc efg hij klm nop qrs tuvw xyz \ +abc efg hij klm nop qrs tuvw xyz abc_efg hij klm nop qrs tuvw xyz\ +"""""" + calculated_string = feature.format_attribute('product', long_attribute) + expected_string = """"""\ +FT /product=""abc efg hij klm nop qrs tuvw xyz abc efg hij klm +FT nop qrs tuvw xyz abc efg hij klm nop qrs tuvw xyz abc_efg +FT hij klm nop qrs tuvw xyz""\ +"""""" + self.assertEqual(calculated_string, expected_string) + + def test_lookup_attribute_creator(self): + feature = self.create_uninitialized_feature() + self.assertEqual(feature.lookup_attribute_creator('some_key'), + feature.create_default_attributes) + self.assertEqual(feature.lookup_attribute_creator('product'), + feature.create_product_attributes) + self.assertEqual(feature.lookup_attribute_creator('locus_tag'), + feature.create_locus_tag_attributes) + self.assertEqual(feature.lookup_attribute_creator('eC_number'), + feature.create_EC_number_attributes) + self.assertEqual(feature.lookup_attribute_creator('inference'), + feature.create_inference_attributes) + self.assertEqual(feature.lookup_attribute_creator('protein_id'), + feature.ignore_attributes) + self.assertEqual(feature.lookup_attribute_creator('ID'), + feature.ignore_attributes) + + + def test_create_product_attributes(self): + feature = self.create_uninitialized_feature() + test_cases = [ + ('""""', [('product', ""Uncharacterised protein"")]), + ('abc,efg,hij', [('product', ""abc"")]), + ('hypothetical protein,efg,hij', [('product', ""efg"")]), + ('efg,hypothetical protein,hij', [('product', ""efg"")]), + ('hypothetical protein,hypothetical protein,hij', [('product', ""hij"")]), + ('hypothetical protein', [('product', ""Uncharacterised protein"")]), + ('conserved hypothetical protein', [('product', ""Uncharacterised protein"")]), + ('hypothetical protein,Unknown protein abc', [('product', ""Uncharacterised protein abc"")]), + ('hypothetical protein,unknown protein abc', [('product', ""uncharacterised protein abc"")]), + ('Hypothetical protein abc', [('product', ""Uncharacterised protein"")]) + + ] + for test_case, expected_result in test_cases: + calculated_result = feature.create_product_attributes('product', test_case) + self.assertEqual(calculated_result, expected_result) + + def test_create_locus_tag_attributes(self): + feature = self.create_uninitialized_feature() + feature.locus_tag = None + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC123') + expected_attributes = [('locus_tag', 'ABC123')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC123_XYZ') + expected_attributes = [('locus_tag', 'ABC123_XYZ')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC_123_XYZ') + expected_attributes = [('locus_tag', 'ABC_123_XYZ')] + self.assertEqual(calculated_attributes, expected_attributes) + + feature.locus_tag = ""some_other_tag"" + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC123') + expected_attributes = [('locus_tag', 'some_other_tag_ABC123')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC123_XYZ') + expected_attributes = [('locus_tag', 'some_other_tag_XYZ')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_locus_tag_attributes('locus_tag', 'ABC_123_XYZ') + expected_attributes = [('locus_tag', 'some_other_tag_XYZ')] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_create_EC_number_attributes(self): + feature = self.create_uninitialized_feature() + calculated_attributes = feature.create_EC_number_attributes('eC_number', '1.2.3.4') + expected_attributes = [('EC_number', '1.2.3.4')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '1.2.3.4,1.2.3.-') + expected_attributes = [('EC_number', '1.2.3.-'), ('EC_number', '1.2.3.4')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '1.2.3.4,1.2.3.4') + expected_attributes = [('EC_number', '1.2.3.4')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '1.2.3.4,1.2.3.-,1.2.3.4') + expected_attributes = [('EC_number', '1.2.3.-'), ('EC_number', '1.2.3.4')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '2.1.1.-),2.1.1.173') + expected_attributes = [ ('EC_number', '2.1.1.173')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '2.7.7.58%2CIrp5,6.3.2.-') + expected_attributes = [ ('EC_number', '6.3.2.-')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_EC_number_attributes('eC_number', '1.2.3.4,1.2.3.-,1.2.3.-') + expected_attributes = [('EC_number', '1.2.3.-'), ('EC_number', '1.2.3.4')] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_create_inference_attributes(self): + feature = self.create_uninitialized_feature() + calculated_attributes = feature.create_inference_attributes('inference', '123') + expected_attributes = [('inference', '123')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', '123,ABC') + expected_attributes = [('inference', '123'), ('inference', 'ABC')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', '123,123') + expected_attributes = [('inference', '123'), ('inference', '123')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', '123,ABC,123') + expected_attributes = [('inference', '123'), ('inference', 'ABC'), ('inference', '123')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', 'B,A,A') + expected_attributes = [('inference', 'B'), ('inference', 'A'), ('inference', 'A')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', 'B,A,B') + expected_attributes = [('inference', 'B'), ('inference', 'A'), ('inference', 'B')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_inference_attributes('inference', '123,similar to AA sequence:UniProtKB:Q2G282') + expected_attributes = [('inference', '123'), ('db_xref', ""UniProtKB/Swiss-Prot:Q2G282"")] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_ignore_attributes(self): + feature = self.create_uninitialized_feature() + calculated_attributes = feature.ignore_attributes('ID', '123') + expected_attributes = [] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_should_convert_to_db_xref(self): + feature = self.create_uninitialized_feature() + self.assertTrue(feature.should_convert_to_db_xref('similar to AA sequence:UniProtKB:Q2G282')) + self.assertTrue(feature.should_convert_to_db_xref('protein motif:Pfam:PF01475.13')) + self.assertTrue(feature.should_convert_to_db_xref('protein motif:CLUSTERS:PRK09462')) + self.assertTrue(feature.should_convert_to_db_xref('protein motif:TIGRFAMs:TIGR01327')) + self.assertTrue(feature.should_convert_to_db_xref('protein motif:Cdd:COG1932')) + self.assertTrue(feature.should_convert_to_db_xref('SOME_PREFIX protein motif:Cdd:COG1932')) + self.assertTrue(feature.should_convert_to_db_xref('protein motif:Cdd:COG1932i SOME_SUFFIX')) + self.assertTrue(feature.should_convert_to_db_xref('SOME_PREFIX protein motif:Cdd:COG1932i SOME_SUFFIX')) + self.assertFalse(feature.should_convert_to_db_xref('protein')) + self.assertFalse(feature.should_convert_to_db_xref('something else')) + self.assertFalse(feature.should_convert_to_db_xref('motif:Cdd:COG1932i')) + + def test_convert_to_db_xref(self): + feature = self.create_uninitialized_feature() + test_cases = [ + ('similar to AA sequence:UniProtKB:Q2G282', ""UniProtKB/Swiss-Prot:Q2G282""), + ('protein motif:Pfam:PF01475.13', ""PFAM:PF01475.13""), + ('protein motif:CLUSTERS:PRK09462', ""CDD:PRK09462""), + ('protein motif:TIGRFAMs:TIGR01327', ""TIGRFAM:TIGR01327""), + ('protein motif:Cdd:COG1932', ""CDD:COG1932""), + ('SOME_PREFIX protein motif:Cdd:COG1932', ""SOME_PREFIX CDD:COG1932""), + ('protein motif:Cdd:COG1932 SOME_SUFFIX', ""CDD:COG1932 SOME_SUFFIX""), + ('SOME_PREFIX protein motif:Cdd:COG1932 SOME_SUFFIX', ""SOME_PREFIX CDD:COG1932 SOME_SUFFIX"") + ] + for test_input, expected_output in test_cases: + self.assertEqual(feature.convert_to_db_xref(test_input), expected_output) + for test_input in ['protein', 'something else', 'motif:Cdd:COG1932i']: + self.assertRaises(ValueError, feature.convert_to_db_xref, test_input) + + def test_create_translation_table_attribute(self): + feature = self.create_uninitialized_feature() + calculated_attributes = feature.create_translation_table_attributes('transl_table', '11') + expected_attributes = [('transl_table', '11')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_translation_table_attributes('transl_table', 'something_else') + expected_attributes = [('transl_table', 'something_else')] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_create_default_attributes(self): + feature = self.create_uninitialized_feature() + calculated_attributes = feature.create_default_attributes('some_value', 'A') + expected_attributes = [('some_value', 'A')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_default_attributes('some_value', 'A,B') + expected_attributes = [('some_value', 'A')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_default_attributes('some_value', 'B,A') + expected_attributes = [('some_value', 'B')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_default_attributes('some_value', 'A,A') + expected_attributes = [('some_value', 'A')] + self.assertEqual(calculated_attributes, expected_attributes) + + calculated_attributes = feature.create_default_attributes('some_value', 'A,A,B') + expected_attributes = [('some_value', 'A')] + self.assertEqual(calculated_attributes, expected_attributes) + + def test_format_coordinates(self): + feature = self.create_uninitialized_feature() + calculated_coordinates = feature.format_coordinates(1, 10, '') + expected_coordinates = '1..10' + self.assertEqual(calculated_coordinates, expected_coordinates) + + calculated_coordinates = feature.format_coordinates(1, 10, '-') + expected_coordinates = 'complement(1..10)' + self.assertEqual(calculated_coordinates, expected_coordinates) + + calculated_coordinates = feature.format_coordinates(1, 10, '***NONSENCE***') + expected_coordinates = '1..10' + self.assertEqual(calculated_coordinates, expected_coordinates) + + def test_no_wrap_at_length_79(self): + source_attributes = {""organism"": 'abc', ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + formatted_product = feature.product_attribute_formatter('product','Anthranilate 1,2-dioxygenase ferredoxin subunit') + expected_product = 'FT /product=""Anthranilate 1,2-dioxygenase ferredoxin subunit""' + assert len(expected_product) == 79 + self.assertEqual(formatted_product, expected_product) + + def test_no_wrap_at_length_80(self): + source_attributes = {""organism"": 'abc', ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + formatted_product = feature.product_attribute_formatter('product','1,4-dihydroxy-2-naphthoate octaprenyltransferase') + expected_product = 'FT /product=""1,4-dihydroxy-2-naphthoate octaprenyltransferase""' + assert len(expected_product) == 80 + self.assertEqual(formatted_product, expected_product) + + def test_wrap_with_space_at_80(self): + source_attributes = {""organism"": 'abc', ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + + formatted_product = feature.product_attribute_formatter('product','Permease for cytosine/purines, uracil, thiamine, allantoin') + expected_product = 'FT /product=""Permease for cytosine/purines, uracil, thiamine,\n' + \ + 'FT allantoin""' + + def test_split_product_attribute_on_hyphen(self): + source_attributes = {""organism"": 'abc', ""db_xref"": ""taxon:5678"", ""note"": ""chromX""} + feature = EMBLFeature('source', 1, 1234, '+', source_attributes) + # TODO: This test currently 'passes' but shows the undesirable + # behaviour of splitting up a long word. + formatted_product = feature.product_attribute_formatter('product','2-succinyl-6-hydroxy-2,4-cyclohexadiene-1-carboxylate synthase') + expected_product = 'FT /product=""2-succinyl-6-hydroxy-2,4-cyclohexadiene-1-carboxy\n' + \ + 'FT late synthase""' + self.assertEqual(formatted_product, expected_product) + + +class TestEMBLSequence(unittest.TestCase): + + def create_uninitialized_sequence(self): + # In most cases I don't want tests to run the __init__ + # This creates an otherwise identical EMBLFeature object + return EMBLSequence.__new__(EMBLSequence) + + def test_init(self): + sequence = EMBLSequence('AAAACCCGGTNN') + expected_header = ""XX\nSQ Sequence 12 BP; 4 A; 3 C; 2 G; 1 T; 2 other;"" + expected_body = ' aaaacccggt nn 12\n' + self.assertEqual(sequence.header, expected_header) + self.assertEqual(sequence.body, expected_body) + self.assertEqual(sequence.length, 12) + + def test_format(self): + sequence = self.create_uninitialized_sequence() + sequence.header = ""XX\nSQ Sequence 12 BP; 4 A; 3 C; 2 G; 1 T; 2 other;"" + sequence.body = ' aaaacccggt nn 12\n' + calculated_string = sequence.format() + expected_string = """"""\ +XX +SQ Sequence 12 BP; 4 A; 3 C; 2 G; 1 T; 2 other; + aaaacccggt nn 12 +"""""" + self.assertEqual(calculated_string, expected_string) + + def test_calculate_neucleotide_counts(self): + sequence = self.create_uninitialized_sequence() + calculated_counts = sequence.calculate_nucleotide_counts('AAAACCCGGTNN') + expected_counts = {'a': 4, 'c': 3, 'g': 2, 't': 1, 'other': 2} + self.assertEqual(calculated_counts, expected_counts) + + calculated_counts = sequence.calculate_nucleotide_counts('AAAAaaaaAAAA') + expected_counts = {'a': 12, 'c': 0, 'g': 0, 't': 0, 'other': 0} + self.assertEqual(calculated_counts, expected_counts) + + calculated_counts = sequence.calculate_nucleotide_counts('------------') + expected_counts = {'a': 0, 'c': 0, 'g': 0, 't': 0, 'other': 12} + self.assertEqual(calculated_counts, expected_counts) + + calculated_counts = sequence.calculate_nucleotide_counts('acgtACGTtttT') + expected_counts = {'a': 2, 'c': 2, 'g': 2, 't': 6, 'other': 0} + self.assertEqual(calculated_counts, expected_counts) + + def test_format_header(self): + sequence = self.create_uninitialized_sequence() + neucleotide_counts = {'a': 4, 'c': 3, 'g': 2, 't': 1, 'other': 2} + calculated_header = sequence.format_header(neucleotide_counts) + expected_header = ""XX\nSQ Sequence 12 BP; 4 A; 3 C; 2 G; 1 T; 2 other;"" + + neucleotide_counts = {'a': 12, 'c': 0, 'g': 0, 't': 0, 'other': 0} + calculated_header = sequence.format_header(neucleotide_counts) + expected_header = ""XX\nSQ Sequence 12 BP; 12 A; 0 C; 0 G; 0 T; 0 other;"" + + neucleotide_counts = {'a': 0, 'c': 0, 'g': 0, 't': 0, 'other': 12} + calculated_header = sequence.format_header(neucleotide_counts) + expected_header = ""XX\nSQ Sequence 12 BP; 0 A; 0 C; 0 G; 0 T; 12 other;"" + + neucleotide_counts = {'a': 2, 'c': 2, 'g': 2, 't': 6, 'other': 0} + calculated_header = sequence.format_header(neucleotide_counts) + expected_header = ""XX\nSQ Sequence 12 BP; 2 A; 2 C; 2 G; 6 T; 0 other;"" + + def test_split_line_of_sequence(self): + sequence = self.create_uninitialized_sequence() + line_of_sequence = ""123"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""123"", '', '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""123456789"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""123456789"", '', '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""1234567890"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""1234567890"", '', '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""12345678901"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""1234567890"", ""1"", '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""1234567890123"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""1234567890"", ""123"", '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""12345678901234567890"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""1234567890"", ""1234567890"", '', '', '', ''] + self.assertEqual(calculated_split, expected_split) + + line_of_sequence = ""1234567890123456789012345"" + calculated_split = sequence.split_line_of_sequence(line_of_sequence) + expected_split = [""1234567890"", ""1234567890"", ""12345"", '', '', ''] + self.assertEqual(calculated_split, expected_split) + + def test_split_sequence(self): + sequence = self.create_uninitialized_sequence() + sequence_string = ""tctgacaatcgctttctt"" + calculated_split = sequence.split_sequence(sequence_string) + expected_split = [ (['tctgacaatc', 'gctttctt', '', '', '', ''], 18) ] + self.assertEqual(calculated_split, expected_split) + + sequence_string = ""tttaaaaccccgggtttcccgggaaa"" + calculated_split = sequence.split_sequence(sequence_string) + expected_split = [ (['tttaaaaccc', 'cgggtttccc', 'gggaaa', '', '', ''], 26) ] + self.assertEqual(calculated_split, expected_split) + + sequence_string = ""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtca"" + calculated_split = sequence.split_sequence(sequence_string) + expected_split = [ ([""tctgacaatc"", ""gctttcttta"", ""aaaagaaact"", ""attgtcgaga"", ""atttgcatta"", ""gcaatatcac""], 60), + ([""tttgtcaaaa"", ""agatgtttga"", ""atgttaaata"", ""aacattcaaa"", ""actgaataca"", ""atatgtca""], 118) ] + self.assertEqual(calculated_split, expected_split) + + sequence_string = ""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtcac"" + calculated_split = sequence.split_sequence(sequence_string) + expected_split = [ ([""tctgacaatc"", ""gctttcttta"", ""aaaagaaact"", ""attgtcgaga"", ""atttgcatta"", ""gcaatatcac""], 60), + ([""tttgtcaaaa"", ""agatgtttga"", ""atgttaaata"", ""aacattcaaa"", ""actgaataca"", ""atatgtcac""], 119) ] + self.assertEqual(calculated_split, expected_split) + + sequence_string = ""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtcaca"" + calculated_split = sequence.split_sequence(sequence_string) + expected_split = [ ([""tctgacaatc"", ""gctttcttta"", ""aaaagaaact"", ""attgtcgaga"", ""atttgcatta"", ""gcaatatcac""], 60), + ([""tttgtcaaaa"", ""agatgtttga"", ""atgttaaata"", ""aacattcaaa"", ""actgaataca"", ""atatgtcaca""], 120) ] + self.assertEqual(calculated_split, expected_split) + + def test_format_sequence_body(self): + sequence = self.create_uninitialized_sequence() + sequence_string=""tctgacaatcgctttctt"" + expected_string = """"""\ + tctgacaatc gctttctt 18 +"""""" + calculated_string = sequence.format_sequence_body(sequence_string) + self.assertEqual(calculated_string, expected_string) + + sequence_string=""TTTAAAACCCCGGGtttcccgggaaa"" + expected_string = """"""\ + tttaaaaccc cgggtttccc gggaaa 26 +"""""" + calculated_string = sequence.format_sequence_body(sequence_string) + self.assertEqual(calculated_string, expected_string) + + sequence_string=""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtca"" + expected_string = """"""\ + tctgacaatc gctttcttta aaaagaaact attgtcgaga atttgcatta gcaatatcac 60 + tttgtcaaaa agatgtttga atgttaaata aacattcaaa actgaataca atatgtca 118 +"""""" + calculated_string = sequence.format_sequence_body(sequence_string) + self.assertEqual(calculated_string, expected_string) + + sequence_string=""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtcac"" + expected_string = """"""\ + tctgacaatc gctttcttta aaaagaaact attgtcgaga atttgcatta gcaatatcac 60 + tttgtcaaaa agatgtttga atgttaaata aacattcaaa actgaataca atatgtcac 119 +"""""" + calculated_string = sequence.format_sequence_body(sequence_string) + self.assertEqual(calculated_string, expected_string) + + sequence_string=""tctgacaatcgctttctttaaaaagaaactattgtcgagaatttgcattagcaatatcactttgtcaaaaagatgtttgaatgttaaataaacattcaaaactgaatacaatatgtcaca"" + expected_string = """"""\ + tctgacaatc gctttcttta aaaagaaact attgtcgaga atttgcatta gcaatatcac 60 + tttgtcaaaa agatgtttga atgttaaata aacattcaaa actgaataca atatgtcaca 120 +"""""" + calculated_string = sequence.format_sequence_body(sequence_string) + self.assertEqual(calculated_string, expected_string) +","Python" +"Pathogens","sanger-pathogens/gff3toembl","gff3toembl/tests/EMBLWriter_test.py",".py","5349","144","import unittest +import sys +import os +from gff3toembl.EMBLWriter import EMBLWriter + +test_modules_dir = os.path.dirname(os.path.realpath(__file__)) +data_dir = os.path.join(test_modules_dir, 'data') + +class TestEMBLWriter(unittest.TestCase): + + def compare_files(self, calculated_filename, expected_filename): + with open(expected_filename, 'r') as expected_file: + expected_string = expected_file.read() + with open(calculated_filename, 'r') as calculated_file: + calculated_string = calculated_file.read() + for calculated, expected in zip(calculated_string.split('\n'), expected_string.split('\n')): + self.assertEqual(calculated, expected) + self.assertEqual(len(calculated_string), len(expected_string)) + + def test_single_feature(self): + '''test that the script will convert from GFF3 to EMBL''' + emblwriter = EMBLWriter(os.path.join(data_dir,'single_feature.gff'), + 'Organism', + 1234, + 'My project', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'single_feature.embl', None,11, None ) + emblwriter.parse_and_run() + self.compare_files('single_feature.embl', os.path.join(data_dir, 'expected_single_feature.embl')) + os.remove('single_feature.embl') + + def test_single_feature_new_locus_tag(self): + '''test that the script will convert from GFF3 to EMBL and change the locus tag''' + emblwriter = EMBLWriter(os.path.join(data_dir,'single_feature.gff'), + 'Organism', + 1234, + 'My project', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'single_feature.embl', 'new_locus_tag', 11, None ) + emblwriter.parse_and_run() + self.compare_files('single_feature.embl', os.path.join(data_dir, 'expected_single_feature_new_locus_tag.embl')) + os.remove('single_feature.embl') + + def test_single_feature_translation_table(self): + '''test that the script will convert from GFF3 to EMBL and change the locus tag''' + emblwriter = EMBLWriter(os.path.join(data_dir,'single_feature.gff'), + 'Organism', + 1234, + 'My project', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'single_feature.embl', None, 1, None ) + emblwriter.parse_and_run() + self.compare_files('single_feature.embl', os.path.join(data_dir, 'expected_single_feature_translation_table.embl')) + os.remove('single_feature.embl') + + def test_large_conversion(self): + '''test a large gff3 file converts to EMBL''' + emblwriter = EMBLWriter(os.path.join(data_dir,'large_annotation.gff'), + 'Organism', + 1234, + 'My project', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'large_annotation.embl', None, 11, None ) + emblwriter.parse_and_run() + self.compare_files('large_annotation.embl', os.path.join(data_dir, 'expected_large_annotation.embl')) + os.remove('large_annotation.embl') + + + def test_chromosome_list_conversion(self): + '''test chromosome list creation''' + emblwriter = EMBLWriter(os.path.join(data_dir,'chromosome_list.gff'), + 'Organism', + 1234, + 'ABC', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'chromosome_list.embl', None, 11, 'chromosome_list.txt' ) + emblwriter.parse_and_run() + self.compare_files('chromosome_list.txt', os.path.join(data_dir, 'expected_chromosome_list.txt')) + os.remove('chromosome_list.embl') + os.remove('chromosome_list.txt') + + def test_chromosome_list_plasmid_conversion(self): + '''test chromosome list creation''' + emblwriter = EMBLWriter(os.path.join(data_dir,'chromosome_list_plasmid_name.gff'), + 'Organism', + 1234, + 'ABC', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'chromosome_list_plasmid_name.embl', None, 11, 'chromosome_list_plasmid_name.txt' ) + emblwriter.parse_and_run() + self.compare_files('chromosome_list_plasmid_name.txt', os.path.join(data_dir, 'expected_chromosome_list_plasmid_name.txt')) + os.remove('chromosome_list_plasmid_name.embl') + os.remove('chromosome_list_plasmid_name.txt') + + + def test_remove_duplicate_tags(self): + '''test remove duplicate tags ''' + emblwriter = EMBLWriter(os.path.join(data_dir,'duplicate_coords.gff'), + 'Organism', + 1234, + 'ABC', + 'My description', + 'John', + 'Some title', + 'Some journal', + 'circular', + 'PROK', + 'duplicate_coords.embl', None, 11, None ) + emblwriter.parse_and_run() + self.compare_files('duplicate_coords.embl', os.path.join(data_dir, 'expected_duplicate_coords.embl')) + os.remove('duplicate_coords.embl') + + +","Python" +"Pathogens","JLSteenwyk/treehouse","server.R",".R","293472","810","# +# This is the server logic of a Shiny web application. You can run the +# application by clicking 'Run App' above. +# +# Find out more about building applications with Shiny here: +# +# http://shiny.rstudio.com/ +# + + +## Load necessary packages +if (!require(""phytools"")) { + install.packages(""phytools"", dependencies = TRUE) + library(phytools) + } + +# Define server logic +shinyServer(function(input, output, session) { + ############# + ### FUNGI ### + ############# + ## read in file reactively + FUNGIdata <- eventReactive(input$FUNGIgo, { + req(input$FUNGIfile) + inFile <- input$FUNGIfile + FUNGItaxa.list<-read.table(inFile$datapath) + return(FUNGItaxa.list) + }) + + ## read in tree based on selected tree + FUNGItree <- eventReactive(input$FUNGIgo, { + if (input$FUNGIphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + FUNGItree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + } else if (input$FUNGIphyloSelect == ""Saccharomycotina, 86 taxa - Shen et al. 2016"") { + FUNGItree <- read.tree(""./Data/Saccharomycotina_fig3_Shen_etal_2016.tre"") + } else if (input$FUNGIphyloSelect == ""Saccharomycotina, 332 taxa - Shen et al. 2018"") { + FUNGItree <- read.tree(""./Data/Saccharomycotina_fig2_Shen_etal_2018.tre"") + } else if (input$FUNGIphyloSelect == ""Saccharomyces cerevisiae, 1,011 strains - Peter et al. 2018"") { + FUNGItree <- read.tree(""./Data/Saccharomyces_cerevisiae_fig1_Peter_etal_2018.tre"") + } else if (input$FUNGIphyloSelect == ""Cryptococcus neoformans, 387 strains - Desjardins et al. 2017"") { + FUNGItree <- read.tree(""./Data/Cryptococcus_neoformans_fig1_Desjardins_etal_2017.tre"") + } else if (input$FUNGIphyloSelect == ""Fungi, 214 taxa - James et al. 2006"") { + FUNGItree <- read.nexus(""./Data/Fungi_fig1_James_etal_2006.nex.tre"") + } else if (input$FUNGIphyloSelect == ""Agaricomycetes, 5,284 taxa - Varga et al. 2019"") { + FUNGItree <- read.nexus(""./Data/Fungi_fig1_Varga_etal_2019.nex.tre"") + } else if (input$FUNGIphyloSelect == ""Fungi, 60 taxa - Nagy et al. 2014"") { + FUNGItree <- read.tree(""./Data/Fungi_fig1_Nagy_etal_2014.tre"") + } else if (input$FUNGIphyloSelect == ""Tree of life, 3,083 taxa - Hug et al. 2016"") { + FUNGItree <- read.tree(""./Data/Tree_of_Life_fig1_Hug_etal_2016.tre"") + } else if (input$FUNGIphyloSelect == ""Ascomycota, 1,113 taxa - Shen et al. 2020"") { + FUNGItree <- read.tree(""./Data/Ascomycota_fig1_Shen_etal_2020.tre"") + } else + FUNGItree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + }) + + ## select outgroup labels based on selected tree + FUNGIoutgroup.labels <- eventReactive(input$FUNGIgo, {input$FUNGIphyloSelect + if (input$FUNGIphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + FUNGIoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + else if (input$FUNGIphyloSelect == ""Saccharomycotina, 86 taxa - Shen et al. 2016"") { + FUNGIoutgroup.labels<-c(""Schizosaccharomyces_pombe"",""Arthrobotrys_oligospora"",""Neurospora_crassa"",""Fusarium_graminearum"",""Geotrichum_candidum_3C"", ""Botrytis_cinerea"", ""Sclerotinia_sclerotiorum"", ""Stagonospora_nodorum"", ""Aspergillus_nidulans"",""Xylona_heveae"") + } + else if (input$FUNGIphyloSelect == ""Saccharomycotina, 332 taxa - Shen et al. 2018"") { + FUNGIoutgroup.labels<-c(""Saitoella_complicata"",""Schizosaccharomyces_pombe"",""Arthrobotrys_oligospora"",""Fusarium_graminearum"",""Neurospora_crassa"", ""Sclerotinia_sclerotiorum"", ""Botrytis_cinerea"", ""Stagonospora_nodorum"", ""Aspergillus_nidulans"",""Xylona_heveae"", ""Coccidioides_immitis"") + } + else if (input$FUNGIphyloSelect == ""Saccharomyces cerevisiae, 1,011 strains - Peter et al. 2018"") { + FUNGIoutgroup.labels<-c(""AMH"",""CEG"",""CEI"") + } + else if (input$FUNGIphyloSelect == ""Cryptococcus neoformans, 387 strains - Desjardins et al. 2017"") { + FUNGIoutgroup.labels<-c(""8-1"",""AD3-11a"",""AD3-9a"",""AD5-67a"",""C12"",""C2"",""C45"",""LP-RSA1684"",""MW-RSA1327"",""MW-RSA3956"",""MW-RSA4119"",""MW_RSA852"",""PMHc1023.ENR"",""T4"",""Ug2462"",""WM626"") + } + else if (input$FUNGIphyloSelect == ""Fungi, 214 taxa - James et al. 2006"") { + FUNGIoutgroup.labels<-c(""Chlamydomonas_reinhardtii"",""Oryza_sativa"",""Arabidopsis_thaliana"",""Populus_trichocarpa"") + } + else if (input$FUNGIphyloSelect == ""Agaricomycetes, 5,284 taxa - Varga et al. 2019"") { + FUNGIoutgroup.labels<-c(""Tremella_polyporina"", ""Syzygospora_effibulata"", ""Cryptococcus_podzolicus"", ""Asterotremella_humicola"", ""Trichosporon_scarabaeorum"", ""Trichosporon_domesticum"", ""Trichosporon_brassicae"", ""Trichosporon_montevideense"", ""Trichosporon_mycotoxinivorans"", ""Trichosporon_loubieri"", ""Trichosporon_multisporum"", ""Trichosporon_veenhuisii"", ""Trichosporon_laibachii"", ""Trichosporon_gracile"", ""Trichosporon_dulcitum"", ""Trichosporon_vadense"", ""Cryptococcus_humicola"", ""Trichosporon_wieringae"", ""Trichosporon_gamsii"", ""Trichosporon_sporotrichoides"", ""Trichosporon_porosum"", ""Trichosporon_inkin"", ""Trichosporon_coremiiforme"", ""Trichosporon_faecale"", ""Trichosporon_japonicum"", ""Trichosporon_jirovecii"", ""Trichosporon_debeurmannianum"", ""Trichosporon_dermatis"", ""Trichosporon_moniliiforme"", ""Tremella_globispora"", ""Cryptococcus_bacillisporus"", ""Cryptococcus_gattii"", ""Cryptococcus_neoformans"", ""Cryptococcus_neoformansvargrubii"", ""Tsuchiyaea_wingfieldii"", ""Cryptococcus_amylolentus"", ""Filobasidiella_depauperata"", ""Cryptococcus_dejecticola"", ""Cryptococcus_bestiolae"", ""Bullera_dendrophila"", ""Cryptococcus_heveanensis"", ""Derxomyces_linzhiensis"", ""Derxomyces_anomala"", ""Derxomyces_simaoensis"", ""Derxomyces_komagatae"", ""Derxomyces_schimicola"", ""Derxomyces_pseudoschimicola"", ""Dioszegia_takashimae"", ""Derxomyces_pseudocylindrica"", ""Derxomyces_wuzhishanensis"", ""Derxomyces_hainanensis"", ""Derxomyces_mrakii"", ""Derxomyces_boninensis"", ""Derxomyces_qinlingensis"", ""Derxomyces_pseudohuiaensis"", ""Derxomyces_cylindrica"", ""Derxomyces_waltii"", ""Derxomyces_nakasei"", ""Derxomyces_boekhoutii"", ""Derxomyces_huiaensis"", ""Derxomyces_hubeiensis"", ""Derxomyces_yunnanensis"", ""Sirobasidium_magnum"", ""Tremella_parmeliarum"", ""Trimorphomyces_nebularis"", ""Tremella_fuciformis"", ""Tremella_brasiliensis"", ""Tremella_indecorata"", ""Cryptococcus_laurentii"", ""Cryptococcus_rajasthanensis"", ""Cryptococcus_cellulolyticus"", ""Sirobasidium_brefeldianum"", ""Tremella_caloplacae"", ""Tremella_dendrographae"", ""Tremella_candelariellae"", ""Tremella_giraffa"", ""Tremella_cetrariicola"", ""Biatoropsis_usnearum"", ""Tremella_tuckerae"", ""Tremella_coppinsii"", ""Tremella_wirthii"", ""Tremella_pertusariae"", ""Tremella_ramalinae"", ""Tremella_lichenicola"", ""Tremella_everniae"", ""Tremella_hypogymniae"", ""Tremella_encephala"", ""Tremella_phaeophysciae"", ""Tremella_leptogii"", ""Tremella_lobariacearum"", ""Tremella_nephromatis"", ""Tremella_cladoniae"", ""Tremella_haematommatis"", ""Tremella_foliacea"", ""Tremella_mesenterica"", ""Fibulobasidium_inconspicuum"", ""Cryptococcus_magnus"", ""Syzygospora_pallida"", ""Syzygospora_alba"", ""Syzygospora_physciacearum"", ""Syzygospora_bachmannii"", ""Cryptococcus_terreus"", ""Cryptococcus_terricola"", ""Cryptococcus_aerius"", ""Cryptococcus_saitoi"") + } + else if (input$FUNGIphyloSelect == ""Fungi, 60 taxa - Nagy et al. 2014"") { + FUNGIoutgroup.labels<-c(""Dicdi"", ""Enthi"", ""Thetr"", ""Monbr"", ""Salro"", ""Traho"", ""Enccu"", ""Antlo"") + } + else if (input$FUNGIphyloSelect == ""Ascomycota, 1,113 taxa - Shen et al. 2020"") { + FUNGIoutgroup.labels<-c(""Malassezia_globosa"", ""Cryptococcus_neoformans"", ""Mixia_osmundae"", ""Phanerochaete_chrysosporium"", ""Microbotryum_violaceum"", ""Ustilago_maydis"") + } + else { + FUNGIoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + }) + + ## display proper citation based on associated manuscript + output$FUNGIcitationText <- renderText({ + if (input$FUNGIphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + paste(""If you use this subtree, please cite: Steenwyk et al. 2019, mBio: 10.1128/mBio.00925-19"") + } else if (input$FUNGIphyloSelect == ""Saccharomycotina, 86 taxa - Shen et al. 2016"") { + paste(""If you use this subtree, please cite: Shen et al. 2016, G3. doi: 10.1534/g3.117.040105"") + } else if (input$FUNGIphyloSelect == ""Saccharomycotina, 332 taxa - Shen et al. 2018"") { + paste(""If you use this subtree, please cite: Shen et al. 2018, Cell. doi: 10.1016/j.cell.2018.10.023"") + } else if (input$FUNGIphyloSelect == ""Saccharomyces cerevisiae, 1,011 strains - Peter et al. 2018"") { + paste(""If you use this subtree, please cite: Peter et al. 2018, Nature. doi: 10.1038/s41586-018-0030-5"") + } else if (input$FUNGIphyloSelect == ""Cryptococcus neoformans, 387 strains - Desjardins et al. 2017"") { + paste(""If you use this subtree, please cite: Desjardins et al. 2017, Genome Research. doi: 10.1101/gr.218727.116"") + } else if (input$FUNGIphyloSelect == ""Fungi, 214 taxa - James et al. 2006"") { + paste(""If you use this subtree, please cite: James et al. 2006, Nature. doi: 10.1038/nature05110"") + } else if (input$FUNGIphyloSelect == ""Agaricomycetes, 5,284 taxa - Varga et al. 2019"") { + paste(""If you use this subtree, please cite: Varga et al. 2019, Nature Ecology and Evolution. doi: 10.1038/s41559-019-0834-1"") + } else if (input$FUNGIphyloSelect == ""Fungi, 60 taxa - Nagy et al. 2014"") { + paste(""If you use this subtree, please cite: Nagy et al. 2014, Nature Communications. doi: 10.1038/ncomms5471"") + } else if (input$FUNGIphyloSelect == ""Ascomycota, 1,113 taxa - Shen et al. 2020"") { + paste(""If you use this subtree, please cite: Shen et al. 2020, bioRxiv. doi: 10.1101/2020.05.11.088658v1"") + } else + paste(""If you use this subtree, please cite: Steenwyk et al. 2018, bioRxiv"") + }) + + ## display table of taxa names + FUNGItipNames <- eventReactive(input$FUNGIgo, { + a<-data.frame(FUNGItree()$tip.label) + # replace column name to ""full list of taxa"" + colnames(a)[1]<-""full list of taxa for possible subtree"" + # return to df_subset + return(a) + }) + output$FUNGItaxaTable <- renderTable(FUNGItipNames()) + + ## function to create plot + output$FUNGIphyloPlot <- renderPlot({ + # root tree + tree<-root(FUNGItree(), outgroup = FUNGIoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(FUNGIdata()$V1) + outgroup.labels<-setdiff(FUNGIoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + }) + + ## save pdf + output$FUNGITreePlot<- downloadHandler( + #Specify The File Name + filename = function() { + paste(""treehouse-"",Sys.Date(),"".pdf"",sep= """")}, + content = function(file){ + # open the pdf + pdf(file) + # root tree + tree<-root(FUNGItree(), outgroup = FUNGIoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(FUNGIdata()$V1) + outgroup.labels<-setdiff(FUNGIoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + dev.off() + } + ) + + ## write treefile + output$FUNGINewick<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(FUNGItree(), outgroup = FUNGIoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(FUNGIdata()$V1) + outgroup.labels<-setdiff(FUNGIoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ## write treefile + output$FUNGINewickNOBL<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(FUNGItree(), outgroup = FUNGIoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(FUNGIdata()$V1) + outgroup.labels<-setdiff(FUNGIoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + prune.tree$edge.length<-NULL + write.tree(pruned.tree, file=file) + } + ) + + ############## + ### ANIMAL ### + ############## + + ## read in file reactively + ANIMALdata <- eventReactive(input$ANIMALgo, { + req(input$ANIMALfile) + inFile <- input$ANIMALfile + taxa.list<-read.table(inFile$datapath) + return(taxa.list) + }) + + ## read in tree based on selected tree + ANIMALtree <- eventReactive(input$ANIMALgo, { + if (input$ANIMALphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + ANIMALtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + } else if (input$ANIMALphyloSelect == ""Metazoans, 36 taxa - Borowiec et al. 2015"") { + ANIMALtree <- read.tree(""./Data/Metazoans_fig3_Borowiec_etal_2015.tre"") + } else if (input$ANIMALphyloSelect == ""Birds, 198 taxa - Prum et al. 2015"") { + ANIMALtree <- read.tree(""./Data/Birds_fig1_Prum_etal_2015.tre"") + } else if (input$ANIMALphyloSelect == ""Vertebrates, 58 taxa - Chen et al. 2015"") { + ANIMALtree <- read.nexus(""./Data/Vertebrates_fig1_Chen_etal_2015.tre"") + } else if (input$ANIMALphyloSelect == ""Metazoans, 70 taxa - Whelan et al. 2015"" ) { + ANIMALtree <- read.tree(""./Data/Metazoans_fig3_Whelan_etal_2015.tre"") + } else if (input$ANIMALphyloSelect == ""Birds, 48 taxa - Jarvis et al. 2014"" ) { + ANIMALtree <- read.tree(""./Data/Birds_fig1_Jarvis_etal_2014.tre"") + } else if (input$ANIMALphyloSelect == ""Mammals, 36 taxa - Tarver et al. 2016"" ) { + ANIMALtree <- read.tree(""./Data/Mammals_fig2_Tarver_etal_2016.tre"") + } else if (input$ANIMALphyloSelect == ""Insects, 144 taxa - Misof et al. 2014"" ) { + ANIMALtree <- read.tree(""./Data/Insects_fig1_Misof_etal_2014.tre"") + } else if (input$ANIMALphyloSelect == ""Mammals, 37 taxa - Song et al. 2016"" ) { + ANIMALtree <- read.tree(""./Data/Mammals_fig1_Song_etal_2012.tre"") + } else if (input$ANIMALphyloSelect == ""Worms, 100 taxa - Struck et al. 2015"" ) { + ANIMALtree <- read.tree(""./Data/Worms_fig1_Struck_etal_2015.tre"") + } else + ANIMALtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + }) + + ## select outgroup labels based on selected tree + ANIMALoutgroup.labels <- eventReactive(input$ANIMALgo, {input$ANIMALphyloSelect + if (input$ANIMALphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + ANIMALoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + else if (input$ANIMALphyloSelect == ""Metazoans, 36 taxa - Borowiec et al. 2015"") { + ANIMALoutgroup.labels<-c(""Monosiga"", ""Salpingoeca"") + } + else if (input$ANIMALphyloSelect == ""Birds, 198 taxa - Prum et al. 2015"") { + ANIMALoutgroup.labels<-c(""I0461_HERP_15451_Alligatoridae_Caiman_croccodilus"", ""I0460_HERP_14722_Crocodylidae_Crocodylus_porosus"") + } + else if (input$ANIMALphyloSelect == ""Vertebrates, 58 taxa - Chen et al. 2015"") { + ANIMALoutgroup.labels<-c(""Cmi"", ""Sca"", ""Ler"") + } + else if (input$ANIMALphyloSelect == ""Metazoans, 70 taxa - Whelan et al. 2015"") { + ANIMALoutgroup.labels<-c(""Allomyces_macrogynus"",""Rhizopus_oryzae"",""Mortierella_verticillata"",""Spizellomyces_punctatus"") + } + else if (input$ANIMALphyloSelect == ""Birds, 48 taxa - Jarvis et al. 2014"") { + ANIMALoutgroup.labels<-c(""ANAPL"",""GALGA"",""MELGA"",""TINMA"",""STRCA"") + } + else if (input$ANIMALphyloSelect == ""Insects, 144 taxa - Misof et al. 2014"") { + ANIMALoutgroup.labels<-c(""IXODES_S"") + } + else if (input$ANIMALphyloSelect == ""Mammals, 36 taxa - Tarver et al. 2016"") { + ANIMALoutgroup.labels<-c(""P001_Platypus"") + } + else if (input$ANIMALphyloSelect == ""Mammals, 37 taxa - Song et al. 2016"") { + ANIMALoutgroup.labels<-c(""Gal"",""Orn"") + } + else if (input$ANIMALphyloSelect == ""Worms, 100 taxa - Struck et al. 2015"") { + ANIMALoutgroup.labels<-c(""Crassostrea_gigas"",""Lottia_gigantea"",""Euprymna_scolopes"",""Hanleya_sp"") + } + else { + ANIMALoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + }) + + ## display proper citation based on associated manuscript + output$ANIMALcitationText <- renderText({ + if (input$ANIMALphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + paste(""If you use this subtree, please cite: Steenwyk et al. 2018, bioRxiv. 10.1101/370429"") + } else if (input$ANIMALphyloSelect == ""Metazoans, 36 taxa - Borowiec et al. 2015"") { + paste(""If you use this subtree, please cite: Borowiec et al. 2015, BMC Genomics. doi: 10.1186/s12864-015-2146-4"") + } else if (input$ANIMALphyloSelect == ""Birds, 198 taxa - Prum et al. 2015"") { + paste(""If you use this subtree, please cite: Prum et al. 2015, Nature doi: 10.1038/nature15697"") + } else if (input$ANIMALphyloSelect == ""Vertebrates, 58 taxa - Chen et al. 2015"") { + paste(""If you use this subtree, please cite: Chen et al. 2015, Systematic Biology doi: 10.1093/sysbio/syv059"") + } else if (input$ANIMALphyloSelect == ""Metazoans, 70 taxa - Whelan et al. 2015"") { + paste(""If you use this subtree, please cite: Whelan et al. 2015, Proceedings of the National Academy of Sciences of the USA doi: 10.1073/pnas.1503453112"") + } else if (input$ANIMALphyloSelect == ""Birds, 48 taxa - Jarvis et al. 2014"") { + paste(""If you use this subtree, please cite: Jarvis et al. 2014, Science doi: 10.1126/science.1253451"") + } else if (input$ANIMALphyloSelect == ""Mammals, 36 taxa - Tarver et al. 2016"") { + paste(""If you use this subtree, please cite: Tarver et al. 2016, Genome Biology and Evolution doi: 10.1093/gbe/evv261 and Zhou et al. 2017, Molecular Biology and Evolution. doi: 10.1093/molbev/msx302. Phylogeny with branch lengths was obtained from Zhou et al. 2017, MBE."") + } else if (input$ANIMALphyloSelect == ""Insects, 144 taxa - Misof et al. 2014"") { + paste(""If you use this subtree, please cite: Misof et al. 2014, Science doi: 10.1126/science.1257570 and Zhou et al. 2017, Molecular Biology and Evolution. doi: 10.1093/molbev/msx302. Phylogeny with branch lengths was obtained from Zhou et al. 2017, MBE."") + } else if (input$ANIMALphyloSelect == ""Mammals, 37 taxa - Song et al. 2016"") { + paste(""If you use this subtree, please cite: Song et al. 2012, Proceedings of the National Academy of Sciences of the USA doi: 10.1073/pnas.1211733109 and Zhou et al. 2017, Molecular Biology and Evolution. doi: 10.1093/molbev/msx302. Phylogeny with branch lengths was obtained from Zhou et al. 2017, MBE."") + } else if (input$ANIMALphyloSelect == ""Worms, 100 taxa - Struck et al. 2015"") { + paste(""If you use this subtree, please cite: Struck et al. 2015, Current Biology doi: 10.1016/j.cub.2015.06.007 and Zhou et al. 2017, Molecular Biology and Evolution. doi: 10.1093/molbev/msx302. Phylogeny with branch lengths was obtained from Zhou et al. 2017, MBE."") + } else + paste(""If you use this subtree, please cite: Steenwyk et al. 2018, bioRxiv"") + }) + + ## display table of taxa names + ANIMALtipNames <- eventReactive(input$ANIMALgo, { + a<-data.frame(ANIMALtree()$tip.label) + # replace column name to ""full list of taxa"" + colnames(a)[1]<-""full list of taxa for possible subtree"" + # return to df_subset + return(a) + }) + output$ANIMALtaxaTable <- renderTable(ANIMALtipNames()) + + ## function to create plot + output$ANIMALphyloPlot <- renderPlot({ + # root tree + tree<-root(ANIMALtree(), outgroup = ANIMALoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(ANIMALdata()$V1) + outgroup.labels<-setdiff(ANIMALoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + }) + + ## save pdf + output$ANIMALTreePlot<- downloadHandler( + #Specify The File Name + filename = function() { + paste(""treehouse-"",Sys.Date(),"".pdf"",sep= """")}, + content = function(file){ + # open the pdf + pdf(file) + # root tree + tree<-root(ANIMALtree(), outgroup = ANIMALoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(ANIMALdata()$V1) + outgroup.labels<-setdiff(ANIMALoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + dev.off() + } + ) + + ## write treefile + output$ANIMALNewick<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(ANIMALtree(), outgroup = ANIMALoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(ANIMALdata()$V1) + outgroup.labels<-setdiff(ANIMALoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ## write treefile + output$ANIMALNewickNOBL<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(ANIMALtree(), outgroup = ANIMALoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(ANIMALdata()$V1) + outgroup.labels<-setdiff(ANIMALoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + pruned.tree$edge.length<-NULL + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ############# + ### PLANT ### + ############# + + ## read in file reactively + PLANTdata <- eventReactive(input$PLANTgo, { + req(input$PLANTfile) + inFile <- input$PLANTfile + taxa.list<-read.table(inFile$datapath) + return(taxa.list) + }) + + ## read in tree based on selected tree + PLANTtree <- eventReactive(input$PLANTgo, { + if (input$PLANTphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + PLANTtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + } else if (input$PLANTphyloSelect == ""Flowering plants, 45 taxa - Xi et al. 2014"") { + PLANTtree <- read.tree(""./Data/Flowering_plants_fig2_Xi_etal_2014.tre"") + } else if (input$PLANTphyloSelect == ""Caryophyllales, 95 taxa - Yang et al. 2015"") { + PLANTtree <- read.tree(""./Data/Caryophyllales_fig3_Yang_etal_2015.tre"") + } else if (input$PLANTphyloSelect == ""Land plants, 103 taxa - Wickett et al. 2014"") { + PLANTtree <- read.tree(""./Data/Land_plants_fig2_Wickett_etal_2014.tre"") + } else + PLANTtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + }) + + ## select outgroup labels based on selected tree + PLANToutgroup.labels <- eventReactive(input$PLANTgo, {input$PLANTphyloSelect + if (input$PLANTphyloSelect == ""Flowering plants, 45 taxa - Xi et al. 2014"") { + PLANToutgroup.labels<-c(""Picea"",""Pinus"",""Zamia"",""Selaginella"") + } + else if (input$PLANTphyloSelect == ""Caryophyllales, 95 taxa - Yang et al. 2015"") { + PLANToutgroup.labels<-c(""Rcom"",""Ptri"",""Pper"",""Mdom"",""Fves"",""Csat"",""Pvul"",""Gmax"",""Mtru"",""Egra"",""Vvin"",""Ccle"",""Csin"",""Tcac"",""Grai"",""Cpap"",""Atha"",""Alyr"",""Crub"",""Brap"",""Thal"",""Lusi"",""Mesc"") + } + else if (input$PLANTphyloSelect == ""Land plants, 103 taxa - Wickett et al. 2014"") { + PLANToutgroup.labels<-c(""Uronema_sp"", ""Monomastix_opisthostigma"",""Nephroselmis_pyriformis"",""Pyramimonas_parkeae"") + } + else { + PLANToutgroup.labels<-c(""Picea"",""Pinus"",""Zamia"",""Selaginella"") + } + }) + + ## display proper citation based on associated manuscript + output$PLANTcitationText <- renderText({ + if (input$PLANTphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + paste(""If you use this subtree, please cite: Steenwyk et al. 2018, bioRxiv. 10.1101/370429"") + } else if (input$PLANTphyloSelect == ""Flowering plants, 45 taxa - Xi et al. 2014"") { + paste(""If you use this subtree, please cite: Xi et al. 2014, Systematic Biology. doi: 10.1093/sysbio/syu055 and Zhou et al. 2017, Molecular Biology and Evolution. doi: 10.1093/molbev/msx302. Phylogeny with branch lengths was obtained from Zhou et al. 2017, MBE."") + } else if (input$PLANTphyloSelect == ""Caryophyllales, 95 taxa - Yang et al. 2015"") { + paste(""If you use this subtree, please cite: Yang et al. 2015, Molecular Biology and Evolution. doi: 10.1093/molbev/msv081"") + } else if (input$PLANTphyloSelect == ""Land plants, 103 taxa - Wickett et al. 2014"") { + paste(""If you use this subtree, please cite: Wickett et al. 2014, Proceedings of the National Academy of Sciences of the USA. doi: 10.1073/pnas.1323926111"") + } else + paste(""If you use this subtree, please cite: Steenwyk et al. 2018, bioRxiv"") + }) + + ## display table of taxa names + PLANTtipNames <- eventReactive(input$PLANTgo, { + a<-data.frame(PLANTtree()$tip.label) + # replace column name to ""full list of taxa"" + colnames(a)[1]<-""full list of taxa for possible subtree"" + # return to df_subset + return(a) + }) + output$PLANTtaxaTable <- renderTable(PLANTtipNames()) + + ## function to create plot + output$PLANTphyloPlot <- renderPlot({ + # root tree + tree<-root(PLANTtree(), outgroup = PLANToutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(PLANTdata()$V1) + outgroup.labels<-setdiff(PLANToutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + }) + + ## save pdf + output$PLANTTreePlot<- downloadHandler( + #Specify The File Name + filename = function() { + paste(""treehouse-"",Sys.Date(),"".pdf"",sep= """")}, + content = function(file){ + # open the pdf + pdf(file) + # root tree + tree<-root(PLANTtree(), outgroup = PLANToutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(PLANTdata()$V1) + outgroup.labels<-setdiff(PLANToutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + dev.off() + } + ) + + ## write treefile + output$PLANTNewick<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(PLANTtree(), outgroup = PLANToutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(PLANTdata()$V1) + outgroup.labels<-setdiff(PLANToutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ## write treefile + output$PLANTNewickNOBL<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(PLANTtree(), outgroup = PLANToutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(PLANTdata()$V1) + outgroup.labels<-setdiff(PLANToutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + pruned.tree$edge.length<-NULL + write.tree(pruned.tree, file=file) + } + ) + + #################### + ### TREE OF LIFE ### + #################### + + ## read in file reactively + TOLdata <- eventReactive(input$TOLgo, { + req(input$TOLfile) + inFile <- input$TOLfile + taxa.list<-read.table(inFile$datapath) + return(taxa.list) + }) + + ## read in tree based on selected tree + TOLtree <- eventReactive(input$TOLgo, { + if (input$TOLphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + TOLtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + } else if (input$TOLphyloSelect == ""Tree of life, 3,083 taxa - Hug et al. 2016"") { + TOLtree <- read.tree(""./Data/Tree_of_Life_fig1_Hug_etal_2016.tre"") + } else + TOLtree <- read.tree(""./Data/Aspergillaceae_fig1_Steenwyk_etal_2018.tre"") + }) + + ## select outgroup labels based on selected tree + TOLoutgroup.labels <- eventReactive(input$TOLgo, {input$TOLphyloSelect + if (input$TOLphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + TOLoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + else if (input$TOLphyloSelect == ""Tree of life, 3,083 taxa - Hug et al. 2016"") { + TOLoutgroup.labels<-c(""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Lelliottia_amnigena_CHS_78"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Leclercia_adecarboxylata_Leclerc_1783_ATCC_23216"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Kluyvera_ascorbata_ATCC_33433"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Citrobacter_rodentium_ICC168"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Salmonella_enterica_Enterica_sv._Heidelberg_41578"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Escherichia_coli_K12__W3110"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Shigella_flexneri_2003036"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Yokenella_regensburgei_ATCC_43003"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Cronobacter_sakazakii_CMCC_45402"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Kosakonia_radicincitans_UMEnt0112"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Trabulsiella_guamensis_ATCC_49490"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Enterobacter_cloacae_SCF1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Raoultella_ornithinolytica_B6"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Klebsiella_oxytoca_HKOPL1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Buttiauxella_agrestis_MCE"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Cedecea_davisae_DSM_4568"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Tatumella_ptyseos_ATCC_33301"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Pseudomonadaceae_Pseudomonas_flectens_ATCC_12775"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Pantoea_ananatis_LMG_5342"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Erwinia_amylovora_CFBP1430"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Pectobacterium_carotovorum_carotovorum_PCC21"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Brenneria_salicis_ATCC_15712"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Lonsdalea_quercina_quercina_NCCB_100489"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Dickeya_dadantii_Ech703"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Wigglesworthia_glossinidia_endosymbiont_of_Glossina_brevipalpis"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Candidatus_Riesia_pediculicola_USDA"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_unclassified_Enterobacteriaceae_Candidatus_Blochmannia_floridanus"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Buchnera_Buchnera_aphidicola_str._APS_Acyrthosiphon_pisum"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_unclassified_Enterobacteriaceae_Candidatus_Hamiltonella_defensa_5AT_Acyrthosiphon_pisum"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Halyomorpha_halys_symbiont"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Thorsellia_anophelis_DSM_18579"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Sodalis_glossinidius_morsitans"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Candidatus_Moranella_endobia_PCIT"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_unclassified_Enterobacteriaceae_Candidatus_Regiella_insecticola_LSR1_genomic_scaffold_Scaffold1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Yersinia_pestis_Nepal516"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Serratia_fonticola_RB_25"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Ewingella_americana_C.024_ATCC_33852"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Rahnella_aquatilis_HX2"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Hafnia_alvei_FB1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Edwardsiella_tarda_C07_087"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Arsenophonus_nasoniae_DSM_15247"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Providencia_stuartii_MRSN_2154"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Xenorhabdus_nematophila_ATCC_19061"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Photorhabdus_luminescens_laumondii_TTO1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Proteus_mirabilis_WGLW4"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Morganella_morganii_morganii_KT"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Pragia_fontium_DSM_5563"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Budvicia_aquatica_DSM_5075"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Leminorella_grimontii_ATCC_33999"",""Bacteria_Proteobacteria_Gammaproteobacteria_Orbales_Orbaceae_Gilliamella_apicola"",""Bacteria_Proteobacteria_Gammaproteobacteria_Orbales_Orbaceae_bacterium_Bimp"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Mannheimia_haemolytica_D174"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Bibersteinia_trehalosi_USDA_ARS_USMARC_189"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Actinobacillus_pleuropneumoniae_serovar_3_str._JL03"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Histophilus_somni_129P"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Avibacterium_paragallinarum_AVPAR72"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Aggregatibacter_actinomycetemcomitans_D7S_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Haemophilus_influenzae_KR494"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Pasteurella_multocida_43137"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Mannheimia_succiniciproducens_MBEL55E"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pasteurellales_Pasteurellaceae_Gallibacterium_anatis_UMN179"",""Bacteria_Proteobacteria_Gammaproteobacteria_Enterobacteriales_Enterobacteriaceae_Plesiomonas_sp._ZOR0011"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Enterovibrio_norvegicus_FF_162"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Enterovibrio_sp._AK16"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Salinivibrio_costicola_costicola_ATCC_33508"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Photobacterium_profundum_SS9"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Vibrio_anguillarum_775_I"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Candidatus_Photodesmus_katoptron_Akat1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Vibrionales_Vibrionaceae_Vibrio_fischeri_MJ11_I"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_Succinivibrio_dextrinosolvens_ACV_10"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_Succinatimonas_hippei_YIT_12066_S_hippeiYIT12066_1.0_Cont1069.1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_Anaerobiospirillum_succiniciproducens_DSM_6400"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_Ruminobacter_sp._RM87"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_WG_1_Wallaby_Group_1_isolate"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Succinivibrionaceae_Succinimonas_amylolytica_DSM_2873"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Aeromonadaceae_Tolumonas_auensis_DSM_9187"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Aeromonadaceae_Aeromonas_hydrophila_AL09_71"",""Bacteria_Proteobacteria_Gammaproteobacteria_Aeromonadales_Aeromonadaceae_Oceanimonas_sp._GK1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Psychromonadaceae_Psychromonas_ingrahamii_37"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Moritellaceae_Moritella_marina_ATCC_15381"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Agarivorans_albus_MKT_106"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Shewanellaceae_Shewanella_oneidensis_MR_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Ferrimonadaceae_Ferrimonas_balearica_DSM_9799"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Gallaecimonas_xiamenensis_3_C_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Glaciecola_nitratireducens_FR1064"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Pseudoalteromonadaceae_Pseudoalteromonas_atlantica_T6c"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Aestuariibacter_salexigens_DSM_15300"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Alteromonas_macleodii_Black_Sea_11"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Salinimonas_chungwhensis_DSM_16280"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Idiomarinaceae_Idiomarina_loihiensis_L2TR"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Gayadomonas_joobiniege_G7"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Catenovulum_agarivorans_YM01"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Pseudoalteromonadaceae_Algicola_sagamiensis_DSM_14643"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Colwelliaceae_Thalassotalea_agarivorans_DSM_19706"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Colwelliaceae_Colwellia_psychrerythraea_34H"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Alishewanella_agri_BL06"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Rheinheimera_nanhaiensis_E407_8"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Alcanivoracaceae_Kangiella_koreensis_DSM_16069"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Carnimonas_nigrificans_ATCC_BAA_78"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Halotalea_alkalilenta_DSM_17697"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Zymobacter_group_Zymobacter_palmae_DSM_10491"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Kushneria_aurantia_DSM_21353"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Chromohalobacter_salexigens_1H11_DSM_3043"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Halomonas_elongata_DSM_2581"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Halomonadaceae_Cobetia_marina_KMM_296"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Marinospirillum_insulare_DSM_21763"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Oceanospirillum_maris_DSM_6286"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Thalassolituus_oleivorans_R6_15"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Oceanobacter_kriegii_DSM_6294"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Oceanobacter_sp._RED65_unfinished_sequence"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Reinekea_blandensis_MED297"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Saccharospirillaceae_Saccharospirillum_impatiens_DSM_12546"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Marinomonas_mediterranea_MMB_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Neptuniibacter_caesariensis_MED92"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Amphritea_japonica_ATCC_BAA_1530"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Marinobacterium_litorale_DSM_23545"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Nitrincola_lacisaponensis_4CA"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Neptunomonas_japonica_DSM_18939"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillaceae_Balneatrix_alpica_DSM_16621"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Hahellaceae_Hahella_chejuensis_KCTC_2396"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadales_genera_incertae_sedis_Gilvimarinus_chinensis_DSM_19667"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Marinimicrobium_agarilyticum_DSM_16975"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Pseudomonadaceae_Cellvibrio_japonicus_Ueda107"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Simiduia_agarivorans_SA1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_B._setacea_BS12"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadales_genera_incertae_sedis_Teredinibacter_turnerae_T7902"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Saccharophagus_degradans_2_40"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Alteromonas_sp._S89"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Porticoccus_hydrocarbonoclasticus_MCTG13d"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_OMG_group_OM60_clade_Congregibacter_litoralis_KT71"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Haliea_rubra_CM41_15a_DSM_19751"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Haliea_salexigens_DSM_19537"",""Bacteria_Proteobacteria_Gammaproteobacteria_gamma_proteobacterium_NOR51_B_scf_1109846220923_genomic_scaffold"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Spongiibacter_tropicus_DSM_19543"",""Bacteria_Proteobacteria_Gammaproteobacteria_Alteromonadales_Alteromonadaceae_Melitea_salexigens_DSM_19753"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_unclassified_Pseudomonadales_Dasania_marina_DSM_21967"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Pseudomonadaceae_Pseudomonas_aeruginosa_B136_33"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Pseudomonadaceae_Azotobacter_group_Azotobacter_vinelandii_CA6"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Hahellaceae_Endozoicomonas_montiporae_LMG_24815"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Hahellaceae_Zooshikella_ganghwensis_DSM_15267"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Psychrobacter_cryohalolentis_K5"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Moraxella_Moraxella_Moraxella_catarrhalis_25240"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Enhydrobacter_aerosaccus_SK60"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Alkanindiges_illinoisensis_DSM_15370"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Acinetobacter_baumannii_AB30"",""Bacteria_Proteobacteria_Gammaproteobacteria_Pseudomonadales_Moraxellaceae_Perlucidibaca_piscinae_DSM_21586"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Alcanivoracaceae_Alcanivorax_borkumensis_SK2"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Francisellaceae_Francisella_philomiragia_subsp._philomiragia_ATCC_25017"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Francisellaceae_Francisella_FSC776"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Piscirickettsia_salmonis_LF_89"",""Bacteria_Proteobacteria_Gammaproteobacteria_Legionellales_Legionellaceae_Legionella_micdadei_ATCC_33218"",""Bacteria_Proteobacteria_Gammaproteobacteria_Legionellales_Legionellaceae_Fluoribacter_dumoffii_Tex_KL_ATCC_33343"",""Bacteria_Proteobacteria_Gammaproteobacteria_Oceanospirillales_Oceanospirillales_bacterium_SCGC_AAA298_N10"",""Bacteria_Proteobacteria_Gammaproteobacteria_Legionellales_Coxiellaceae_Rickettsiella_grylli"",""Bacteria_Proteobacteria_Gammaproteobacteria_Legionellales_Coxiellaceae_Diplorickettsia_massiliensis_20B"",""Bacteria_Proteobacteria_Gammaproteobacteria_Legionellales_Coxiellaceae_Coxiella_burnetii_CbuK_Q154"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Thiomicrospira_crunogena_XCL_2"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Thiomicrospira_CG2_30_FULL_Thiomicrospira_44_34"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Hydrogenovibrio_marinus_MH_110"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Thioalkalimicrobium_cyclicum_ALM1"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Candidatus_Ruthia_magnifica_str._Cm_Calyptogena_magnifica"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylosarcina_lacus_LW14"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylobacter_tundripaludum_2122"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylovulum_miyakonense_HT12"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methyloglobulus_morosus_KoM1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylomarinum_vadi_IT_4"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylomonas_mecanica_MC09"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylocaldum_szegediense_O_12"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylococcus_capsulatus_Bath"",""Bacteria_Proteobacteria_Gammaproteobacteria_Methylococcales_Methylococcaceae_Methylohalobius_crimeensis_10Ki"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Cycloclasticus_sp._P1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Piscirickettsiaceae_Methylophaga_frappieri_JAM7"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Nitrosococcus_oceani_C_107_ATCC_19707"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Thiorhodococcus_drewsii_AZ1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Allochromatium_vinosum_DSM_180"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Thiocystis_violascens_611_DSM_198"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Thiocapsa_marina_5811_DSM_5653"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Marichromatium_purpuratum_987"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Lamprocystis_purpurea_DSM_4197"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Thioflavicoccus_mobilis_8321"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Chromatiaceae_Thiorhodovibrio_sp._970"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Dechloromarinus_chlorophilus_NSS"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Thiohalomonas_denitrificans_HLD2"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Thiotrichaceae_Beggiatoa_sp._Orange_Guaymas"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Thiotrichaceae_Thiomargarita_sp._Thio36"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiothrichales_uncultured_SG8_50"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Arhodomonas_aquaeolei_DSM_8974"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Ectothiorhodospiraceae_bacterium_M19_40"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Nitrococcus_mobilis_Nb_231"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Alkalilimnicola_ehrlichii_MLHE_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Thiohalospira_halophilus_HL3"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Ectothiorhodospira_sp._PHS_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Halorhodospira_halochloris_A"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Thiorhodospira_sibirica_A12_ATCC_700588"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Ectothiorhodospiraceae_Thioalkalivibrio_nitratireducens_DSM_14787"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Thiotrichaceae_Thiothrix_flexilis_DSM_14609"",""Bacteria_Proteobacteria_Gammaproteobacteria_Thiotrichales_Thiotrichaceae_Leucothrix_mucor_DSM_2157"",""Bacteria_Proteobacteria_Gammaproteobacteria_Chromatiales_Halothiobacillaceae_Halothiobacillus_neapolitanus_c2"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Stenotrophomonas_maltophilia_K279a"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Stenotrophomonas_maltophilia_ATCC_19867"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Xanthomonas_oryzae_ATCC_35933"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Xanthomonas_axonopodis_Xac29_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Xylella_fastidiosa_multiplex_ATCC_35871"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Xylella_fastidiosa_sandyi_Ann_1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_RIFOXYA1_FULL_Xanthomonadales_68_6"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Pseudoxanthomonas_spadix_BD_a59"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Luteimonas_sp._J16"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Luteimonas_mephitis_DSM_12574"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Thermomonas_fusca_DSM_15424"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Lysobacter_antibioticus_HS124"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Lysobacter_defluvii_DSM_18482"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Arenimonas_donghaensis_DSM_18148_HO3_R19"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Arenimonas_oryziterrae_DSM_21050"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Silanimonas_lenta_DSM_16282"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Rudaea_cellulosilytica_DSM_22992"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_RIFOXYA1_FULL_Rhodanobacter_67_6"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Rhodanobacter_sp._2APBS1"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Frateuria_terrea_CGMCC_1.7053"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Dyella_japonica_A8"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Frateuria_aurantia_Kondo_67_DSM_6220"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Luteibacter_sp._9145"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Wohlfahrtiimonas_chitiniclastica_DSM_18708"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Wohlfahrtiimonas_chitiniclastica_SH04"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Xanthomonadaceae_Ignatzschineria_larvae_DSM_13226"",""Bacteria_Proteobacteria_Gammaproteobacteria_Cardiobacteriales_Cardiobacteriaceae_Cardiobacterium_valvarum_F0432"",""Bacteria_Proteobacteria_Gammaproteobacteria_Cardiobacteriales_Cardiobacteriaceae_Dichelobacter_nodosus_VCS1703A"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Sinobacteraceae_Singularimonas_variicoloris_DSM_15731"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Solimonas_soli_DSM_21787"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Sinobacteraceae_Hydrocarboniphaga_effusa_AP103"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Sinobacteraceae_Nevskia_ramosa_DSM_11499"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Sinobacteraceae_Polycyclovorans_algicola_TG408"",""Bacteria_Proteobacteria_Gammaproteobacteria_Xanthomonadales_Algiphilaceae_Algiphilus_aromaticivorans_DG1253"",""Bacteria_Proteobacteria_Gammaproteobacteria_Salinisphaerales_Salinisphaeraceae_Salinisphaera_shabanensis_E1L3A"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Delftia_acidovorans_SPH_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Comamonas_testosteroni_TK102"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Alicycliphilus_denitrificans_K601"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Acidovorax_avenae_subsp._citrulli_AAC00_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Giesbergeria_anulus_ATCC_35958"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Simplicispira_psychrophila_DSM_11588"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Verminephrobacter_eiseniae_EF01_2"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Curvibacter_lanceolatus_ATCC_14669"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Rhodoferax_CG1_02_FULL_Comamonadaceae_60_18"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Rhodoferax_CG2_30_FULL_Comamonadaceae_60_41"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Rhodoferax_CG2_30_FULL_Comamonadaceae_59_20"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Rhodoferax_CG2_30_FULL_Comamonadaceae_57_122"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Rhodoferax_ferrireducens_T118"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Hylemonella_gracilis_ATCC_19624"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Xenophilus_azovorans_DSM_13620"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Pseudacidovorax_intermedius_NH_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Variovorax_paradoxus_B4"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Ramlibacter_tataouinensis_TTB310"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Ottowia_thiooxydans_DSM_14619"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Brachymonas_chironomi_DSM_19884"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Limnohabitans_sp._Rim28_Limnohabitans_sp._Rim28_73_Contigs"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Polaromonas_naphthalenivorans_CJ2"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Hydrogenophaga_sp._T4"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Comamonadaceae_sp._CR"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Ideonella_sp._B508_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Rubrivivax_gelatinosus_IL144"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Azohydromonas_australica_DSM_1124"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Mitsuaria_sp._H24L5A"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Sphaerotilus_natans_natans_DSM_6575"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Leptothrix_cholodnii_SP_6"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Methylibium_sp._T29"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Comamonadaceae_Caldimonas_manganoxidans_ATCC_BAA_369"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_unclassified_Burkholderiales_Burkholderiales_Genera_incertae_sedis_Thiomonas_intermedia_K12"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Sutterellaceae_Sutterella_wadsworthensis_HGA0223"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Sutterellaceae_Parasutterella_Parasutterella_excrementihominis_YIT_11859_P_excrementihominisYIT11859_1.0_Cont110.1_whole_genome_shotgun"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Limnobacter_sp._MED105_unfinished_sequence"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Brackiella_oedipodis_DSM_13743"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Oligella_ureolytica_DSM_18253"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Pelistega_sp._HM_7"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Taylorella_asinigenitalis_MCE3"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Basilea_psittacipulmonis_DSM_24701"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Tetrathiobacter_kashmirensis_WT001"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Achromobacter_xylosoxidans_NBRC_15126_ATCC_27061"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Bordetella_bronchiseptica_RB50"",""Bacteria_Proteobacteria_Betaproteobacteria_unclassified_Betaproteobacteria_Candidatus_Kinetoplastibacterium_oncopeltii_TCC290E"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Pusillimonas_sp._T7_7"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Alcaligenes_faecalis_phenolicus_DSM_16503"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Lautropia_mirabilis_ATCC_51599_contig00020"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Duganella_zoogloeoides_ATCC_25935"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Zoogloea_ramigera_ATCC_19544"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Massilia_alkalitolerans_DSM_17462"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Janthinobacterium_sp._Marseille"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Herminiimonas_arsenicoxydans"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Collimonas_fungivorans_Ter331"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Herbaspirillum_seropedicae_SmR1"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Oxalobacteraceae_Oxalobacter_formigenes_OXCC13_genomic_scaffold_supercont1.1"",""Bacteria_Proteobacteria_Betaproteobacteria_unclassified_Betaproteobacteria_Candidatus_Profftella_armatura_syncytium_symbiont_of_Diaphorina_citri"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Ralstonia_solanacearum_GMI1000"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Ralstonia_eutropha_JMP134"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Polynucleobacter_necessarius_asymbioticus_MWH_MoK4_closed_genome"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Glomeribacter_sp._1016415"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Burkholderia_cenocepacia_AU_1054"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Pandoraea_pnomenusa_RB38"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Alcaligenaceae_Derxia_gummosa_DSM_723"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Dechlorobacter_hydrogenophilus_LT_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Dechloromonas_aromatica_RCB"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Azonexus_hydrophilus_DSM_23864"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Azovibrio_restrictus_DSM_23866"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Dechlorosoma_suillum_PS"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Propionivibrio_dicarboxylicus_DSM_5885"",""Bacteria_Proteobacteria_Betaproteobacteria_unclassified_Betaproteobacteria_Candidatus_Accumulibacter_phosphatis_clade_IIA_str._UW_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Aromatoleum_aromaticum_EbN1"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Azoarcus_sp._KH32C"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Thauera_sp._MZ1T"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Uliginosibacterium_gangwonense_DSM_18521"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_CG2_30_FULL_Betaproteobacteria_68_42"",""Bacteria_Proteobacteria_Betaproteobacteria_Hydrogenophilales_Hydrogenophilaceae_Tepidiphilus_margaritifer_DSM_15129"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_GWA2_Rhodocyclales_65_20"",""Bacteria_Proteobacteria_Betaproteobacteria_Rhodocyclales_Rhodocyclaceae_Methyloversatilis_universalis_EHg5"",""Bacteria_Proteobacteria_Betaproteobacteria_uncultured_SG8_41"",""Bacteria_Proteobacteria_Betaproteobacteria_uncultured_SG8_39"",""Bacteria_Proteobacteria_Betaproteobacteria_uncultured_SG8_40"",""Bacteria_Proteobacteria_Betaproteobacteria_Gallionellales_Gallionellaceae_Ferriphaselus_sp._R_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Gallionellales_Gallionellaceae_Gallionella_capsiferriformans_ES_2"",""Bacteria_Proteobacteria_Betaproteobacteria_Gallionellales_Gallionellaceae_Sideroxydans_lithotrophicus_ES_1"",""Bacteria_Proteobacteria_Betaproteobacteria_Nitrosomonadales_Nitrosomonadaceae_Nitrosospira_multiformis_ATCC_25196"",""Bacteria_Proteobacteria_Betaproteobacteria_Nitrosomonadales_Nitrosomonadaceae_Nitrosomonas_europaea_ATCC_19718"",""Bacteria_Proteobacteria_Betaproteobacteria_Hydrogenophilales_Hydrogenophilaceae_Thiobacillus_denitrificans_ATCC_25259"",""Bacteria_Proteobacteria_Betaproteobacteria_Hydrogenophilales_GWE1_Thiobacillus_62_9"",""Bacteria_Proteobacteria_Betaproteobacteria_Hydrogenophilales_Hydrogenophilaceae_CG1_02_SUB10_Hydrogenophilaceae_62_390"",""Bacteria_Proteobacteria_Betaproteobacteria_Hydrogenophilales_Hydrogenophilaceae_Sulfuricella_denitrificans_skB26"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Simonsiella_muelleri_ATCC_29453"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Kingella_kingae_PYKK081"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Alysiella_crassa_DSM_2578"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Conchiformibius_steedae_DSM_2580"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Eikenella_corrodens_ATCC_23834"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Neisseria_gonorrhoeae_FA_1090"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Stenoxybacter_acetivorans_DSM_19021"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Snodgrassella_alvi_wkB2"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Chromobacterium_group_Vitreoscilla_stercoraria_DSM_513"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Chromobacteriaceae_Lutiella_nitroferrum_2002_unfinished_sequence"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Paludibacterium_yongneupense_DSM_18731"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Chromobacterium_group_Chromobacterium_violaceum_ATCC_12472"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Microvirgula_aerodenitrificans_DSM_15089"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Laribacter_hongkongensis_HLHK9"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Deefgea_rivuli_DSM_18356"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Formivibrio_citricus_DSM_6150"",""Bacteria_Proteobacteria_Betaproteobacteria_Burkholderiales_Burkholderiaceae_Chitinimonas_koreensis_DSM_17726"",""Bacteria_Proteobacteria_Betaproteobacteria_Neisseriales_Neisseriaceae_Leeia_oryzae_DSM_17879"",""Bacteria_Proteobacteria_Betaproteobacteria_Methylophilales_Methylophilaceae_Methylophilus_methylotrophus_ATCC_53528"",""Bacteria_Proteobacteria_Betaproteobacteria_Methylophilales_Methylophilaceae_Methylotenera_sp._301"",""Bacteria_Proteobacteria_Betaproteobacteria_Methylophilales_Methylophilaceae_Methylovorus_sp._SIP3_4"",""Bacteria_Proteobacteria_Betaproteobacteria_Methylophilales_Methylophilaceae_Methylobacillus_flagellatus_KT"",""Bacteria_Proteobacteria_Acidithiobacillia_Acidithiobacillales_Thermithiobacillaceae_Thermithiobacillus_tepidarius_DSM_3134"",""Bacteria_Proteobacteria_Acidithiobacillia_Acidithiobacillales_Acidithiobacillaceae_Acidithiobacillus_ferrivorans_SS3"",""Bacteria_Proteobacteria_Gammaproteobacteria_unclassified_Gammaproteobacteria_Thiohalorhabdus_denitrificans_HL19"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_137_J06"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_133_G06"",""Bacteria_Proteobacteria_Zetaproteobacteria_Mariprofundales_Mariprofundaceae_Mariprofundus_ferrooxydans_M34"",""Bacteria_Proteobacteria_Zetaproteobacteria_Mariprofundales_Mariprofundaceae_Mariprofundus_sp._EKF_M39"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_137_L23"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_137_C09"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_137_I08"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AB_133_C04"",""Bacteria_Proteobacteria_Zetaproteobacteria_Zetaproteobacteria_bacterium_TAG_1"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AC_673_C02"",""Bacteria_Proteobacteria_Zetaproteobacteria_zeta_proteobacterium_SCGC_AC_673_M07"",""Bacteria_Proteobacteria_unclassified_Proteobacteria_CG1_02_FULL_Proteobacteria_64_396"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_Neorhizobium_galegae_bv._orientalis_HAMBI_540"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_RhizobiumAgrobacterium_group_Rhizobium_leguminosarum_bv._trifolii_CB782"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_RhizobiumAgrobacterium_group_Agrobacterium_sp._H13_3"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_Shinella_zoogleoides_DD12_SHLA"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_SinorhizobiumEnsifer_group_Ensifer_meliloti_GR4"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_SinorhizobiumEnsifer_group_Ensifer_adhaerens_OV14"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Aurantimonadaceae_Martelella_mediterranea_DSM_17316"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_Candidatus_Liberibacter_americanus_Sao_Paulo"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Hoeflea_phototrophica_DFL_43"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Ahrensia_sp._13_GOM_1096m"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Aquamicrobium_defluvii_W13Z1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Mesorhizobium_australicum_WSM2073"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Pseudaminobacter_salicylatoxidans_KCT001"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Aminobacter_sp._J41"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Aliihoeflea_sp._2WW"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Nitratireductor_aquibiodomus_JCM_21793"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Chelativorans_sp._BNC1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Brucellaceae_Ochrobactrum_anthropi_ATCC_49188_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Brucellaceae_Brucella_abortus_A13334"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Brucellaceae_Pseudochrobactrum_sp._AO18b"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bartonellaceae_Bartonella_clarridgeiae_73"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Phyllobacterium_sp._YR531"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Aurantimonadaceae_Fulvimarina_pelagi_HTCC2506_unfinished_sequence"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Aurantimonadaceae_Aurantimonas_manganoxydans_SI85_9A1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Aurantimonadaceae_Aurantimonas_ureilytica_DSM_18598"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Beijerinckiaceae_Methylocapsa_acidiphila_B2"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Beijerinckiaceae_Methylocella_silvestris_BL2"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Beijerinckiaceae_Beijerinckia_indica_subsp._indica_ATCC_9039"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Beijerinckiaceae_Methyloferula_stellata_AR4"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylocystaceae_Methylocystis_sp._SC2"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylocystaceae_Methylosinus_sp._PW1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Salinarimonas_rosea_DSM_21201"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylobacteriaceae_Methylobacterium_extorquens_PA1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylobacteriaceae_Microvirga_sp._WSM3557"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Bosea_sp._UNC402CLCol"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Beijerinckiaceae_Chelatococcus_sp._GW1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Rhodopseudomonas_palustris_BisB18"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Bradyrhizobium_japonicum_SEMIA_5079"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Nitrobacter_hamburgensis_X14"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Oligotropha_carboxidovorans_OM5"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Bradyrhizobiaceae_Afipia_sp._OHSU_I_C6"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Rhodovulum_sp._PH10"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Xanthobacteraceae_Xanthobacter_autotrophicus_Py2"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Xanthobacteraceae_Azorhizobium_caulinodans_ORS_571"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Xanthobacteraceae_Ancylobacter_sp._FA202"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Xanthobacteraceae_Starkeya_novella_DSM_506"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylocystaceae_Methylopila_sp._M107"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Prosthecomicrobium_hirschii_ATCC_27832"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhizobiaceae_Kaistia_adipata_DSM_17808"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_unclassified_Rhizobiales_Bauldia_litoralis_ATCC_35022"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylocystaceae_Pleomorphomonas_oryzae_DSM_16300"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhodobiaceae_Lutibaculum_baratangense_AMV1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_unclassified_Rhizobiales_Amorphus_coralli_DSM_19760"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Roseibium_sp._TrichSKD4_genomic_scaffold_scf_1119120597021"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Labrenzia_alexandrii_DFL_11"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Pannonibacter_phragmitetus_DSM_14782"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Stappia_stellulata_DSM_5886"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Nesiotobacter_exalbescens_DSM_16456"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Pseudovibrio_sp._FO_BEG1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_unclassified_Rhizobiales_Vasilyevaea_enhydra_ATCC_23634"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Devosia_sp._17_2_E_8"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Pelagibacterium_halotolerans_B2"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Maritalea_myrionectae_DSM_19524"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Cucumibacter_marinus_DSM_18995"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Rhodobiaceae_Afifella_pfennigii_DSM_17143"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Rhodomicrobium_vannielii_ATCC_17100"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Hyphomicrobiaceae_Hyphomicrobium_nitrativorans_NL23"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Phyllobacteriaceae_Parvibaculum_lavamentivorans_DS_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_unclassified_Alphaproteobacteriar_Canditatus_Phaeomarinobacter_ectocarpi_Ec32"",""Bacteria_Proteobacteria_Alphaproteobacteria_unclassified_Alphaproteobacteria_Thermopetrobacter_sp._TC1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Sulfitobacter_sp._NAS_14.1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Oceanibulbus_indolifex_HEL_45_unfinished_sequence"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Roseobacter_litoralis_Och_149"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Sedimentitalea_cNanh_4411"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Loktanella_vestfoldensis_SKA53"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Octadecabacter_arcticus_238"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Roseobacter_Thalassiobium_sp._R2A62_genomic_scaffold_scf_1112329232034"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Thalassobacter_arenae_DSM_19593"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Jannaschia_sp._CCS1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Sediminimonas_qiaohouensis_DSM_21189"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Planktomarina_temperata_RCA23_DSM_22400_RCA23"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Nereida_ignava_DSM_16309"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_cArct_4215"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_cMeth_4145"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Phaeobacter_gallaeciensis_2.10"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Silicibacter_pomeroyi_DSS_3"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Donghicola_xiamenensis_DSM_18339"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Salipiger_mucosus_DSM_16094_scaffold_version"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Pelagibaca_bermudensis_HTCC2601"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Citreicella_sp._SE45"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Sagittula_stellata_E_37_unfinished_sequence"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Roseivivax_sp._22II_s10s"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Roseovarius_sp._217"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Actibacterium_mucosum_KCTC_23349"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Dinoroseobacter_shibae_DFL_12"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Maritimibacter_sp._HL_12"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Celeribacter_sp._P73_complete_genome"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Oceaniovalibus_guishaninsula_JLT2003"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Maribius_sp._MOLA_401"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Oceanicola_granulosus_HTCC2516"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Rubellimicrobium_thermophilum_DSM_16684"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Ketogulonigenium_vulgarum_WSH_001"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Wenxinia_marina_DSM_24838"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_CG2_30_SUB100_Rhodobacteraceae_10_405"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Pseudorhodobacter_ferrugineus_DSM_5888"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Catellibacterium_nectariphilum_DSM_15620"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Rhodobacter_capsulatus_SB1003"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Thioclava_pacifica_DSM_10166"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Haematobacter_missouriensis_CCUG_52307"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Defluviimonas_sp._20V17"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Rhodobacteraceae_Paracoccus_denitrificans_PD1222_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylobacteriaceae_Meganema_perideroedes_DSM_15528"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Oceanicaulis_alexandrii_HTCC2633"",""Bacteria_Proteobacteria_Alphaproteobacteria_Caulobacterales_Caulobacteraceae_Woodsholea_maritima_DSM_17123"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Maricaulis_maris_MCS10"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Robiginitomaculum_antarcticum_DSM_21748"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Hellea_balneolensis_DSM_19091"",""Bacteria_Proteobacteria_Alphaproteobacteria_Caulobacterales_Caulobacteraceae_Asticcacaulis_excentricus_CB_48_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Caulobacterales_Caulobacteraceae_Brevundimonas_subvibrioides_ATCC_15264"",""Bacteria_Proteobacteria_Alphaproteobacteria_Caulobacterales_Caulobacteraceae_Phenylobacterium_zucineum_HLK1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Caulobacterales_Caulobacteraceae_Caulobacter_segnis_ATCC_21756"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Henriciella_marina_DSM_19595"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Hyphomonas_neptunium_ATCC_15444"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodobacterales_Hyphomonadaceae_Hirschia_baltica_ATCC_49814"",""Bacteria_Proteobacteria_Alphaproteobacteria_Parvularculales_Parvularculaceae_Parvularcula_bermudensis_HTCC2503"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Erythrobacteraceae_Erythrobacter_litoralis_HTCC2594"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Citromicrobium_sp._JLT1363"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Erythrobacteraceae_Altererythrobacter_ishigakiensis_ATCC_BAA_2084"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Erythrobacteraceae_Porphyrobacter_sp._AAP82"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Novosphingobium_sp._PP1Y"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Blastomonas_sp._AAP53"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Sphingobium_japonicum_UT26S_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Sphingopyxis_alaskensis_RB2256"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Zymomonas_mobilis_mobilis_CP4"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Sphingomonas_wittichii_RW1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sphingomonadales_Sphingomonadaceae_Sandarakinorhabdus_sp._AAP62"",""Bacteria_Proteobacteria_Alphaproteobacteria_Kordiimonadales_Kordiimonas_gwangyangensis_DSM_19435"",""Bacteria_Proteobacteria_Alphaproteobacteria_Sneathiellales_Sneathiellaceae_Sneathiella_glossodoripedis_JCM_23214"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhizobiales_Methylocystaceae_Terasakiella_pusilla_DSM_6293"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Thalassospira_profundimaris_WP0211"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Gluconobacter_oxydans_621H"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Saccharibacter_floricola_DSM_15669"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Kozakia_baliensis_SR_745"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Asaia_platycodi_JCM_25414"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Gluconacetobacter_xylinus_NBRC_3288"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Gluconacetobacter_diazotrophicus_PAl_5"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Acetobacter_pasteurianus_386B"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Commensalibacter_sp._MX_MONARCH01"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Granulibacter_bethesdensis_CGDNIH1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Acidiphilium_multivorum_AIU301"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Acidocella_facilis_ATCC_35904"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Roseomonas_mucosa_ATCC_BAA_692"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Belnapia_moabensis_DSM_16746"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Acetobacteraceae_Rubritepida_flocculans_DSM_14296"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_unclassified_Rhodospirillales_Elioraea_tepidiphila_DSM_17972"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_unclassified_Rhodospirillales_Reyranella_Reyranella_massiliensis_521_DSM_23428"",""Bacteria_Proteobacteria_Alphaproteobacteria_unclassified_Alphaproteobacteria_Micavibrio_aeruginosavorus_ARL_13"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Azospirillum_irakense_DSM_11586"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Azospirillum_amazonense_CBAmc"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Skermanella_stibiiresistens_SB22"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Inquilinus_limosus_DSM_16000"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Dongia_sp._URHE0060"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Rhodospirillum_rubrum_S1_ATCC_11170"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Caenispirillum_salinarum_AK4"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Novispirillum_itersonii_ATCC_12639"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Magnetospirillum_magneticum_AMB_1"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Thalassobaculum_salexigens_DSM_19539"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Candidatus_Endolissoclinum_faulkneri_L5"",""Bacteria_Proteobacteria_Alphaproteobacteria_Alpha_proteobacterium_IMCC1322"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Nisaea_denitrificans_DSM_18348"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Oceanibaculum_indicum_P24"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Rhodovibrio_salinarum_DSM_9154"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Fodinicurvata_sediminis_DSM_21159"",""Bacteria_Proteobacteria_Alphaproteobacteria_Kiloniellales_Kiloniellaceae_Kiloniella_laminariae_DSM_19542"",""Bacteria_Proteobacteria_Alphaproteobacteria_unclassified_Alphaproteobacteria_Geminicoccus_roseus_DSM_18922"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rhodospirillales_Rhodospirillaceae_Tistrella_mobilis_KA081020_065"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Rickettsiales_genera_incertae_sedis_Candidatus_Odyssella_thessalonicensis_L13"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Anaplasmataceae_Anaplasma_marginale_St._Maries"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Anaplasmataceae_Ehrlichia_chaffeensis_Osceola"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Anaplasmataceae_Wolbachieae_Wolbachia_endosymbiont_of_Drosophila_melanogaster"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Anaplasmataceae_Neorickettsia_sennetsu_Miyayama"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Anaplasmataceae_Candidatus_Xenolissoclinum_pacificiensis_L6"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Candidatus_Midichloria_mitochondrii_IricVA"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Rickettsiaceae_Rickettsieae_Rickettsia_conorii_Malish_7"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Rickettsiaceae_Rickettsieae_Orientia_tsutsugamushi_Boryong"",""Bacteria_Proteobacteria_Alphaproteobacteria_Rickettsiales_Holosporaceae_Holospora_undulata_HU1"",""Bacteria_Proteobacteria_Alphaproteobacteria_unclassified_Alphaproteobacteria_SAR11_cluster_Candidatus_Pelagibacter_sp._IMCC9063"",""Bacteria_Proteobacteria_Alphaproteobacteria_Magnetococcales_Magnetococcaceae_Magnetococcus_sp._MC_1"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Helicobacteraceae_Sulfuricurvum_sp._RIFRC_1"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Helicobacteraceae_Sulfurimonas_denitrificans_DSM_1251"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Helicobacteraceae_Thiovulum_sp._ES"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Campylobacteraceae_Arcobacter_nitrofigilis_DSM_7299"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_unclassified_Epsilonproteobacteria_Sulfurovum_sp._NBC37_1"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Helicobacteraceae_Wolinella_succinogenes_DSM_1740"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Helicobacteraceae_Helicobacter_cetorum_MIT_99_5656"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Campylobacteraceae_Campylobacter_jejuni_jejuni_NCTC_11168"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Campylobacterales_Campylobacteraceae_Sulfurospirillum_barnesii_SES_3"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_unclassified_Epsilonproteobacteria_Nitratiruptor_sp._SB155_2"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Nautiliales_Nautiliaceae_Lebetimonas_sp._JS032"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Nautiliales_Nautiliaceae_Nautilia_profundicola_AmH"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Epsilonproteobacteria_Nautiliales_Nautiliaceae_Caminibacter_mediatlanticus_TB_2_unfinished_sequence"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfurellales_Desulfurellaceae_Hippea_maritima_MH2_DSM_10411"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfurellales_Desulfurellaceae_Desulfurella_acetivorans_A63_DSM_5264"",""Bacteria_CP_TM6_GWE2_TM6_42_60"",""Bacteria_CP_TM6_gwf2_TM6_43_87"",""Bacteria_CP_TM6_GWF2_TM6_43_17_partial"",""Bacteria_CP_TM6_GWE2_TM6_41_16"",""Bacteria_TM6_RIFCSPHIGHO2_12_FULL_TM6_38_8"",""Bacteria_CP_TM6_GWF2_TM6_32_72"",""Bacteria_TM6_bacterium_JCVI_TM6SC1"",""Bacteria_CP_TM6_GWF2_TM6_30_66"",""Bacteria_TM6_RIFCSPHIGHO2_12_FULL_TM6_36_22"",""Bacteria_TM6_RIFCSPHIGHO2_12_FULL_TM6_32_22"",""Bacteria_CP_TM6_GWF2_TM6_36_6_partial"",""Bacteria_CP_TM6_GWF2_TM6_37_49"",""Bacteria_CP_TM6_GWF2_TM6_38_10"",""Bacteria_CP_TM6_GWF2_TM6_28_16"",""Bacteria_Spirochatetes_Spirochaetia_Spirochaetales_RIFOXYC1_FULL_Spirochaetes_54_7"",""Bacteria_Spirochatetes_Spirochaetia_Spirochaetales_GWB1_Spirochaetes_59_5"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Spirochaetaceae_Treponema_denticola_ATCC_35405"",""Bacteria_Spirochatetes_Spirochaetia_Spirochaetales_RBG_16_Spirochaete_67_19"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Spirochaetaceae_Spirochaeta_sp._Buddy"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Spirochaetaceae_Spirochaeta_sp._L21_RPul_D2"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Spirochaetaceae_Borrelia_garinii_PBi_linear"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Brevinemataceae_Brevinema_andersonii_ATCC_43811"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Brachyspiraceae_Brachyspira_murdochii_DSM_12563"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Leptospiraceae_Leptospira_biflexa_serovar_Patoc_strain_Patoc_1_Paris_I"",""Bacteria_Spirochaetes_Spirochaetia_Leptospirales_Leptospiraceae_Leptonema_illini_3055_DSM_21528"",""Bacteria_Spirochaetes_Spirochaetia_Spirochaetales_Leptospiraceae_Turneriella_parva_H_DSM_21527"",""Bacteria_CP_NKB19_candidate_division_NKB19_bacterium_JGI_0000039_J10_Combined_Assembly_NKB19_1__NKB19"",""Bacteria_CP_NKB19_candidate_division_NKB19_bacterium_JGI_0000059_N10_TAbiofilm_001_172"",""Bacteria_unclassified_bacteria_CG1_02_FULL_NKB19_42_14"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Selenovibrio_woodruffii_S4"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Denitrovibrio_acetiphilus_DSM_12809"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Geovibrio_thiophilus_L21_Ace_BES"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Mucispirillum_schaedleri_ASF457"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Calditerrivibrio_nitroreducens_DSM_19672"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Flexistipes_sinusarabici_MAS10_DSM_4947"",""Bacteria_Deferribacteres_Deferribacteres_Deferribacterales_Deferribacteraceae_Deferribacter_desulfuricans_SSM1"",""Bacteria_Chrysiogenetes_Chrysiogenetes_Chrysiogenales_Chrysiogenaceae_Desulfurispirillum_indicum_S5"",""Bacteria_Chrysiogenetes_Chrysiogenetes_Chrysiogenales_Chrysiogenaceae_Chrysiogenes_arsenatis_DSM_11915"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfobacula_toluolica_Tol2"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfobacter_postgatei_2ac9"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfospira_joergensenii_DSM_10085"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfotignum_phosphitoxidans_FiPS_3"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfobacterium_autotrophicum_HRM2"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfobotulus_alkaliphilus_ASO4_4"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulforegula_conservatrix_Mb1Pa_DSM_13527"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfatirhabdium_butyrativorans_DSM_18734"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfonema_limicola"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfosarcina_variabilis"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfococcus_oleovorans_Hxd3"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfatibacillum_alkenivorans_AK_01_Desulfatibacillum_alkenivorans_AK_01"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Candidatus_Magnetoglobus_multicellularis_Araruama"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobacteraceae_Desulfobacterium_anilini_DSM_4660"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophaceae_Desulfobacca_acetoxidans_DSM_11109"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobulbaceae_Desulfocapsa_sulfexigens_DSM_10523"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobulbaceae_Desulfotalea_psychrophila_LSv54"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobulbaceae_Desulfobulbus_propionicus_DSM_2032"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfobacterales_Desulfobulbaceae_Desulfurivibrio_alkaliphilus_AHT2"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfarculales_Desulfarculaceae_Desulfarculus_baarsii_DSM_2075"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfobacterium_hveragerdense_DSM_12571"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfobacterium_thermophilum_DSM_1276"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfobacterium_commune_DSM_2178"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfobacterium_hydrogeniphilum_DSM_14290"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfobacterium_sp._OPB45"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfatator_indicus_CIR29812_DSM_15286"",""Bacteria_Thermodesulfobacteria_Thermodesulfobacteria_Thermodesulfobacteriales_Thermodesulfobacteriaceae_Thermodesulfatator_atlanticus_DSM_21156"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophobacteraceae_Syntrophobacter_fumaroxidans_MPOB"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophobacteraceae_Thermodesulforhabdus_norvegica_DSM_9990"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfovibrionaceae_Bilophila_wadsworthia_3_1_6"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfovibrionaceae_Lawsonia_intracellularis_PHEMN1_00"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfovibrionaceae_Desulfovibrio_desulfuricans_subsp._desulfuricans_str._ATCC_27774"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfovibrionaceae_Desulfocurvus_vexinensis_DSM_17965"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfonatronumaceae_Desulfonatronum_thioautotrophicum_ASO4_1"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfohalobiaceae_Desulfonatronospira_thiodismutans_ASO3_1_unfinished_sequence"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfohalobiaceae_Desulfonatronovibrio_hydrogenovorans_DSM_9292"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfomicrobiaceae_Desulfomicrobium_baculatum_DSM_4028"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfohalobiaceae_Desulfovermiculus_halophilus_DSM_18834"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfovibrionales_Desulfohalobiaceae_Desulfohalobium_retbaense_DSM_5692"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophaceae_Desulfomonile_tiedjei_DCB_1_DSM_6799"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophaceae_Smithella_sp._F21"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophaceae_Syntrophus_aciditrophicus_SB"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Syntrophobacterales_Syntrophorhabdaceae_Syntrophorhabdus_aromaticivorans_UI"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Cystobacterineae_Myxococcaceae_Myxococcus_xanthus_DK_1622"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Cystobacterineae_Myxococcaceae_Corallococcus_coralloides_DSM_2259"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Cystobacterineae_Cystobacteraceae_Stigmatella_aurantiaca_DW43_1"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Cystobacterineae_Cystobacteraceae_Cystobacter_violaceus_Cb_vi76"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Cystobacterineae_Myxococcaceae_Anaeromyxobacter_dehalogenans_2CP_C"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Sorangiineae_Sandaracinaceae_Sandaracinus_amylolyticus_DSM_53668"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Nannocystineae_Nannocystaceae_Plesiocystis_pacifica_SIR_1_unfinished_sequence"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Nannocystineae_Nannocystaceae_Nannocystis_exedens_ATCC_25963"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Nannocystineae_Kofleriaceae_Haliangium_ochraceum_DSM_14365"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Sorangiineae_Polyangiaceae_Chondromyces_apiculatus_DSM_436"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Myxococcales_Sorangiineae_Polyangiaceae_Sorangium_cellulosum_So0157_2"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Bdellovibrionales_Bacteriovoracaceae_Bacteriovorax_marinus_SJ"",""Bacteria_Bdellovibrio_Bdellovibrionales_Bacteroivoracaceae_GWA2_Bdellovibrionales_49_15"",""Bacteria_Bdellovibrio_Bdellovibrionales_Bacteroivoracaceae_RIFOXYA1_FULL_Bacteriovorax_38_20"",""Bacteria_Bdellovibrio_Bdellovibrionales_Bdellovibrionaceae_GWA1_Bdellovibrionales_52_35"",""Bacteria_Bdellovibrio_Bdellovibrionales_Bacteroivoracaceae_RIFOXYD1_FULL_Bdellovibrionales_53_11"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Bdellovibrionales_Bdellovibrionaceae_Bdellovibrio_bacteriovorus_HD100"",""Bacteria_Bdellovibrio_Bdellovibrionales_RBG_16_Bdellovibrionales_40_8"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Desulfuromonadaceae_Desulfuromonas_acetoxidans_DSM_684"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Geobacteraceae_Geoalkalibacter_ferrihydriticus_DSM_17813"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Pelobacteraceae_Pelobacter_carbinolicus_DSM_2380"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Geobacteraceae_Geopsychrobacter_electrodiphilus_DSM_16401"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Desulfuromonadaceae_Desulfuromusa_kysingii_DSM_7343"",""Bacteria_Proteobacteria_deltaepsilon_subdivisions_Deltaproteobacteria_Desulfuromonadales_Geobacteraceae_Geobacter_lovleyi_SZ"",""Bacteria_CP_Dadabacteria_LAC_COMBO_lowCGbin1_like_51_6394_partial"",""Bacteria_CP_Dadabacteria_LAC_S2O1_bin1_lowgc_50_27"",""Bacteria_CP_Dadabacteria_LAC_COMBO_lowcgbin1_52_3600"",""Bacteria_CP_Dadabacteria_CSP1_2"",""Bacteria_Dadabacteria_RIFCSPHIGHO2_12_FULL_Dadabacteria_53_21"",""Bacteria_unclassified_bacteria_RIFCSPLOWO2_02_FULL_unclassified_bacteria_53_8"",""Bacteria_Nitrospirae_RBG_19FT_COMBO_Thermodesulfovibrio_41_18"",""Bacteria_Nitrospirae_CG2_30_FULL_Nitrospirae_41_42"",""Bacteria_Nitrospirae_RBG_13_Nitrospirae_39_12"",""Bacteria_Nitrospirae_RBG_19FT_COMBO_Thermodesulfovibrio_42_12"",""Bacteria_Nitrospirae_RBG_13_Nitrospirae_41_22"",""Bacteria_Nitrospira_uncultured_SMTZ_35"",""Bacteria_Nitrospirae_RBG_13_Nitrospirae_43_8"",""Bacteria_Nitrospirae_RBG_16_Nitrospirae_43_8"",""Bacteria_Nitrospirae_GWF2_Nitrospirae_44_13"",""Bacteria_Nitrospirae_CG1_02_FULL_Nitrospirae_44_142"",""Bacteria_Nitrospirae_BJP_IG2158_Nitrospirae_45_240"",""Bacteria_Nitrospirae_GWB2_Nitrospirae_47_37"",""Bacteria_Nitrospirae_Nitrospira_Nitrospirales_Nitrospiraceae_Thermodesulfovibrio_yellowstonii_DSM_11347"",""Bacteria_Nitrospirae_Nitrospira_Nitrospirales_Nitrospiraceae_Candidatus_Magnetobacterium_sp._MYR_1"",""Bacteria_Nitrospira_uncultured_SG8_35_1"",""Bacteria_Nitrospira_uncultured_SG8_35_4"",""Bacteria_Nitrospirae_RIFCSPHIGHO2_02_FULL_Nitrospirae_40_19"",""Bacteria_Nitrospirae_GWC2_Nitrospirae_56_14"",""Bacteria_Nitrospirae_GWC2_Nitrospirae_57_9"",""Bacteria_Nitrospirae_RBG_19FT_COMBO_Nitrospirae_55_12"",""Bacteria_Nitrospirae_GWC2_Nitrospirae_57_13"",""Bacteria_Nitrospirae_RBG_16_Nitrospirae_64_22"",""Bacteria_Nitrospirae_Nitrospira_Candidatus_Nitrospira_defluvii"",""Bacteria_Nitrospirae_RBG_19FT_COMBO_Nitrospirae_58_9"",""Bacteria_Nitrospirae_RIFCSPLOWO2_02_FULL_Nitrospirae_62_14"",""Bacteria_Nitrospirae_RIFCSPHIGHO2_01_FULL_Nitrospirae_66_17"",""Bacteria_Nitrospirae_Nitrospira_Nitrospirales_Nitrospiraceae_Leptospirillum_ferriphilum_YSK"",""Bacteria_Nitrospirae_RBG_16_Nitrospirae_43_11"",""Bacteria_Nitrospirae_RifCSPlowO2_12_Nitrospirae_42_9"",""Bacteria_Nitrospirae_RBG_19FT_COMBO_Nitrospirae_42_15"",""Bacteria_Nitrospirae_CG2_30_FULL_Nitrospirae_53_67"",""Bacteria_Nitrospirae_CG2_30_FULL_Nitrospirae_70_394"",""Bacteria_Nitrospinae_Nitrospinia_Nitrospinales_Nitrospinaceae_Nitrospina_sp._SCGC_AAA288_L16"",""Bacteria_Nitrospinae_Nitrospinia_Nitrospinales_Nitrospinaceae_Nitrospina_sp._AB_629_B18"",""Bacteria_Nitrospinae_Nitrospinia_Nitrospinales_Nitrospinaceae_Nitrospina_sp._AB_629_B06"",""Bacteria_Nitrospinae_RIFCSPLOWO2_12_FULL_Nitrospinae_47_7"",""Bacteria_Nitrospinae_RifCSPlowO2_12_Nitrospinae_39_15"",""Bacteria_Nitrospinae_RIFCSPLOWO2_01_FULL_Nitrospinae_39_10"",""Bacteria_CP_Tectomicrobia_Candidatus_Entotheonella_sp._TSY2"",""Bacteria_CP_Tectomicrobia_Candidatus_Entotheonella_sp._TSY1"",""Bacteria_unclassified_bacteria_RIFCSPLOWO2_12_FULL_uncultured_45_22"",""Bacteria_CP_RIF3_RIFCSPLOWO2_12_FULL_RIF3_38_15"",""Bacteria_CP_RIF3_RBG_16_RIF3_38_10"",""Bacteria_CP_RIF3_GWA2_RIF3_38_11"",""Bacteria_CP_RIF3_RBG_16_RIF3_38_11"",""Bacteria_Unclassified_bacteria_RIFCSPLOWO2_12_FULL_uncultured_69_37"",""Bacteria_unclassified_bacteria_RBG_13_uncultured_48_7"",""Bacteria_Modulibacteria_KSB3_bacterium_UASB270"",""Bacteria_Modulibacteria_KSB3_bacterium_UASB14"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Acidobacteriia_Acidobacteriales_Acidobacteriaceae_Edaphobacter_aggregans_DSM_19364"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Acidobacteriia_Acidobacteriales_Acidobacteriaceae_Acidobacterium_sp._MP5ACTX8"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Acidobacteriia_Acidobacteriales_Acidobacteriaceae_Terriglobus_saanensis_SP1PR4"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Acidobacteriia_Acidobacteriales_Acidobacteriaceae_Acidobacterium_capsulatum_ATCC_51196"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Acidobacteriia_Acidobacteriales_Acidobacteriaceae_Candidatus_Koribacter_versatilis_Ellin345"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Solibacteres_Solibacterales_Solibacteraceae_Solibacter_usitatus_Ellin6076"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_unclassified_Acidobacteria_Bryobacter_aggregatus_DSM_18758"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_60_22"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_61_28"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_60_20"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_54_10"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_59_11"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_59_13"",""Bacteria_Acidobacteria_RIFCSPHIGHO2_01_FULL_Acidobacteria_67_28"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_65_11"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_65_29"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_67_14b"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_66_21"",""Bacteria_Acidobacteria_RBG_16_Acidobacteria_68_9"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_67_21"",""Bacteria_Acidobacteria_RIFCSPLOWO2_02_FULL_Acidobacteria_68_18"",""Bacteria_Acidobacteria_RIFCSPLOWO2_12_FULL_Acidobacteria_66_10"",""Bacteria_Acidobacteria_RBG_16_Acidobacteria_70_10"",""Bacteria_Acidobacteria_RBG_13_Acidobacteria_68_16"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_unclassified_Acidobacteria_Thermoanaerobaculum_aquaticum_MP_01"",""Bacteria_Acidobacteria_RBG_16_Acidobacteria_64_8"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Holophagae_Holophagales_Holophagaceae_Geothrix_fermentans_DSM_14018"",""Bacteria_Fibrobacteres_Acidobacteria_group_Acidobacteria_Holophagae_Holophagales_Holophagaceae_Holophaga_foetida_TMBS4_DSM_6591"",""Bacteria_Aminicenantes_OP8_RBG_19FT_COMBO_Aminicenantes_58_17"",""Bacteria_Aminicenantes_OP8_RBG_19FT_COMBO_Aminicenantes_59_29"",""Bacteria_Aminicenantes_OP8_RBG_16_Aminicenantes_63_16"",""Bacteria_Aminicenantes_OP8_RBG_13_Aminicenantes_59_9"",""Bacteria_Aminicenantes_OP8_RBG_19FT_COMBO_Aminicenantes_65_30"",""Bacteria_Aminicenantes_OP8_RBG_13_Aminicenantes_64_14"",""Bacteria_Aminicenantes_OP8_RBG_16_Aminicenantes_66_30"",""Bacteria_Aminicenantes_OP8_RBG_13_Aminicenantes_63_10"",""Bacteria_Aminicenantes_OP8_RBG_13_Aminicenantes_62_12"",""Bacteria_CP_OP8_candidate_division_OP8_bacterium_SCGC_AAA252_O11_SAK_001_85"",""Bacteria_CP_OP8_candidate_division_OP8_bacterium_SCGC_AAA252_F08_Combined_Assembly_OP8_2__OP8"",""Bacteria_CP_OP8_candidate_division_OP8_bacterium_SCGC_AAA252_A02_Combined_Assembly_OP8_1__OP8"",""Bacteria_CP_OP8_candidate_division_OP8_bacterium_SCGC_AAA252_K06_SAK_001_60"",""Bacteria_CP_OP8_candidate_division_OP8_bacterium_SCGC_AAA255_E10_SAK_001_126"",""Bacteria_CP_RIF25_RBG_13_RIF25_37_8"",""Bacteria_CP_Rokubacteria_13_1_40CM_4_Rokubacteria_69_39"",""Bacteria_CP_Rokubacteria_13_1_20CM_4_Rokubacteria_70_14"",""Bacteria_CP_Rokubacteria_13_2_20CM_2_Rokubacteria_70_11"",""Bacteria_CP_Rokubacteria_13_2_20CM_Rokubacteria19cls_69_15"",""Bacteria_CP_Rokubacteria_RIFCSPLOWO2_12_FULL_Rokubacteria_71_22"",""Bacteria_CP_Rokubacteria_GWA2_Rokubacteria_73_35"",""Bacteria_CP_Rokubacteria_13_1_40CM_Rokubacteria_69_27"",""Bacteria_CP_Rokubacteria_13_2_20CM_2_Rokubacteria_64_8"",""Bacteria_CP_Rokubacteria_GWA2_Rokubacteria_70_23"",""Bacteria_CP_Rokubacteria_GWC2_Rokubacteria_70_16"",""Bacteria_CP_Rokubacteria_CSP1_6"",""Bacteria_CP_Rokubacteria_RIFCSPLOWO2_02_FULL_Rokubacteria_68_19"",""Bacteria_CP_Rokubacteria_RIFCSPLOWO2_02_FULL_Rokubacteria_71_18"",""Bacteria_NC10_RBG_16_NC10_65_8"",""Bacteria_NC10_RIFCSPLOWO2_02_FULL_NC10_66_22"",""Bacteria_CP_NC10_Candidatus_Methylomirabilis_oxyfera"",""Bacteria_CP_NC10_CSP1_5"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_45_21"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_46_37"",""Bacteria_Omnitrophica_WOR-2_GWF2_WOR_2_43_52"",""Bacteria_Omnitrophica_WOR-2_GWB2_WOR_2_45_9"",""Bacteria_Omnitrophica_WOR-2_RIFOXYC2_FULL_WOR_2_45_15"",""Bacteria_Omnitrophica_WOR-2_RBG_13_WOR_2_41_10"",""Bacteria_Omnitrophica_WOR-2_RIFCSPLOWO2_01_FULL_WOR_2_41_12"",""Bacteria_Omnitrophica_WOR-2_RIFCSPLOWO2_12_FULL_WOR_2_51_8"",""Bacteria_Omnitrophica_WOR-2_RBG_13_WOR-2_44_8b"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_44_16"",""Bacteria_Omnitrophica_WOR-2_GWA2_WOR_2_53_43"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_01_FULL_WOR_2_52_10"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_50_17"",""Bacteria_Omnitrophica_WOR-2_GWA2_WOR_2_45_18"",""Bacteria_Omnitrophica_WOR-2_RIFOXYB2_FULL_WOR_2_38_16"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_52_10"",""Bacteria_Omnitrophica_WOR-2_GWA2_WOR_2_47_8"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_48_11"",""Bacteria_Omnitrophica_WOR-2_uncultured_SMTZ_29"",""Bacteria_Omnitrophica_WOR-2_RIFCSPLOWO2_12_FULL_WOR_2_51_24"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_63_39"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_67_20"",""Bacteria_Omnitrophica_WOR-2_RIFCSPHIGHO2_02_FULL_WOR_2_68_15"",""Bacteria_OP3X_RIFCSPLOWO2_02_FULL_OP3X_45_16"",""Bacteria_OP3X_RIFCSPLOWO2_01_FULL_OP3X_45_10"",""Bacteria_OP3X_RBG_13_OP3X_46_9"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_40_15"",""Bacteria_OP3X_GWA2_OP3X_41_15"",""Bacteria_Omnitrophica_CG1_02_SUB10_Omnitrophica_43_210"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_49_10"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_46_14"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_49_16"",""Bacteria_OP3X_RIFCSPHIGHO2_02_FULL_OP3X_51_18"",""Bacteria_OP3X_RIFCSPHIGHO2_02_FULL_OP3X_63_14"",""Bacteria_Omnitrophica_GWA2_OP3_52_12"",""Bacteria_CP_OP3_candidate_division_OP3_bacterium_SCGC_AAA257_O07_Etoliko_001_147"",""Bacteria_Omnitrophica_RifOxyB12_full_OP3_50_7"",""Bacteria_Omnitrophica_GWA2_OP3_52_8"",""Bacteria_Omnitrophica_RIFCSPLOWO2_01_FULL_Omnitrophica_50_24"",""Bacteria_Omnitrophica_RIFCSPLOWO2_12_FULL_Omnitrophica_50_11"",""Bacteria_Omnitrophica_RIFCSPLOWO2_01_FULL_Omnitrophica_45_10b"",""Bacteria_Omnitrophica_RIFCSPLOWO2_02_FULL_Omnitrophica_44_11"",""Bacteria_Omnitrophica_GWA2_OP3_50_21"",""Bacteria_CP_OP3_candidate_division_OP3_bacterium_SCGC_AAA011_A17_Dusel_001_263"",""Bacteria_Omnitrophica_CG1_02_FULL_Omnitrophica_41_171"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Verrucomicrobiae_Verrucomicrobiales_Verrucomicrobiaceae_Rubritalea_marina_DSM_17716_SAORIC_165"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Verrucomicrobiae_Verrucomicrobiales_Verrucomicrobiaceae_Rubritalea_marina_DSM_17716"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Verrucomicrobiae_Verrucomicrobiales_Verrucomicrobiaceae_Akkermansia_muciniphila_ATCC_BAA_835"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Verrucomicrobiae_Verrucomicrobiales_Verrucomicrobiaceae_Verrucomicrobium_spinosum_DSM_4136_unfinished_sequence"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Spartobacteria_Chthoniobacter_flavus_Ellin428_unfinished_sequence"",""Bacteria_Verrucomicrobia_Verrucomicrobiae_RIFCSPHIGHO2_12_FULL_Verrucumicrobia_41_10"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_unclassified_Verrucomicrobia_Methylacidiphilales_Methylacidiphilaceae_Methylacidiphilum_infernorum_V4"",""Bacteria_Verrucomicrobia_Verrucomicrobiae_GWF2_Verrucomicrobia_62_7"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Verrucomicrobiae_Verrucomicrobiales_Verrucomicrobia_subdivision_3_bacterium_Ellin514"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Opitutae_Opitutales_Opitutaceae_Opitutaceae_sp._TAV2"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Opitutae_Opitutales_Opitutaceae_Opitutaceae_sp._TAV5"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Opitutae_Opitutales_Opitutaceae_Opitutus_terrae_PB90_1"",""Bacteria_Verrucomicrobia_Opitutae_RIFCSPLOWO2_12_FULL_Verrucomicrobia_64_8"",""Bacteria_Verrucomicrobia_Opitutae_GWC2_Verrucomicrobia_42_7"",""Bacteria_Verrucomicrobia_Opitutae_GWF2_Verrucomicrobia_51_19"",""Bacteria_Verrucomicrobia_CG1_02_FULL_Verrucomicrobia_43_26"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Verrucomicrobia_Opitutae_Puniceicoccales_Puniceicoccaceae_Coraliomargarita_akajimensis_DSM_45221"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_50_93"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_49_21"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_38_69"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_44_16"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_52_8"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Lentisphaerae_Lentisphaeria_Victivallales_Victivallaceae_Victivallis_vadensis_ATCC_BAA_548"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_45_14"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Lentisphaerae_Lentisphaerales_Lentisphaeraceae_Lentisphaera_araneosa_HTCC2155_unfinished_sequence"",""Bacteria_Lentisphaerae_RIFOXYB12_FULL_Lentisphaerae_65_16"",""Bacteria_Lentisphaerae_RifOxyA12_full_Lentisphaerae_48_11"",""Bacteria_Lentisphaerae_RIFOXYC12_FULL_Lentisphaerae_60_16"",""Bacteria_Lentisphaerae_GWF2_Lentisphaerae_57_35"",""Bacteria_Chlamydiae_Chlamydiia_RIFCSPHIGHO2_12_FULL_Chlamydiae_27_8"",""Bacteria_Chlymidae_uncultured_SMTZ_39"",""Bacteria_Chlamydiae_Chlamydiia_RIFCSPHIGHO2_12_FULL_Chlamydiae_49_9"",""Bacteria_Chlamydiae_Chlamydiia_RIFCSPLOWO2_02_FULL_Chlamydiae_45_22"",""Bacteria_Chlamydiae_Chlamydiia_Chlamydiales_RIFCSPLOWO2_02_FULL_Chlamydiae_49_12"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Simkaniaceae_Simkania_negevensis_Z_gsn.131"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Parachlamydiaceae_Neochlamydia_sp._S13"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Parachlamydiaceae_Parachlamydia_acanthamoebae_UV7"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Waddliaceae_Waddlia_chondrophila_WSU_86_1044"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Parachlamydiaceae_Candidatus_Protochlamydia_amoebophila_UWE25"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Chlamydiaceae_ChlamydiaChlamydophila_group_Chlamydophila_abortus_S263"",""Bacteria_Chlamydiae_Verrucomicrobia_group_Chlamydiae_Chlamydiia_Chlamydiales_Chlamydiaceae_ChlamydiaChlamydophila_group_Chlamydophila_pneumoniae_AR39"",""Bacteria_Chlamydiae_RIFCSPHIGHO2_12_FULL_Chlamydiae_49_11"",""Bacteria_Plantomycetes_Phycisphaerae_uncultured_SG8_4"",""Bacteria_Plantomycetes_Phycisphaerae_uncultured_SMTZ1_79"",""Bacteria_Planctomycetes_Phycisphaerae_RBG_16_Planctomycetes_55_9"",""Bacteria_Plantomycetes_Phycisphaerae_uncultured_SMTZ_30"",""Bacteria_Plantomycetes_Phycisphaerae_uncultured_SMTZ_33"",""Bacteria_Planctomycetes_Phycisphaerae_uncultured_SMTZ_32_1"",""Bacteria_Planctomycetes_Phycisphaerae_Phycisphaerales_Phycisphaeraceae_Phycisphaera_mikurensis_NBRC_102666"",""Bacteria_Planctomyce_uncultured_SMTZ_25"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Blastopirellula_marina_SH_106T_DSM_3645"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Rhodopirellula_baltica_SH_1"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Pirellula_staleyi_DSM_6068"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Planctomyces_limnophilus_DSM_3776"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Schlesneria_paludicola_DSM_18645"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Isosphaera_pallida_ATCC_43644"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Singulisphaera_acidiphila_MOB10_DSM_18658"",""Bacteria_Planctomycetes_Planctomycetia_Planctomycetales_Planctomycetaceae_Zavarzinella_formosa_DSM_19928"",""Bacteria_Planctomycetes_Planctomycetia_Candidatus_Brocadiales_Candidatus_Brocadiaceae_Candidatus_Kuenenia_stuttgartiensis_RU1"",""Bacteria_Planctomycetes_Brocadiales_GWB2_Planctomycetes_41_19"",""Bacteria_Planctomyce_uncultured_SMTZ_32"",""Bacteria_Plantomycetes_uncultured_DG_23"",""Bacteria_Plantomycetes_uncultured_DG_58"",""Bacteria_Elusimicrobia_RIFCSPHIGHO2_02_FULL_Elusimicrobia_61_10"",""Bacteria_Elusimicrobia_CG1_02_FULL_Elusimicrobia_56_21"",""Bacteria_Elusimicrobia_GWC2_Elusimicrobia_61_19"",""Bacteria_Elusimicrobia_GWA2_Elusimicrobia_61_42"",""Bacteria_Elusimicrobia_GWB2_Elusimicrobia_63_16"",""Bacteria_Elusimicrobia_GWD2_Elusimicrobia_63_28"",""Bacteria_Elusimicrobia_GWA2_Elusimicrobia_62_23"",""Bacteria_Elusimicrobia_RifOxyA12_full_Elusimicrobia_57_11"",""Bacteria_Elusimicrobia_GWF2_Elusimicrobia_62_30"",""Bacteria_Elusimicrobia_GWC2_Elusimicrobia_56_31"",""Bacteria_Elusimicrobia_RIFOXYA2_FULL_Elusimicrobia_53_38"",""Bacteria_Elusimicrobia_RIFOXYB2_FULL_Elusimicrobia_62_6"",""Bacteria_Elusimicrobia_GWA2_Elusimicrobia_51_34"",""Bacteria_Elusimicrobia_Elusimicrobia_Elusimicrobiales_Elusimicrobiaceae_Elusimicrobium_minutum_Pei191"",""Bacteria_Elusimicrobia_RIFOXYD12_FULL_Elusimicrobia_66_9"",""Bacteria_Elusimicrobia_RBG_16_Elusimicrobia_66_12"",""Bacteria_Elusimicrobia_GWC2_Elusimicrobia_65_9"",""Bacteria_Elusimicrobia_RIFOXYA2_FULL_Elusimicrobia_69_6"",""Bacteria_Elusimicrobia_RIFCSPHIGHO2_02_FULL_Elusimicrobia_57_9"",""Bacteria_Elusimicrobia_CG1_02_FULL_Elusimicrobia_63_36"",""Bacteria_Elusimicrobia_GWA2_Elusimicrobia_69_24"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_12_FULL_Elusimicrobia_59_9"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_01_FULL_Elusimicrobia_54_10"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_01_FULL_Elusimicrobia_60_11"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_01_FULL_Elusimicrobia_64_13"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_02_FULL_Elusimicrobia_39_32"",""Bacteria_Elusimicrobia_RIFCSPLOWO2_01_FULL_Elusimicrobia_59_12"",""Bacteria_Elusimicrobia_RIFOXYB2_FULL_Elusimicrobia_49_7"",""Bacteria_Elusimicrobia_RIFOXYB2_FULL_Elusimicrobia_50_12"",""Bacteria_Elusimicrobia_RIFOXYA2_FULL_Elusimicrobia_47_53"",""Bacteria_Elusimicrobia_Elusimicrobia_uncultured_Termite_group_1_bacterium_phylotype_Rs_D17"",""Bacteria_Elusimicrobia_Endomicrobia_Candidatus_Endomicrobium_trichonymphae_submission_450"",""Bacteria_Elusimicrobia_RIFOXYD2_FULL_Elusimicrobia_34_30"",""Bacteria_Elusimicrobia_RIFOXYD2_FULL_Elusimicrobia_34_15"",""Bacteria_Elusimicrobia_RIFOXYB2_FULL_Elusimicrobia_48_7"",""Bacteria_Elusimicrobia_RIFOXYA2_FULL_Elusimicrobia_40_6"",""Bacteria_Elusimicrobia_RIFOXYA2_FULL_Elusimicrobia_39_19"",""Bacteria_Elusimicrobia_CG1_02_SUB10_Elusimicrobia_37_114"",""Bacteria_CP_RIF1_GWA2_RIF1_43_8"",""Bacteria_CP_RIF1_RIFOXYA2_FULL_RIF1_40_8"",""Bacteria_CP_RIF1_RIFOXYC2_FULL_RIF1_39_67"",""Bacteria_Unclassified_bacteria_CG1_02_FULL_CP_49_89"",""Bacteria_Unclassified_bacteria_CG1_02_FULL_CP_38_46"",""Bacteria_Unclassified_bacteria_CG2_30_FULL_CP_40_21"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Olleya_sp._Hel_I_94"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Mesoflavibacter_zeaxanthinifaciens_DSM_18436"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Lacinutrix_sp._5H_3_7_4"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Flavobacteriaceae_bacterium_P7_3_5"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Gaetbulibacter_saemankumensis_DSM_17032"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Bizionia_argentinensis_JUB59_DSM_19628"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Formosa_agariphila_KMM_3901"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Gelidibacter_mesophilus_DSM_14095"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Sediminibacter_sp._Hel_I_10"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Winogradskyella_psychrotolerans_RS_3"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Aequorivita_sublithincola_QSSC9_3_DSM_14238"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Salegentibacter_sp._Hel_I_6"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Gramella_forsetii_KT0803"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Zunongwangia_profunda_SM_A87"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Salinimicrobium_xinjiangense_DSM_19287"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Gillisia_sp._CAL575"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Donghaeana_dokdonensis_DSW_6"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Psychroflexus_gondwanensis_ACAM_44"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Croceibacter_atlanticus_HTCC2559_Re_annotation_of_existing_genome_that_was_not_originally_submitted_by_me"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Mesonia_mobilis_DSM_19841"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Krokinobacter_sp._4H_3_7_5"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Leeuwenhoekiella_blandensis_MED217"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Aquimarina_megaterium_XH134"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Cellulophaga_lytica_HI1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Eudoraea_adriatica_DSM_19308"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Muricauda_ruestringensis_B1_DSM_13258"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Zobellia_uliginosa_MAR_2009_138"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Arenibacter_certesii_DSM_19833"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriales_bacterium_HTCC2170"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Robiginitalea_biformata_HTCC2501"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Imtechella_halotolerans_K1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Capnocytophaga_ochracea_DSM_7271"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Sinomicrobium_oceani_CGMCC_1.12145"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Galbibacter_sp._ck_I2_15"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Joostella_marina_En5_DSM_19592"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Zhouia_amylolytica_AD3"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Kordia_algicida_OT_1_unfinished_sequence"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Myroides_odoratimimus_CCUG_12700"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Flavobacterium_psychrophilum_JIP0286"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Lutibacter_sp._Hel_I_33_5"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Polaribacter_sp._MED152"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Tenacibaculum_ovolyticum_DSM_18103"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Epilithonimonas_tenax_DSM_16811"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Chryseobacterium_gregarium_DSM_19109"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Elizabethkingia_anophelis_NUH6"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Bergeyella_zoohelcum_CCUG_30536"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Riemerella_anatipestifer_RA_CH_2"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Empedobacter_brevis_ATCC_43319"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Weeksella_virosa_DSM_16922"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Flavobacteriaceae_Ornithobacterium_rhinotracheale_DSM_15997"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Blattabacteriaceae_Blattabacterium_sp._Blattella_germanica_str._Bge"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Cryomorphaceae_Owenweeksia_Owenweeksia_hongkongensis_DSM_17368"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Cryomorphaceae_Fluviicola_taffensis_RW262_DSM_16823"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Flavobacteriia_Flavobacteriales_Cryomorphaceae_Crocinitomix_catalasitica_ATCC_23190"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Tannerella_forsythensis_ATCC_43037"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Parabacteroides_distasonis_ATCC_8503"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Candidatus_Azobacteroides_pseudotrichonymphae_genomovar._CFP2"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Porphyromonas_gingivalis_W83"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Dysgonomonas_gadei_ATCC_BAA_286_cont1.32"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Proteiniphilum_acetatigenes_DSM_18083"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Coprobacter_fastidiosus_NSB1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Barnesiella_viscericola_C46_DSM_18177"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Prevotellaceae_Hallella_seregens_ATCC_51272"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Prevotellaceae_Prevotella_dentalis_ES_2772_DSM_3688"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Prevotellaceae_Prevotella_tannerae_ATCC_51259"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Prevotellaceae_Paraprevotella_xylaniphila_YIT_11841_P_xylaniphilaYIT11841_1.0_Cont168.1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Bacteroidaceae_Bacteroides_fragilis_NCTC_9343"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Paludibacter_propionicigenes_WB4"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Marinilabiaceae_Marinilabilia_salmonicolor_JCM_21150"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Marinilabiaceae_Anaerophaga_thermohalophila_Fru22_DSM_12881"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Marinilabiaceae_Anaerophaga_sp._HS1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Marinilabiaceae_Alkaliflexus_imshenetskii_Z_7010_DSM_15055"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Cytophaga_fermentans_IAM_14302_DSM_9555"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_unclassified_Bacteroidetes_Prolixibacter_bellariivorans_ATCC_BAA_1284"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Prolixibacteraceae_Draconibacterium_orientale_FH5"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Butyricimonas_virosa_DSM_23226"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Porphyromonadaceae_Odoribacter_splanchnicus_DSM_20712"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Rikenellaceae_Rikenella_microfusus_Q_1_DSM_15922"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Rikenellaceae_Alistipes_finegoldii_AHN_2437_DSM_17242"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Sphingobacterium_sp._21"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Pseudosphingobacterium_domesticum_DSM_18733"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Olivibacter_sitiensis_DSM_17696"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Mucilaginibacter_paludis_TPT56_DSM_18603"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Arcticibacter_svalbardensis_MN12_7"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Pedobacter_saltans_DSM_12145"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Sphingobacteriaceae_Solitalea_canadensis_USAM_9D_DSM_3403"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Niabella_soli_JS13_8_DSM_19437"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Terrimonas_ferruginea_DSM_30193"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Niastella_koreensis_GR20_10_DSM_17620"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Segetibacter_koreensis_DSM_18137"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Chitinophaga_pinensis_DSM_2588"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Saprospiraceae_Saprospira_grandis_Lewin"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Saprospiraceae_Aureispira_sp._CCB_QB1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Saprospiraceae_Haliscomenobacter_hydrossis_O_DSM_1100"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Saprospiraceae_Lewinella_cohaerens_DSM_23179"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Indibacter_alkaliphilus_LW1_Draft1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Aquiflexum_balticum_BA160_DSM_16537"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Cecembia_lonarensis_LW9"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Mariniradius_saccharolyticus_AK6"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Nitritalea_halalkaliphila_LW7_Draft1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Algoriphagus_sp._PR1_unfinished_sequence"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Belliella_baltica_BA134_DSM_15883"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Rhodonellum_psychrophilum_DSM_17998"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Anditalea_andensis_LY1"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Echinicola_vietnamensis_KMM_6221_DSM_17526"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cyclobacteriaceae_Cyclobacterium_marinum_DSM_745"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Flammeovirgaceae_Nafulsella_turpanensis_ZLM_10"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Flammeovirgaceae_Cesiribacter_andamanensis_AMV16"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Flammeovirgaceae_Fulvivirga_imtechensis_AK7"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Flammeovirgaceae_Marivirga_tractuosa_DSM_4126"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Microscilla_marina_ATCC_23134_unfinished_sequence"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Flammeovirgaceae_Flexithrix_dorotheae_DSM_6795"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Spirosoma_linguale_DSM_74"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Fibrisoma_limi_BUZ_3"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Rudanella_lutea_DSM_19387"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Fibrella_aestuarina"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Dyadobacter_fermentans_DSM_18053"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Runella_slithyformis_LSU4_DSM_19594"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Leadbetterella_byssophila_DSM_17132"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Emticicia_oligotrophica_GPTSA100_15_DSM_17448"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Flectobacillus_major_VKMB_859_DSM_103"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Pontibacter_roseus_DSM_17521"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Adhaeribacter_aquaticus_MBRG1.5_DSM_16391"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Hymenobacter_sp._APR13"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Cytophaga_hutchinsonii_ATCC_33406"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Sporocytophaga_myxococcoides_DSM_11118"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Cytophagaceae_Flexibacter_litoralis_Fx_l1_DSM_6794"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Cytophagia_Cytophagales_Amoebophilaceae_Candidatus_Amoebophilus_asiaticus_5a2"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidetes_Order_III._Incertae_sedis_Thermonema_rossianum_DSM_10300"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Gracilimonas_tropica_DSM_19535"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Sphingobacteriia_Sphingobacteriales_Chitinophagaceae_Balneola_vulgaris_DSM_17893"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidetes_Order_II._Incertae_sedis_Rhodothermaceae_Salisaeta_longa_DSM_21114"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidetes_Order_II._Incertae_sedis_Rhodothermaceae_Rhodothermus_marinus_DSM_4252"",""Bacteria_Ignavibacteria_RIFOXYD12_FULL_Ignavibacteria_36_8"",""Bacteria_Ignavibacteria_CG2_30_FULL_Ignavibacteria_36_16"",""Bacteria_Ignavibacteria_RIFOXYA2_FULL_Ignavibacteria_37_17"",""Bacteria_Ignavibacteria_RBG_16_Ignavibacteria_34_14"",""Bacteria_Ignavibacteria_CG1_02_FULL_Ignavibacteria_37_35"",""Bacteria_Ignavibacteria_RBG_16_Ignavibacteria_36_9"",""Bacteria_Bacteroidetes_Chlorobi_group_Ignavibacteria_Ignavibacteria_Ignavibacteriales_Ignavibacteriaceae_Ignavibacterium_album_Mat9_16_JCM_16511"",""Bacteria_Ignavibacteria_GWB2_Ignavibacteria_35_6b"",""Bacteria_Ignavibacteria_RBG_13_Ignavibacteria_36_8"",""Bacteria_Ignavibacteria_RIFOXYC2_FULL_Ignavibacteria_38_25"",""Bacteria_Bacteroidetes_Chlorobi_group_Ignavibacteria_Ignavibacteria_Ignavibacteriales_Ignavibacteriaceae_Melioribacter_roseus_P3M"",""Bacteria_Ignavibacteria_GWA2_Ignavibacteriae_55_25"",""Bacteria_Ignavibacteria_GWA2_Ignavibacteria_54_16"",""Bacteria_Ignavibacteria_RIFCSPLOWO2_02_FULL_Ignavibacteria_55_14"",""Bacteria_Ignavibacteria_RIFOXYC2_FULL_RIF_IGX_35_21"",""Bacteria_Ignavibacteria_GWF2_RIF_IGX_33_9"",""Bacteria_Bacteroidetes_Chlorobi_group_Chlorobi_Chlorobia_Chlorobiales_Chlorobiaceae_ChlorobiumPelodictyon_group_Chlorobium_chlorochromatii_CaD3"",""Bacteria_Bacteroidetes_Chlorobi_group_Chlorobi_Chlorobia_Chlorobiales_Chlorobiaceae_ChlorobiumPelodictyon_group_Pelodictyon_luteolum_DSM_273"",""Bacteria_Bacteroidetes_Chlorobi_group_Chlorobi_Chlorobia_Chlorobiales_Chlorobiaceae_Chlorobaculum_parvum_NCIB_8327"",""Bacteria_Bacteroidetes_Chlorobi_group_Chlorobi_Chlorobia_Chlorobiales_Chlorobiaceae_Prosthecochloris_aestuarii_DSM_271"",""Bacteria_Bacteroidetes_Chlorobi_group_Chlorobi_Chlorobia_Chlorobiales_Chlorobiaceae_Chloroherpeton_thalassium_ATCC_35110"",""Bacteria_CP_RIF26_GWF2_RIF26_40_14"",""Bacteria_CP_RIF26_DOLJORAL78_RIF26_32_13"",""Bacteria_Caldithrix_RBG_13_Caldithrix_44_9"",""Bacteria_unclassified_Bacteria_Caldithrix_abyssi_LF13_DSM_13497"",""Bacteria_CP_uncultured_SMTZ_31"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000113_G11"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_SCGC_AAA076_M08"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_SCGC_AAA298_D23"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000113_D11"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_sp._SCGC_AAA003_E22_Tropical_gyre_001_268"",""Bacteria_Unclassified_bacteria_CG1_02_FULL_SAR406_48_14"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000039_D08_TAsludge_001_149"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000059_L03_TAbiofilm_001_169"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000039_E15_TAsludge_001_150"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_JGI_0000039_D08_Combined_Assembly_SAR406_1__SAR406"",""Bacteria_Marine_group_A_SAR406_SAR406_cluster_bacterium_SCGC_AAA257_N23_Etoliko_001_146"",""Bacteria_Unclassified_bacteria_RBG_16_unknown_48_16"",""Bacteria_Unclassified_bacteria_uncultured_SMTZ_57"",""Bacteria_Zixibacteria_uncultured_SMTZ_73"",""Bacteria_Zixibacteria_uncultured_SMTZ1_73"",""Bacteria_Zixibacteria_uncultured_SMTZ_73_3"",""Bacteria_Zixibacteria_RBG_16_Zixibacteria_43_9"",""Bacteria_Zixibacteria_uncultured_SMTZ_73_2"",""Bacteria_Zixibacteria_RBG_16_Zixibacteria_50_21"",""Bacteria_CP_Zixibacteria_RBG1"",""Bacteria_Zixibacteria_RBG_16_Zixibacteria_53_22"",""Bacteria_Zixibacteria_uncultured_DG_27"",""Bacteria_CP_Zixibacteria_BJP_IG2158_Zixibacteria_48_33"",""Bacteria_Zixibacteria_uncultured_SMTZ_81"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA252_M08_SAK_001_72"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA252_O17_SAK_001_87"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA255_B16_SAK_001_121"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA252_F02_SAK_001_45"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA252_E13_SAK_001_43"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA252_N14_SAK_002_78"",""Bacteria_CP_KSB1_candidate_division_KSB1_bacterium_SCGC_AAA255_C20_SAK_001_123"",""Bacteria_CP_WWE1_candidate_division_WWE1_bacterium_JGI_0000014_H19_Combined_Assembly_WWE1_4__WWE1"",""Bacteria_CP_WWE1_candidate_division_WWE1_bacterium_JGI_0000014_H19_Etoliko_001_275"",""Bacteria_CP_WWE1_Candidatus_Cloacamonas_acidaminovorans"",""Bacteria_CP_WWE1_candidate_division_WWE1_bacterium_JGI_0000039_M09_TAsludge_001_159"",""Bacteria_CP_WWE1_candidate_division_WWE1_bacterium_JGI_0000059_L07_TAbiofilm_001_170"",""Bacteria_CP_WWE1_candidate_division_WWE1_bacterium_JGI_0000039_G13_Combined_Assembly_WWE1_1__WWE1"",""Bacteria_WWE1_DOLZORAL124_Cloacimonas_38_13"",""Bacteria_Fibrobacteres_Acidobacteria_group_Fibrobacteres_Fibrobacteria_Fibrobacterales_Fibrobacteraceae_Fibrobacter_succinogenes_elongatus_HM2"",""Bacteria_Fibrobacteres_Acidobacteria_group_Fibrobacteres_Fibrobacteria_Fibrobacterales_Fibrobacteraceae_Fibrobacter_succinogenes_subsp._succinogenes_S85"",""Bacteria_Fibrobacteres_Acidobacteria_Fibrobacteres_Fibrobacteria_Fibrobacterales_CG_Fibrob_01"",""Bacteria_CP_RIF7_RIFOXYB2_FULL_RIF7_49_35"",""Bacteria_CP_TG3_candidate_division_TG3_bacterium_ACht1"",""Bacteria_Gemmatiomonas_uncultured_SG8_17"",""Bacteria_Gemmatiomonas_uncultured_SG8_28"",""Bacteria_Gemmatimonadetes_RIFCSPLOWO2_12_FULL_Gemmatimonadetes_68_9"",""Bacteria_Gemmatimonadetes_RBG_16_Gemmatimonadetes_66_8"",""Bacteria_Gemmatimonadetes_RIFCSPLOWO2_02_FULL_Gemmatimonadetes_71_11"",""Bacteria_Gemmatimonadetes_GWC2_Gemmatimonadetes_71_10"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadales_Gemmatimonadaceae_Gemmatimonas_aurantiaca_T_27"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadales_Gemmatimonadaceae_Gemmatimonas_sp._AP64"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadetes_bacterium_KBS708"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadetes_bacterium_SCGC_AB_629_I08"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadetes_bacterium_SCGC_AAA007_O21"",""Bacteria_Gemmatiomonas_uncultured_SG8_23"",""Bacteria_Gemmatimonadetes_Gemmatimonadetes_Gemmatimonadetes_bacterium_SCGC_AAA003_K10"",""Bacteria_Gemmatiomonas_uncultured_SG8_38_2"",""Bacteria_Gemmatiomonas_uncultured_SMTZ_52"",""Bacteria_CP_RIF5_RBG_16_RIF5_58_8"",""Bacteria_CP_RIF5_RIFCSPLOWO2_12_FULL_RIF5_58_11"",""Bacteria_WOR_3_uncultured_SMTZ_60"",""Bacteria_WOR-3_RBG_13_WOR_3_43_14"",""Bacteria_WOR_3_uncultured_SMTZ_42"",""Bacteria_TA06_uncultured_SMTZ_40"",""Bacteria_TA06_uncultured_SMTZ1_40"",""Bacteria_TA06_uncultured_DG_24"",""Bacteria_TA06_RIFOXYC12_FULL_TA06_54_24"",""Bacteria_CP_RIF28_uncultured_DG_63"",""Bacteria_CP_RIF-WS3X_RBG_16_RIF_WS3X_71_46"",""Bacteria_CP_WS3_candidate_division_WS3_bacterium_SCGC_AAA252_E07_SAK_001_42"",""Bacteria_CP_WS3_candidate_division_WS3_bacterium_SCGC_AAA252_D10_SAK_001_39"",""Bacteria_CP_RIF27_RIFCSPLOWO2_12_FULL_RIF27_64_10"",""Bacteria_unclassified_Bacteria_Poribacteria_Candidatus_Poribacteria_WGA_3G_final_clean_version"",""Bacteria_unclassified_Bacteria_Poribacteria_Candidatus_Poribacteria_sp._WGA_4C_final_clean_version"",""Bacteria_CP_RIF8_RBG_13_RIF8_66_14"",""Bacteria_CP_BRC1_BJP_IG2102_BRC1_58_13"",""Bacteria_CP_BRC1_uncultured_SMTZ_51"",""Bacteria_CP_OP9_candidate_division_OP9_bacterium_SCGC_AAA255_N14_SAK_001_136"",""Bacteria_CP_OP9_candidate_division_OP9_bacterium_SCGC_AAA255_G05_SAK_001_130"",""Bacteria_Atribacteria_RBG_19FT_COMBO_JS1_35_14"",""Bacteria_CP_OP9_CG2_30_FULL_OP9_33_13"",""Bacteria_CP_JS1_candidate_division_JS1_bacterium_SCGC_5329"",""Bacteria_CP_OP9_candidate_division_OP9_bacterium_JGI_0000059_I14_TAbiofilm_001_167"",""Bacteria_Atribacteria_OP9_Candidatus_Caldatribacterium_saccharofermentans_OP9_77CS"",""Bacteria_unclassified_Bacteria_Atribacteria_Candidatus_Caldatribacterium_californiense_OP9_cSCG"",""Bacteria_Aquificae_Aquificae_Aquificales_Aquificaceae_Hydrogenobacter_thermophilus_TK_6"",""Bacteria_Aquificae_Aquificae_Aquificales_Aquificaceae_Thermocrinis_albus_DSM_14484"",""Bacteria_Aquificae_Aquificae_Aquificales_Aquificaceae_Hydrogenobaculum_sp._HO_Finished_QAed"",""Bacteria_Aquificae_Aquificae_Aquificales_Aquificaceae_Aquifex_aeolicus_VF5"",""Bacteria_Aquificae_Aquificae_Aquificales_Hydrogenothermaceae_Sulfurihydrogenibium_azorense_Az_Fu1"",""Bacteria_Aquificae_Aquificae_Aquificales_Hydrogenothermaceae_Persephonella_marina_EX_H1"",""Bacteria_Aquificae_Aquificae_Aquificales_Desulfurobacteriaceae_Desulfurobacterium_thermolithotrophum_DSM_11699"",""Bacteria_Aquificae_Aquificae_Aquificales_Desulfurobacteriaceae_Thermovibrio_ammonificans_HB_1"",""Bacteria_CP_EM_19_candidate_division_EM_19_bacterium_JGI_0000106_G12_Combined_Assembly_EM19_1__EM19"",""Bacteria_CP_EM_19_candidate_division_EM_19_bacterium_JGI_0000106_N7_GBS_C_001_292"",""Bacteria_CP_EM_19_candidate_division_EM_19_bacterium_JGI_0000106_J16_GBS_C_001_289"",""Bacteria_CP_EM_19_candidate_division_EM_19_bacterium_SCGC_AAA471_M6_GBS_N_001_25"",""Bacteria_Caldiserica_Caldisericia_Caldisericales_Caldisericaceae_Caldisericum_exile_AZM16c01_NBRC_104410"",""Bacteria_Caldiserica_Caldisericia_Caldisericales_Caldisericaceae_Caldisericum_CG2_30_FULL_Caldisericum_36_11"",""Bacteria_Dictyoglomi_Dictyoglomia_Dictyoglomales_Dictyoglomaceae_Dictyoglomus_turgidum_DSM_6724"",""Bacteria_Dictyoglomi_Dictyoglomia_Dictyoglomales_Dictyoglomaceae_Dictyoglomus_thermophilum_H_6_12"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Thermosipho_africanus_TCF52B"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Fervidobacterium_nodosum_Rt17_B1"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Thermotoga_thermarum_LA3_DSM_5069"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Thermotoga_maritima_MSB8"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Petrotoga_mobilis_SJ95"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Marinitoga_piezophila_KA3"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogaceae_Kosmotoga_olearia_TBF_19.5.1"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_Thermotogales_sp._mesG1.Ag.4.2"",""Bacteria_Thermotogae_Thermotogae_Thermotogales_unclassified_Thermotogales_Laodecianella_thermoacidophila_DSM_25116"",""Bacteria_CP_RIF31_RBG_16_RIF31_55_9"",""Bacteria_Deinococcus_Thermus_Deinococci_Thermales_Thermaceae_Marinithermus_hydrothermalis_T1_DSM_14884"",""Bacteria_Deinococcus_Thermus_Deinococci_Thermales_Thermaceae_Oceanithermus_profundus_DSM_14977"",""Bacteria_Deinococcus_Thermus_Deinococci_Thermales_Thermaceae_Thermus_oshimai_JL_2"",""Bacteria_Deinococcus_Thermus_Deinococci_Thermales_Thermaceae_Meiothermus_ruber_DSM_1279"",""Bacteria_Deinococcus_Thermus_Deinococci_Deinococcales_Trueperaceae_Truepera_radiovictrix_DSM_17093"",""Bacteria_Deinococcus_Thermus_Deinococci_Deinococcales_Deinococcaceae_Deinococcus_geothermalis_DSM_11300"",""Bacteria_CP_RIF2_RIFCSPLOWO2_12_FULL_RIF2_62_27"",""Bacteria_CP_RIF32_GWC2_RIF32_50_8"",""Bacteria_CP_RIF32_BJP_IG2103_RIF32_50_23"",""Bacteria_CP_RIF32_BJP_IG2102_CP_RIF32_51_10"",""Bacteria_CP_RIF32_CG2_30_FULL_CP_RIF32_54_10"",""Bacteria_CP_RIF33_GWC2_RIF33_49_35"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Thermanaerovibrio_acidaminovorans_DSM_6589"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Aminomonas_paucivorans_GLU_3_DSM_12260"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Cloacibacillus_evryensis_158_DSM_19522"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Aminiphilus_circumscriptus_DSM_16581"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Pyramidobacter_piscolens_W5455_contig00040"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Jonquetella_anthropi_E3_33_E1"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Dethiosulfovibrio_peptidovorans_SEBR_4207_DSM_11002"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Aminobacterium_colombiense_DSM_12261"",""Bacteria_Synergistetes_Synergistetes_sp._SGP1_draft_genome."",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Thermovirga_lienii_Cas60314_DSM_17291"",""Bacteria_Synergistetes_Synergistia_Synergistales_Synergistaceae_Anaerobaculum_mobile_NGA_DSM_13181"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Fusobacteriaceae_Cetobacterium_somerae_ATCC_BAA_474"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Fusobacteriaceae_Cetobacterium_sp._ZWU0022"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Fusobacteriaceae_Fusobacterium_nucleatum_nucleatum_ATCC_25586"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Fusobacteriaceae_Ilyobacter_polytropus_DSM_2926"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Fusobacteriaceae_Psychrilyobacter_atlanticus_DSM_19335"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Leptotrichiaceae_Leptotrichia_goodfellowii_F0264_contig00021"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Leptotrichiaceae_Sebaldella_termitidis_ATCC_33386"",""Bacteria_Fusobacteria_Fusobacteriia_Fusobacteriales_Leptotrichiaceae_Streptobacillus_moniliformis_DSM_12112"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Salinibacterium_amurskyense_PAMC_21357"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Clavibacter_michiganensis_subsp._michiganensis_NCPPB_382"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Glaciibacter_superstes_DSM_21135"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Cryobacterium_sp._MLB_32"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Herbiconiux_sp._YR403"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Agromyces_subbeticus_DSM_16689"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Humibacter_albus_DSM_18994"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Curtobacterium_ginsengisoli_DSM_22003"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Cryocola_sp._340MFSha3.1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Leifsonia_xyli_xyli_CTCB07"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Rathayibacter_toxicus_DSM_7488"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Microbacterium_paraoxydans_DH1b"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Curtobacterium_flaccumfaciens_UCD_AKU"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Curtobacterium_sp._9128"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Agrococcus_lahaulensis_DSM_17612"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Leucobacter_chromiiresistens_JG_31"",""Bacteria_Actinobacteria_Actinobacteria_Micrococcales_Microbacteriaceae_Zimmermannella_faecalis_ATCC_13722"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Microbacteriaceae_Gulosibacter_molinativorax_DSM_13485"",""Bacteria_Actinobacteria_marine_actinobacterium_IMCC13023"",""Bacteria_Actinobacteria_Actinobacteria_Micrococcales_Microbacteriaceae_Candidatus_Rhodoluna_lacicola_MWH_Ta8_Sequence_finished_Aug._2010"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Micrococcus_luteus_NCTC_2665"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Citricoccus_sp._CH26A"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Yaniellaceae_Yaniella_halotolerans_DSM_15476"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Nesterenkonia_alba_DSM_19423"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Renibacterium_salmoninarum_ATCC_33209"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Acaricomes_phytoseiuli_DSM_14247"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Arthrobacter_phenanthrenivorans_Sphe3"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Micrococcaceae_Kocuria_rhizophila_DC2201"",""Bacteria_Actinobacteria_Actinobacteria_Micrococcales_Micrococcaceae_Rothia_dentocariosa_ATCC_17931"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Brevibacteriaceae_Brevibacterium_linens_BL2"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Promicromonosporaceae_Promicromonospora_kroppenstedtii_RS16_DSM_19349"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Promicromonosporaceae_Xylanimonas_cellulosilytica_DSM_15894"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Promicromonosporaceae_Isoptericola_variabilis_225"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Promicromonosporaceae_Cellulosimicrobium_cellulans_J36_ICCI"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Cellulomonadaceae_Paraoerskovia_marina_DSM_21750"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Jonesiaceae_Jonesia_denitrificans_DSM_20603"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Sanguibacteraceae_Sanguibacter_keddieii_DSM_10542"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Cellulomonadaceae_Actinotalea_ferrariae_CF5_4"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Cellulomonadaceae_Cellulomonas_flavigena_DSM_20109"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Beutenbergiaceae_Beutenbergia_cavernae_DSM_12333"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_unclassified_Micrococcineae_Ruania_albidiflava_DSM_18029"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Bogoriellaceae_Georgenia_sp._SUBG003"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_Bifidobacteriaceae_Scardovia_inopinata_F0304_genomic_scaffold_supercont1.1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_Bifidobacteriaceae_Parascardovia_denticolens_DSM_10105_Contig1484"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_Bifidobacteriaceae_Bifidobacterium_animalis_animalis_ATCC_25527"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_Bifidobacteriaceae_Gardnerella_vaginalis_409_05"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_Bifidobacteriaceae_Alloscardovia_omnicolens_DSM_21503"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_MobiluncusFalcivibrio_group_Mobiluncus_curtisii_ATCC_43063"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Varibaculum_cambriense_DSM_15806"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Trueperella_pyogenes_TP6375"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Arcanobacterium_haemolyticum_DSM_20595"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Actinobaculum_schaalii_CCUG_27420"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Actinomyces_naeslundii_Howell_279_ATCC_12104"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinomycineae_Actinomycetaceae_Actinomyces_sp._oral_taxon_170_str._F0386"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermabacteraceae_Dermabacter_sp._HFH0086"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermabacteraceae_Brachybacterium_faecium_DSM_4810"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Tetrasphaera_elongata_DSM_14184"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Janibacter_sp._HTCC2649"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Arsenicicoccus_bolidensis_DSM_15745"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Terracoccus_sp._273MFTsu3.1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Intrasporangium_calvum_DSM_43043"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermatophilaceae_Mobilicoccus_pelagius_NBRC_104925"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermatophilaceae_Kineosphaera_limosa_NBRC_100340"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermatophilaceae_Dermatophilus_congolensis_DSM_44180"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermatophilaceae_Austwickia_chelonae_NBRC_105200"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Serinicoccus_marinus_MCCC_1A05965"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Intrasporangiaceae_Ornithinimicrobium_pekingense_DSM_21552"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermacoccaceae_Kytococcus_sedentarius_DSM_20547"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermacoccaceae_Dermacoccus_nishinomiyaensis_M25"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micrococcineae_Dermacoccaceae_Demetria_terragena_DSM_11295"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Kineosporiineae_Kineosporiaceae_Kineococcus_radiotolerans_SRS30216"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Propionibacteriaceae_Propionibacterium_acnes_KPA171202"",""Bacteria_Actinobacteria_Actinobacteria_Propionibacteriales_Propionibacteriaceae_Propionibacterium_CG1_02_FULL_Propionibacterium_60_36"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Propionibacteriaceae_Propionimicrobium_lymphophilum_DSM_4903"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Propionibacteriaceae_Aestuariimicrobium_kwangyangense_DSM_21549"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Propionicicella_superfundia_DSM_22317"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Propionibacteriaceae_Microlunatus_phosphovorus_NM_1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Kribbella_flavida_DSM_17836"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Nocardioides_sp._JS614"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Nocardioidaceae_bacterium_Broad_1_cont1.61"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Marmoricola_sp._URHB0036"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Aeromicrobium_marinum_DSM_15272"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Propionibacterineae_Nocardioidaceae_Actinopolymorpha_alba_DSM_45243"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Jiangella_gansuensis_YIM_002_DSM_44835"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptomycineae_Streptomycetaceae_Streptacidiphilus_oryzae_TH49"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptomycineae_Streptomycetaceae_Kitasatospora_setae_KM_6054_NBRC_14216"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptomycineae_Streptomycetaceae_Streptomycetaceae_bacterium_MP113_05"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptomycineae_Streptomycetaceae_Streptomyces_coelicolor_A32"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Catenulisporineae_Catenulisporaceae_Catenulispora_acidiphila_DSM_44928"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Catenulisporineae_Actinospicaceae_Actinospica_robiniae_DSM_44927"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Sporichthyaceae_Sporichthya_polymorpha_DSM_43042"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Saccharomonospora_viridis_DSM_43017"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Prauserella_rugosa_DSM_43194"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Thermocrispum_agreste_DSM_44070"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Amycolatopsis_mediterranei_RB"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Sciscionella_marina_DSM_45152"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Actinopolysporineae_Actinopolysporaceae_Actinopolyspora_mortivallis_HS_1_DSM_44261"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Saccharopolyspora_erythraea_NRRL_2338"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Actinoalloteichus_cyanogriseus_DSM_43889"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Saccharothrix_espanaensis_DSM_44229"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Actinosynnema_mirum_DSM_43827"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Actinokineospora_inagensis_DSM_44258"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Kutzneria_albida_DSM_43870"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Pseudonocardia_dioxanivorans_CB1190"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Nocardiaceae_Nocardia_brasiliensis_ATCC_700358"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Nocardiaceae_Smaragdicoccus_niigatensis_DSM_44881"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Nocardiaceae_Rhodococcus_sp._BCP1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Mycobacteriaceae_Mycobacterium_abscessus_bolletii_50594"",""Bacteria_Actinobacteria_Actinobacteria_Corynebacteriales_Gordoniaceae_Gordonia_bronchialis_DSM_43247"",""Bacteria_Actinobacteria_Actinobacteria_Corynebacteriales_Gordoniaceae_Gordonia_sp._KTR9"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Tsukamurellaceae_Tsukamurella_paurometabola_DSM_20162"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Corynebacteriaceae_Corynebacterium_argentoratense_DSM_44202"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Bifidobacteriales_unclassified_Bifidobacteriales_Turicella_otitidis_ATCC_51513"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Dietziaceae_Dietzia_cinnamea_P4_contig00104"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Mycobacteriaceae_Amycolicicoccus_subflavus_DQS3_9A1"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Corynebacterineae_Segniliparaceae_Segniliparus_rotundus_DSM_44985"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Actinomycetospora_chiangmaiensis_DSM_45062"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Nakamurellaceae_Nakamurella_multipartita_DSM_44233"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Geodermatophilaceae_Blastococcus_saxobsidens_DD2"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Geodermatophilaceae_Geodermatophilus_obscurus_DSM_43160"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Micromonospora_sp._L5"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Verrucosispora_maris_AB_18_032"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Salinispora_arenicola_CNS_205"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Actinoplanes_missouriensis_NBRC_102363"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Hamadaea_tsunoensis_DSM_44101"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Catelliglobosispora_koreensis_DSM_44566"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Micromonosporaceae_bacterium_URHE0070"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Micromonosporineae_Micromonosporaceae_Longispora_albida_DSM_44784"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Glycomycineae_Glycomycetaceae_Haloglycomyces_albus_DSM_45210"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Glycomycineae_Glycomycetaceae_Glycomyces_arizonensis_DSM_44726"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Glycomycineae_Glycomycetaceae_Stackebrandtia_nassauensis_DSM_44728"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Cryptosporangiaceae_Cryptosporangium_arvum_YU_629_21_DSM_44712"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Frankiaceae_Frankia_alni_ACN14a"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Streptosporangiaceae_Streptosporangium_roseum_DSM_43021"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Streptosporangiaceae_Microbispora_sp._ATCC_PTA_5024"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Streptosporangiaceae_Nonomuraea_coxensis_DSM_45129"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Pseudonocardineae_Pseudonocardiaceae_Thermobispora_bispora_DSM_43833"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Nocardiopsaceae_Marinactinospora_thermotolerans_DSM_45154"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Nocardiopsaceae_Thermobifida_fusca_YX"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Nocardiopsaceae_Nocardiopsis_alba_ATCC_BAA_2165"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Thermomonosporaceae_Actinomadura_madurae_LIID_AJ290"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Streptosporangineae_Thermomonosporaceae_Thermomonospora_curvata_DSM_43183"",""Bacteria_Actinobacteria_Actinobacteria_Actinobacteridae_Actinomycetales_Frankineae_Acidothermaceae_Acidothermus_cellulolyticus_11B"",""Bacteria_Actinobacteria_Actinobacteria_Nitriliruptoridae_Nitriliruptorales_Nitriliruptoraceae_Nitriliruptor_alkaliphilus_DSM_45188"",""Bacteria_Actinobacteria_Actinobacteria_unclassified_Actinobacteria_Candidatus_Microthrix_parvicella_Bio17_1"",""Bacteria_Actinobacteria_Actinobacteria_Acidimicrobidae_Acidimicrobiales_Acidimicrobineae_Acidimicrobiaceae_Ilumatobacter_coccineum_YM16_304"",""Bacteria_Actinobacteria_Actinobacteria_Acidimicrobidae_Acidimicrobiales_Acidimicrobineae_Acidimicrobiaceae_Acidimicrobium_ferrooxidans_DSM_10331"",""Bacteria_Actinobacteria_Actinobacteria_Acidimicrobidae_Acidimicrobiales_Acidimicrobineae_Acidimicrobiaceae_Ferrimicrobium_acidiphilum_DSM_19497"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Eggerthella_lenta_DSM_2243"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Eggerthella_sp._YY7918"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Gordonibacter_pamelaeae_7_10_1_b_draft_genome."",""Bacteria_Actinobacteria_Coriobacteriia_Coriobacteriales_Coriobacteriaceae_Senegalemassilia_anaerobia_JC110"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Enterorhabdus_mucosicola_DSM_19490"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Enterorhabdus_caecimuris_B7"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Adlercreutzia_equolifaciens_DSM_19450"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Denitrobacterium_detoxificans_DSM_21843"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Cryptobacterium_curtum_DSM_15641"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Slackia_piriformis_YIT_12062"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Slackia_heliotrinireducens_DSM_20476"",""Bacteria_Actinobacteria_Coriobacteriia_Coriobacteriales_Coriobacteriaceae_Enorma_massiliensis_phI"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Coriobacterium_glomerans_PW2_DSM_20642"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Collinsella_intestinalis_DSM_13280"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Olsenella_sp.OF0356"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Olsenella_uli_DSM_7084"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Atopobium_parvulum_DSM_20469"",""Bacteria_Actinobacteria_Actinobacteria_Coriobacteridae_Coriobacteriales_Coriobacterineae_Coriobacteriaceae_Atopobium_rimae_ATCC_49626"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Solirubrobacterales_Solirubrobacteraceae_Solirubrobacter_soli_DSM_22325"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Solirubrobacterales_Conexibacteraceae_Conexibacter_woesei_DSM_14684"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Solirubrobacterales_Patulibacteraceae_Patulibacter_sp._I11"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Thermoleophilales_Thermoleophilaceae_Thermoleophilum_album_ATCC_35263"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Rubrobacterales_Rubrobacterineae_Rubrobacteraceae_Rubrobacter_xylanophilus_DSM_9941"",""Bacteria_Actinobacteria_Actinobacteria_Rubrobacteridae_Solirubrobacterales_CG2_30_FULL_Actinobacteria_50_142"",""Bacteria_Actinobacteria_BJP_IG2158_Novel_57_21"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_54_11"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_50_21"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_47_49"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_49_13"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_47_9"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_56_12"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_54_18"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_57_11"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_52_11"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_55_16"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_51_16"",""Bacteria_Chloroflexi_RIFOXYC12_FULL_Chloroflexi_59_14"",""Bacteria_Chloroflexi_Anaerolinea_Anaerolineales_Anaerolineaceae_CG2_30_FULL_Anaerolineae_57_67"",""Bacteria_Chloroflexi_Anaerolineae_CG2_30_FULL_Anaerolineae_58_95"",""Bacteria_Chloroflexi_GWC2_Chloroflexi_49_37"",""Bacteria_Chloroflexi_GWB2_Chloroflexi_54_36"",""Bacteria_Chloroflexi_Anaerolineae_Anaerolineales_Anaerolineaceae_Anaerolinea_thermophila_UNI_1"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_48_8"",""Bacteria_Chloroflexi_Anaerolineae_uncultured_SMTZ_63"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_66_10"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_68_17"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_64_43"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_60_9"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_63_12"",""Bacteria_Chloroflexi_Anaerolineae_uncultured_SG8_19"",""Bacteria_Chloroflexi_Thermoflexia_Thermoflexales_Thermoflexaceae_Bacterium_sp._JAD2_Draft_Genome"",""Bacteria_Chloroflexi_Caldilineae_Caldilineales_Caldilineaceae_Caldilinea_aerophila_STL_6_O1_DSM_14535"",""Bacteria_Chloroflexi_Anaerolineae_CG2_30_FULL_Anaerolineae_64_16"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_57_9"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_56_8"",""Bacteria_Chloroflexi_Anaerolineae_uncultured_SMTZ_84"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_56_8"",""Bacteria_Chloroflexi_Chloroflexi_Chloroflexales_Oscillochloridaceae_Oscillochloris_trichoides_DG6_OSCTcontig_003"",""Bacteria_Chloroflexi_Chloroflexi_Chloroflexales_Chloroflexaceae_Chloroflexus_aurantiacus_J_10_fl"",""Bacteria_Chloroflexi_unclassified_Chloroflexi_Candidatus_Chlorothrix_halophila"",""Bacteria_Chloroflexi_Chloroflexi_Chloroflexales_Chloroflexaceae_Roseiflexus_castenholzii_DSM_13941"",""Bacteria_Chloroflexi_bacterium_JKG1"",""Bacteria_Chloroflexi_Chloroflexi_Herpetosiphonales_Herpetosiphonaceae_Herpetosiphon_aurantiacus_DSM_785"",""Bacteria_Chloroflexi_Thermomicrobia_Sphaerobacteridae_Sphaerobacterales_Sphaerobacterineae_Sphaerobacteraceae_Nitrolancetus_hollandicus_Lb"",""Bacteria_Chloroflexi_Thermomicrobia_Sphaerobacteridae_Sphaerobacterales_Sphaerobacterineae_Sphaerobacteraceae_Sphaerobacter_thermophilus_DSM_20745_1"",""Bacteria_Chloroflexi_Thermomicrobia_Thermomicrobiales_Thermomicrobiaceae_Thermomicrobium_roseum_DSM_5159"",""Bacteria_Chloroflexi_Thermobaculum_terrenum_ATCC_BAA_798_1"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_51_52"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_51_18"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_50_11"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_52_12"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_57_8"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_56_11"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_60_22"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_58_8"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_50_9"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_51_9"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_46_14"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_57_8"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_46_9"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_56_8b"",""Bacteria_Chloroflexi_Dehalococcoidetes_Dehalogenimonas_lykanthroporepellens_BL_DC_9"",""Bacteria_Chloroflexi_Dehalococcoidetes_Dehalococcoidales_Dehalococcoidaceae_Dehalococcoides_mccartyi_CBDB1"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_48_17"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_47_15"",""Bacteria_Chloroflexi_RBG_19FT_COMBO_Chloroflexi_48_23"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_50_10"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_48_7"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_51_36"",""Bacteria_Chloroflexi_Dehalococcoidia_CG2_30_FULL_Dehalococcoidia_46_9"",""Bacteria_Chloroflexi_Dehalococcoidia_CG2_30_FULL_Dehalococcoidia_46_19"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_54_8"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_53_26"",""Bacteria_Chloroflexi_Dehalococcoidia_uncultured_DG_18"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_52_14"",""Bacteria_Chloroflexi_RBG_13_Chloroflexi_54_9"",""Bacteria_Chloroflexi_Dehalococcoidia_uncultured_DG_22"",""Bacteria_Chloroflexi_Dehalococcoidia_uncultured_SMTZ_28_1"",""Bacteria_Chloroflexi_Dehalococcoidia_uncultured_SMTZ_28_2"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_64_32"",""Bacteria_Chloroflexi_RBG_16_Chloroflexi_68_14"",""Bacteria_Chloroflexi_Ktedonobacteria_Ktedonobacterales_Ktedonobacteraceae_Ktedonobacter_racemifer_DSM_44963_Krac_Contig206"",""Bacteria_Chloroflexi_Ktedonobacteria_Thermogemmatisporales_Thermogemmatisporaceae_Thermogemmatispora_sp._PM5"",""Bacteria_Chloroflexi_RBG_16_RIF_CHLX_69_14"",""Bacteria_Chloroflexi_RBG_16_RIF_CHLX_70_13"",""Bacteria_Chloroflexi_RBG_16_RIF_CHLX_72_14"",""Bacteria_Chloroflexi_GWC2_RIF_CHLX_73_18"",""Bacteria_Chloroflexi_RIFCSPLOWO2_12_FULL_RIF_CHLX_71_12"",""Bacteria_Armatimonadetes_RBG_19FT_COMBO_Armatimonadetes_69_19"",""Bacteria_Armatimonadetes_13_1_40CM_Armatimonadetes_64_14"",""Bacteria_Armatimonadetes_RBG_16_Armatimonadetes_67_12"",""Bacteria_CP_Armatimonadetes_CSP1_3"",""Bacteria_Armatimonadetes_Armatimonadetes_bacterium_JGI_0000077_K19_TAbiofilm_001_240"",""Bacteria_Armatimonadetes_Chthonomonadetes_Chthonomonadales_Chthonomonadaceae_Chthonomonas_calidirosea_T49_EMBL_Bank_version_circular_IHQD"",""Bacteria_Armatimonadetes_Fimbriimonas_ginsengisoli_Gsoil_348"",""Bacteria_Armatimonadetes_CG2_30_FULL_Armatimonadetes_59_28"",""Bacteria_Armatimonadetes_CG2_30_FULL_Armatimonadetes_66_41"",""Bacteria_KD3_62_uncultured_DG_56"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Leuconostocaceae_Leuconostoc_kimchii_IMSNU11154"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Leuconostocaceae_Fructobacillus_fructosus_KCTC_3544_contig00014"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Leuconostocaceae_Oenococcus_oeni_PSU_1"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Leuconostocaceae_Weissella_ceti_WS74"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Lactobacillaceae_Pediococcus_claussenii_P06_ATCC_BAA_344"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Lactobacillaceae_Lactobacillus_acidophilus_NCFM"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Alloiococcus_otitis_ATCC_51267"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Dolosigranulum_pigrum_ATCC_51524"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Allofustis_seminis_DSM_15817"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Atopococcus_tabaci_DSM_17538"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Lacticigenium_naphtae_DSM_19658"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Enterococcaceae_Melissococcus_plutonius_ATCC_35311"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Enterococcaceae_Enterococcus_faecalis_D32"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Enterococcaceae_Tetragenococcus_halophilus_NBRC_12172"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Streptococcaceae_Lactococcus_garvieae_Lg2"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Streptococcaceae_Streptococcus_mutans_GS_5"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Enterococcaceae_Catellicoccus_marimammalium_M35043"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Carnobacterium_maltaromaticum_LMA28"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Catonella_morbi_ATCC_51271_C_morbi_1.0.1_Cont0.13"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Aerococcaceae_Abiotrophia_defectiva_ATCC_49176"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Aerococcaceae_Globicatella_sulfidifaciens_DSM_15739"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Aerococcaceae_Eremococcus_coleocola_ACS_139_V_Col8_contig00001"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Aerococcaceae_Facklamia_ignava_CCUG_37419"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Aerococcaceae_Aerococcus_urinae_ACS_120_V_Col10a"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Atopobacter_phocae_ATCC_BAA_285"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Enterococcaceae_Bavariicoccus_seileri_DSM_19936"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Carnobacteriaceae_Granulicatella_elegans_ATCC_700633_genomic_scaffold_supercont1.2"",""Bacteria_Firmicutes_Bacilli_Bacillales_Listeriaceae_Listeria_innocua_sv._6a_Clip11262"",""Bacteria_Firmicutes_Bacilli_Bacillales_Listeriaceae_Brochothrix_thermosphacta_FSL_F6_1036"",""Bacteria_Firmicutes_Bacilli_Bacillales_Staphylococcaceae_Jeotgalicoccus_psychrophilus_DSM_19085"",""Bacteria_Firmicutes_Bacilli_Bacillales_Staphylococcaceae_Salinicoccus_carnicancri_Crm"",""Bacteria_Firmicutes_Bacilli_Bacillales_Staphylococcaceae_Nosocomiicoccus_sp._NP2"",""Bacteria_Firmicutes_Bacilli_Bacillales_Staphylococcaceae_Macrococcus_caseolyticus_JCSC5402"",""Bacteria_Firmicutes_Bacilli_Bacillales_Staphylococcaceae_Staphylococcus_aureus_502A"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillales_incertae_sedis_Bacillales_Family_XI._Incertae_Sedis_Gemella_haemolysans_ATCC_10379"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Lysinibacillus_sphaericus_C3_41"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Solibacillus_silvestris_StLB046"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Ureibacillus_thermosphaericus_Thermo_BF"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Viridibacillus_arenosi_FSL_R5_213"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Kurthia_massiliensis_JC30"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Planococcus_donghaensis_MPA1U2_contig00058"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Paenisporosarcina_sp._TG_14"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillales_incertae_sedis_Bhargavaea_cecembensis_DSE10"",""Bacteria_Firmicutes_Bacilli_Bacillales_Planococcaceae_Sporosarcina_newyorkensis_2681"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Bacillus_anthracis_52_G"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Eubacterium_biforme_DSM_3989_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Eubacterium_cylindroides_T2_87_draft_genome."",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Streptococcaceae_Streptococcus_pleomorphus_DSM_20574"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Allobaculum_stercoricanis_DSM_13633"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_innocuum_2959"",""Bacteria_Firmicutes_Erysipelotrichia_Erysipelotrichales_Erysipelotrichaceae_Dielma_fastidiosa_JC13"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Bulleidia_extructa_W1219_contig00009"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Solobacterium_moorei_F0204_S_mooreiF0204_1.0_Cont15.1"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Holdemania_sp._AP2"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Erysipelothrix_rhusiopathiae_str._Fujisawa"",""Bacteria_Firmicutes_Erysipelotrichia_Erysipelotrichales_Erysipelotrichaceae_Eggerthia_catenaformis_DSM_20559"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Lactobacillaceae_Lactobacillus_catenaformis_OT_569"",""Bacteria_Firmicutes_Bacilli_Lactobacillales_Lactobacillaceae_Sharpea_azabuensis_DSM_18934"",""Bacteria_Firmicutes_Erysipelotrichia_Erysipelotrichales_Erysipelotrichaceae_Kandleria_vitulina_MC3001"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Catenibacterium_mitsuokai_DSM_15897_C_mitsuokai_1.0_Cont88.1"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Erysipelotrichaceae_bacterium_AP9"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Coprobacillus_sp._8_2_54BFAA"",""Bacteria_Tenericutes_Mollicutes_Entomoplasmatales_Entomoplasmataceae_Mesoplasma_florum_W37"",""Bacteria_Tenericutes_Mollicutes_Entomoplasmatales_Entomoplasmataceae_Entomoplasma_luminosum_ATCC_49195"",""Bacteria_Tenericutes_Mollicutes_Entomoplasmatales_Spiroplasmataceae_Spiroplasma_culicicola_AES_1"",""Bacteria_Tenericutes_Mollicutes_Mycoplasmatales_Mycoplasmataceae_Mycoplasma_agalactiae"",""Bacteria_Tenericutes_Mollicutes_Mycoplasmatales_Mycoplasmataceae_Candidatus_Hepatoplasma_crinochetorum_Av"",""Bacteria_Tenericutes_Mollicutes_Mycoplasmatales_Mycoplasmataceae_Ureaplasma_parvum_serovar_3_str._ATCC_27815"",""Bacteria_Tenericutes_Mollicutes_Mollicutes_bacterium_HR1"",""Bacteria_Tenericutes_Mollicutes_Mollicutes_bacterium_HR2"",""Bacteria_Tenericutes_Mollicutes_Acholeplasmatales_Acholeplasmataceae_Candidatus_Phytoplasma_aster_yellows_witches_broom_AY_WB"",""Bacteria_Tenericutes_Mollicutes_Acholeplasmatales_Acholeplasmataceae_Acholeplasma_laidlawii_PG_8A"",""Bacteria_unclassified_Bacteria_Haloplasmatales_Haloplasmataceae_Haloplasma_contractile_SSD_17B"",""Bacteria_Firmicutes_Erysipelotrichi_Erysipelotrichales_Erysipelotrichaceae_Turicibacter_sp._HGF1_contig00015"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Anoxybacillus_flavithermus_WK1"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Geobacillus_kaustophilus_HTA426"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Geobacillus_debilis_gb1_GenePRIMP"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Salimicrobium_sp._MJ3"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Halobacillus_halophilus_DSM_2266"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Thalassobacillus_devorans_MSP14"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Pontibacillus_halophilus_DSM_19796"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Terribacillus_aidingensis_MP602"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Gracilibacillus_lacisalsi_DSM_19029"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Sediminibacillus_halophilus_NSP9.3"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Paucisalibacillus_globulus_DSM_18846"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Ornithinibacillus_sp._TW25"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Virgibacillus_sp._CM_4"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Oceanobacillus_iheyensis_HTE831"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Lentibacillus_sp._Grbi"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Halalkalibacillus_halophilus_DSM_18494"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Alkalibacillus_haloalkaliphilus_C5"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Amphibacillus_xylanus_NBRC_15112"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Salsuginibacillus_kocurii_DSM_18087"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Marinococcus_halotolerans_DSM_16375"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Bacillus_selenitireducens_MLS10"",""Bacteria_Firmicutes_Bacilli_Bacillales_Sporolactobacillaceae_Sporolactobacillus_terrae_HKM_1"",""Bacteria_Firmicutes_Bacilli_Bacillales_Sporolactobacillaceae_Tuberibacillus_calidus_DSM_17572"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Bacillus_gelatini_DSM_15865"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillales_incertae_sedis_Bacillales_Family_XII._Incertae_Sedis_Exiguobacterium_sp._AT1b"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Caldalkalibacillus_thermarum_TA2.A1_ctg240"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillales_incertae_sedis_Bacillales_Family_X._Incertae_Sedis_Thermicanus_aegyptius_DSM_12793"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Aneurinibacillus_group_Aneurinibacillus_terranovensis_DSM_18919"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Brevibacillus_brevis_NBRC_100599"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Saccharibacillus_sacchari_GR21_DSM_19268"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Paenibacillus_lactis_154"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Cohnella_panacarvi_Gsoil_349_DSM_18696"",""Bacteria_Firmicutes_Bacilli_Bacillales_Paenibacillaceae_Thermobacillus_composti_KWC4_DSM_18247"",""Bacteria_Firmicutes_Bacilli_Bacillales_Thermoactinomycetaceae_Shimazuella_kribbensis_DSM_45090"",""Bacteria_Firmicutes_Bacilli_Bacillales_Thermoactinomycetaceae_Thermoactinomyces_sp._Gus2_1"",""Bacteria_Firmicutes_Bacilli_Bacillales_Thermoactinomycetaceae_Desmospora_sp._8437"",""Bacteria_Firmicutes_Bacilli_Bacillales_Bacillaceae_Bacillus_tusciae_DSM_2912"",""Bacteria_Firmicutes_Bacilli_Bacillales_Alicyclobacillaceae_Alicyclobacillus_acidocaldarius_LAA1_unfinished_sequence"",""Bacteria_Firmicutes_Bacilli_Bacillales_Alicyclobacillaceae_Tumebacillus_flagellatus_GST4"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XIV._Incertae_Sedis_Anaerobranca_gottschalkii_DSM_13577"",""Bacteria_Firmicutes_Clostridia_Natranaerobiales_Natranaerobiaceae_Natranaerobius_thermophilus_JWNM_WN_LF"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Syntrophomonadaceae_Dethiobacter_alkaliphilus_AHT_1_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Butyrivibrio_fibrisolvens_164_draft_genome."",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Pseudobutyrivibrio_ruminis_HUN009"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Shuttleworthia_satelles_DSM_14600_S_satelles_1.0.1_Cont0.3"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Lachnobacterium_bovis_C6A12"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Roseburia_hominis_A2_183_DSM_16839"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Lachnospiraceae_bacterium_sp._ICM7"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Johnsonella_ignava_ATCC_51276"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Lachnospiraceae_bacterium_ACC2"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Oribacterium_sp._NK2B42"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Lachnospira_multipara_LB2003"",""Bacteria_Bacteroidetes_Chlorobi_group_Bacteroidetes_Bacteroidia_Bacteroidales_Bacteroidaceae_Bacteroides_pectinophilus_ATCC_43243_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Marvinbryantia_Marvinbryantia_formatexigens_I_52_DSM_14469"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Robinsoniella_sp._KNHs210"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Ruminococcus_obeum_A2_162_draft_genome."",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Dorea_longicatena_AGR2136"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_nexile_DSM_1787_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_phytofermentans_ISDg"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Lachnospiraceae_Anaerostipes_hadrus_comb._nov._VPI_82_52_DSM_3319"",""Bacteria_Firmicutes_Clostridia_Clostridiales_unclassified_Clostridiales_Epulopiscium_sp._N.t._morphotype_B"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_lentocellum_DSM_5427"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Faecalibacterium_prausnitzii_L26_draft_genome."",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Subdoligranulum_sp._4_3_54A2FAA"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Anaerotruncus_colihominis_DSM_17241_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Ruminococcus_sp._18P13_draft_genome."",""Bacteria_Firmicutes_Clostridia_Clostridiales_unclassified_Clostridiales_Flavonifractor_Flavonifractor_plautii_ATCC_29863"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_orbiscindens_1_3_50AFAA"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Oscillospiraceae_Oscillibacter_valericigenes_Sjm18_20"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Butyricicoccus_pullicaecorum_1.2"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_clariflavum_EBR_45_DSM_19732"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Ruminococcaceae_Acetivibrio_cellulolyticus_CD2_DSM_1870_ORNL_annotation"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Helcococcus_sueciensis_DSM_17243"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Kallipyga_massiliensis_ph2"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Anaerococcus_prevotii_DSM_20548"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Finegoldia_magna_ATCC_29328"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptostreptococcaceae_Peptostreptococcus_micros_ATCC_33270_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Peptoniphilus_harei_ACS_146_V_Sch2b_contig00003"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Tepidimicrobium_xylanilyticum_DSM_23310"",""Bacteria_Firmicutes_Clostridia_Clostridiales_unclassified_Clostridiales_Proteiniborus_ethanoligenes_DSM_21650"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_acidurici_9a_DSM_604"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridiisalibacter_paucivorans_DSM_22131"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XI._Incertae_Sedis_Sedimentibacter_sp._B4"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_glycolicum_DSM_1288"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_bartlettii_DSM_16795_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_difficile_CF5"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptostreptococcaceae_Peptostreptococcus_anaerobius_VPI_4330"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptostreptococcaceae_Filifactor_alocis_ATCC_35896"",""Bacteria_Firmicutes_Clostridia_Clostridiales_unclassified_Clostridiales_Proteocatella_sphenisci_DSM_23131"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Eubacterium_sp._AS15"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Natronincola_peptidivorans_DSM_18979"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Alkaliphilus_oremlandii_OhILAs"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XIII._Incertae_Sedis_Mogibacterium_timidum_ATCC_33093"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XIII._Incertae_Sedis_Anaerovorax_odorimutans_DSM_5092"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XII._Incertae_Sedis_Acidaminobacter_hydrogenoformans_DSM_2784"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Eubacterium_limosum_KIST612"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Pseudoramibacter_alactolyticus_ATCC_23263_contig00019"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Acetobacterium_woodii_WB1_DSM_1030"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Eubacteriaceae_Anaerofustis_stercorihominis_DSM_17244_unfinished_sequence"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Proteiniclasticum_ruminis_DSM_24773"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Youngiibacter_fragile_232.1"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Clostridium_acetobutylicum_EA_2018"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Candidatus_Arthromitus_sp._SFB_mouse_Japan"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Fervidicella_Metallireducens_AeB"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Thermobrachium_celere_JWYL_NZ35_DSM_8682"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiaceae_Caloramator_australicus_RC3"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Thermoanaerobacter_italicus_Ab9"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Caldanaerobacter_subterraneus_tengcongensis_MB4T"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacterales_Family_III._Incertae_Sedis_Thermoanaerobacterium_thermosaccharolyticum_M0795"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Caldanaerobius_polysaccharolyticum_KMTHCJ_DSM_13641"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Caldicoprobacteraceae_Caldicoprobacter_oshimai_DSM_21659"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacterales_Family_IV._Incertae_Sedis_Mahella_australiensis_50_1_BON_DSM_15567"",""Bacteria_Firmicutes_Clostridia_Clostridiales_unclassified_Clostridiales_Anaerocellum_group_Anaerocellum_thermophilum_DSM_6725"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacterales_Family_III._Incertae_Sedis_Caldanaerovirga_acetigignens_DSM_18802"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacterales_Family_III._Incertae_Sedis_Thermosediminibacter_oceani_DSM_16646"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Tepidanaerobacter_acetatoxydans_Re1"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Selenomonas_ruminantium_lactilytica_TAM6421"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Mitsuokella_multacida_DSM_20544"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Centipeda_periodontii_DSM_2778_contig00059"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Anaerovibrio_sp._RM50"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Zymophilus_raffinosivorans_DSM_20765"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Propionispira_arboris_DSM_2179"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Dialister_microaerophilus_UPII_345_E_contig00002"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Allisonella_histaminiformans_DSM_15230"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Anaeroglobus_geminatus_F0357"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Megasphaera_sp._BV3C16_1"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Veillonella_parvula_DSM_2008"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Acidaminococcaceae_Phascolarctobacterium_sp._YIT_12067_P_spYIT12067_1.0_Cont77.1"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Acidaminococcaceae_Acidaminococcus_fermentans_DSM_20731"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Acidaminococcaceae_Succinispira_mobilis_DSM_6222"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Anaeroarcus_burkinensis_DSM_6283"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Anaeromusa_acidaminophila_DSM_3853"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Pelosinus_sp._UFO1"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Acetonema_longum_DSM_6540_Contig00019"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Sporomusa_ovata_DSM_2662"",""Bacteria_Firmicutes_Negativicutes_Selenomonadales_Veillonellaceae_Sporolituus_thermophilus_DSM_23256"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Pelotomaculum_thermopropionicum_SI"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfotomaculum_gibsoniae_Groll_DSM_7213"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfurispora_thermophila_DSM_16022"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Desulfovirgula_thermocuniculi_DSM_16036"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Moorella_group_Ammonifex_degensii_KC4"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Candidatus_Desulforudis_audaxviator_MP104C"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Carboxydothermus_hydrogenoformans_Z_2901_DSM_6008"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Thermincola_sp._JR"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Moorella_group_Moorella_thermoacetica_ATCC_39073"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Thermanaeromonas_toyohensis_ToBE_DSM_14490"",""Bacteria_Firmicutes_Clostridia_Thermoanaerobacterales_Thermoanaerobacteraceae_Thermacetogenium_phaeum_DSM_12270"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfitobacterium_hafniense_Y51"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfosporosinus_orientis_Singapore_I_DSM_765"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Syntrophobotulus_glycolicus_DSM_8271"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Dehalobacter_restrictus_DSM_9455"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Heliobacteriaceae_Heliobacterium_modesticaldum_Ice1"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfonispora_thiosulfatigenes_GKNTAUT__DSM_11270"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Syntrophomonadaceae_Syntrophomonas_wolfei_Goettingen_DSM_2245B"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Syntrophomonadaceae_Syntrophothermus_lipocalidus_DSM_12680"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Peptococcaceae_Desulfitibacter_alkalitolerans_DSM_16504"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XVII._Incertae_Sedis_Thermaerobacter_marianensis_DSM_12885"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XVII._Incertae_Sedis_Sulfobacillus_acidophilus_TPY"",""Bacteria_Firmicutes_Clostridia_Clostridiales_Clostridiales_incertae_sedis_Clostridiales_Family_XVIII._Incertae_Sedis_Symbiobacterium_thermophilum_IAM_14863"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halobacteroidaceae_Orenia_marismortui_DSM_5156"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halobacteroidaceae_Halonatronum_saccharophilum_Z_7986_DSM_13868"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halobacteroidaceae_Halobacteroides_halobius_MD_1_DSM_5150"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halobacteroidaceae_Acetohalobium_arabaticum_DSM_5501"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halanaerobiaceae_Halanaerobium_sp._sapolanicus"",""Bacteria_Firmicutes_Clostridia_Halanaerobiales_Halanaerobiaceae_Halothermothrix_orenii_H_168"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Aphanizomenon_flos_aquae_NIES_81"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Anabaena_circinalis_AWQC131C_Submitted_file_with_automatic_translation_by_Kostas"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Raphidiopsis_brookii_D9_D9_7"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Cylindrospermopsis_raciborskii_509_upload_fresh_set"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Nostoc_azollae"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Anabaena_cylindrica_PCC_7122"",""Bacteria_Cyanobacteria_Nostocales_Microchaetaceae_Microchaete_sp._PCC_7126"",""Bacteria_Cyanobacteria_Nostocales_Microchaetaceae_Fremyella_diplosiphon_UTEX_481"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Cylindrospermum_stagnale_PCC_7417"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Nodularia_spumigena_CCY9414"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Nostoc_sp._PCC_7524"",""Bacteria_Cyanobacteria_Nostocales_Rivulariaceae_Calothrix_sp._PCC_6303"",""Bacteria_Cyanobacteria_Stigonematales_Fischerella_muscicola_SAG_1427_1"",""Bacteria_Cyanobacteria_Stigonematales_Chlorogloeposis_fritschii_PCC_6912_CLC_Draft_2"",""Bacteria_Cyanobacteria_Stigonematales_Mastigocladopsis_repens_MORA_PCC_10914"",""Bacteria_Cyanobacteria_Nostocales_Nostocaceae_Richelia_intracellularis_HH01"",""Bacteria_Cyanobacteria_Nostocales_Rivulariaceae_Rivularia_sp._PCC_7116"",""Bacteria_Cyanobacteria_Pleurocapsales_Chroococcidiopsis_thermalis_PCC_7203"",""Bacteria_Cyanobacteria_Chroococcales_Chamaesiphon_sp._PCC_6605"",""Bacteria_Cyanobacteria_Oscillatoriales_Crinalium_epipsammum_PCC_9333"",""Bacteria_Cyanobacteria_Pleurocapsales_Xenococcus_sp._PCC_7305"",""Bacteria_Cyanobacteria_Pleurocapsales_Myxosarcina_sp._GI1"",""Bacteria_Cyanobacteria_Pleurocapsales_Stanieria_cyanosphaera_PCC_7437"",""Bacteria_Cyanobacteria_Chroococcales_Cyanobacterium_stanieri_PCC_7202"",""Bacteria_Cyanobacteria_Chroococcales_Synechocystis_sp._PCC_6308"",""Bacteria_Cyanobacteria_Chroococcales_Cyanobacterium_UCYN_A"",""Bacteria_Cyanobacteria_Chroococcales_Crocosphaera_watsonii_WH_8501"",""Bacteria_Cyanobacteria_Chroococcales_Synechocystis_sp._PCC_6803"",""Bacteria_Cyanobacteria_Pleurocapsales_Pleurocapsa_sp._PCC_7327"",""Bacteria_Cyanobacteria_Chroococcales_Gloeocapsa_sp._PCC_73106"",""Bacteria_Cyanobacteria_Prochlorales_Prochloraceae_Prochloron_didemni_P3_Solomon"",""Bacteria_Cyanobacteria_Chroococcales_Halothece_cluster_Halothece_sp._PCC_7418"",""Bacteria_Cyanobacteria_Chroococcales_Dactylococcopsis_salina_PCC_8305"",""Bacteria_Cyanobacteria_Chroococcales_Rubidibacter_lacunae_KORDI_51_2_k51_img_annotated_130412"",""Bacteria_Cyanobacteria_Oscillatoriophycideae_Oscillatoriales_Spirulina_major_PCC_6313"",""Bacteria_Cyanobacteria_Oscillatoriales_Lyngbya_majuscula_3L"",""Bacteria_Cyanobacteria_Oscillatoriales_Microcoleus_chthonoplastes_PCC_7420_scf_1103659003820_genomic_scaffold"",""Bacteria_Cyanobacteria_Oscillatoriales_Microcoleus_sp._PCC_7113"",""Bacteria_Cyanobacteria_Oscillatoriales_Planktothrix_agardhii_NIVA_CYA_34"",""Bacteria_Cyanobacteria_Oscillatoriales_Lyngbya_sp._PCC_8106_unfinished_sequence"",""Bacteria_Cyanobacteria_Oscillatoriales_Arthrospira_platensis_NIES_39"",""Bacteria_Cyanobacteria_Oscillatoriales_Trichodesmium_erythraeum_IMS101"",""Bacteria_Cyanobacteria_Oscillatoriales_Oscillatoria_sp._PCC_6506"",""Bacteria_Cyanobacteria_Oscillatoriales_Oscillatoria_sp._PCC_7112"",""Bacteria_Cyanobacteria_Oscillatoriales_Oscillatoriales_sp._JSC_1"",""Bacteria_Cyanobacteria_Oscillatoriales_Geitlerinema_sp._PCC_7407"",""Bacteria_Cyanobacteria_Chroococcales_Cyanothece_sp._PCC_7425"",""Bacteria_Cyanobacteria_Chroococcales_Thermosynechococcus_elongatus_BP_1"",""Bacteria_Cyanobacteria_Oscillatoriales_Pseudanabaena_sp._PCC_7367"",""Bacteria_Cyanobacteria_Chroococcales_Acaryochloris_marina_MBIC11017"",""Bacteria_Cyanobacteria_Chroococcales_Synechococcus_sp._CC9902"",""Bacteria_Cyanobacteria_Prochlorales_Prochlorococcaceae_Prochlorococcus_marinus_str._MIT_9301"",""Bacteria_Cyanobacteria_Chroococcales_Cyanobium_gracile_PCC_6307"",""Bacteria_Cyanobacteria_Prochlorales_Prochlorotrichaceae_Prochlorothrix_hollandica_PCC_9006"",""Bacteria_Cyanobacteria_Oscillatoriales_Leptolyngbya_sp._PCC_7104"",""Bacteria_Cyanobacteria_Gloeobacteria_Gloeobacterales_Gloeobacter_violaceus_PCC_7421"",""Bacteria_Melainabacteria_Gastranaerophilaceae_MH_37"",""Bacteria_Melainabacteria_MEL_C1"",""Bacteria_Melainabacteria_Gastranaerophilales_YS2_Zagget_bin_1"",""Bacteria_Melainabacteria_MEL_A1"",""Bacteria_Melainabacteria_Gastranaerophilaceae_Zag_111"",""Bacteria_Melainabacteria_Gastranaerophilales_YS2_Zagget_bin_221"",""Bacteria_Melainabacteria_MEL_B1"",""Bacteria_Melainabacteria_MEL_B2"",""Bacteria_Melainabacteria_GWF2_Melainabacteria_32_7"",""Bacteria_Melainabacteria_RIFOXYA2_FULL_Melainabacteria_32_9"",""Bacteria_Melainabacteria_ACD20"",""Bacteria_Melainabacteria_GWF2_Melainabacteria_37_15"",""Bacteria_Melainabacteria_GWA2_Melainabacteria_34_9"",""Bacteria_Melainabacteria_RIFCSPHIGHO2_02_FULL_Melainabacteria_34_12"",""Bacteria_Melainabacteria_RIFCSPLOWO2_12_FULL_Melainabacteria_35_11"",""Bacteria_Melainabacteria_Obscuribacteriales_Obscuribacter_phosphatis_Mle1_12"",""Bacteria_CP_novel_BJP_IG2069_Novel_57_5"",""Bacteria_WOR-1_RIFCSPHIGHO2_01_FULL_WOR_1_53_15"",""Bacteria_WOR-1_RIFOXYA2_FULL_WOR_1_51_19"",""Bacteria_WOR-1_RIFOXYB2_FULL_WOR_1_48_7"",""Bacteria_WOR_1_uncultured_DG_54_3"",""Bacteria_WOR-1_RIFCSPLOWO2_02_FULL_WOR_1_46_20"",""Bacteria_WOR-1_RIFOXYC2_FULL_WOR_1_41_25"",""Bacteria_WOR-1_RIFOXYB2_FULL_WOR_1_37_13"",""Bacteria_WOR-1_RIFOXYA2_FULL_WOR_1_36_21"",""Bacteria_WOR-1_RIFOXYA12_FULL_WOR_1_43_27"",""Bacteria_CP_RIF30_GWF2_RIF30_38_17"",""Bacteria_CP_RIF30_GWF2_RIF30_35_9"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFOXYC2_FULL_OD1_Nomurabacteria_36_19"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_39_10"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_42_17"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_12_FULL_OD1_Nomurabacteria_40_42"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_40_18"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_41_18"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWA1_OD1_37_20_partial"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_02_FULL_OD1_Nomurabacteria_36_29"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_36_5"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_41_12"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_40_12"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_12_FULL_OD1_Nomurabacteria_37_8"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_39_18"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_37_25"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWB1_OD1_Nomurabacteria_40_6"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFOXYB1_FULL_OD1_Nomurabacteria_39_16"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWB1_OD1_40_7"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWB1_OD1_47_6_part"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWA2_OD1_43_15"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWA2_OD1_41_25_partial"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWA1_OD1_43_17"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWF2_OD1_40_31"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_38_19"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_CG1_02_FULL_Nomurabacteria_OD1_31_12"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWE2_OD1_31_40"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_02_FULL_OD1_Nomurabacteria_35_13"",""Bacteria_CPR_Parcubacteria_OD1_candidate_division_OD1_bacterium_SCGC_AAA011_A08_DUSEL_001_185"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_40_15"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_39_17"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_40_20"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWA2_OD1_40_9"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_12_FULL_OD1_Nomurabacteria_44_11"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_02_FULL_OD1_Nomurabacteria_42_19"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_41_52b"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_12_FULL_OD1_Nomurabacteria_46_14"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_46_18"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_42_16"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWB1_OD1_37_5"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_42_18"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_02_FULL_OD1_Nomurabacteria_38_15"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_02_FULL_OD1_Nomurabacteria_33_12"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWB1_OD1_36_6"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RAAC4_OD1"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPHIGHO2_01_FULL_OD1_Nomurabacteria_39_9"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_36_10b"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_RIFCSPLOWO2_01_FULL_OD1_Nomurabacteria_33_24"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPHIGHO2_01_FULL_RIF_OD1_09_41_20"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_GWC2_OD1_42_20"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_CG2_30_FULL_Nomurabacteria_OD1_43_9"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPHIGHO2_01_FULL_RIF_OD1_09_44_41"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_CG1_02_FULL_Nomurabacteria_OD1_43_90"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPLOWO2_01_FULL_RIF_OD1_09_47_33b"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPLOWO2_01_FULL_RIF_OD1_09_43_27"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPHIGHO2_01_FULL_RIF_OD1_09_51_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFOXYC1_FULL_RIF_OD1_09_52_10"",""Bacteria_CPR_Parcubacteria_OD1_Nomurabacteria_CG1_02_FULL_Nomurabacteria_OD1_47_685"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPHIGHO2_02_FULL_RIF_OD1_09_50_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPLOWO2_02_FULL_RIF_OD1_09_54_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPLOWO2_01_FULL_RIF_OD1_09_50_20"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RifOxyC12_full_RIF_OD1_09_46_25"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPHIGHO2_01_FULL_RIF_OD1_09_49_22"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-9_RIFCSPLOWO2_02_FULL_RIF_OD1_09_51_11"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_59_21"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_54_24"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_55_17"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_54_13"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_GWB1_OD1_50_17_partial"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_02_FULL_OD1_Kaiserbacteria_51_13"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_54_11b"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_55_20"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_53_29"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_54_22"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_GWA2_OD1_52_12"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_56_24"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_01_FULL_OD1_56_18"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_53_17"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_55_25"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_49_16"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_12_FULL_OD1_Kaiserbacteria_53_13"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_GWA2_OD1_Kaiserbacteria_50_9"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_55_19"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_55_17"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_57_6"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_54_22"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_52_12b"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_50_68"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFOXYD1_FULL_OD1_Kaiserbacteria_47_14"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_53_31"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_12_FULL_OD1_Kaiserbacteria_56_13"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFOXYD1_FULL_OD1_Kaiserbacteria_42_15"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_12_FULL_OD1_Kaiserbacteria_45_26"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_44_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_01_FULL_RIF16_46_22"",""Bacteria_CPR_Parcubacteria_OD1_L1_Parcubacteria_bacterium_SCGC_AAA040_L21_CrabSpa_001_179"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_12_FULL_OD1_Kaiserbacteria_50_10"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_49_34"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_48_10"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_43_11"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_02_FULL_OD1_Kaiserbacteria_49_11"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPHIGHO2_01_FULL_OD1_Kaiserbacteria_49_13"",""Bacteria_CPR_Parcubacteria_OD1_Kaiserbacteria_RIFCSPLOWO2_01_FULL_OD1_Kaiserbacteria_51_21"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFCSPHIGHO2_01_FULL_OD1_Adlerbacteria_54_23"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFCSPLOWO2_01_FULL_OD1_Adlerbacteria_54_21b"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFOXYC1_FULL_OD1_Adlerbacteria_48_26"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFCSPHIGHO2_12_FULL_OD1_Adlerbacteria_53_18"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFCSPHIGHO2_02_FULL_OD1_Adlerbacteria_52_17"",""Bacteria_CPR_Parcubacteria_OD1_Adlerbacteria_RIFCSPLOWO2_01_FULL_OD1_Adlerbacteria_51_16"",""Bacteria_CPR_Parcubacteria_OD1_Campbellbacteria_GWD2_OD1_35_24"",""Bacteria_CPR_Parcubacteria_OD1_Campbellbacteria_RIFCSPLOWO2_02_FULL_OD1_Campbellbacteria_35_11"",""Bacteria_CPR_Parcubacteria_OD1_Campbellbacteria_RIFOXYC2_FULL_OD1_Campbellbacteria_35_25"",""Bacteria_CPR_Parcubacteria_OD1_Campbellbacteria_RIFCSPLOWO2_02_OD1_Campbellbacteria_35_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPLOWO2_01_FULL_RIF_OD1_10_47_33"",""Bacteria_CPR_Parcubacteria_OD1_GWD1_OD1_44_9_partial"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_49_11_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFOXYD2_FULL_RIF_OD1_10_43_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_01_FULL_RIF15_43_60"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPHIGHO2_02_FULL_RIF_OD1_10_39_16"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPLOWO2_02_FULL_RIF15_44_12b"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_02_FULL_RIF15_43_37"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_01_FULL_RIF15_49_18"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_01_FULL_RIF15_46_25"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_50_10_part"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPHIGHO2_01_FULL_RIF_OD1_10_44_22b"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPLOWO2_02_FULL_RIF15_39_26"",""Bacteria_CPR_Parcubacteria_OD1_GWC2_OD1_40_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPLOWO2_02_RIF15_39_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPHIGHO2_02_FULL_RIF_OD1_10_39_19"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPLOWO2_12_FULL_RIF_OD1_10_39_16"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFOXYD1_FULL_RIF_OD1_10_39_35"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-1_RIFCSPLOWO2_01_FULL_RIF_OD1_10_35_19"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_12_FULL_RIF15_43_12b"",""Bacteria_CPR_Parcubacteria_OD1_RIF15_RIFCSPHIGHO2_12_FULL_RIF15_44_12b"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_47_64"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPLOWO2_02_RIF16_50_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_01_FULL_RIF16_51_15"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_02_FULL_RIF16_47_18"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_47_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_02_FULL_RIF16_43_32b"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_like_47_16"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_44_15_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPLOWO2_02_FULL_RIF16_44_35"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_44_7"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_47_21_part"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_02_FULL_RIF16_45_35"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPLOWO2_12_FULL_RIF16_47_20"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_02_FULL_RIF16_46_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_01_FULL_RIF16_46_22b"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPLOWO2_12_FULL_RIF16_43_20"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPLOWO2_01_FULL_RIF16_45_15b"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_40_21"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFOXYD2_FULL_RIF16_36_9"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_44_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF16_RIFCSPHIGHO2_12_FULL_RIF16_45_16"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD2_FULL_OD1_44_9"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYB1_FULL_OD1_42_16"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD1_FULL_OD1_46_19"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD1_FULL_OD1_44_32"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_51_14"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD2_FULL_OD1_52_8"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_01_FULL_OD1_45_26"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_43_8"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_02_OD1_41_19"",""Bacteria_CPR_Parcubacteria_OD1_GWC2_OD1_40_31"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_41_6_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_42_9"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_39_11"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_12_FULL_OD1_41_13"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_45_48"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPHIGHO2_02_OD1_Giovannonibacteria_43_16"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_12_FULL_OD1_Giovannonibacteria_43_11c"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-2_RIFCSPLOWO2_12_FULL_RIF_OD1_02_44_15"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_01_FULL_OD1_Giovannonibacteria_46_13"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD1_FULL_OD1_48_21"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_GWF2_OD1_42_19"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_GWA2_OD1_53_7_partial"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPHIGHO2_01_FULL_OD1_Giovannonibacteria_45_23"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_01_FULL_OD1_Giovannonibacteria_45_140"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_GWA1_OD1_44_29"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_GWA2_OD1_rel_44_26"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_01_FULL_OD1_Giovannonibacteria_46_32"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_01_FULL_OD1_Giovannonibacteria_44_16"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPLOWO2_12_FULL_OD1_Giovannonibacteria_44_32"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPHIGHO2_02_FULL_OD1_Giovannonibacteria_44_11"",""Bacteria_CPR_Parcubacteria_OD1_Giovannonibacteria_RIFCSPHIGHO2_02_FULL_OD1_Giovannonibacteria_46_20"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPHIGHO2_02_FULL_RIF10_45_17b"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPLOWO2_02_FULL_RIF10_45_11c"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPHIGHO2_02_FULL_RIF10_45_13b"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPHIGHO2_01_FULL_RIF10_48_27"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_47_10b"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPLOWO2_01_FULL_RIF10_48_26"",""Bacteria_CPR_Parcubacteria_OD1_RIF10_RIFCSPLOWO2_01_FULL_RIF10_44_230"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_02_FULL_RIF17_52_23"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_02_FULL_RIF17_53_17"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_01_FULL_RIF17_50_25"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_GWC2_RIF17_49_10"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_45_30"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_02_FULL_RIF17_47_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPLOWO2_12_FULL_RIF17_41_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPLOWO2_01_FULL_RIF17_47_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPLOWO2_02_FULL_RIF17_51_17"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_02_FULL_RIF17_49_20"",""Bacteria_CPR_Parcubacteria_OD1_GWC2_OD1_52_8_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPHIGHO2_02_FULL_RIF17_49_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPLOWO2_01_FULL_RIF17_60_25"",""Bacteria_CPR_Parcubacteria_OD1_RIF17_RIFCSPLOWO2_01_FULL_RIF17_59_16"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_59_11"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_56_20"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_53_13"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_01_FULL_OD1_57_28"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_45_15"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_52_25"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_49_6"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD1_FULL_OD1_36_11"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_12_FULL_OD1_60_15"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_47_11"",""Bacteria_CPR_Parcubacteria_OD1_RBG_13_OD1_48_8"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_02_FULL_OD1_45_11"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_42_13"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_12_FULL_OD1_43_12"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_48_10"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_12_FULL_OD1_44_17"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_GWA2_OD1_ACD81_47_9"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFOXYB1_FULL_OD1_Wolfebacteria_54_12"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_GWE2_OD1_ACD81_44_13"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_CG1_02_FULL_Wolfebacteria_OD1_39_135"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RBG_13_OD1_Wolfebacteria_41_7"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPLOWO2_01_FULL_OD1_Wolfebacteria_38_11"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_GWB1_OD1_41_12"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPLOWO2_01_FULL_OD1_Wolfebacteria_47_17b"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_GWA1_OD1_Wolfebacteria_42_9"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPHIGHO2_12_FULL_OD1_Wolfebacteria_48_16"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPLOWO2_01_FULL_OD1_Wolfebacteria_44_18"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPLOWO2_02_FULL_OD1_Wolfebacteria_41_13b"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPLOWO2_02_FULL_OD1_Wolfebacteria_45_10c"",""Bacteria_CPR_Parcubacteria_OD1_Wolfebacteria_RIFCSPHIGHO2_02_FULL_OD1_Wolfebacteria_42_16"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_40_28"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_45_9"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_RIFCSPHIGHO2_02_FULL_OD1_Jorgensenbacteria_45_20"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_GWA2_OD1_45_13"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_GWB1_OD1_49_9"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_GWB1_OD1_50_10"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_49_17"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_GWA1_OD1_Jorgensenbacteria_54_12"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_RIFCSPLOWO2_01_FULL_OD1_Jorgensenbacteria_45_25b"",""Bacteria_CPR_Parcubacteria_OD1_Jorgensenbacteria_RIFCSPLOWO2_12_FULL_OD1_Jorgensenbacteria_42_11"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_48_18"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_rel_45_10"",""Bacteria_CPR_Parcubacteria_OD1_RIFOXYD1_FULL_OD1_41_16"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_rel_46_8"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_44_31"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_RIFCSPHIGHO2_01_FULL_OD1_Azambacteria_40_24"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_GWA2_OD1_39_10_partial"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_GWA1_OD1_42_19_partial"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_GWE1_OD1"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_RIFCSPLOWO2_02_FULL_OD1_Azambacteria_44_14"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_58_14"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_48_14"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPLOWO2_01_FULL_OD1_Falkowbacteria_40_23"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_44_24"",""Bacteria_CPR_Parcubacteria_OD1_RBG_16_OD1_47_10"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPLOWO2_01_FULL_OD1_46_25"",""Bacteria_CPR_Parcubacteria_OD1_GWD1_OD1_38_16"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_rel_39_18"",""Bacteria_CPR_Parcubacteria_OD1_Azambacteria_GWD2_OD1_46_48"",""Bacteria_CPR_Parcubacteria_OD1_uncultured_DG_74_1"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPLOWO2_01_FULL_RIF21_41_9"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_36_42"",""Bacteria_CPR_Parcubacteria_OD1_uncultured_DG_74_3"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_36_18"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_39_15"",""Bacteria_CPR_Parcubacteria_OD1_L1_Parcubacteria_bacterium_SCGC_AAA255_P19_SAK_001_138"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RBG_13_RIF21_38_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RBG_13_RIF21_42_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFOXYB1_FULL_RIF21_40_15"",""Bacteria_CPR_Parcubacteria_OD1_uncultured_DG_72"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RBG_13_RIF21_37_56"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_38_27"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_12_FULL_RIF21_40_12"",""Bacteria_CPR_Parcubacteria_OD1_GWA1_OD1_36_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RBG_13_RIF21_36_15"",""Bacteria_CPR_Parcubacteria_OD1_GWF2_OD1_rel_43_11_partial"",""Bacteria_unclassified_bacteria_RIFCSPHIGHO2_02_FULL_SM2F11_43_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-7_RIFCSPLOWO2_01_FULL_RIF_OD107_43_32"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_01_FULL_RIF21_47_27"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_01_FULL_RIF21_48_27b"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_49_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_02_FULL_RIF21_45_25"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_02_FULL_RIF21_47_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_01_FULL_RIF21_49_22b"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPHIGHO2_02_FULL_RIF21_48_16"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_RIFCSPLOWO2_01_FULL_RIF21_48_16"",""Bacteria_CPR_Parcubacteria_OD1_RIF21_GWA2_RIF21_46_15"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPHIGHO2_02_FULL_RIF20_34_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPHIGHO2_12_FULL_RIF20_38_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_43_17b"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_33_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPHIGHO2_01_FULL_RIF20_39_25"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_38_12b"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPHIGHO2_02_FULL_RIF20_42_22"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPHIGHO2_02_FULL_RIF20_34_9"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFOXYB1_FULL_RIF20_37_44"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFOXYC1_FULL_RIF20_38_18"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_37_25b"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFOXYB1_FULL_RIF20_38_37"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_37_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_33_9"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFOXYD1_FULL_RIF20_32_13"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_37_13"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_41_26"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_36_21"",""Bacteria_CPR_Parcubacteria_OD1_RIF19_RIFCSPLOWO2_02_FULL_RIF19_38_8"",""Bacteria_CPR_Parcubacteria_OD1_RIF19_RIFCSPLOWO2_12_FULL_RIF19_38_22"",""Bacteria_CPR_Parcubacteria_OD1_RIF19_RIFCSPLOWO2_01_FULL_RIF19_43_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF19_RIFCSPLOWO2_01_FULL_RIF19_46_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF19_RIFCSPHIGHO2_02_FULL_RIF19_43_15b"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RBG_13_RIF22_41_18"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RBG_13_RIF22_40_8"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_40_82"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RIFCSPLOWO2_01_FULL_RIF22_43_11"",""Bacteria_CPR_Parcubacteria_OD1_GWB1_OD1_42_6"",""Bacteria_CPR_Parcubacteria_OD1_GWF2_OD1_rel_44_7_partial"",""Bacteria_CPR_Parcubacteria_OD1_GWF2_OD1_rel_39_13_partial"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_44_18"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RIFCSPLOWO2_01_RIF22_38_39"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RIFCSPHIGHO2_01_FULL_RIF22_40_12b"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_44_65"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_40_25"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_rel_38_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF22_RBG_13_RIF22_37_53"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_39_10"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_39_8b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_38_22b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_41_29"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_44_24"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_41_11"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_43_22"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_43_42"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_01_FULL_OD1_Yanofskybacteria_42_49"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_01_FULL_OD1_Yanofskybacteria_49_17"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_02_FULL_OD1_Yanofskybacteria_47_9b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_02_FULL_OD1_Yanofskybacteria_50_12"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_41_21"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_48_25b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_GWA1_OD1_39_13_partial"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_43_32"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_01_FULL_OD1_Yanofskybacteria_41_34"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_GWC2_OD1_41_9"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_44_22"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_GWD1_OD1_39_16_partial"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_GWF1_OD1_44_227"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_01_FULL_OD1_Yanofskybacteria_44_88"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_02_FULL_OD1_Yanofskybacteria_45_18"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_02_FULL_OD1_Yanofskybacteria_43_10b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_12_FULL_OD1_Yanofskybacteria_45_19b"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPHIGHO2_01_FULL_OD1_Yanofskybacteria_44_17"",""Bacteria_CPR_Parcubacteria_OD1_Yanofskybacteria_RIFCSPLOWO2_01_FULL_OD1_Yanofskybacteria_49_25"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_01_FULL_OD1_40_30"",""Bacteria_CPR_Parcubacteria_OD1_L1_Parcubacteria_bacterium_SCGC_AAA011_A09_DUSEL_001_189"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_31_28_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIFCSPHIGHO2_01_FULL_OD1_47_10b"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_CG2_30_FULL_Moranbacteria_OD1_45_14"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_CG2_30_SUB10_Moranbacteria_OD1_41_165"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFCSPLOWO2_12_FULL_OD1_Moranbacteria_48_12"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFCSPHIGHO2_01_FULL_OD1_Moranbacteria_54_31"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFCSPHIGHO2_01_FULL_OD1_Moranbacteria_55_24"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWF1_OD1_34_10"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWE1_OD1_ACD7_35_17"",""Bacteria_CPR_Parcubacteria_OD1_ALUMROCK_MS4_OD1_33_19"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWD1_OD1_37_17"",""Bacteria_CPR_Parcubacteria_OD1_GWD2_OD1_38_11"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWE2_OD1_36_40"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWC2_OD1_i_37_82"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWC2_OD1_i_45_10"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWE1_OD1_i_ACD11_lin_49_15"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFCSPHIGHO2_12_FULL_OD1_Moranbacteria_40_10"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RifOxyA12_full_OD1_Moranbacteria_44_15"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RifOxyA12_full_OD1_Moranbacteria_35_19"",""Bacteria_CPR_Parcubacteria_OD1_MoranbacteriaOD1_i_GWA2_OD1_39_41"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RBG_19FT_COMBO_OD1_Moranbacteria_42_6"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFOXYC1_FULL_OD1_Moranbacteria_44_13"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RIFOXYB1_FULL_OD1_Moranbacteria_44_23"",""Bacteria_CPR_Parcubacteria_OD1_Moranbacteria_RBG_13_OD1_Moranbacteria_45_13"",""Bacteria_CPR_Parcubacteria_OD1_RIF9_RIFCSPHIGHO2_12_FULL_RIF9_45_11b"",""Bacteria_CPR_Parcubacteria_OD1_RIF9_RIFCSPHIGHO2_01_FULL_RIF9_46_36"",""Bacteria_CPR_Parcubacteria_OD1_RIF9_RIFCSPHIGHO2_02_FULL_RIF9_46_16"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWD2_OD1_43_18"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_CG1_02_FULL_Magasanikbacteria_OD1_41_34"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_02_FULL_OD1_Magasanikbacteria_41_13"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_02_FULL_OD1_Magasanikbacteria_47_14"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYB1_FULL_OD1_Magasanikbacteria_40_15"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_02_FULL_OD1_Magasanikbacteria_33_17"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_02_FULL_OD1_Magasanikbacteria_51_14"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPLOWO2_02_FULL_OD1_Magasanikbacteria_47_16"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYD12_FULL_OD1_Magasanikbacteria_33_17"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RifOxyC12_full_OD1_Magasanikbacteria_33_11"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_CG1_02_FULL_Magasanikbacteria_OD1_32_51"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYC2_FULL_OD1_Magasanikbacteria_39_8"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_56_11"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_12_FULL_OD1_Magasanikbacteria_41_16"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_Parcubacteria_bacterium_SCGC_AAA011_J21_DUSEL_001_191"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPLOWO2_12_FULL_OD1_Magasanikbacteria_43_12"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWC2_OD1_37_14"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYD2_FULL_OD1_Magasanikbacteria_41_14"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYC2_FULL_OD1_Magasanikbacteria_42_28"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYD2_FULL_OD1_Magasanikbacteria_36_9"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYA2_FULL_OD1_Magasanikbacteria_44_8"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_01_FULL_OD1_Magasanikbacteria_47_8"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_50_22_partial"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPLOWO2_02_FULL_OD1_Magasanikbacteria_44_11"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFOXYD1_FULL_OD1_Magasanikbacteria_40_23"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_40_10_partial"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_46_17_plus"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_RIFCSPHIGHO2_02_FULL_OD1_Magasanikbacteria_50_9b"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_02_FULL_OD1_Uhrbacteria_51_9"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_42_32"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWC2_OD1_41_17"",""Bacteria_CPR_Parcubacteria_OD1_Magasanikbacteria_GWA2_OD1_45_39_plus"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWA2_OD1_52_8b"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWF2_OD1_39_13"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFOXYB2_FULL_OD1_Uhrbacteria_45_11"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWF2_OD1_46_218"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFOXYB2_FULL_OD1_Uhrbacteria_41_18"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_01_FULL_OD1_Uhrbacteria_63_20"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFOXYB2_FULL_OD1_Uhrbacteria_57_15"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWA2_OD1_53_10"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWE2_OD1_45_35"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWA2_OD1_41_10"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_56_7_partial"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_02_FULL_OD1_Uhrbacteria_54_11"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWD2_OD1_52_7"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_GWB2_OD1_ACD66_rel_41_36"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_02_FULL_OD1_Uhrbacteria_53_13"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_ACD76"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_58_44"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFOXYC2_FULL_OD1_Uhrbacteria_47_19"",""Bacteria_CPR_Parcubacteria_OD1_uncultured_SG8_24"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_02_FULL_OD1_Uhrbacteria_60_10"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_12_FULL_OD1_Uhrbacteria_60_25"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_47_26"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_02_FULL_OD1_Uhrbacteria_46_25"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPHIGHO2_02_FULL_OD1_Uhrbacteria_57_19"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_02_FULL_OD1_Uhrbacteria_48_12"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_01_FULL_OD1_Uhrbacteria_47_25"",""Bacteria_CPR_Parcubacteria_OD1_Parcubacteria_bacterium_SCGC_AAA011_N16_Dusel_001_262"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_48_51"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_GWF2_OD1_43_32"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_CG1_02_FULL_Falkowbacteria_OD1_37_21"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_CG1_02_FULL_Falkowbacteria_OD1_41_21"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_GWA2_OD1_39_24"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_GWE2_OD1_38_254"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYD2_FULL_OD1_Falkowbacteria_34_120"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYA2_FULL_OD1_Falkowbacteria_47_19"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_Parcubacteria_bacterium_SCGC_AAA036_E14_CrabSpa_001_178"",""Bacteria_CPR_Parcubacteria_OD1_GWC2_OD1_42_12"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPLOWO2_12_FULL_OD1_Falkowbacteria_45_13"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_CG2_30_FULL_Parcubacteria_OD1_45_37"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_CG1_02_FULL_Falkowbacteria_OD1_37_44"",""Bacteria_CPR_Parcubacteria_OD1_GWE2_OD1_38_18"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYA2_FULL_OD1_Falkowbacteria_47_9"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_02_FULL_OD1_Falkowbacteria_45_15"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_02_FULL_OD1_Falkowbacteria_39_17"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPLOWO2_02_FULL_OD1_Falkowbacteria_46_11b"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_01_FULL_OD1_Falkowbacteria_39_8"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_01_FULL_OD1_Falkowbacteria_44_11"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_02_FULL_OD1_Falkowbacteria_56_16"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_01_FULL_OD1_Falkowbacteria_47_11b"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_38_13"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RBG_13_OD1_Falkowbacteria_39_9"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RBG_13_OD1_Falkowbacteria_36_9"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPLOWO2_01_FULL_OD1_Falkowbacteria_39_33"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_40_23"",""Bacteria_CPR_Parcubacteria_OD1_GWC2_OD1_38_7"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYC2_FULL_OD1_Falkowbacteria_48_21"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYC2_FULL_OD1_Falkowbacteria_36_12"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFOXYA2_FULL_OD1_Falkowbacteria_38_12"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RBG_13_OD1_Falkowbacteria_39_14"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPHIGHO2_02_FULL_OD1_Falkowbacteria_39_13"",""Bacteria_CPR_Parcubacteria_OD1_Kuenenbacteria_CG2_30_FULL_Kuenenbacteria_OD1_39_24"",""Bacteria_CPR_Parcubacteria_OD1_Falkowbacteria_RIFCSPLOWO2_12_FULL_OD1_Falkowbacteria_42_13"",""Bacteria_CPR_Parcubacteria_OD1_Kuenenbacteria_CG1_02_FULL_Kuenenbacteria_OD1_38_13"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_02_FULL_OD1_Uhrbacteria_54_37"",""Bacteria_CPR_Parcubacteria_OD1_Uhrbacteria_RIFCSPLOWO2_02_FULL_OD1_Uhrbacteria_49_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFCSPLOWO2_01_FULL_RIF6_45_10"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_43_17_A823"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_37_51"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFOXYC1_FULL_RIF6_37_11"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_36_10"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFCSPLOWO2_01_FULL_RIF6_52_15"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFCSPLOWO2_01_FULL_RIF6_53_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFCSPLOWO2_02_FULL_RIF6_48_11"",""Bacteria_CPR_Parcubacteria_OD1_CG1_02_FULL_Parcubacteria_OD1_41_12"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_46_39_partial"",""Bacteria_CPR_Parcubacteria_OD1_RIF6_RIFOXYC2_FULL_RIF6_42_11"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-2_RIFCSPLOWO2_01_FULL_RIF_OD1_02_44_13"",""Bacteria_CPR_Parcubacteria_OD1_GWA2_OD1_44_12"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-2_RIFOXYD2_FULL_RIF_OD1_02_43_21"",""Bacteria_CPR_Parcubacteria_OD1_RIF-OD1-2_RIFCSPLOWO2_02_FULL_RIF_OD1_02_44_20"",""Bacteria_CPR_Parcubacteria_OD1_Parcubacteria_bacterium_SCGC_AB_164_E21_SAK_001_209"",""Bacteria_CPR_Parcubacteria_OD1_CG2_30_FULL_Parcubacteria_OD1_36_38"",""Bacteria_CPR_Parcubacteria_OD1_RIF4_RIFCSPLOWO2_02_FULL_RIF4_42_19"",""Bacteria_CPR_Parcubacteria_OD1_RIF4_RIFCSPHIGHO2_12_FULL_RIF4_48_17"",""Bacteria_CPR_Parcubacteria_OD1_RIF4_RIFOXYA2_FULL_RIF4_38_24"",""Bacteria_CPR_Parcubacteria_OD1_RIF4_RIFCSPLOWO2_01_FULL_RIF4_48_11"",""Bacteria_SM2F11_RIFCSPHIGHO2_02_FULL_SM2F11_43_13b"",""Bacteria_SM2F11_RIFCSPHIGHO2_12_FULL_SM2F11_48_16"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_45_18"",""Bacteria_SM2F11_RIFCSPHIGHO2_12_FULL_SM2F11_42_22"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_46_24"",""Bacteria_SM2F11_RIFCSPLOWO2_02_FULL_SM2F11_48_13"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_46_14"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_49_9"",""Bacteria_Unclassified_bacteria_GWA2_OD1_rel_51_12"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_SM2F11_52_17"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_43_23"",""Bacteria_SM2F11_RIFCSPHIGHO2_01_FULL_SM2F11_50_11"",""Bacteria_SM2F11_RIFCSPHIGHO2_02_FULL_SM2F11_46_11"",""Bacteria_CPR_PER-ii_RIFCSPHIGHO2_01_FULL_PER_ii_55_13"",""Bacteria_CPR_PER-ii_RIFCSPLOWO2_12_FULL_PER_ii_53_10"",""Bacteria_CPR_PER-ii_RIFCSPHIGHO2_01_FULL_PER_ii_51_35"",""Bacteria_CPR_PER-ii_RIFOXYC2_FULL_CPR_PER-ii_58_32"",""Bacteria_CPR_Peregrinibacteria_CG1_02_FULL_Peregrinibacteria_PER_54_53"",""Bacteria_CPR_PER-ii_GWB1_PER_54_5"",""Bacteria_CPR_PER-ii_RIFOXYD2_FULL_PER_ii_58_15"",""Bacteria_CPR_PER-ii_RIFCSPLOWO2_12_FULL_PER_ii_55_15"",""Bacteria_CPR_PER-ii_RIFCSPHIGHO2_02_FULL_PER_ii_49_16"",""Bacteria_CPR_PER-ii_RIFCSPHIGHO2_01_FULL_PER_ii_51_9"",""Bacteria_CPR_PER-ii_RIFCSPHIGHO2_02_FULL_PER_ii_51_15"",""Bacteria_CP_Peregrinibacteria_ALUMROCK_MS4_Peregrinibacteria_34_52"",""Bacteria_CPR_Peregrinibacteria_RIFOXYC2_FULL_Peregrinibacteria_41_22"",""Bacteria_CPR_PeregrinibacteriaPER_PER_GWF2_43_17"",""Bacteria_CPR_Peregrinibacteria_CG_PER_02"",""Bacteria_CPR_PeregrinibacteriaPER_PER_GWF2_39_17"",""Bacteria_CPR_PeregrinibacteriaPER_GWA2_PER_44_7"",""Bacteria_CPR_Peregrinibacteria_RIFCSPLOWO2_02_FULL_Peregrinibacteria_48_14"",""Bacteria_CPR_Peregrinibacteria_RIFCSPLOWO2_01_FULL_Peregrinibacteria_39_12"",""Bacteria_CP_Peregrinibacteria_BJP_IG2102_PER_44_74_final"",""Bacteria_CPR_PeregrinibacteriaPER_PER_GWC2_39_14"",""Bacteria_CPR_PeregrinibacteriaPER_PER_GWF2_33_10"",""Bacteria_CPR_Peregrinibacteria_RIFOXYB2_FULL_Peregrinibacteria_32_7"",""Bacteria_CPR_Peregrinibacteria_RIFOXYA2_FULL_Peregrinibacteria_33_7"",""Bacteria_GN02_CG1_02_SUB10_Gracilibacteria_GN02_38_174"",""Bacteria_GN02_CG2_30_FULL_Gracilibacteria_GN02_37_12"",""Bacteria_CPR_GracilibacteriaBD1_5_ACD49"",""Bacteria_CP_GN02_candidate_division_GN02_bacterium_JGI_0000069_K10_CrabSpa_001_277"",""Bacteria_CP_GN02_candidate_division_GN02_bacterium_JGI_0000069_P22_CrabSpa_001_278"",""Bacteria_uncultured_bacterium_SCGC_AB_137_L08"",""Bacteria_CP_SR1_candidate_division_SR1_bacterium_taxon_345_1OR1_recoded_II"",""Bacteria_CP_SR1_RAAC1_SR1_1"",""Bacteria_CP_SR1_bacterium_Aalborg_AAW_1"",""Bacteria_CPR_Peregrinibacteria_CG1_02_FULL_Peregrinibacteria_PER_41_10"",""Bacteria_CPR_unclassified_bacteria_RIFCSPHIGHO2_01_FULL_PER_46_8"",""Bacteria_CPR_unclassified_bacteria_RBG_16_CPR_42_10"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharibacteria_Candidatus_TM7_s7_Draft1_Illumina_assembly"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharibacteria_Candidatus_TM7_s1_Draft1_Illumina_assembly"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharibacteria_Candidatus_TM7_SBR2"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharibacteria_Candidatus_TM7_SBR4"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharibacteria_Candidatus_TM7_SBR3"",""Bacteria_CPR_Saccharibacteria_TM7_Candidatus_Saccharimonas_aalborgensis_complete"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_01_FULL_Saccharibacteria_45_15"",""Bacteria_CPR_Saccharibacteria_TM7_GWC2_TM7_44_17_complete"",""Bacteria_CPR_Saccharibacteria_TM7_CG2_30_FULL_Saccharibacteria_TM7_41_52"",""Bacteria_CPR_Saccharibacteria_TM7_BJP_IG2103_TM7_39_1400"",""Bacteria_CPR_Saccharibacteria_TM7_GWC2_TM7_48_9"",""Bacteria_CPR_Saccharibacteria_TM7_RAAC3_TM7_complete"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_42_8"",""Bacteria_CP_TM7_candidate_division_TM7_genomosp._GTL1_unfinished_sequence"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_47_16b"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_47_17"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_48_21"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_49_19"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_12_FULL_Saccharibacteria_41_12"",""Bacteria_CPR_Saccharibacteria_TM7_RIFCSPHIGHO2_02_FULL_Saccharibacteria_47_12"",""Bacteria_CPR_Saccharibacteria_TM7_DOLZORAL124_TM7_51_29"",""Bacteria_CPR2_GWC2_CPR2_39_10"",""Bacteria_CPR2_CG2_30_FULL_CPR2_37_16"",""Bacteria_CPR2_GWD2_CPR2_39_7"",""Bacteria_CPR2_CG2_30_FULL_CPR2_33_46"",""Bacteria_CPR_Berkelbacteria_ACD58_GWA1_Berkelbacteria_36_9_partial"",""Bacteria_CPR_Berkelbacteria_ACD58_GWB1_Berkelbacteria_38_5"",""Bacteria_CPR_Berkelbacteria_ACD58_GWE1_Berkelbacteria_39_12_complete"",""Bacteria_CPR_Berkelbacteria_RBG_13_Berkelbacteria_40_8"",""Bacteria_CPR_Berkelbacteria_ACD58"",""Bacteria_CPR_Berkelbacteria_RIFCSPHIGHO2_12_FULL_Berkelbacteria_36_9"",""Bacteria_CPR_Berkelbacteria_ACD58_GWA2_Berkelbacteria_35_9"",""Bacteria_CPR_Berkelbacteria_CG2_30_FULL_Berkelbacteria_39_44"",""Bacteria_CPR_Berkelbacteria_CG2_30_FULL_Berkelbacteria_43_20"",""Bacteria_CPR_Berkelbacteria_RIFCSPLOWO2_01_FULL_Berkelbacteria_50_28"",""Bacteria_CPR_Berkelbacteria_ACD58_GWA2_ACD58_46_7"",""Bacteria_CPR_Berkelbacteria_CG1_02_FULL_Berkelbacteria_42_45"",""Bacteria_CPR_Berkelbacteria_RIFOXYA2_FULL_Berkelbacteria_43_10"",""Bacteria_CPR_Berkelbacteria_ACD58_GWA2_Berkelbacteria_38_9"",""Bacteria_CPR_Kazan_RIFCSPLOWO2_01_FULL_KAZAN_48_13"",""Bacteria_CPR_Kazan_RBG_13_KAZAN_50_9"",""Bacteria_CPR_Kazan_GWA1_Kazan_rel_44_22_partial"",""Bacteria_CPR_Kazan_RIFCSPLOWO2_01_FULL_KAZAN_45_19"",""Bacteria_CPR_Kazan_GWA1_Kazan_50_15_complete"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWD2_OP11_40_19"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA1_OP11_41_7"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA1_OP11_44_23"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA2_OP11_40_7"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWB1_OP11_45_5_partial"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWB1_OP11_41_10"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFOXYA1_FULL_OP11_Woesebacteria_31_71"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWC2_OP11_47_16"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA2_ACD61_rel_44_33"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_12_FULL_OP11_Woesebacteria_46_16"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFOXYD1_FULL_OP11_Woesebacteria_40_21"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_13_OP11_Woesebacteria_46_13"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_16_OP11_Woesebacteria_42_24"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_12_FULL_OP11_Woesebacteria_42_9"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA1_OP11_45_8_very_partial"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFOXYA1_FULL_OP11_Woesebacteria_43_9"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_16_OP11_Woesebacteria_36_11"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_39_10"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_39_25"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_39_14"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_13_OP11_Woesebacteria_34_9"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_01_FULL_OP11_Woesebacteria_40_22"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_01_FULL_OP11_Woesebacteria_37_10"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_02_FULL_OP11_Woesebacteria_39_13"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_01_FULL_OP11_Woesebacteria_38_26b"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_39_10b"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA1_OP11_Woesebacteria_41_8"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_16_OP11_Woesebacteria_34_12"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RBG_16_OP11_Woesebacteria_39_8b"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWB1_OP11_Woesebacteria_43_5"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_44_24b"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_01_FULL_OP11_Woesebacteria_41_10"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWB1_OP11_43_14"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFOXYB1_FULL_OP11_Woesebacteria_38_16"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPLOWO2_01_FULL_OP11_Woesebacteria_44_14"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWB1_OP11_44_11_partial"",""Bacteria_CPR_Microgenomates_OP11_RIF-OP11-2_RBG_16_RIF_OP11_02_41_13"",""Bacteria_CPR_Microgenomates_OP11_RIF-OP11-2_RIFCSPLOWO2_01_FULL_RIF_OP11_02_39_21"",""Bacteria_CPR_Microgenomates_OP11_RIF-OP11-2_RIFCSPLOWO2_01_FULL_RIF_OP11_02_38_20"",""Bacteria_CPR_Microgenomates_OP11_RIF35_RIFCSPHIGHO2_12_FULL_RIF35_44_25"",""Bacteria_CPR_Microgenomates_OP11_RIF35_RIFCSPHIGHO2_01_FULL_RIF35_43_15b"",""Bacteria_CPR_Microgenomates_OP11_RIF35_RIFCSPLOWO2_01_FULL_RIF35_40_20"",""Bacteria_CPR_Microgenomates_OP11_RIF35_RIFCSPHIGHO2_12_FULL_RIF35_41_13b"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_GWB1_OP11_47_19"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_RIFCSPHIGHO2_12_FULL_OP11_Amesbacteria_48_14"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_GWA1_OP11_47_16"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_RIFOXYB1_FULL_OP11_Amesbacteria_44_23"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_RIFCSPHIGHO2_01_FULL_OP11_Amesbacteria_48_32b"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_RIFCSPHIGHO2_01_FULL_OP11_Amesbacteria_48_32"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_GWC2_OP11_47_8"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_GWB1_OP11_47_26"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_GWA1_OP11_41_13b"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_GWA2_OP11_42_12"",""Bacteria_CPR_Microgenomates_OP11_Amesbacteria_Microgenomates_bacterium_SCGC_AAA011_B20_DUSEL_001_197"",""Bacteria_CPR_Microgenomates_OP11_GWA1_OP11_45_10_partial"",""Bacteria_CPR_Microgenomates_OP11_GWA2_OP11_40_6"",""Bacteria_CPR_Microgenomates_OP11_Shapirobacteria_CG2_30_FULL_Shapirobacteria_OP11_35_20"",""Bacteria_CPR_Microgenomates_OP11_Shapirobacteria_GWF2_OP11_rel_37_20"",""Bacteria_CPR_Microgenomates_OP11_Shapirobacteria_RBG_13_OP11_Shapirobacteria_44_7"",""Bacteria_CPR_Microgenomates_OP11_Shapirobacteria_RIFOXYA1_FULL_OP11_Shapirobacteria_39_17"",""Bacteria_CPR_Microgenomates_OP11_Shapirobacteria_Microgenomates_bacterium_SCGC_AAA255_J07_SAK_001_132"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_RIFOXYC2_FULL_OP11_Collierbacteria_43_15"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_CG1_02_FULL_Collierbacteria_OP11_44_10"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_GWA2_OP11_ACD61_44_13"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_GWA2_OP11_44_99"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_GWB1_OP11_44_6"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_GWA2_OP11_42_17"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_RIFOXYD1_FULL_OP11_Collierbacteria_40_9"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_GWE1_OP11_ACD61_46_18"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_Microgenomates_bacterium_SCGC_AAA011_I21_DUSEL_001_204"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_RIFCSPHIGHO2_01_FULL_OP11_Collierbacteria_50_25"",""Bacteria_CPR_Microgenomates_OP11_Collierbacteria_RIFOXYB1_FULL_OP11_Collierbacteria_49_13"",""Bacteria_CPR_Microgenomates_OP11_GWA2_OP11_46_7"",""Bacteria_CPR_Microgenomates_OP11_GWA2_OP11_46_16_partial"",""Bacteria_CPR_Microgenomates_OP11_GWF1_OP11_46_12"",""Bacteria_CPR_Microgenomates_OP11_GWF2_OP11_47_9"",""Bacteria_CPR_Microgenomates_OP11_Pacebacteria_GWB1_OP11_rel_47_8"",""Bacteria_CPR_Microgenomates_OP11_Pacebacteria_RIFOXYA1_FULL_OP11_Pacebacteria_38_18"",""Bacteria_CPR_Microgenomates_OP11_Pacebacteria_CG2_30_FULL_Pacebacteria_OP11_36_39"",""Bacteria_CPR_Microgenomates_OP11_Pacebacteria_RIFCSPHIGHO2_02_FULL_OP11_Pacebacteria_46_9"",""Bacteria_CPR_Microgenomates_OP11_Pacebacteria_CG1_02_FULL_Pacebacteria_OP11_43_31"",""Bacteria_CPR_Microgenomates_OP11_GWB1_OP11_45_17"",""Bacteria_CPR_Microgenomates_OP11_GWF1_OP11_44_10"",""Bacteria_CPR_Microgenomates_OP11_RIFCSPHIGHO2_01_FULL_OP11_45_11"",""Bacteria_CPR_Microgenomates_OP11_RIFCSPLOWO2_01_FULL_OP11_47_10"",""Bacteria_CPR_Microgenomates_OP11_RBG_16_OP11_45_19"",""Bacteria_CPR_Microgenomates_OP11_RIF36_RIFCSPLOWO2_01_FULL_RIF36_49_14"",""Bacteria_CPR_Microgenomates_OP11_RIF36_RIFCSPLOWO2_01_FULL_RIF36_50_28"",""Bacteria_CPR_Microgenomates_OP11_RIF36_RIFCSPHIGHO2_01_FULL_RIF36_48_12"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_RIFCSPLOWO2_02_FULL_OP11_Beckwithbacteria_47_23"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_CG1_02_FULL_Beckwithbacteria_OP11_47_37"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_CG2_30_FULL_Beckwithbacteria_OP11_44_31"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_GWA2_OP11_43_10"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_GWC1_OP11_49_16_complete"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_RBG_13_OP11_Beckwithbacteria_35_6"",""Bacteria_CPR_Microgenomates_OP11_Beckwithbacteria_RBG_13_OP11_Beckwithbacteria_42_9"",""Bacteria_CPR_Microgenomates_OP11_RBG_19FT_COMBO_OP11_39_10"",""Bacteria_CPR_Microgenomates_OP11_uncultured_DG_75"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_OP11_GWA2_32_13"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_Microgenomates_bacterium_SCGC_AAA011_L05_DUSEL_001_205"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_GWC2_OP11_ACD12_rel_34_23"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_GWC2_OP11P37_13"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_44_13"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_GWA2_OP11_nov_36_23"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_02_FULL_OP11_Roizmanbacteria_38_11"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_12_FULL_OP11_Roizmanbacteria_36_11"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_37_12"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_35_13"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_01_FULL_OP11_Roizmanbacteria_39_12c"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_02_FULL_OP11_Roizmanbacteria_39_9"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_41_22"",""Bacteria_CPR_Parcubacteria_OD1_RIF20_RIFCSPLOWO2_01_FULL_RIF20_38_12"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFOXYB2_FULL_OP11_Roizmanbacteria_38_10"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_CG2_30_FULL_Roizmanbacteria_OP11_33_16"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_12_OP11_Roizmanbacteria_41_18"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_12_FULL_OP11_Roizmanbacteria_33_9"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_02_FULL_OP11_Roizmanbacteria_43_10"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_38_11"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_12_FULL_OP11_Roizmanbacteria_44_10"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_12_FULL_OP11_Roizmanbacteria_37_23"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_01_FULL_OP11_Roizmanbacteria_39_12b"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_02_FULL_OP11_Roizmanbacteria_36_11"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_02_FULL_OP11_Roizmanbacteria_38_10"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPHIGHO2_01_FULL_OP11_Roizmanbacteria_39_24"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFOXYA1_FULL_OP11_Roizmanbacteria_41_12"",""Bacteria_CPR_Microgenomates_OP11_Roizmanbacteria_GWC2_OP11_41_7"",""Bacteria_CPR_Microgenomates_OP11_Roizmannbacteria_RIFCSPLOWO2_01_FULL_OP11_Roizmanbacteria_45_11"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWB1_OP11_49_7"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFOXYB1_FULL_OP11_Gottesmanbacteria_47_11"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RBG_13_OP11_Gottesmanbacteria_45_10"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_46_9"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA1_OP11_48_13"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_01_FULL_OP11_Gottesmanbacteria_46_14"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_43_11b"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_49_10"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RBG_16_OP11_Gottesmanbacteria_43_7"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RBG_16_OP11_Gottesmanbacteria_52_11"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA2_OP11_44_17_partial"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA1_OP11_43_11"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA2_OP11_nov_42_16"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RBG_16_OP11_Gottesmanbacteria_37_8"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_02_FULL_OP11_Gottesmanbacteria_39_14"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_12_FULL_OP11_Gottemanbacteria_40_13"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA2_OP11_43_14"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_42_22"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RBG_13_OP11_Gottesmanbacteria_37_7"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbakteria_CG1_02_FULL_Gottesmanbakteria_OP11_37_22"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_39_12b"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_02_FULL_OP11_Gottesmanbacteria_39_11"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_02_FULL_OP11_Gottesmanbacteria_40_13"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_GWA2_OP11_41_12"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_01_FULL_OP11_Gottesmanbacteria_39_10"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_37_17"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_01_FULL_OP11_Levybacteria_36_13"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RBG_13_OP11_Levybacteria_35_9"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_Microgenomates_bacterium_SCGC_AAA011_E14_DUSEL_001_182"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_GWA2_OP11_nov_40_8"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFOXYB1_FULL_OP11_Levybacteria_40_17"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_01_FULL_OP11_Levybacteria_39_10"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_02_FULL_OP11_Levybacteria_37_11"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RBG_16_OP11_Levybacteria_35_6"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RBG_16_OP11_Levybacteria_35_11"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_01_FULL_OP11_Levybacteria_38_21"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_37_33"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_41_15"",""Bacteria_CPR_Microgenomates_OP11_Woesebacteria_RIFCSPHIGHO2_01_FULL_OP11_Woesebacteria_38_26"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_02_FULL_OP11_Levybacteria_37_13"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_40_16"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_02_FULL_OP11_Levybacteria_37_10"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_02_FULL_OP11_Levybacteria_36_8b"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_12_FULL_OP11_Levybacteria_38_12"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_01_FULL_OP11_Levybacteria_42_15"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_40_15b"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_40_58"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_40_10"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_12_FULL_OP11_Levybacteria_39_17"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_CG2_30_FULL_Levybacteria_OP11_37_29"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPHIGHO2_01_FULL_OP11_Levybacteria_36_15"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPHIGHO2_01_FULL_OP11_Gottesmanbacteria_42_12"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_01_FULL_OP11_Daviesbacteria_40_11"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPLOWO2_01_FULL_OP11_Daviesbacteria_41_32"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_02_FULL_OP11_Curtissbacteria_40_16"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPLOWO2_02_FULL_OP11_Daviesbacteria_36_7"",""Bacteria_CPR_Microgenomates_OP11_Levybacteria_RIFCSPLOWO2_02_FULL_OP11_Levybacteria_36_8"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_02_FULL_OP11_Daviesbacteria_36_13"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_02_FULL_OP11_Daviesbacteria_39_12"",""Bacteria_CPR_Microgenomates_OP11_Gottesmanbacteria_RIFCSPLOWO2_01_FULL_OP11_Gottesmanbacteria_39_12"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPLOWO2_02_FULL_OP11_Daviesbacteria_38_18"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_12_FULL_OP11_Daviesbacteria_37_11"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_12_FULL_OP11_Daviesbacteria_37_16"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_01_FULL_OP11_Daviesbacteria_44_29"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_12_FULL_OP11_Daviesbacteria_43_11"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_GWB1_OP11_41_15"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFCSPHIGHO2_01_FULL_OP11_Daviesbacteria_41_45"",""Bacteria_CPR_Microgenomates_OP11_Daviesbacteria_RIFOXYD1_FULL_OP11_Daviesbacteria_41_10"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_GWA1_OP11_41_11_plus"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPLOWO2_02_FULL_OP11_Curtissbacteria_40_11"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RBG_13_OP11_Curtissbacteria_35_7"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPLOWO2_01_FULL_OP11_Curtissbacteria_38_11b"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPLOWO2_01_FULL_OP11_Curtissbacteria_42_26"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPLOWO2_01_FULL_OP11_Curtissbacteria_41_18"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_Microgenomates_bacterium_SCGC_AAA011_L6_Dusel_001_266"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_GWA1_OP11_40_9_partial"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_GWA1_OP11_40_16_partial"",""Bacteria_CPR_Microgenomates_OP11_RBG_13_OP11_40_7"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_12_FULL_OP11_Curtissbacteria_38_9b"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_12_FULL_OP11_Curtissbacteria_41_17"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_GWA1_OP11_40_24_partial"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_02_FULL_OP11_Curtissbacteria_42_15"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPLOWO2_02_OP11_Curtissbacteria_41_11"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_GWA1_OP11_40_47"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_01_FULL_OP11_Curtissbacteria_41_44"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RIFCSPHIGHO2_01_FULL_OP11_Curtissbacteria_41_11"",""Bacteria_CPR_Microgenomates_OP11_Curtissbacteria_RBG_16_OP11_Curtissbacteria_39_7"",""Bacteria_CPR_Microgenomates_OP11_RBG_16_OP11_43_9"",""Bacteria_CPR_Microgenomates_OP11_RBG_19FT_COMBO_OP11_43_10"",""Bacteria_CPR_Microgenomates_OP11_RBG_13_OP11_40_15"",""Bacteria_CPR_Microgenomates_OP11_RBG_16_OP11_44_10"",""Bacteria_CPR_Microgenomates_OP11_GWB1_OP11_45_5"",""Bacteria_CPR_Microgenomates_OP11_RIFCSPLOWO2_01_FULL_OP11_41_12"",""Bacteria_CPR_Microgenomates_OP11_RBG_16_OP11_39_9b"",""Bacteria_CPR_Microgenomates_OP11_RIFCSPHIGHO2_12_FULL_OP11_45_10"",""Bacteria_CPR_Microgenomates_OP11_RBG_13_OP11_40_7b"",""Bacteria_CPR_Microgenomates_OP11_RIFCSPLOWO2_01_FULL_OP11_43_14"",""Bacteria_CPR_WWE3_RIFOXYD1_FULL_WWE3_43_17"",""Bacteria_CPR_WWE3_GWB1_WWE3_42_6"",""Bacteria_CPR_WWE3_RIFOXYC1_FULL_WWE3_42_17"",""Bacteria_CPR_WWE3_RIFOXYD2_FULL_WWE3_43_10"",""Bacteria_CPR_WWE3_RAAC2_WWE3_complete"",""Bacteria_CPR_WWE3_RIFOXYA2_FULL_WWE3_46_9"",""Bacteria_CPR_WWE3_RIFOXYD1_FULL_WWE3_39_9"",""Bacteria_CPR_WWE3_RBG_13_WWE3_37_7"",""Bacteria_CPR_WWE3_RIFCSPLOWO2_01_FULL_WWE3_37_15"",""Bacteria_CPR_WWE3_RBG_16_WWE3_37_10"",""Bacteria_CPR_WWE3_RIFCSPHIGHO2_12_FULL_WWE3_38_15"",""Bacteria_CPR_WWE3_GWB1_WWE3_41_6"",""Bacteria_CPR_WWE3_RBG_19FT_COMBO_WWE3_34_6"",""Bacteria_CPR_WWE3_GWA2_WWE3_46_9"",""Bacteria_CPR_WWE3_GWA2_WWE3_44_16"",""Bacteria_CPR_WWE3_RIFCSPHIGHO2_01_FULL_WWE3_42_13"",""Bacteria_CPR_WWE3_RIFCSPLOWO2_12_FULL_WWE3_36_10"",""Bacteria_CPR_WWE3_RIFCSPHIGHO2_01_FULL_WWE3_40_23"",""Bacteria_CPR_WWE3_CG2_30_FULL_WWE3_related_40_12"",""Bacteria_CPR_WWE3_RIFCSPHIGHO2_01_FULL_WWE3_35_17"",""Bacteria_CPR_WWE3_RIFCSPLOWO2_01_FULL_WWE3_39_13"",""Bacteria_CPR_WWE3_RIFCSPLOWO2_01_FULL_WWE3_42_11"",""Bacteria_CPR_WWE3_CSP1_7"",""Bacteria_CPR_WWE3_RIFCSPLOWO2_01_FULL_WWE3_53_14"",""Bacteria_CPR_WWE3_RBG_19FT_COMBO_WWE3_53_11"",""Bacteria_CPR_WWE3_RIFCSPHIGHO2_01_FULL_WWE3_48_15"",""Bacteria_CPR_CPR3_CG1_02_FULL_CPR3_42_9"",""Bacteria_CPR_CPR3_GWF2_CPR3_35_18"",""Bacteria_CPR_CPR1_GWA2_CPR1_42_17"",""Bacteria_CPR_Dojkabacteria_WS6_GWE1_WS6_34_7"",""Bacteria_CPR_Dojkabacteria_WS6_RIFOXYB1_FULL_WS6_33_14"",""Bacteria_CPR_Dojkabacteria_WS6_RIFOXYB1_FULL_WS6_33_15"",""Bacteria_CPR_Dojkabacteria_WS6_BJP_IG2158_WS6_35_49"",""Bacteria_CPR_Dojkabacteria_WS6_GWC2_WS6_36_7"",""Bacteria_CPR_Dojkabacteria_WS6_GWF1_WS6_35_23_partial"",""Bacteria_CPR_Dojkabacteria_WS6_GWA2_WS6_37_6"",""Bacteria_Wirthbacteria_CG2_30_FULL_Wirthbacteria_54_11"") + } + else { + TOLoutgroup.labels<-c(""Neurospora_crassa"",""Microsporum_canis"",""Uncinocarpus_reesii"",""Trichophyton_rubrum"",""Basipetospora_chlamydospora"",""Coccidioides_posadasii"",""Paracoccidioides_brasiliensis"",""Trichoderma_reesei"",""Coccidioides_immitis"",""Histoplasma_capsulatum"",""Talaromyces_occitanis"",""Talaromyces_marneffei"") + } + }) + + ## display proper citation based on associated manuscript + output$TOLcitationText <- renderText({ + if (input$TOLphyloSelect == ""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"") { + paste(""If you use this subtree, please cite: Steenwyk et al. 2019, mBio: 10.1128/mBio.00925-19"") + } else if (input$TOLphyloSelect == ""Tree of life, 3,083 taxa - Hug et al. 2016"") { + paste(""If you use this subtree, please cite: Hug et al. 2016, Nature Microbiology. doi: 10.1038/nmicrobiol.2016.48"") + } else + paste(""If you use this subtree, please cite: Steenwyk et al. 2019, mBio: 10.1128/mBio.00925-19"") + }) + + ## display table of taxa names + TOLtipNames <- eventReactive(input$TOLgo, { + a<-data.frame(TOLtree()$tip.label) + # replace column name to ""full list of taxa"" + colnames(a)[1]<-""full list of taxa for possible subtree"" + # return to df_subset + return(a) + }) + output$TOLtaxaTable <- renderTable(TOLtipNames()) + + ## function to create plot + output$TOLphyloPlot <- renderPlot({ + # root tree + tree<-root(TOLtree(), outgroup = TOLoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(TOLdata()$V1) + outgroup.labels<-setdiff(TOLoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + }) + + ## save pdf + output$TOLTreePlot<- downloadHandler( + #Specify The File Name + filename = function() { + paste(""treehouse-"",Sys.Date(),"".pdf"",sep= """")}, + content = function(file){ + # open the pdf + pdf(file) + # root tree + tree<-root(TOLtree(), outgroup = TOLoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(TOLdata()$V1) + outgroup.labels<-setdiff(TOLoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + dev.off() + } + ) + + ## write treefile + output$TOLNewick<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(TOLtree(), outgroup = TOLoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(TOLdata()$V1) + outgroup.labels<-setdiff(TOLoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ## write treefile + output$TOLNewickNOBL<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + # root tree + tree<-root(TOLtree(), outgroup = TOLoutgroup.labels(), resolve.root = TRUE) + # drop outgroup tips not in ingroup.labels + ingroup.labels<-as.vector(TOLdata()$V1) + outgroup.labels<-setdiff(TOLoutgroup.labels(),ingroup.labels) + tree<-drop.tip(tree, outgroup.labels) + # prune taxa not of interest + pruned.tree<-try(drop.tip(tree,tree$tip.label[-match(ingroup.labels, tree$tip.label)]), silent=TRUE) + if(""try-error"" %in% class(pruned.tree)) stop(""\nlist of tip names does not match names in phylogeny. Please check tip names again. A full list of tip names is available below\n\nR error:only 0's may be mixed with negative subscripts"") + # plot tree + p<-try(plotTree(pruned.tree)) + if(""try-error"" %in% class(p)) p<-plot.phylo(pruned.tree) + p + # write tree file out + pruned.tree$edge.length<-NULL + write.tree(pruned.tree, file=file) + } + ) + + ### USERTREE + ## read in file reactively + userData <- eventReactive(input$userGO, { + req(input$fileUser) + inFile <- input$fileUser + taxa.list<-read.table(inFile$datapath) + return(taxa.list) + }) + + ## read in tree based on selected tree + userTree <- eventReactive(input$userGO, { + req(input$treeFile) + inFile <- input$treeFile + userTree <- read.tree(inFile$datapath) + }) + + ## display table of taxa names + USERtipNames <- eventReactive(input$userGO, { + a<-data.frame(userTree()$tip.label) + # replace column name to ""full list of taxa"" + colnames(a)[1]<-""full list of taxa for possible subtree"" + # return to df_subset + return(a) + }) + output$USERtaxaTable <- renderTable(USERtipNames()) + + ## function to create plot + output$userPhyloPlot <- renderPlot({ + # prune taxa not of interest + ingroup.labels<-as.vector(userData()$V1) + pruned.tree<-drop.tip(userTree(),userTree()$tip.label[-match(ingroup.labels, userTree()$tip.label)]) + # plot tree + plotTree(pruned.tree) + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + }) + + ## save pdf + output$userTreePlot<- downloadHandler( + #Specify The File Name + filename = function() { + paste(""treehouse-"",Sys.Date(),"".pdf"",sep= """")}, + content = function(file){ + # open the pdf + pdf(file) + # prune taxa not of interest + ingroup.labels<-as.vector(userData()$V1) + pruned.tree<-drop.tip(userTree(),userTree()$tip.label[-match(ingroup.labels, userTree()$tip.label)]) + # plot tree + plotTree(pruned.tree) + add.scale.bar(cex = 0.7, font = 2, col = ""black"") + dev.off() + } + ) + + ## write treefile + output$userNewick<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + ingroup.labels<-as.vector(userData()$V1) + pruned.tree<-drop.tip(userTree(),userTree()$tip.label[-match(ingroup.labels, userTree()$tip.label)]) + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + + ## write treefile + output$userNewickNOBL<- downloadHandler( + # Specify the file name + filename=function() { + paste(""treehouse-"",Sys.Date(),"".tre"",sep= """")}, + content=function(file){ + ingroup.labels<-as.vector(userData()$V1) + pruned.tree<-drop.tip(userTree(),userTree()$tip.label[-match(ingroup.labels, userTree()$tip.label)]) + pruned.tree$edge.length<-NULL + # write tree file out + write.tree(pruned.tree, file=file) + } + ) + +}) +","R" +"Pathogens","JLSteenwyk/treehouse","ui.R",".R","10823","245","library(shiny) + +# Define UI for application +shinyUI(fluidPage( + navbarPage("""", + # open userTree + tabPanel(""userTree"", + # display logo + titlePanel(title=div(img(src=""treehouse_logo.png"",""""))), + hr(), + # Create a spot for the choices + sidebarLayout( + sidebarPanel( + # input file + fileInput(""treeFile"", ""Tree input:""), + # input file + fileInput(""fileUser"", ""Taxa input:""), + # reactive button + actionButton(""userGO"", ""Update""), + hr(), + # user instructions + h5(""Quick Start""), + p(""1) Upload a phylogeny you want a subtree from in Tree input:'""), + p(""2) Upload a single column text file with species names of desired taxa in subtree.""), + p(""If you are unsure of what taxa names are used in the phylogeny, click the Update button and see the 'full list of taxa for possible subtree'""), + p(""3) Press the update button to display your desired subtree""), + p(""4) Download the figure as a pdf or a newick tree using the buttons below the phylogeny""), + hr(), + helpText(""treehouse is developed and maintained by "", a(""Jacob L. Steenwyk"",href=""https://jlsteenwyk.github.io/"")) + ), + + # plot phylogeny in main panel + mainPanel( + plotOutput(""userPhyloPlot"", width = ""100%""), + # download buttons + downloadButton(outputId = ""userTreePlot"", label = ""Download Plot""), + downloadButton(outputId = ""userNewick"", label = ""Download Newick File""), + downloadButton(outputId = ""userNewickNOBL"", label = ""Download Newick File (w/out branch lengths)""), + hr(), + tableOutput('USERtaxaTable') + # close mainPanel + ) + # close sidebarLayout + ) + # close tabPanel, userTree + ), + tabPanel(""Animal"", + # display logo + titlePanel(title=div(img(src=""treehouse_logo.png"",""""))), + hr(), + # Create a spot for the choices + sidebarLayout( + sidebarPanel( + # drop down select menu to select phylogeny + selectInput(""ANIMALphyloSelect"", ""Phylogeny:"", + choices=c(""Birds, 198 taxa - Prum et al. 2015"", + ""Birds, 48 taxa - Jarvis et al. 2014"", + ""Insects, 144 taxa - Misof et al. 2014"", + ""Mammals, 37 taxa - Song et al. 2016"", + ""Mammals, 36 taxa - Tarver et al. 2016"", + ""Metazoans, 36 taxa - Borowiec et al. 2015"", + ""Metazoans, 70 taxa - Whelan et al. 2015"", + ""Vertebrates, 58 taxa - Chen et al. 2015"", + ""Worms, 100 taxa - Struck et al. 2015"") + ), + # input file + fileInput(""ANIMALfile"", ""File input:""), + # reactive button + actionButton(""ANIMALgo"", ""Update""), + hr(), + # user instructions + h5(""Quick Start""), + p(""1) Select a phylogeny you want a subtree from""), + p(""2) Upload a single column text file with species names of desired taxa in subtree.""), + p(""If you are unsure of what taxa names are used in the phylogeny, click the Update button and see the 'full list of taxa for possible subtree'""), + p(""3) Press the update button to display your desired subtree""), + p(""4) Download the figure as a pdf or a newick tree using the buttons below the phylogeny""), + hr(), + helpText(""treehouse is developed and maintained by "", a(""Jacob L. Steenwyk"",href=""https://jlsteenwyk.github.io/"")) + ), + + # plot phylogeny in main panel + mainPanel( + plotOutput(""ANIMALphyloPlot"", width = ""100%""), + # download buttons + downloadButton(outputId = ""ANIMALTreePlot"", label = ""Download Plot""), + downloadButton(outputId = ""ANIMALNewick"", label = ""Download Newick File""), + downloadButton(outputId = ""ANIMALNewickNOBL"", label = ""Download Newick File (w/out branch lengths)""), + hr(), + textOutput(""ANIMALcitationText""), + hr(), + tableOutput('ANIMALtaxaTable') + # close mainPanel + ) + # close sidebarLayout + ) + # close tabPanel, Animal + ), + tabPanel(""Fungi"", + # display logo + titlePanel(title=div(img(src=""treehouse_logo.png"",""""))), + hr(), + # Create a spot for the choices + sidebarLayout( + sidebarPanel( + # drop down select menu to select phylogeny + selectInput(""FUNGIphyloSelect"", ""Phylogeny:"", + choices=c(""Aspergillus and Penicillium, 81 taxa - Steenwyk et al. 2019"", + ""Cryptococcus neoformans, 387 strains - Desjardins et al. 2017"", + ""Fungi, 214 taxa - James et al. 2006"", + ""Fungi, 60 taxa - Nagy et al. 2014"", + ""Agaricomycetes, 5,284 taxa - Varga et al. 2019"", + ""Saccharomyces cerevisiae, 1,011 strains - Peter et al. 2018"", + ""Saccharomycotina, 86 taxa - Shen et al. 2016"", + ""Saccharomycotina, 332 taxa - Shen et al. 2018"", + ""Ascomycota, 1,113 taxa - Shen et al. 2020"") + ), + # input file + fileInput(""FUNGIfile"", ""File input:""), + # reactive button + actionButton(""FUNGIgo"", ""Update""), + hr(), + # user instructions + h5(""Quick Start""), + p(""1) Select a phylogeny you want a subtree from""), + p(""2) Upload a single column text file with species names of desired taxa in subtree.""), + p(""If you are unsure of what taxa names are used in the phylogeny, click the Update button and see the 'full list of taxa for possible subtree'""), + p(""3) Press the update button to display your desired subtree""), + p(""4) Download the figure as a pdf or a newick tree using the buttons below the phylogeny""), + hr(), + helpText(""treehouse is developed and maintained by "", a(""Jacob L. Steenwyk"",href=""https://jlsteenwyk.github.io/"")) + ), + + # plot phylogeny in main panel + mainPanel( + plotOutput(""FUNGIphyloPlot"", width = ""100%""), + # download buttons + downloadButton(outputId = ""FUNGITreePlot"", label = ""Download Plot""), + downloadButton(outputId = ""FUNGINewick"", label = ""Download Newick File""), + downloadButton(outputId = ""FUNGINewickNOBL"", label = ""Download Newick File (w/out branch lengths)""), + hr(), + textOutput(""FUNGIcitationText""), + hr(), + tableOutput('FUNGItaxaTable') + # close mainPanel + ) + # close sidebarLayout + ) + # close tabPanel, Fungi + ), + tabPanel(""Plant"", + # display logo + titlePanel(title=div(img(src=""treehouse_logo.png"",""""))), + hr(), + # Create a spot for the choices + sidebarLayout( + sidebarPanel( + # drop down select menu to select phylogeny + selectInput(""PLANTphyloSelect"", ""Phylogeny:"", + choices=c(""Caryophyllales, 95 taxa - Yang et al. 2015"", + ""Flowering plants, 45 taxa - Xi et al. 2014"", + ""Land plants, 103 taxa - Wickett et al. 2014"") + ), + # input file + fileInput(""PLANTfile"", ""File input:""), + # reactive button + actionButton(""PLANTgo"", ""Update""), + hr(), + # user instructions + h5(""Quick Start""), + p(""1) Select a phylogeny you want a subtree from""), + p(""2) Upload a single column text file with species names of desired taxa in subtree.""), + p(""If you are unsure of what taxa names are used in the phylogeny, click the Update button and see the 'full list of taxa for possible subtree'""), + p(""3) Press the update button to display your desired subtree""), + p(""4) Download the figure as a pdf or a newick tree using the buttons below the phylogeny""), + hr(), + helpText(""treehouse is developed and maintained by "", a(""Jacob L. Steenwyk"",href=""https://jlsteenwyk.github.io/"")) + ), + + # plot phylogeny in main panel + mainPanel( + plotOutput(""PLANTphyloPlot"", width = ""100%""), + # download buttons + downloadButton(outputId = ""PLANTTreePlot"", label = ""Download Plot""), + downloadButton(outputId = ""PLANTNewick"", label = ""Download Newick File""), + downloadButton(outputId = ""PLANTNewickNOBL"", label = ""Download Newick File (w/out branch lengths)""), + hr(), + textOutput(""PLANTcitationText""), + hr(), + tableOutput('PLANTtaxaTable') + # close mainPanel + ) + # close sidebarLayout + ) + # close tabPanel, Plant + ), + tabPanel(""Tree of Life"", + # display logo + titlePanel(title=div(img(src=""treehouse_logo.png"",""""))), + hr(), + # Create a spot for the choices + sidebarLayout( + sidebarPanel( + # drop down select menu to select phylogeny + selectInput(""TOLphyloSelect"", ""Phylogeny:"", + choices=c(""Tree of life, 3,083 taxa - Hug et al. 2016"") + ), + # input file + fileInput(""TOLfile"", ""File input:""), + # reactive button + actionButton(""TOLgo"", ""Update""), + hr(), + # user instructions + h5(""Quick Start""), + p(""1) Select a phylogeny you want a subtree from""), + p(""2) Upload a single column text file with species names of desired taxa in subtree.""), + p(""If you are unsure of what taxa names are used in the phylogeny, click the Update button and see the 'full list of taxa for possible subtree'""), + p(""3) Press the update button to display your desired subtree""), + p(""4) Download the figure as a pdf or a newick tree using the buttons below the phylogeny""), + hr(), + helpText(""treehouse is developed and maintained by "", a(""Jacob L. Steenwyk"",href=""https://jlsteenwyk.github.io/"")) + ), + + # plot phylogeny in main panel + mainPanel( + plotOutput(""TOLphyloPlot"", width = ""100%""), + # download buttons + downloadButton(outputId = ""TOLTreePlot"", label = ""Download Plot""), + downloadButton(outputId = ""TOLNewick"", label = ""Download Newick File""), + downloadButton(outputId = ""TOLNewickNOBL"", label = ""Download Newick File (w/out branch lengths)""), + hr(), + textOutput(""TOLcitationText""), + hr(), + tableOutput('TOLtaxaTable') + # close mainPanel + ) + # close sidebarLayout + ) + # close tabPanel, Plant + ) + # close navbarPage + ) +# close shinyUI and fliudPage +)) +","R" +"Pathogens","emvolz-phylodynamics/mlesky","R/package.R",".R","540","16","#' @name mlesky +#' @title mlesky: Maximum likelihood estimation of effective population size through time, growth rates, and phylodynamic regressions +#' +#' @description mlesky is a R package to perform Maximum likelihood estimation of effective population size through time, growth rates, and phylodynamic regressions. +#' +#' @author Erik Volz \email{erik.volz@gmail.com} +#' +#' @seealso https://github.com/emvolz-phylodynamics/mlesky +#' +#' @import stats +#' @import graphics +#' @import ape +#' @import utils +#' @importFrom methods hasArg +NULL +","R" +"Pathogens","emvolz-phylodynamics/mlesky","R/mlesky.R",".R","27232","812","# derive timeseries of coalescent and ltt along appropriate time axis +.tre2df <- function( apephylo, tre, res, maxHeight = Inf, minLTT = 1, adapt_time_axis = F, sampleTimes = NULL ){ + n <- ape::Ntip( apephylo ) + if (is.null( minLTT)) + minLTT <- floor( n / 5 ) + + + if ( inherits( tre, c('multiPhylo','list') ) ){ + phys <- lapply( tre, function(tr) {class(tr) <- 'phylo'; tr } ) + stopifnot( !is.null( sampleTimes )) + rts <- sapply( phys, function( phy ) { + mdepth <- max( node.depth.edgelength( phy ) ) + mst <- max( sampleTimes [ phy$tip.label ] ) + mst - mdepth + }) + mst = max( sampleTimes ) + sts <- sampleTimes - min( rts ) + rhs = mst - rts + rh = max( rhs ) + maxHeight <- min( rh, maxHeight ) + shs = rh - sts + inhs_list <- lapply( 1:length(phys), function(k){ + phy <- phys[[k]] + rh = rhs[k] + ndel <- ape::node.depth.edgelength( phy ) + sort( rh - ndel[ (Ntip(phy)+1):(Ntip(phy) + phy$Nnode) ] ) + }) + inhs <- sort( do.call( c, inhs_list ) ) + }else{ + stopifnot( inherits (tre, c('phylo','treedater') )) + D <- ape::node.depth.edgelength( apephylo ) + rh <- max( D[1:n] ) + rhs = rh # for compatibility with multitree version + sts <- D[1:n] + maxHeight <- min( rh, maxHeight ) + + shs <- rh - sts + inhs <- sort( rh - D[ (n+1):(n + apephylo$Nnode) ] ) + } + + u_shs <- unique( shs ) + u_inhs <- unique( inhs ) + nnode <- sum( inhs <= maxHeight) + + ne_haxis <- seq( maxHeight/res ,maxHeight*(1-1/res), le = res-1 ) + if (adapt_time_axis){ + ne_haxis <- approx( seq(0,1,length.out=nnode), inhs[inhs <= maxHeight], xout = seq(1/res, 1-1/res, length.out = res-1 ) )$y + } + dh_ne <- diff( c(0, ne_haxis, maxHeight ) ) + + #< h , event, ltt(descending), intervallength, nco, likterm, ne_bin > + tredat <- data.frame( h= c( u_shs, u_inhs, ne_haxis) + , type = c( rep('sample', length( u_shs)) + , rep('node', length(u_inhs)) + , rep('neswitch', length(ne_haxis)) + ) + ) + tredat <- tredat[ tredat$h <= maxHeight , ] + + tredat$ne_bin <- sapply( tredat$h, function(x) sum( ne_haxis < x ) + 1) + + ltt.h <- function(h) max(1, sum( shs <= h ) - sum( inhs < h ) - sum( rhs < h ) ) # note <= for samples + tredat$ltt <- sapply( tredat$h, ltt.h ) + + tredat$nco <- 0 + tredat$nco[ tredat$type=='node' ] <- sapply( tredat$h[ tredat$type=='node' ], function(x) sum( x == inhs )) + + tredat <- tredat[ order( tredat$h ), ] + tredat$intervalLength <- c( 0, diff( tredat$h )) + tredat$ltt_terms <- tredat$ltt * (tredat$ltt-1) / 2 + + # combine ne bins: + done <- ( minLTT == 1 ) + while(!done){ + done <- TRUE + bin2maxltt <- sapply( 1:res, function( bin ){ + i = which( tredat$ne_bin == bin ) + if (length(i) > 0) + return( max( tredat$ltt[ i ] ) ) + -Inf + }) + for (i in 1:nrow(tredat)){ + if ( bin2maxltt[ tredat$ne_bin[i] ] < minLTT ){ + tredat$ne_bin[i] <- max( 1, tredat$ne_bin[i] - 1 ) + done <- FALSE + } + } + } + + tredat$dh <- dh_ne[ tredat$ne_bin ] + tredat +} + +#' Heuristic selection of grid resolution. Selects res based on +#' reduction in MSE of coalescent times relative to nearest grid point. +#' @param tree A dated phylogeny in ape::phylo format +#' @param th Precision parameter +#' @export +suggest_res <- function(tree, th = .001 ) +{ + ct = tail( ape::node.depth.edgelength( tree ) , ape::Nnode( tree )) + rct = range(ct) + k <- 1 + x <- seq( rct[1], rct[2], length = k + 2 ) + l0 <- sum( apply( sapply( ct, function(y) (y - x)^2 ), MARGIN = 2, FUN = min ) ) + ll <- l0 + repeat{ + k <- k + 1 + x <- seq( rct[1], rct[2], length = k + 2 ) + l <- sum( apply( sapply( ct, function(y) (y - x)^2 ), MARGIN = 2, FUN = min ) ) + #print( c( k, l, x )) + if ( (l < (th*l0)) | (ll<=l) ) break + #if ( ((ll - l ) / l) < th ) break + ll <- l + } + k <- k - 1 + k +} + + +#' Optimize the skygrid time axis resolution using AIC criterion +#' +#' @param tree A dated phylogeny in ape::phylo format +#' @param res A vector of time axis resolution parameters to test +#' @param ncpu Integer number of cores to use with parallel processing +#' @param ... Remaining parameters are passed to mlskygrid +#' @export +optim_res_aic <- function(tree, res = c(1,3,5, seq(10, 100, by = 10)), ncpu = 1, ... ) +{ + res2aic <- function(r){ + ll1 <- mlskygrid( tree, res = r, ncpu =ncpu, ...)$loglik + 2 * r - 2 * ll1 + } + aics <- unlist( pbmcapply::pbmclapply( res, res2aic, mc.cores = ncpu ) ) + res[ which.min( aics )] +} + +#' Optimize the skygrid time axis resolution using BIC criterion +#' +#' @param tree A dated phylogeny in ape::phylo format +#' @param res A vector of time axis resolution parameters to test +#' @param ncpu Integer number of cores to use with parallel processing +#' @param ... Remaining parameters are passed to mlskygrid +#' @export +optim_res_bic <- function(tree, res = c(1:5, seq(10, 100, by = 10)), ncpu = 1, ... ) +{ + res2bic <- function(r){ + ll1 <- mlskygrid( tree, res = r, ncpu =ncpu, ...)$loglik + r * log(tree$Nnode) - 2 * ll1 + } + bics <- unlist( pbmcapply::pbmclapply( res, res2bic, mc.cores = ncpu ) ) + res[ which.min( bics )] +} + + + +roughness_penalty <- function(x,dh,tau,b=NULL,model=1, responsevar = 'logNe'){ + logne <- rev( x ) + y=0 + B <- rep( 1, length( logne )) + if (!is.null(b)) { + if ( responsevar == 'logNe' ){ + B <- b + } else if (responsevar == 'diffLogNe' ){ + B <- cumsum(b) + } else if (responsevar == 'diffDiffLogNe' ){ + B <- cumsum( cumsum( b )) + } + } + + if (model==1) {#skykappa model + dh2 <- dh[ -c(1, length(dh)) ] + y <- diff(diff( B)) + rp_terms=dnorm(diff(diff( logne)), y, sd = sqrt(dh2/tau), log = TRUE) + #plot( b[-1], diff( logne )) + } + + if (model==2) {#skygrid model + dh2 <- dh[ -1 ] + y <- diff ( B ) + rp_terms=dnorm(diff(logne), y, sd = sqrt(dh2/tau), log = TRUE) + } + + if (model==3) { # skygrowth model + dh2 <- dh[ -c(1, length(dh)) ] + rhos=diff(exp(logne))/exp(logne[-length(logne)]) + y <- diff( diff(exp(B))/exp(B[-length(B)]) ) + rp_terms=dnorm( diff(rhos), y, sd = sqrt(dh2/tau), log = TRUE) + } + rv = sum(rp_terms) + rv +} + +#This function calculates the cross-validation score for a given tau +.mlskygrid_oos <- function( tau, tredat, ne0, res = 50, maxHeight = Inf, quiet = TRUE, control = NULL, ncross = 5, ncpu = 1,model=1 +, cvtype = 'interweaved' ){ +#~ , cvtype = 'segmented' ){ + if ( ncross < 2 ) stop('*ncross* must be at least two') + + ne=ne0 #ne <- rlnorm( res , log( ne0 ), .2 ) # add some jitter + + if ( cvtype == 'interweaved' ){ + cvsets = lapply( 1:ncross, function(icross) seq( icross, nrow(tredat), by = ncross ) ) + } else if ( cvtype == 'segmented' ) { + cvbounds <- cbind( + seq( 1/nrow(tredat), 1-1/ncross , length = ncross ) + , seq( 1/ncross, 1 , length = ncross ) + ) * nrow(tredat) + cvbounds[,1] <- ceiling( cvbounds[,1] ) + cvbounds[,2] <- floor( cvbounds[,2] ) + cvsets <- lapply( 1:ncross, function(icross){ + cvbounds[icross,1]:cvbounds[icross,2] + }) + } else{ + stop('Incorrect cvtype') + } + + dh <- sapply( 1:res, function(i) tredat$dh[ which(tredat$ne_bin==i)[1]] ) + + lterms <- function(logne) + { + ne <- exp( logne ) + sterms <- with(tredat, { + -intervalLength * ltt_terms / ne [ ne_bin ] + }) + coterms <- with(tredat, { + nco * ( log( ltt_terms ) - logne[ ne_bin ] ) + }) + coterms[ is.na(coterms)] <- 0 + coterms + sterms + } + + of.cv.oos <- function(logne, icross ){ + sum( lterms( logne )[ cvsets[[icross]] ] ) + } + + of.cv.ws <- function(logne, icross){ + i = setdiff(1:nrow(tredat) , cvsets[[icross]] ) + sum( lterms( logne )[ i ] ) + roughness_penalty( logne,dh,tau,model = model ) + } + + fits <- pbmcapply::pbmclapply( 1:ncross, function(icross){ + optim( par = log(ne), fn = of.cv.ws + , method = 'BFGS' + , control = list( trace = ifelse( quiet ,0, 1), fnscale = -1 ) + , hessian = FALSE + , icross = icross + ) + }, mc.cores = ncpu ) + oos_perfs <- sapply( 1:ncross, function(i){ + logne = fits[[i]]$par + of.cv.oos( logne, i ) + }) + sum( oos_perfs ) +} + +.bind_tres <- function(tres, sts){ + phys <- lapply( tres, function(tr) {class(tr) <- 'phylo'; tr } ) + rts <- sapply( phys, function( phy ) { + mdepth <- max( node.depth.edgelength( phy ) ) + mst <- max( sts [ phy$tip.label ] ) + mst - mdepth + }) + minrt <- min( rts ) + maxrt <- max( rts ) + rels <- rts - minrt + 1e-3 + phys <- lapply( 1:length(phys), function(k) { + phy <- phys[[k]] + phy$root.edge <- rels[k]; phy + }) + + .phy <- phys[[1]] + for ( k in 2:length( phys )){ + #.phy <- bind.tree( .phy , phys[[k]] ) + .phy <- .phy + phys[[k]] + } + multi2di( .phy ) +} + + +#' Maximum likelihood non-parametric estimation of effective population size through time +#' +#' +#' +#' @param tre A dated phylogeny in ape::phylo or treedater format (see documentation for ape). This can also be a multiPhylo or list of trees, in which case each is treated as a clade sampled from within the same population. In this case the sampleTimes vector should be supplied so that clades can be aligned in time. +#' @param sampleTimes An optional named vector of sample times for each taxon. Names should correspond to tip labels in trees. This is required if providing a list of trees or covariates. +#' @param res Length of time axis over which to estimate Ne(t) (integer). If NULL, will heuristically search for a good value +#' @param tau Precision parameter. Larger values generate smoother trajectories of Ne(t). If NULL, will optimize using cross-validation. +#' @param tau_lower Lower bound for precision parameter if estimating +#' @param tau_upper Upper bound for precision parameter if estimating +#' @param tau_tol Optimization tolerance when optimizing tau by cross-validation +#' @param ncross Number of folds in cross-validation +#' @param ncpu If doing cross-validation, each fold will be handled in parallel if ncpu > 1 (see parallel package) +#' @param quiet Provide verbose output from optimizer? +#' @param NeStartTimeBeforePresent If .ne + .ne[ .ne == 0 ] <- NA + ne0 <- median( .ne, na.rm=T) + ne0<-rep(ne0,res);ne<-ne0#ne <- rlnorm( res , log( ne0 ), .2 ) # add some jitter + } else{ + if ( length(ne0)==1){ + ne0 <- rep( ne0, res ) + } + ne = ne0 + } + + + # if covariates + ncovar <- 0 + covar.df <- NA + responsevar <- 'logNe' # response if using covariates + betanames <- c() + if (!is.null( formula )){ + stopifnot( !is.null(sampleTimes) ) + stopifnot( !is.null(data) ) + + # do an initial fit without covars to serve as initial condition + fit0 <- mlskygrid(tre + , sampleTimes = sampleTimes + , res = res + , tau = tau + , tau_lower = tau_lower + , tau_upper = tau_upper + , tau_tol = tau_tol + , ncross = ncross + , ncpu = ncpu + , quiet = quiet + , NeStartTimeBeforePresent = NeStartTimeBeforePresent + , ne0 = ne0 + , adapt_time_axis = adapt_time_axis + , model = model + , formula = NULL + , data = NULL + ) + + v <- all.vars( formula ) + if ( !(v[1] %in% c('logNe', 'diffLogNe', 'diffDiffLogNe' ) )) { + stop( ""Left hand side must be one of 'logNe', 'diffLogNe', or 'diffDiffLogNe' "" ) + } + responsevar = v[1] + + data$logNe <- 1 + data$diffLogNe <- 0 + data$diff2LogNe <- 0 + X0 <- as.data.frame( model.matrix( formula , data ) ) + betanames <- colnames( X0 )#[-1] # not counting intercept? + ncovar = length( betanames ) + X0 <- cbind( time = data$time + , X0 ) + covar.df <- data.frame( time =fit0$time #[-c(1,length(fit0$time))] + , logNe = log(fit0$ne) #[-c(1,length(fit0$time))] + , diffLogNe = c( NA, diff( log ( fit0$ne )) ) + , diffDiffLogNe = c( NA, diff( diff ( log ( fit0$ne ))), NA ) + ) + for ( bn in betanames ){ + itime <- setdiff( order( X0$time ), which(is.na( X0[[bn]] )) ) + + covar.df[[bn]] <- approx( X0$time[itime] , X0[[bn]][itime], xout = covar.df$time,rule = 2)$y + } + covar.df <- covar.df[ order( covar.df$time) , ] + lmfit <- lm ( formula + , data = covar.df + ) + + beta0 <- coef(lmfit) + tau = fit0$tau + ne0 = fit0$ne + beta2zxb <- function( beta ){ + if ( length( betanames ) > 1 ){ + zedCrossBeta <- as.vector( as.matrix(covar.df[, betanames]) %*% beta ) + } else{ + zedCrossBeta <- covar.df[, betanames] * beta + } + zedCrossBeta # NOTE logne is in reverse order in optimizer but this is in forward order + } + } + + dh <- sapply( 1:res, function(i) tredat$dh[ which(tredat$ne_bin==i)[1]] ) + + # estimate tau + tauof <- function(tau){ + .mlskygrid_oos( tau, tredat, ne0, res =res, maxHeight = NeStartTimeBeforePresent, ncross = ncross, ncpu = ncpu,quiet=quiet,model=model) + } + if (is.null(tau) && res>=3){ + message('Precision parameter *tau* not provided. Computing now....') + taustar <- optimize( tauof, lower = tau_lower, upper = tau_upper, maximum = TRUE , tol = tau_tol) + tau = taustar$maximum + message( paste( 'Precision parameter tau = ', tau ) ) + } + #/estimate tau + + lterms <- function(logne) + { + ne <- exp( logne ) + sterms <- with(tredat, { + -intervalLength * ltt_terms / ne [ ne_bin ] + }) + coterms <- with(tredat, { + nco * ( log( ltt_terms ) - logne[ ne_bin ] ) + }) + coterms[ is.na(coterms)] <- 0 + coterms + sterms + } + + of <- function( theta ){ + if (ncovar == 0) b = NULL else b = tail( theta , ncovar ) + logne = head( theta, length(theta) - ncovar ) + lt = sum(lterms( logne)) + .beta2zxb <- NULL + if ( ncovar > 0 ){ + .beta2zxb = beta2zxb(b) + } + rp = roughness_penalty(logne, dh, tau, b=.beta2zxb, model=model, responsevar = responsevar ) + lt + rp + } + + theta0 <- log( ne ) + if (ncovar > 0 ){ + theta0 <- c( theta0, beta0 ) + } + parscale = rep(1, length( theta0 )) + if ( ncovar > 0 ){ + parscale = c( rep(1, length(ne)), abs(beta0) / abs(median(log(ne)) ) ) + parscale[ parscale<=0 ] <- 1 + } + optim( par = theta0, fn = of + , method = 'BFGS' + , control = list( trace = ifelse(quiet, 0, 1) + , fnscale = -1 + , parscale = parscale + ) + , hessian = F + ) -> fit + + + + # output + # note reverse axis + theta <- fit$par + + # disabling Fisher approx CI's + #~ H <- -fit$hessian + #~ if ( ncovar > 0 ) + #~ H <- solve( -fit$hessian[ !(rownames(fit$hessian)%in%betanames), !(rownames(fit$hessian)%in%betanames) ] ) + #~ fi <- tryCatch( H, error = function(e) { + #~ warning('Hessian could not be computed. Will not compute CIs.') + #~ NA + #~ }) + fi <- NA + fsigma <- if (!any(is.na(fi))) { + sqrt( diag( fi ) ) + } else{ + rep( NA, length( theta ) - ncovar ) + } + logne = theta + beta = NULL + if ( ncovar > 0 ){ + logne <- head( theta , length( theta ) - ncovar ) + beta <- tail( theta, ncovar ) + } + # reverse + fsigma_ne <- rev( fsigma ) + logne <- rev( logne ) + ne <- exp( logne ) + nelb <- exp( logne - fsigma_ne*1.96 ) + neub <- exp( logne + fsigma_ne*1.96 ) + ne_ci <- cbind( nelb, ne, neub ) + + loglik = of ( fit$par ) - roughness_penalty ( fit$par,dh,tau,model=model, responsevar = responsevar ) + + mst = ifelse( is.null(sampleTimes), 0, max(sampleTimes) ) + + h2 <- -c( sort( -tredat$h[ tredat$type == 'neswitch' ] ) , 0) + time <- h2 - diff( c(max(tredat$h), h2) )/2 + time <- mst - time + growthrate = c( diff( logne ) / diff( time ), NA ) + rv <- list( + ne = ne + , ne_ci = ne_ci + , growthrate = growthrate + , tau = tau + , time = time + , tredat = tredat + , tre = tre + , sigma = fsigma_ne + , fsigma = fsigma + , optim = fit + , loglik = loglik + , lterms = lterms( theta ) + , sampleTimes = sampleTimes + , beta = beta + , covar.df = covar.df + # other inputs: + , model = model + , res = res + , tau_tol = tau_tol + , ncross = ncross + , quiet = quiet + , NeStartTimeBeforePresent = NeStartTimeBeforePresent + , ne0 = ne0 + , adapt_time_axis = adapt_time_axis + , formula = formula + , data = data + ) + class(rv) <- 'mlskygrid' + rv +} + +#' Parametric bootstrap for Ne and regression coefficients. +#' +#' This will simulate coalescent trees conditional on the provided mlesky estimate of Ne. +#' The model is refitted to each coalescent tree to provide an estimate of the standard error of Ne estimates over time. +#' +#' @param fit mlesky fit +#' @param nrep Number of simulations +#' @param ncpu Number of CPUs +#' @param dd Whether or not to use dd simulation method. Default is false for ntip<=500 and true otherwise +#' @return A fitted mlesky model with updated confidence intervals for Ne and regression coefficients +#' @export +parboot <- function( fit, nrep = 200 , ncpu = 1, dd) +{ + if (missing(dd)) { + if (Ntip(fit$tre)<=500) dd=F else dd=T + } + if ( fit$adapt_time_axis ) + stop( 'parboot not supported with adapt_time_axis==TRUE' ) + af <- approxfun( fit$time, fit$ne, rule = 2) + sts <- fit$sampleTimes + if ( is.null( fit$sampleTimes )){ + sts <- ape::node.depth.edgelength( fit$tre )[ 1:ape::Ntip(fit$tre) ] + sts = sts-max(sts) + names(sts)=fit$tre$tip.label + } + message('Simulating coalescent trees for parametric bootstrap: ') + res = pbmcapply::pbmclapply( 1:nrep, function(irep){ + if (dd==T) + tr = ddSimCoal( sts, alphaFun = af, guessRootTime = min( c(min(sts), min(fit$time)) ) ) + else + tr = simCoal( sts, alphaFun = af) + f1 <- mlskygrid( tr + , sampleTimes = sts + , res = fit$res + , tau = fit$tau + , tau_tol = fit$tau_tol + , ncross = fit$ncross + , quiet = fit$quiet + , NeStartTimeBeforePresent = fit$NeStartTimeBeforePresent + , ne0 = median( fit$ne ) #note + , adapt_time_axis = FALSE #note re-use time axis + , formula = fit$formula + , data = fit$data + , ncpu = 1 #note, 1 b/c not optimising res or tau + , model = fit$model + ) + list( ne = f1$ne, beta = f1$beta, growthrate = f1$growthrate ) + } , mc.cores = ncpu) + nemat <- do.call( cbind, lapply( res, '[[', 'ne' ) ) + lognesd <- apply( log( nemat ), MARGIN=1, sd ) + fit$ne_ci <- cbind( + nelb= exp( log(fit$ne) - 1.96 * lognesd ) + , ne = fit$ne + , neub = exp( log(fit$ne) + 1.96 * lognesd ) + ) +#~ fit$ne_ci <- cbind( +#~ nelb= apply( nemat, MARGIN=1, function(x) quantile(x, prob=.025) ) +#~ , ne = fit$ne +#~ , neub = apply( nemat, MARGIN=1, function(x) quantile(x, prob=.975) ) +#~ ) + grmat <- do.call( cbind, lapply( res, '[[', 'growthrate' ) ) + grsd <- apply( grmat, MARGIN=1, sd ) + fit$growthrate_ci <- cbind( + grlb= fit$growthrate - 1.96 * grsd + , gr = fit$growthrate + , grub = fit$growthrate + 1.96 * grsd + ) + if ( !is.null( fit$beta )) + { + betamat <- do.call( cbind, lapply( res, '[[', 'beta' ) ) + fit$beta_ci <- cbind( + betalb= apply( betamat, MARGIN = 1 , FUN=function(x) quantile(x, prob=.025 ) ) + , beta = fit$beta + , betaub = apply( betamat, MARGIN = 1 , FUN=function(x) quantile(x, prob=.975 ) ) + ) + } + fit +} + +#' Bootstrap for Ne and regression coefficients +#' +#' The trees provided to this function can be based on a non-parametric bootstrap such as produced by IQ-TREE or PhyML. +#' Confidence intervals for Ne are based on a normal approximation to the bootstrap distribution at each time point. +#' +#' @param fit mlesky fitted object (mlskygrid class) +#' @param trees list of trees or ape::multiPhylo object +#' @param ncpu Number of CPUs to use for parallel computation +#' @return A list of fitted mlesky models (length equal to the number of trees provided) with confidence intervals for Ne and regression coefficients +#' @export +boot <- function( fit, trees, ncpu = 1) { + stopifnot(inherits(fit, 'mlskygrid')) + stopifnot(inherits(trees, c('multiPhylo','list'))) + all_tips_equal = sapply(1:length(trees), function(x) identical(sort(fit$tre$tip.label), sort(trees[[x]]$tip.label))) + stopifnot(all(all_tips_equal)) + + sts = fit$sampleTimes + if ( is.null( trees[[1]]$sampleTimes )){ + sts = ape::node.depth.edgelength( trees[[1]] )[ 1:ape::Ntip(trees[[1]]) ] + } + names(sts) = fit$tre$tip.label + + message('Calculating mlesky fits for the input trees:') + taxis <- fit$time + res = pbmcapply::pbmclapply( 1:length(trees), function(irep){ + f1 <- mlskygrid( trees[[irep]], sampleTimes = sts, res = fit$res, + tau = fit$tau, tau_tol = fit$tau_tol , ncross = fit$ncross, + quiet = fit$quiet, NeStartTimeBeforePresent = fit$NeStartTimeBeforePresent , + ne0 = median( fit$ne ), adapt_time_axis = FALSE, formula = fit$formula, + data = fit$data, ncpu = ncpu, model = fit$model ) + af <- approxfun( f1$time, f1$ne, rule = 2) + afgr <- approxfun( f1$time, f1$growthrate , rule =2) + list(ne = af(taxis), beta = f1$beta, growthrate = afgr(taxis) ) + }, mc.cores = ncpu) + + nemat <- do.call( cbind, lapply( res, '[[', 'ne' ) ) + grmat <- do.call( cbind, lapply( res, '[[', 'growthrate' )) + + fit$ne_ci <- cbind( + nelb = unname( apply( nemat, 1, FUN = function(x) quantile(x, c(.025))) ) + , ne = unname( apply( nemat, 1, FUN = function(x) quantile(x, c(.50))) ) + , neub = unname( apply( nemat, 1, FUN = function(x) quantile(x, c(.975))) ) + ) + + fit$growthrate_ci <- cbind( + grlb = unname( apply( grmat, 1, FUN = function(x) quantile(x, c(.025))) ) + , gr = unname( apply( grmat, 1, FUN = function(x) quantile(x, c(.50))) ) + , grub = unname( apply( grmat, 1, FUN = function(x) quantile(x, c(.975))) ) + ) + + if ( !is.null( fit$beta )) + { + betamat <- do.call( cbind, lapply( res, '[[', 'beta' ) ) + fit$beta_ci <- cbind( + betalb= apply( betamat, MARGIN = 1 , FUN=function(x) quantile(x, prob=.025 ) ) + , beta = apply( betamat, MARGIN = 1 , FUN=function(x) quantile(x, prob=.50 ) ) + , betaub = apply( betamat, MARGIN = 1 , FUN=function(x) quantile(x, prob=.975 ) ) + ) + } + + fit +} + + +############## +.neplot <- function( fit, ggplot=TRUE, logy = TRUE , ... ) +{ + nemed <- nelb <- neub <- NULL + stopifnot(inherits(fit, ""mlskygrid"")) + + if (length(fit$ne)==1) {#This is in case res=1 + fit$ne=rep(fit$ne,2) + fit$ne_ci=rbind(fit$ne_ci,fit$ne_ci) + fit$time=rep(fit$time,2) + } + + #if (!is.null(fit$sampleTimes)) { + # root_time <- max(fit$sampleTimes)-max(fit$tredat$h) + # fit$time <- fit$time - ( min(fit$time) - root_time ) + #} + + ne <- fit$ne_ci + if ( 'ggplot2' %in% installed.packages()[,1] & ggplot) + { + pldf <- data.frame( t = fit$time, nelb = ne[,1], nemed = ne[,2], neub = ne[,3] ) + pl <- ggplot2::ggplot( pldf, ggplot2::aes( x = t, y = nemed), ... ) + ggplot2::geom_line() + ggplot2::geom_ribbon( ggplot2::aes( ymin = nelb, ymax = neub), fill = 'blue', alpha = .2) + ggplot2::ylab('Effective population size') + ggplot2::xlab('Time before most recent sample') + if (logy) pl <- pl + ggplot2::scale_y_log10() + return(pl) + } else{ + if (!hasArg('ylim')) ylim=range(ne[,1:3],na.rm=T) else ylim=list(...)$ylim + args=list(x=fit$time,y=ne[,2],ylim=ylim,lwd =2, col = 'black', type = 'l', xlab='Time', ylab='Effective population size') + if (logy) args=modifyList(args,list(log='y')) + args=modifyList(args,list(...)) + do.call(plot,args) + lines( fit$time, ne[,1] , lty=3) + lines( fit$time, ne[,3] , lty=3) + invisible(fit) + } +} + +.growthplot <- function( fit , ggplot=TRUE, logy=FALSE, ...) +{ + gr<-NULL + stopifnot(inherits(fit, ""mlskygrid"")) + dateLastSample=0 + if ( 'ggplot2' %in% installed.packages() & ggplot) + { + pldf <- data.frame( t = dateLastSample+fit$time, gr = fit$growthrate) + pl <- ggplot2::ggplot( pldf, ggplot2::aes( x = t, y = gr), ... ) + ggplot2::geom_line() + ggplot2::ylab('Growth rate') + ggplot2::xlab('Time before most recent sample') + if (logy) pl <- pl + ggplot2::scale_y_log10() + return(pl) + } else{ + if (logy) + plot( dateLastSample+fit$time, fit$growthrate, lwd =2, col = 'black', type = 'l', log='y', xlab='Time', ylab='Growth rate',...) + else + plot( dateLastSample+fit$time, fit$growthrate, lwd =2, col = 'black', type = 'l', xlab='Time', ylab='Growth rate', ...) + + invisible(fit) + } +} + + +#' Plot mlskygrid +#' +#' @param x A fitted object +#' @param growth If TRUE will plot estimated growth rate instead of Ne(t) +#' @param logy If TRUE, the plot is returned with logarithmic y-axis (default is TRUE for Ne plot and FALSE for growth plot) +#' @param ggplot If TRUE, returns a ggplot2 figure +#' @param ... Additional parameters are passed to ggplot or the base plotting function +#' @return Plotted object +#' @export +plot.mlskygrid <- function(x, growth=FALSE, ggplot=FALSE,logy, ... ){ + if (growth) { + if (missing(logy)) logy=FALSE + return(.growthplot(x, ggplot, logy, ... )) + } else{ + if (missing(logy)) logy=TRUE + return(.neplot(x, ggplot, logy, ... )) + } +} + +#' Print fitted mlskygrid +#' +#' @param x Fitted mlskygrid object +#' @param ... Additional parameters are passed on +#' @export +print.mlskygrid <- function( x,... ){ + stopifnot(inherits(x, ""mlskygrid"")) + d <- as.data.frame( x$ne_ci ) + d <- cbind( x$time, d ) + if ( is.null ( x$sampleTimes )){ + colnames( d ) <- c( 'Time before most recent sample', '2.5%', 'MLE', '97.5%' ) + } else { + colnames( d ) <- c( 'Time', '2.5%', 'MLE', '97.5%' ) + } + cat(paste( 'mlskygrid fit + Smoothing parameter tau =', x$tau, '\n\n')) + + cat( 'Estimated Ne(t): \n') + print ( d,... ) + invisible( x ) +} +","R" +"Pathogens","emvolz-phylodynamics/mlesky","R/simulate.R",".R","7134","228","#' Simulation of coalescent dated phylogeny +#' @param dates Sampling dates +#' @param alphaFun Population size function Ne(t) +#' @param alphaMin Minimum value of alphaFun +#' @return A simulated dated phylogeny +#' @export +simCoal = function(dates=1990:2010,alphaFun=function(x){return(10)},alphaMin=NA) { + if (is.na(alphaMin)) alphaMin=optimize(alphaFun,c(-1e5,max(dates)))$objective + ind <- order( dates, decreasing=TRUE ) + tim <- dates [ ind ] #s <- sort(dates,decreasing=TRUE,index.return = TRUE) + n <- length(tim) + nodes <- cbind(-Inf,ind[1],-Inf)#Start with one node at time -Inf and with the first isolate connected to it + i <- 2 + while (i <= n) {#Graft branches one by one + curt <- tim[i]#Current time:start with date of isolate and go back in time until coalescence happens + accept=F + while (accept==F) { + r <- -log(runif(1)) * alphaMin + fi <- which( nodes[ ,1] < curt )[1] + if (fi<=nrow(nodes)) for (j in (fi:nrow(nodes))) { + if (r > (curt-nodes[j,1]) * (i-j)) { + r <- r-(curt-nodes[j,1]) * (i-j) + curt <- nodes[j,1] + } else { + curt <- curt-r/(i-j)#Proposed coalescent time + break + } + } + #Filtering the Poisson process to obtain non-homogeneous Poisson + if (runif(1)= j + n] <- a[a >= j + n] + 1 + nodes[ ,2:3] <- a#Renumbering according to table insertion in next line + nodes2=c(curt,ind[i],0) + if (1<=j-1) nodes2=rbind(nodes[1:(j-1), ],nodes2) + if (j<=nrow(nodes)) nodes2=rbind(nodes2,nodes[j:nrow(nodes),]) + nodes=unname(nodes2) + #Now choose on which branch to coalesce among the branches alive at date curt + no <- j + side <- 2 + w <- 1 + floor(runif(1) * (nrow(nodes)-j)) + while (w > 0) { + no <- no + side-1 + side <- 3-side + if (nodes[no,side + 1] <= n ||(nodes[no,side + 1] > n && nodes[nodes[no,side + 1]-n,1] > curt)) { + w <- w-1 + } + } + nodes[j,3] <- nodes[no,side + 1] + nodes[no,side + 1] <- n + j + i <- i + 1 + } + v=nrow(nodes)-1 + if (nrow(nodes)>2) v=c(v,1:(nrow(nodes)-2)) + nodes=nodes[v,,drop=F] + m=nodes[,2:3] + m[which(m>n)]=m[which(m>n)]+1 + nodes[,2:3]=m + nodes <- rbind(matrix(0, nrow = n, ncol = 3),nodes) + nodes[1:n,1] <- dates + + #Convert into phylo object from package ape + t=list() + t$Nnode=n-1 + t$tip.label=as.character(1:n) + if (!is.null( names(dates ))) + t$tip.label <- names(dates) + t$edge=matrix(NA,2*n-2,2) + t$edge.length=rep(NA,n*2-2) + t$root.time=nodes[n+1,1] + c=1 + for (i in (n+1):nrow(nodes)) for (j in 2:3) { + t$edge[c,1]=i + t$edge[c,2]=nodes[i,j] + t$edge.length[c]=nodes[nodes[i,j],1]-nodes[i,1] + c=c+1 + } + class(t)='phylo' + return(t) +} + +.solve_A <- function(dates=1990:2010 + , alphaFun=function(x){return(10)} + , guessRootTime = 1950 + , res = 1e3) +{ + mst <- max(dates) + stopifnot( guessRootTime <= min(dates) ) + dco <- function( t, y, parms ){ + cumco <- y['cumco'] + A <- max( 1 , y['A'] ) + x = mst - t # t is on reverse time axis + ne <- alphaFun( x ) + stopifnot( ne > 0 ) + list( c( + cumco = unname( A * (A-1) / ne / 2 ) + , A = unname( -A * (A-1) / ne / 2 ) + ) ) + } + eventdf <- data.frame( + var = 'A' + , time = sort( mst - dates ) + , value = 1 + , method = 'add' + ) + y0 <- c( cumco = 0 , A = 0 ) + taxis <- seq( 0, mst - guessRootTime , length = res ) + o = suppressWarnings( deSolve::ode( dco, times = taxis, y = y0 , parms = NULL, method = 'lsoda', events = list( data = eventdf ) )) + o +} + + +#' Simulation of coalescent dated phylogeny using deterministic/'sideways' distribution of coalescent times +#' @param dates Sampling dates +#' @param alphaFun Population size function Ne(t) +#' @param res Time axis resolution +#' @param guessRootTime Optional (but recommended) guess for when root may be reached. +#' @param A_tol Tolerance for reaching time of root >0 +#' @return A simulated dated phylogeny +#' @export +ddSimCoal <- function(dates=1990:2010,alphaFun=function(x){return(10)}, guessRootTime = NA, res = 1e3, A_tol = 1e-2) { + mst <- max(dates ) + if ( is.na( guessRootTime )){ + guessRootTime = min(dates) - 2 * diff(range(dates))#alphaFun( min( dates )) + } + A1 <- Inf + while( (A1 - 1) > A_tol ){ + o <- suppressWarnings( .solve_A(dates=dates, alphaFun = alphaFun, guessRootTime = guessRootTime, res = res) ) + A1 <- tail( o[, 'A'], 1) + h1 <- tail( o[, 'time'], 1) + if ( A1 < 3 ) + h2 <- h1 + A1 * alphaFun( mst - h1 ) + else + h2 <- h1 + 2 * diff( range(dates)) + guessRootTime <- mst - h2 + } + n <- length(dates) + treedf1 <- data.frame( + node = 1:n + , type = 'sample' + , height = mst - dates + , dA = 1 + , stringsAsFactors = FALSE + + ) + tcofun <- suppressWarnings( approxfun( + x = o[,'cumco'] + , y = o[, 'time'] ) ) + tco <- suppressWarnings( tcofun ( runif(n-1 , 0, tail(o[,'cumco'],1) ) ) ) + treedf2 <- data.frame( + node = (n+1):(n+n-1) + , type = 'coalescent' + , height = sort( tco , decreasing=TRUE ) + , dA = -1 + , stringsAsFactors = FALSE + + ) + treedf <- rbind( treedf1, treedf2 ) + treedf <- treedf[ order( treedf$height ) , ] + treedf$A <- cumsum( treedf$dA ) + # resampling to fix any negative branch lengths + wresample <- which( treedf$A <= 1 & treedf$dA < 0 ) + while( length( wresample ) > 0 ){ + treedf$height[wresample] <- suppressWarnings( tcofun ( runif( length( wresample ) , 0, tail(o[,'cumco'],1) ) ) ) + treedf <- treedf[ order( treedf$height ) , ] + treedf$A <- cumsum( treedf$dA ) + wresample <- which( treedf$A <= 0 & treedf$dA < 0 ) + } + nonbl <- Inf + + edge <- matrix( NA, nrow = 2*n-2 , ncol = 2 ) + edge.length <- rep( NA, 2*n-2) + tip.label = names(dates); if (is.null( names(dates))) tip.label <- as.character(1:n) + Nnode = n -1 + + k <- 1 + extant <- c() + for ( i in 1:nrow( treedf )){ + if ( treedf$type[i] == 'sample' ){ + extant <- c( extant , treedf$node[i] ) + } else if ( treedf$type[i] == 'coalescent' ){ + uv = sample( extant, size = 2, replace=FALSE) + u = uv[1]; v = uv[2] + + edge[k,1] <- treedf$node[i] + edge[k,2] <- u + edge.length[k] <- treedf$height[i] - treedf$height[treedf$node==u] + k <- k + 1 + edge[k,1] <- treedf$node[i] + edge[k,2] <- v + edge.length[k] <- treedf$height[i] - treedf$height[treedf$node==v] + k <- k +1 + + extant <- c( extant, treedf$node[i] ) + extant <- setdiff( extant, uv ) + } + } + .trd = list( edge = edge, edge.length = edge.length, Nnode = Nnode + , tip.label = tip.label + , treedf = treedf) + tr = structure( .trd + , class = 'phylo' ) + ape::read.tree( text = ape::write.tree( tr ) ) +} + + + +#' Plot a dated phylogeny and alpha function +#' @param tree Dated phylogeny +#' @param alphaFun Population size function Ne(t) +#' @return Figure +#' @export +plotBoth = function(tree,alphaFun) { + oldpar <- par(no.readonly = TRUE) + on.exit(par(oldpar)) + par(mfrow=c(2,1),mar=c(4,4,1,4)) + plot(tree,show.tip.label = F) + axisPhylo(1,backward = F) + if (!is.null(tree$root.time)) from=tree$root.time else from=-max(dist.nodes(tree)[Ntip(tree)+1,]) + to=from+max(dist.nodes(tree)[Ntip(tree)+1,]) + xs=seq(from=from,to=to,length.out=100) + ys=xs + for (i in 1:length(ys)) ys[i]=alphaFun(ys[i]) + plot(xs,ys,type='l',xlab='',ylab='Effective population size', bty='l',ylim=c(0,1.05*max(ys))) +} +","R" +"Pathogens","phylogeography/spread","start_all_components.sh",".sh","1129","38","#!/bin/bash + +set -evx + +# tmux kill-session -t spread + +# start dockerized components +tmux new-session -s spread -d 'source env/dev; bash -i'; +tmux send-keys -t ""spread:0"" 'docker-compose -f deployments/dev/docker-compose.yml up' Enter; + +# start worker thread +tmux new-window -t ""spread:1""; +tmux send-keys -t ""spread:1"" 'source env/dev' Enter; +tmux send-keys -t ""spread:1"" 'clj -A:run-worker' Enter; + +# start API +# NOTE: api needs three more ENV vars exported for the login to work properly +# PRIVATE_KEY_DEV, GOOGLE_CLIENT_SECRET and SENDGRID_API_KEY +# which are NOT under source version control for security reasons +# ask for them before running the software locally +tmux new-window -t ""spread:2""; +tmux send-keys -t ""spread:2"" 'source env/dev' Enter; +tmux send-keys -t ""spread:2"" 'clj -A:run-api' Enter; + +# start frontend +tmux new-window -t ""spread:3""; +tmux send-keys -t ""spread:3"" 'source env/dev' Enter; +tmux send-keys -t ""spread:3"" 'yarn watch' Enter; + +# start viewer +tmux new-window -t ""spread:4""; +tmux send-keys -t ""spread:4"" 'source env/dev' Enter; +tmux send-keys -t ""spread:4"" 'yarn watch:viewer' Enter; + +tmux a; + +exit $? +","Shell" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/ParsersUtils.java",".java","5250","147","package com.spread.utils; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import com.spread.exceptions.SpreadException; + +import jebl.evolution.graphs.Node; +import jebl.evolution.io.ImportException; +import jebl.evolution.io.NexusImporter; +import jebl.evolution.io.TreeImporter; +import jebl.evolution.trees.RootedTree; + +public class ParsersUtils { + + public static final double EARTH_RADIUS = 6371.0; + public static final String EMPTY_STRING = """"; + public static final String BLANK_SPACE = ""\\s+""; + public static final String TAB = ""\t""; + public static final String HASH_COMMENT = ""#""; + public static final String INDICATORS = ""indicators""; + public static final String DURATION = ""duration""; + public static final String DISTANCE = ""distance""; + public static final String LOCATION = ""location""; + public static final String POSTERIOR = ""posterior""; + // public static final String HPD = ""hpd""; + public static final String START = ""start""; + public static final String END = ""end""; + public static final String ONE = ""1""; + public static final String TWO = ""2""; + public static final String RATE = ""rate""; + public static final String PRECISION = ""precision""; + public static final int LATITUDE_INDEX = 0; + public static final int LONGITUDE_INDEX = 1; + public static final String HPD = ""hpd""; + public static final String TRAIT = ""trait""; + public static final int YEAR_INDEX = 0; + public static final int MONTH_INDEX = 1; + public static final int DAY_INDEX = 2; + public static final int X_INDEX = 0; + public static final int Y_INDEX = 1; + public static final String NEGATIVE_SIGN = ""-""; + public static final String X_COORDINATE = ""xCoordinate""; + public static final String Y_COORDINATE = ""yCoordinate""; + + public static final String CONTINUOUS_TREE = ""ContinuousTree""; + public static final String DISCRETE_TREE = ""DiscreteTree""; + public static final String BAYES_FACTOR = ""BayesFactor""; + public static final String TIME_SLICER = ""TimeSlicer""; + + // Use this for all random numbers + private static final Random random = new Random(); + + public static String[] readLines(String filename, String comment) throws IOException { + + FileReader fileReader = new FileReader(filename); + BufferedReader bufferedReader = new BufferedReader(fileReader); + List lines = new ArrayList(); + + String line = null; + while ((line = bufferedReader.readLine()) != null) { + // skip commented lines + if (!line.contains(comment)) { + lines.add(line); + } + } + + bufferedReader.close(); + return lines.toArray(new String[lines.size()]); + } + + public static String splitString(String string, String c) { + String[] id = string.split(c); + return id[id.length - 1]; + } + + public static RootedTree importRootedTree(String treefile) throws IOException, ImportException { + TreeImporter importer = new NexusImporter(new FileReader(treefile)); + return (RootedTree) importer.importNextTree(); + } + + public static Double getNodeHeight(RootedTree tree, Node node) throws SpreadException { + return tree.getHeight(node); + } + + public static Object getObjectNodeAttribute(Node node, String attributeName) throws SpreadException { + Object nodeAttribute = node.getAttribute(attributeName); + if (nodeAttribute == null) { + throw new SpreadException(""Attribute "" + attributeName + "" missing from the node. \n""); + } + return nodeAttribute; + } + + public static Object[] getObjectArrayNodeAttribute(Node node, String attributeName) throws SpreadException { + Object[] nodeAttributeArray = (Object[]) node.getAttribute(attributeName); + if (nodeAttributeArray == null) { + throw new SpreadException(""Attribute "" + attributeName + "" missing from the node. \n""); + } + return nodeAttributeArray; + } + + public static Object[] getObjectArrayTreeAttribute(RootedTree tree, String attributeName) { + + Object o = tree.getAttribute(attributeName); + + if (o == null) { + throw new RuntimeException(""Attribute "" + attributeName + "" missing from the tree. \n""); + } + + return (Object[]) o; + } + + public static Double[] getDoubleArrayTreeAttribute(RootedTree tree, String attributeName) { + + Object[] o = getObjectArrayTreeAttribute(tree, attributeName); + + Double[] array = new Double[o.length]; + for (int i = 0; i < o.length; i++) { + array[i] = Double.valueOf(o[i].toString()); + } + + return array; + } + + public static double round(double value, double precision) { + return (double) Math.round(value * precision) / precision; + } + + public static Object pickRand(Object[] array) { + int rnd = random.nextInt(array.length); + return array[rnd]; + } + + public static String breakTiesRandomly(String tiedState) { + + String[] array = tiedState.split(""\\+""); + String state = (String) pickRand(array); + + return state; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/Trait.java",".java","1632","70","package com.spread.utils; + +public class Trait { + + private Object id; + private Object[] array; + private boolean isMultivariate = false; + + public Trait(Object obj) { + this.id = obj; + if (obj instanceof Object[]) { + isMultivariate = true; + array = (Object[]) obj; + } + } + + public boolean isMultivariate() { + return isMultivariate; + } + + public boolean isNumber() { + if (!isMultivariate) + return (id instanceof Double); + return (array[0] instanceof Double); + } + + public int getDim() { + if (isMultivariate) { + return array.length; + } + return 1; + } + + public double[] getValue() { + int dim = getDim(); + double[] result = new double[dim]; + if (!isMultivariate) { + result[0] = (Double) id; + } else { + for (int i = 0; i < dim; i++) + result[i] = (Double) array[i]; + } + return result; + } + + public void multiplyBy(double factor) { + if (!isMultivariate) { + id = ((Double) id * factor); + } else { + for (int i = 0; i < array.length; i++) { + array[i] = ((Double) array[i] * factor); + } + } + } + + public String toString() { + if (!isMultivariate) + return id.toString(); + StringBuffer sb = new StringBuffer(array[0].toString()); + for (int i = 1; i < array.length; i++) + sb.append(""\t"").append(array[i]); + return sb.toString(); + } + + public Object getId() { + return id; + } + +}// END: class +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/PrintUtils.java",".java","1147","44","package com.spread.utils; + +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +public class PrintUtils { + + public static void printArray(E[] array) { + for (E element : array) { + System.out.printf(""%s "", element); + } + System.out.println(); + } + + public static void print2DArray(E[][] array) { + int nRow = array.length; + int nCol = array[0].length; + for (int row = 0; row < nRow; row++) { + for (int col = 0; col < nCol; col++) { + System.out.print(array[row][col] + "" ""); + } + System.out.print(""\n""); + } + } + + public static void printList(List x) { + for (int i = 0; i < x.size(); i++) { + System.out.print(x.get(i) + "" ""); + } + System.out.println(); + } + + public static void printMap(Map map) { + Iterator it = map.entrySet().iterator(); + while (it.hasNext()) { + Entry pairs = (Entry) it.next(); + System.out.println(pairs.getKey() + "" = "" + pairs.getValue()); + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/ComparableDouble.java",".java","1867","69","/* + * ComparableDouble.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.utils; + +/** + * This class is unfortunate but necessary to conform to JDK 1.1 + * + * @version $Id: ComparableDouble.java,v 1.3 2005/05/24 20:26:01 rambaut Exp $ + * + * @author Alexei Drummond + */ +public class ComparableDouble implements Comparable { + + private final double value; + + public ComparableDouble(double d) { + value = d; + } + + public int compareTo(Object o) { + + ComparableDouble cd = (ComparableDouble) o; + + if (value < cd.value) { + return -1; + } else if (value > cd.value) { + return 1; + } else + return 0; + } + + public boolean equals(Object o) { + + ComparableDouble cd = (ComparableDouble) o; + return cd.value == value; + } + + public double doubleValue() { + return value; + } + + public String toString() { + return value + """"; + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/NumberFormatter.java",".java","6262","171","/* + * NumberFormatter.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.utils; + +import java.text.DecimalFormat; + +/** + * The world's most intelligent number formatter with the following features :-) + *

+ * It guarantee's the display of a user-specified number of significant figures, + * sf
+ * It displays decimal format for numbers with absolute values between 1 and + * 10^(sf-1)
+ * It displays scientific notation for all other numbers (i.e. really big and + * really small absolute values)
+ * note: Its display integers for doubles with integer value
+ * + * @version $Id: NumberFormatter.java,v 1.6 2005/05/24 20:26:01 rambaut Exp $ + * + * @author Alexei Drummond + */ +public class NumberFormatter { + + private int sf; + private double upperCutoff; + private double[] cutoffTable; + private final DecimalFormat decimalFormat = new DecimalFormat(); + private DecimalFormat scientificFormat = null; + private boolean isPadding = false; + private int fieldWidth; + + public NumberFormatter(int sf) { + setSignificantFigures(sf); + } + + public NumberFormatter(int sf, int fieldWidth) { + setSignificantFigures(sf); + setPadding(true); + setFieldWidth(fieldWidth); + } + + public void setSignificantFigures(int sf) { + this.sf = sf; + upperCutoff = Math.pow(10, sf - 1); + cutoffTable = new double[sf]; + long num = 10; + for (int i = 0; i < cutoffTable.length; i++) { + cutoffTable[i] = (double) num; + num *= 10; + } + decimalFormat.setMinimumIntegerDigits(1); + decimalFormat.setMaximumFractionDigits(sf - 1); + decimalFormat.setMinimumFractionDigits(sf - 1); + decimalFormat.setGroupingUsed(false); + scientificFormat = new DecimalFormat(getScientificPattern(sf)); + fieldWidth = sf; + } + + public void setPadding(boolean padding) { + isPadding = padding; + } + + public void setFieldWidth(int fw) { + if (fw < sf + 4) + throw new IllegalArgumentException(); + fieldWidth = fw; + } + + public int getFieldWidth() { + return fieldWidth; + } + + public String formatToFieldWidth(String s, int fieldWidth) { + int size = fieldWidth - s.length(); + StringBuffer buffer = new StringBuffer(s); + for (int i = 0; i < size; i++) { + buffer.append(' '); + } + return buffer.toString(); + } + + /** + * @return the given value formatted to have exactly then number of fraction + * digits specified. + */ + public String formatDecimal(double value, int numFractionDigits) { + + decimalFormat.setMaximumFractionDigits(numFractionDigits); + decimalFormat.setMinimumFractionDigits(Math.min(numFractionDigits, 1)); + return decimalFormat.format(value); + } + + /** + * This method formats a number 'nicely':
+ * It guarantee's the display of a user-specified total significant figures, + * sf
+ * It displays decimal format for numbers with absolute values between 1 and + * 10^(sf-1)
+ * It displays scientific notation for all other numbers (i.e. really big + * and really small absolute values)
+ * note: Its display integers for doubles with integer value
+ * + * @return a nicely formatted number. + */ + public String format(double value) { + + StringBuffer buffer = new StringBuffer(); + + double absValue = Math.abs(value); + + if ((absValue > upperCutoff) || (absValue < 0.1 && absValue != 0.0)) { + buffer.append(scientificFormat.format(value)); + } else { + int numFractionDigits = 0; + if (value != (int) value) { + numFractionDigits = getNumFractionDigits(value); + } + buffer.append(formatDecimal(value, numFractionDigits)); + } + + if (isPadding) { + int size = fieldWidth - buffer.length(); + for (int i = 0; i < size; i++) { + buffer.append(' '); + } + } + return buffer.toString(); + } + + private int getNumFractionDigits(double value) { + value = Math.abs(value); + for (int i = 0; i < cutoffTable.length; i++) { + if (value < cutoffTable[i]) + return sf - i - 1; + } + return sf - 1; + } + + private String getScientificPattern(int sf) { + String pattern = ""0.""; + for (int i = 0; i < sf - 1; i++) { + pattern += ""#""; + } + pattern += ""E0""; + return pattern; + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/utils/HeapSort.java",".java","13619","477","/* + * HeapSort.java + * + * Copyright (C) 2002-2009 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.utils; + +import java.util.AbstractList; +import java.util.Comparator; +import java.util.Random; +import java.util.Vector; + +/** + * sorts numbers and comparable objects by treating contents of array as a + * binary tree. KNOWN BUGS: There is a horrible amount of code duplication here! + * + * @author Alexei Drummond + * @author Korbinian Strimmer + * @version $Id: HeapSort.java,v 1.7 2006/02/20 17:36:23 rambaut Exp $ + */ +public class HeapSort { + + // + // Public stuff + // + + /** + * Sorts an array of indices to vector of comparable objects into increasing + * order. + */ + @SuppressWarnings({ ""rawtypes"" }) + public static void sort(AbstractList array, int[] indices) { + + // ensures we are starting with valid indices + for (int i = 0; i < indices.length; i++) { + indices[i] = i; + } + + int temp; + int j, n = array.size(); + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, indices, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = indices[0]; + indices[0] = indices[j]; + indices[j] = temp; + adjust(array, indices, 1, j); + } + } + + /** + * Sorts a vector of comparable objects into increasing order. + */ + public static void sort(AbstractList array) { + + Object temp; + int j, n = array.size(); + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = array.get(0); + array.set(0, array.get(j)); + array.set(j, temp); + adjust(array, 1, j); + } + } + + /** + * Sorts an array of comparable objects into increasing order. + */ + @SuppressWarnings(""rawtypes"") + public static void sort(Comparable[] array) { + + Comparable temp; + int j, n = array.length; + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = array[0]; + array[0] = array[j]; + array[j] = temp; + adjust(array, 1, j); + } + } + + /** + * Sorts an array of objects into increasing order given a comparator. + */ + public static void sort(Object[] array, Comparator c) { + + Object temp; + int j, n = array.length; + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, c, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = array[0]; + array[0] = array[j]; + array[j] = temp; + adjust(array, c, 1, j); + } + } + + /** + * Sorts an array of doubles into increasing order. + */ + public static void sort(double[] array) { + + double temp; + int j, n = array.length; + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = array[0]; + array[0] = array[j]; + array[j] = temp; + adjust(array, 1, j); + } + } + + /** + * Sorts an array of doubles into increasing order, ingoring sign. + */ + public static void sortAbs(double[] array) { + + double temp; + int j, n = array.length; + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjustAbs(array, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = array[0]; + array[0] = array[j]; + array[j] = temp; + adjustAbs(array, 1, j); + } + } + + /** + * Sorts an array of indices into an array of doubles into increasing order. + */ + public static void sort(double[] array, int[] indices) { + + // ensures we are starting with valid indices + for (int i = 0; i < indices.length; i++) { + indices[i] = i; + } + + int temp; + int j, n = indices.length; + + // turn input array into a heap + for (j = n / 2; j > 0; j--) { + adjust(array, indices, j, n); + } + + // remove largest elements and put them at the end + // of the unsorted region until you are finished + for (j = n - 1; j > 0; j--) { + temp = indices[0]; + indices[0] = indices[j]; + indices[j] = temp; + adjust(array, indices, 1, j); + } + } + + /** + * test harness for heapsort algorithm + */ + @SuppressWarnings(""rawtypes"") + public static void main(String[] args) { + + int testSize = 100; + + // test array of Comparable objects + + ComparableDouble[] test = new ComparableDouble[testSize]; + + Random random = new Random(); + + for (int i = 0; i < test.length; i++) { + test[i] = new ComparableDouble(random.nextInt(testSize * 10)); + } + + sort(test); + for (ComparableDouble aTest : test) { + System.out.print(aTest + "" ""); + } + System.out.println(); + + // test index to Vector of Comparable objects + + Vector testv = new Vector(); + int[] indices = new int[testSize]; + + for (int i = 0; i < testSize; i++) { + testv + .addElement(new ComparableDouble(random + .nextInt(testSize * 10))); + } + + sort(testv, indices); + for (int i = 0; i < test.length; i++) { + System.out.print(testv.elementAt(indices[i]) + "" ""); + } + System.out.println(); + + // test index to array of doubles + + double[] testd = new double[testSize]; + // int[] indices = new int[testSize]; + + for (int i = 0; i < testSize; i++) { + testd[i] = random.nextInt(testSize * 10); + } + + sort(testd, indices); + for (int i = 0; i < test.length; i++) { + System.out.print(testd[indices[i]] + "" ""); + } + System.out.println(); + + } + + // PRIVATE STUFF + + /** + * helps sort an array of indices into a vector of comparable objects. + * Assumes that array[lower+1] through to array[upper] is already in heap + * form and then puts array[lower] to array[upper] in heap form. + */ + @SuppressWarnings({ ""unchecked"", ""rawtypes"" }) + private static void adjust(AbstractList array, int[] indices, + int lower, int upper) { + + int j, k; + int temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) + && (array.get(indices[k - 1]).compareTo( + array.get(indices[k])) < 0)) { + k += 1; + } + if (array.get(indices[j - 1]).compareTo(array.get(indices[k - 1])) < 0) { + temp = indices[j - 1]; + indices[j - 1] = indices[k - 1]; + indices[k - 1] = temp; + } + j = k; + k *= 2; + } + } + + /** + * helps sort an vector of comparable objects. Assumes that array[lower+1] + * through to array[upper] is already in heap form and then puts + * array[lower] to array[upper] in heap form. + */ + @SuppressWarnings(""unchecked"") + private static void adjust(AbstractList array, int lower, int upper) { + + int j, k; + Object temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) + && (((Comparable) array.get(k - 1)).compareTo(array.get(k)) < 0)) { + k += 1; + } + if (((Comparable) array.get(j - 1)).compareTo(array.get(k - 1)) < 0) { + temp = array.get(j - 1); + array.set(j - 1, array.get(k - 1)); + array.set(k - 1, temp); + } + j = k; + k *= 2; + } + } + + /** + * Assumes that array[lower+1] through to array[upper] is already in heap + * form and then puts array[lower] to array[upper] in heap form. + */ + @SuppressWarnings({ ""unchecked"", ""rawtypes"" }) + private static void adjust(Comparable[] array, int lower, int upper) { + + int j, k; + Comparable temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) && (array[k - 1].compareTo(array[k]) < 0)) { + k += 1; + } + if (array[j - 1].compareTo(array[k - 1]) < 0) { + temp = array[j - 1]; + array[j - 1] = array[k - 1]; + array[k - 1] = temp; + } + j = k; + k *= 2; + } + } + + /** + * Assumes that array[lower+1] through to array[upper] is already in heap + * form and then puts array[lower] to array[upper] in heap form. + */ + private static void adjust(Object[] array, Comparator c, int lower, + int upper) { + + int j, k; + Object temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) && (c.compare(array[k - 1], array[k]) < 0)) { + k += 1; + } + if (c.compare(array[j - 1], array[k - 1]) < 0) { + temp = array[j - 1]; + array[j - 1] = array[k - 1]; + array[k - 1] = temp; + } + j = k; + k *= 2; + } + } + + /** + * helps sort an array of doubles. Assumes that array[lower+1] through to + * array[upper] is already in heap form and then puts array[lower] to + * array[upper] in heap form. + */ + private static void adjust(double[] array, int lower, int upper) { + + int j, k; + double temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) && (array[k - 1] < array[k])) { + k += 1; + } + if (array[j - 1] < array[k - 1]) { + temp = array[j - 1]; + array[j - 1] = array[k - 1]; + array[k - 1] = temp; + } + j = k; + k *= 2; + } + } + + /** + * helps sort an array of doubles. Assumes that array[lower+1] through to + * array[upper] is already in heap form and then puts array[lower] to + * array[upper] in heap form. + */ + private static void adjustAbs(double[] array, int lower, int upper) { + + int j, k; + double temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) && (Math.abs(array[k - 1]) < Math.abs(array[k]))) { + k += 1; + } + if (Math.abs(array[j - 1]) < Math.abs(array[k - 1])) { + temp = array[j - 1]; + array[j - 1] = array[k - 1]; + array[k - 1] = temp; + } + j = k; + k *= 2; + } + } + + /** + * helps sort an array of indices into an array of doubles. Assumes that + * array[lower+1] through to array[upper] is already in heap form and then + * puts array[lower] to array[upper] in heap form. + */ + private static void adjust(double[] array, int[] indices, int lower, + int upper) { + + int j, k; + int temp; + + j = lower; + k = lower * 2; + + while (k <= upper) { + if ((k < upper) && (array[indices[k - 1]] < array[indices[k]])) { + k += 1; + } + if (array[indices[j - 1]] < array[indices[k - 1]]) { + temp = indices[j - 1]; + indices[j - 1] = indices[k - 1]; + indices[k - 1] = temp; + } + j = k; + k *= 2; + } + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/progress/IProgressReporter.java",".java","172","7","package com.spread.progress; + +public interface IProgressReporter { + void registerProgressObserver(IProgressObserver observer); + void updateProgress(double progress); +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/progress/IProgressObserver.java",".java","112","6","package com.spread.progress; + +public interface IProgressObserver { + void handleProgress (double progress); +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/NormalDistribution.java",".java","15917","413","/* + * NormalDistribution.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * normal distribution (pdf, cdf, quantile) + * + * @author Korbinian Strimmer + * @version $Id: NormalDistribution.java,v 1.7 2005/05/24 20:26:01 rambaut Exp $ + */ +public class NormalDistribution implements Distribution { + // + // Public stuff + // + + /** + * Constructor + */ + public NormalDistribution(double mean, double sd) { + this.m = mean; + this.sd = sd; + } + + public double getMean() { + return m; + } + + public void setMean(double value) { + m = value; + } + + public double getSD() { + return sd; + } + + public void setSD(double value) { + sd = value; + } + + public double pdf(double x) { + return pdf(x, m, sd); + } + + public double logPdf(double x) { + return logPdf(x, m, sd); + } + + public double cdf(double x) { + return cdf(x, m, sd); + } + + public double quantile(double y) { + return quantile(y, m, sd); + } + + public double mean() { + return mean(m, sd); + } + + public double variance() { + return variance(m, sd); + } + + public final UnivariateFunction getProbabilityDensityFunction() { + return pdfFunction; + } + + private final UnivariateFunction pdfFunction = new UnivariateFunction() { + public final double evaluate(double x) { + return pdf(x); + } + + public final double getLowerBound() { + return Double.NEGATIVE_INFINITY; + } + + public final double getUpperBound() { + return Double.POSITIVE_INFINITY; + } + }; + + /** + * probability density function + * + * @param x + * argument + * @param m + * mean + * @param sd + * standard deviation + * @return pdf at x + */ + public static double pdf(double x, double m, double sd) { + double a = 1.0 / (Math.sqrt(2.0 * Math.PI) * sd); + double b = -(x - m) * (x - m) / (2.0 * sd * sd); + + return a * Math.exp(b); + } + + /** + * the natural log of the probability density function of the distribution + * + * @param x + * argument + * @param m + * mean + * @param sd + * standard deviation + * @return log pdf at x + */ + public static double logPdf(double x, double m, double sd) { + double a = 1.0 / (Math.sqrt(2.0 * Math.PI) * sd); + double b = -(x - m) * (x - m) / (2.0 * sd * sd); + + return Math.log(a) + b; + } + + /** + * cumulative density function + * + * @param x + * argument + * @param m + * mean + * @param sd + * standard deviation + * @return cdf at x + */ + public static double cdf(double x, double m, double sd) { + double a = (x - m) / (Math.sqrt(2.0) * sd); + + return 0.5 * (1.0 + ErrorFunction.erf(a)); + } + + /** + * quantiles (=inverse cumulative density function) + * + * @param z + * argument + * @param m + * mean + * @param sd + * standard deviation + * @return icdf at z + */ + public static double quantile(double z, double m, double sd) { + return m + Math.sqrt(2.0) * sd + * ErrorFunction.inverseErf(2.0 * z - 1.0); + } + + /** + * mean + * + * @param m + * mean + * @param sd + * standard deviation + * @return mean + */ + public static double mean(double m, double sd) { + return m; + } + + /** + * variance + * + * @param m + * mean + * @param sd + * standard deviation + * @return variance + */ + public static double variance(double m, double sd) { + return sd * sd; + } + + /** + * A more accurate and faster implementation of the cdf (taken from function + * pnorm in the R statistical language) This implementation has + * discrepancies depending on the programming language and system + * architecture In Java, returned values become zero once z reaches -37.5193 + * exactly on the machine tested In the other implementation, the returned + * value 0 at about z = -8 In C, this 0 value is reached approximately z = + * -37.51938 + * + * Will later need to be optimised for BEAST + * + * @param x + * argument + * @param mu + * mean + * @param sigma + * standard deviation + * @param log_p + * is p logged + * @return cdf at x + */ + public static double cdf(double x, double mu, double sigma, boolean log_p) { + boolean i_tail = false; + double p, cp = Double.NaN; + + if (Double.isNaN(x) || Double.isNaN(mu) || Double.isNaN(sigma)) { + return Double.NaN; + } + if (Double.isInfinite(x) && mu == x) { /* x-mu is NaN */ + return Double.NaN; + } + if (sigma <= 0) { + if (sigma < 0) { + return Double.NaN; + } + return (x < mu) ? 0.0 : 1.0; + } + p = (x - mu) / sigma; + if (Double.isInfinite(p)) { + return (x < mu) ? 0.0 : 1.0; + } + x = p; + if (Double.isNaN(x)) { + return Double.NaN; + } + + double xden, xnum, temp, del, eps, xsq, y; + int i; + boolean lower, upper; + eps = DBL_EPSILON * 0.5; + lower = !i_tail; + upper = i_tail; + + y = Math.abs(x); + if (y <= 0.67448975) { /* Normal.quantile(3/4, 1, 0) = 0.67448975 */ + if (y > eps) { + xsq = x * x; + xnum = a[4] * xsq; + xden = xsq; + for (i = 0; i < 3; i++) { + xnum = (xnum + a[i]) * xsq; + xden = (xden + b[i]) * xsq; + } + } else { + xnum = xden = 0.0; + } + temp = x * (xnum + a[3]) / (xden + b[3]); + if (lower) { + p = 0.5 + temp; + } + if (upper) { + cp = 0.5 - temp; + } + if (log_p) { + if (lower) { + p = Math.log(p); + } + if (upper) { + cp = Math.log(cp); + } + } + } + + else if (y <= M_SQRT_32) { + /* + * Evaluate pnorm for 0.67448975 = Normal.quantile(3/4, 1, 0) < |x| + * <= sqrt(32) ~= 5.657 + */ + + xnum = c[8] * y; + xden = y; + for (i = 0; i < 7; i++) { + xnum = (xnum + c[i]) * y; + xden = (xden + d[i]) * y; + } + temp = (xnum + c[7]) / (xden + d[7]); + + // do_del(y); + // swap_tail; + // #define do_del(X) \ + xsq = ((int) (y * CUTOFF)) * 1.0 / CUTOFF; + del = (y - xsq) * (y + xsq); + if (log_p) { + p = (-xsq * xsq * 0.5) + (-del * 0.5) + Math.log(temp); + if ((lower && x > 0.0) || (upper && x <= 0.0)) { + cp = Math.log(1.0 - Math.exp(-xsq * xsq * 0.5) + * Math.exp(-del * 0.5) * temp); + } + } else { + p = Math.exp(-xsq * xsq * 0.5) * Math.exp(-del * 0.5) * temp; + cp = 1.0 - p; + } + // #define swap_tail \ + if (x > 0.0) { + temp = p; + if (lower) { + p = cp; + } + cp = temp; + } + } + /* + * else |x| > sqrt(32) = 5.657 : the next two case differentiations were + * really for lower=T, log=F Particularly *not* for log_p ! Cody had + * (-37.5193 < x && x < 8.2924) ; R originally had y < 50 Note that we + * do want symmetry(0), lower/upper -> hence use y + */ + else if (log_p || (lower && -37.5193 < x && x < 8.2924) + || (upper && -8.2924 < x && x < 37.5193)) { + + /* Evaluate pnorm for x in (-37.5, -5.657) union (5.657, 37.5) */ + xsq = 1.0 / (x * x); + xnum = p_[5] * xsq; + xden = xsq; + for (i = 0; i < 4; i++) { + xnum = (xnum + p_[i]) * xsq; + xden = (xden + q[i]) * xsq; + } + temp = xsq * (xnum + p_[4]) / (xden + q[4]); + temp = (M_1_SQRT_2PI - temp) / y; + + // do_del(x); + xsq = ((int) (x * CUTOFF)) * 1.0 / CUTOFF; + del = (x - xsq) * (x + xsq); + if (log_p) { + p = (-xsq * xsq * 0.5) + (-del * 0.5) + Math.log(temp); + if ((lower && x > 0.0) || (upper && x <= 0.0)) { + cp = Math.log(1.0 - Math.exp(-xsq * xsq * 0.5) + * Math.exp(-del * 0.5) * temp); + } + } else { + p = Math.exp(-xsq * xsq * 0.5) * Math.exp(-del * 0.5) * temp; + cp = 1.0 - p; + } + // swap_tail; + if (x > 0.0) { + temp = p; + if (lower) { + p = cp; + } + cp = temp; + } + } else { /* no log_p , large x such that probs are 0 or 1 */ + if (x > 0) { + p = 1.0; + cp = 0.0; + } else { + p = 0.0; + cp = 1.0; + } + } + return p; + + } + + // Private + + protected double m, sd; + + private static final double[] a = { 2.2352520354606839287, + 161.02823106855587881, 1067.6894854603709582, + 18154.981253343561249, 0.065682337918207449113 }; + private static final double[] b = { 47.20258190468824187, + 976.09855173777669322, 10260.932208618978205, 45507.789335026729956 }; + private static final double[] c = { 0.39894151208813466764, + 8.8831497943883759412, 93.506656132177855979, + 597.27027639480026226, 2494.5375852903726711, + 6848.1904505362823326, 11602.651437647350124, + 9842.7148383839780218, 1.0765576773720192317e-8 }; + private static final double[] d = { 22.266688044328115691, + 235.38790178262499861, 1519.377599407554805, 6485.558298266760755, + 18615.571640885098091, 34900.952721145977266, + 38912.003286093271411, 19685.429676859990727 }; + private static final double[] p_ = { 0.21589853405795699, + 0.1274011611602473639, 0.022235277870649807, + 0.001421619193227893466, 2.9112874951168792e-5, + 0.02307344176494017303 }; + private static final double[] q = { 1.28426009614491121, + 0.468238212480865118, 0.0659881378689285515, + 0.00378239633202758244, 7.29751555083966205e-5 }; + + private static final int CUTOFF = 16; /* Cutoff allowing exact ""*"" and ""/"" */ + + private static final double M_SQRT_32 = 5.656854249492380195206754896838; /* + * The + * square + * root + * of + * 32 + */ + private static final double M_1_SQRT_2PI = 0.398942280401432677939946059934; + private static final double DBL_EPSILON = 2.2204460492503131e-016; +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/MersenneTwisterFast.java",".java","42845","937","/* + * MersenneTwisterFast.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +import java.io.Serializable; + +/** + * MersenneTwisterFast: + *

+ * A simulation quality fast random number generator (MT19937) with the same + * public methods as java.util.Random. + *

+ *

+ * About the Mersenne Twister. This is a Java version of the C-program for + * MT19937: Integer version. next(32) generates one pseudorandom unsigned + * integer (32bit) which is uniformly distributed among 0 to 2^32-1 for each + * call. next(int bits) >>>'s by (32-bits) to get a value ranging between 0 and + * 2^bits-1 long inclusive; hope that's correct. setSeed(seed) set initial + * values to the working area of 624 words. For setSeed(seed), seed is any + * 32-bit integer except for 0. + *

+ * Reference. M. Matsumoto and T. Nishimura, ""Mersenne Twister: A + * 623-Dimensionally Equidistributed Uniform Pseudo-Random Number Generator"", + * ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1, + * January 1998, pp 3--30. + *

+ *

+ * Bug Fixes. This implementation implements the bug fixes made in Java 1.2's + * version of Random, which means it can be used with earlier versions of Java. + * See + * the JDK 1.2 java.util.Random documentation for further documentation on + * the random-number generation contracts made. Additionally, there's an + * undocumented bug in the JDK java.util.Random.nextBytes() method, which this + * code fixes. + *

+ *

+ * Important Note. Just like java.util.Random, this generator accepts a long + * seed but doesn't use all of it. java.util.Random uses 48 bits. The Mersenne + * Twister instead uses 32 bits (int size). So it's best if your seed does not + * exceed the int range. + *

+ *

+ * Sean Luke's web page + *

+ *

+ * - added shuffling method (Alexei Drummond) + *

+ * - added gamma RV method (Marc Suchard) + *

+ * This is now package private - it should be accessed using the instance in + * Random + */ +class MersenneTwisterFast implements Serializable { + /** + * + */ + private static final long serialVersionUID = 6185086957226269797L; + // Period parameters + private static final int N = 624; + private static final int M = 397; + private static final int MATRIX_A = 0x9908b0df; // private static final * + // constant vector a + private static final int UPPER_MASK = 0x80000000; // most significant w-r + // bits + private static final int LOWER_MASK = 0x7fffffff; // least significant r + // bits + + // Tempering parameters + private static final int TEMPERING_MASK_B = 0x9d2c5680; + private static final int TEMPERING_MASK_C = 0xefc60000; + + // #define TEMPERING_SHIFT_U(y) (y >>> 11) + // #define TEMPERING_SHIFT_S(y) (y << 7) + // #define TEMPERING_SHIFT_T(y) (y << 15) + // #define TEMPERING_SHIFT_L(y) (y >>> 18) + + private int mt[]; // the array for the state vector + private int mti; // mti==N+1 means mt[N] is not initialized + private int mag01[]; + + // a good initial seed (of int size, though stored in a long) + private static final long GOOD_SEED = 4357; + + private double nextNextGaussian; + private boolean haveNextNextGaussian; + + // The following can be accessed externally by the static accessor methods + // which + // inforce synchronization + public static final MersenneTwisterFast DEFAULT_INSTANCE = new MersenneTwisterFast(); + + // Added to curernt time in default constructor, and then adjust to allow + // for programs that construct + // multiple MersenneTwisterFast in a short amount of time. + private static long seedAdditive_ = 0; + + private long initializationSeed; + + /** + * Constructor using the time of day as default seed. + */ + public MersenneTwisterFast() { + this(System.currentTimeMillis() + seedAdditive_); + seedAdditive_ += nextInt(); + } + + /** + * Constructor using a given seed. Though you pass this seed in as a long, + * it's best to make sure it's actually an integer. + * + * @param seed + * generator starting number, often the time of day. + */ + private MersenneTwisterFast(long seed) { + if (seed == 0) { + setSeed(GOOD_SEED); + } else { + setSeed(seed); + } + } + + /** + * Initalize the pseudo random number generator. The Mersenne Twister only + * uses an integer for its seed; It's best that you don't pass in a long + * that's bigger than an int. + * + * @param seed + * from constructor + */ + public final void setSeed(long seed) { + if (seed == 0) { + throw new IllegalArgumentException(""Non zero random seed required.""); + } + initializationSeed = seed; + haveNextNextGaussian = false; + + mt = new int[N]; + + // setting initial seeds to mt[N] using + // the generator Line 25 of Table 1 in + // [KNUTH 1981, The Art of Computer Programming + // Vol. 2 (2nd Ed.), pp102] + + // the 0xffffffff is commented out because in Java + // ints are always 32 bits; hence i & 0xffffffff == i + + mt[0] = ((int) seed); // & 0xffffffff; + + for (mti = 1; mti < N; mti++) + mt[mti] = (69069 * mt[mti - 1]); // & 0xffffffff; + + // mag01[x] = x * MATRIX_A for x=0,1 + mag01 = new int[2]; + mag01[0] = 0x0; + mag01[1] = MATRIX_A; + } + + public final long getSeed() { + return initializationSeed; + } + + public final int nextInt() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return y; + } + + public final short nextShort() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return (short) (y >>> 16); + } + + public final char nextChar() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return (char) (y >>> 16); + } + + public final boolean nextBoolean() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return ((y >>> 31) != 0); + } + + public final byte nextByte() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return (byte) (y >>> 24); + } + + public final void nextBytes(byte[] bytes) { + int y; + + for (int x = 0; x < bytes.length; x++) { + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + bytes[x] = (byte) (y >>> 24); + } + } + + public final long nextLong() { + int y; + int z; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + for (; kk < N - 1; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1]; + + mti = 0; + } + + z = mt[mti++]; + z ^= z >>> 11; // TEMPERING_SHIFT_U(z) + z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z) + z ^= (z << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(z) + z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) + + return (((long) y) << 32) + (long) z; + } + + public final double nextDouble() { + int y; + int z; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + for (; kk < N - 1; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1]; + + mti = 0; + } + + z = mt[mti++]; + z ^= z >>> 11; // TEMPERING_SHIFT_U(z) + z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z) + z ^= (z << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(z) + z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) + + /* derived from nextDouble documentation in jdk 1.2 docs, see top */ + return ((((long) (y >>> 6)) << 27) + (z >>> 5)) / (double) (1L << 53); + } + + public final double nextGaussian() { + if (haveNextNextGaussian) { + haveNextNextGaussian = false; + return nextNextGaussian; + } else { + double v1, v2, s; + do { + int y; + int z; + int a; + int b; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + for (; kk < N - 1; kk++) { + z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (z >>> 1) ^ mag01[z & 0x1]; + } + z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1]; + + mti = 0; + } + + z = mt[mti++]; + z ^= z >>> 11; // TEMPERING_SHIFT_U(z) + z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z) + z ^= (z << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(z) + z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + a = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (a >>> 1) ^ mag01[a & 0x1]; + } + for (; kk < N - 1; kk++) { + a = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (a >>> 1) ^ mag01[a & 0x1]; + } + a = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (a >>> 1) ^ mag01[a & 0x1]; + + mti = 0; + } + + a = mt[mti++]; + a ^= a >>> 11; // TEMPERING_SHIFT_U(a) + a ^= (a << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(a) + a ^= (a << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(a) + a ^= (a >>> 18); // TEMPERING_SHIFT_L(a) + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + b = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (b >>> 1) ^ mag01[b & 0x1]; + } + for (; kk < N - 1; kk++) { + b = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (b >>> 1) ^ mag01[b & 0x1]; + } + b = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (b >>> 1) ^ mag01[b & 0x1]; + + mti = 0; + } + + b = mt[mti++]; + b ^= b >>> 11; // TEMPERING_SHIFT_U(b) + b ^= (b << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(b) + b ^= (b << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(b) + b ^= (b >>> 18); // TEMPERING_SHIFT_L(b) + + /* + * derived from nextDouble documentation in jdk 1.2 docs, see + * top + */ + v1 = 2 * (((((long) (y >>> 6)) << 27) + (z >>> 5)) / (double) (1L << 53)) - 1; + v2 = 2 * (((((long) (a >>> 6)) << 27) + (b >>> 5)) / (double) (1L << 53)) - 1; + s = v1 * v1 + v2 * v2; + } while (s >= 1); + double multiplier = Math.sqrt(-2 * Math.log(s) / s); + nextNextGaussian = v2 * multiplier; + haveNextNextGaussian = true; + return v1 * multiplier; + } + } + + public final float nextFloat() { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return (y >>> 8) / ((float) (1 << 24)); + } + + /** + * Returns an integer drawn uniformly from 0 to n-1. Suffice it to say, n + * must be > 0, or an IllegalArgumentException is raised. + */ + public int nextInt(int n) { + if (n <= 0) + throw new IllegalArgumentException(""n must be positive""); + + if ((n & -n) == n) // i.e., n is a power of 2 + { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + return (int) ((n * (long) (y >>> 1)) >> 31); + } + + int bits, val; + do { + int y; + + if (mti >= N) // generate N words at one time + { + int kk; + + for (kk = 0; kk < N - M; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + for (; kk < N - 1; kk++) { + y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); + mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; + } + y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); + mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= y >>> 11; // TEMPERING_SHIFT_U(y) + y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) + y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) + y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) + + bits = (y >>> 1); + val = bits % n; + } while (bits - val + (n - 1) < 0); + return val; + } + + /** + * Returns a uniform random permutation of int objects in array + */ + public final void permute(int[] array) { + int l = array.length; + for (int i = 0; i < l; i++) { + int index = nextInt(l - i) + i; + int temp = array[index]; + array[index] = array[i]; + array[i] = temp; + } + } + + /** + * Shuffles an array. + */ + public final void shuffle(int[] array) { + int l = array.length; + for (int i = 0; i < l; i++) { + int index = nextInt(l - i) + i; + int temp = array[index]; + array[index] = array[i]; + array[i] = temp; + } + } + + /** + * Shuffles an array. Shuffles numberOfShuffles times + */ + public final void shuffle(int[] array, int numberOfShuffles) { + int i, j, temp, l = array.length; + for (int shuffle = 0; shuffle < numberOfShuffles; shuffle++) { + do { + i = nextInt(l); + j = nextInt(l); + } while (i != j); + temp = array[j]; + array[j] = array[i]; + array[i] = temp; + } + } + + /** + * Returns an array of shuffled indices of length l. + * + * @param l + * length of the array required. + */ + public int[] shuffled(int l) { + + int[] array = new int[l]; + + // initialize array + for (int i = 0; i < l; i++) { + array[i] = i; + } + shuffle(array); + + return array; + } + + /** + * Returns a uniform random permutation of ints 0,...,l-1 + * + * @param l + * length of the array required. + */ + public int[] permuted(int l) { + + int[] array = new int[l]; + + // initialize array + for (int i = 0; i < l; i++) { + array[i] = i; + } + permute(array); + + return array; + } + + public double nextGamma(double alpha, double lambda) { + /****************************************************************** + * * Gamma Distribution - Acceptance Rejection combined with * + * Acceptance Complement * * + ****************************************************************** + * * FUNCTION: - gds samples a random number from the standard * gamma + * distribution with parameter a > 0. * Acceptance Rejection gs for a < + * 1 , * Acceptance Complement gd for a >= 1 . * REFERENCES: - J.H. + * Ahrens, U. Dieter (1974): Computer methods * for sampling from gamma, + * beta, Poisson and * binomial distributions, Computing 12, 223-246. * + * - J.H. Ahrens, U. Dieter (1982): Generating gamma * variates by a + * modified rejection technique, * Communications of the ACM 25, 47-54. + * * SUBPROGRAMS: - drand(seed) ... (0,1)-Uniform generator with * + * unsigned long integer *seed * - NORMAL(seed) ... Normal generator + * N(0,1). * * + ******************************************************************/ + double a = alpha; + double aa = -1.0, aaa = -1.0, b = 0.0, c = 0.0, d = 0.0, e, r, s = 0.0, si = 0.0, ss = 0.0, q0 = 0.0, q1 = 0.0416666664, q2 = 0.0208333723, q3 = 0.0079849875, q4 = 0.0015746717, q5 = -0.0003349403, q6 = 0.0003340332, q7 = 0.0006053049, q8 = -0.0004701849, q9 = 0.0001710320, a1 = 0.333333333, a2 = -0.249999949, a3 = 0.199999867, a4 = -0.166677482, a5 = 0.142873973, a6 = -0.124385581, a7 = 0.110368310, a8 = -0.112750886, a9 = 0.104089866, e1 = 1.000000000, e2 = 0.499999994, e3 = 0.166666848, e4 = 0.041664508, e5 = 0.008345522, e6 = 0.001353826, e7 = 0.000247453; + + double gds, p, q, t, sign_u, u, v, w, x; + double v1, v2, v12; + + // Check for invalid input values + + if (a <= 0.0) + throw new IllegalArgumentException(); + if (lambda <= 0.0) + new IllegalArgumentException(); + + if (a < 1.0) { // CASE A: Acceptance rejection algorithm gs + b = 1.0 + 0.36788794412 * a; // Step 1 + for (;;) { + p = b * nextDouble(); + if (p <= 1.0) { // Step 2. Case gds <= 1 + gds = Math.exp(Math.log(p) / a); + if (Math.log(nextDouble()) <= -gds) + return (gds / lambda); + } else { // Step 3. Case gds > 1 + gds = -Math.log((b - p) / a); + if (Math.log(nextDouble()) <= ((a - 1.0) * Math.log(gds))) + return (gds / lambda); + } + } + } else { // CASE B: Acceptance complement algorithm gd (gaussian + // distribution, box muller transformation) + if (a != aa) { // Step 1. Preparations + aa = a; + ss = a - 0.5; + s = Math.sqrt(ss); + d = 5.656854249 - 12.0 * s; + } + // Step 2. Normal deviate + do { + v1 = 2.0 * nextDouble() - 1.0; + v2 = 2.0 * nextDouble() - 1.0; + v12 = v1 * v1 + v2 * v2; + } while (v12 > 1.0); + t = v1 * Math.sqrt(-2.0 * Math.log(v12) / v12); + x = s + 0.5 * t; + gds = x * x; + if (t >= 0.0) + return (gds / lambda); // Immediate acceptance + + u = nextDouble(); // Step 3. Uniform random number + if (d * u <= t * t * t) + return (gds / lambda); // Squeeze acceptance + + if (a != aaa) { // Step 4. Set-up for hat case + aaa = a; + r = 1.0 / a; + q0 = ((((((((q9 * r + q8) * r + q7) * r + q6) * r + q5) * r + q4) + * r + q3) + * r + q2) + * r + q1) + * r; + if (a > 3.686) { + if (a > 13.022) { + b = 1.77; + si = 0.75; + c = 0.1515 / s; + } else { + b = 1.654 + 0.0076 * ss; + si = 1.68 / s + 0.275; + c = 0.062 / s + 0.024; + } + } else { + b = 0.463 + s - 0.178 * ss; + si = 1.235; + c = 0.195 / s - 0.079 + 0.016 * s; + } + } + if (x > 0.0) { // Step 5. Calculation of q + v = t / (s + s); // Step 6. + if (Math.abs(v) > 0.25) { + q = q0 - s * t + 0.25 * t * t + (ss + ss) + * Math.log(1.0 + v); + } else { + q = q0 + + 0.5 + * t + * t + * ((((((((a9 * v + a8) * v + a7) * v + a6) * v + a5) + * v + a4) + * v + a3) + * v + a2) + * v + a1) * v; + } // Step 7. Quotient acceptance + if (Math.log(1.0 - u) <= q) + return (gds / lambda); + } + + for (;;) { // Step 8. Double exponential deviate t + do { + e = -Math.log(nextDouble()); + u = nextDouble(); + u = u + u - 1.0; + sign_u = (u > 0) ? 1.0 : -1.0; + t = b + (e * si) * sign_u; + } while (t <= -0.71874483771719); // Step 9. Rejection of t + v = t / (s + s); // Step 10. New q(t) + if (Math.abs(v) > 0.25) { + q = q0 - s * t + 0.25 * t * t + (ss + ss) + * Math.log(1.0 + v); + } else { + q = q0 + + 0.5 + * t + * t + * ((((((((a9 * v + a8) * v + a7) * v + a6) * v + a5) + * v + a4) + * v + a3) + * v + a2) + * v + a1) * v; + } + if (q <= 0.0) + continue; // Step 11. + if (q > 0.5) { + w = Math.exp(q) - 1.0; + } else { + w = ((((((e7 * q + e6) * q + e5) * q + e4) * q + e3) * q + e2) + * q + e1) + * q; + } // Step 12. Hat acceptance + if (c * u * sign_u <= w * Math.exp(e - 0.5 * t * t)) { + x = s + 0.5 * t; + return (x * x / lambda); + } + } + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/Distribution.java",".java","2362","92","/* + * Distribution.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * an interface for a distribution. + * + * @author Alexei Drummond + * @author Andrew Rambaut + * @version $Id: Distribution.java,v 1.7 2005/05/24 20:26:00 rambaut Exp $ + */ +public interface Distribution { + /** + * probability density function of the distribution + * + * @param x + * argument + * @return pdf value + */ + public double pdf(double x); + + /** + * the natural log of the probability density function of the distribution + * + * @param x + * argument + * @return log pdf value + */ + public double logPdf(double x); + + /** + * cumulative density function of the distribution + * + * @param x + * argument + * @return cdf value + */ + public double cdf(double x); + + /** + * quantile (inverse cumulative density function) of the distribution + * + * @param y + * argument + * @return icdf value + */ + public double quantile(double y); + + /** + * mean of the distribution + * + * @return mean + */ + public double mean(); + + /** + * variance of the distribution + * + * @return variance + */ + public double variance(); + + /** + * @return a probability density function representing this distribution + */ + public UnivariateFunction getProbabilityDensityFunction(); + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/MultivariateNormalDistribution.java",".java","8733","263","package com.spread.math; + +/** + * @author Marc Suchard + */ +public class MultivariateNormalDistribution implements MultivariateDistribution { + + public static final String TYPE = ""MultivariateNormal""; + + private final double[] mean; + private final double[][] precision; + private double[][] variance = null; + private double[][] cholesky = null; + private Double logDet = null; + + public MultivariateNormalDistribution(double[] mean, double[][] precision) { + this.mean = mean; + this.precision = precision; + } + + public String getType() { + return TYPE; + } + + public double[][] getVariance() { + if (variance == null) { + variance = new SymmetricMatrix(precision).inverse().toComponents(); + } + return variance; + } + + public double[][] getCholeskyDecomposition() { + if (cholesky == null) { + cholesky = getCholeskyDecomposition(getVariance()); + } + return cholesky; + } + + public double getLogDet() { + if (logDet == null) { + logDet = Math.log(calculatePrecisionMatrixDeterminate(precision)); + } + return logDet; + } + + public double[][] getScaleMatrix() { + return precision; + } + + public double[] getMean() { + return mean; + } + + public double[] nextMultivariateNormal() { + return nextMultivariateNormalCholesky(mean, getCholeskyDecomposition(), + 1.0); + } + + public double[] nextMultivariateNormal(double[] x) { + return nextMultivariateNormalCholesky(x, getCholeskyDecomposition(), + 1.0); + } + + // Scale lives in variance-space + public double[] nextScaledMultivariateNormal(double[] mean, double scale) { + return nextMultivariateNormalCholesky(mean, getCholeskyDecomposition(), + Math.sqrt(scale)); + } + + // Scale lives in variance-space + public void nextScaledMultivariateNormal(double[] mean, double scale, + double[] result) { + nextMultivariateNormalCholesky(mean, getCholeskyDecomposition(), Math + .sqrt(scale), result); + } + + public static double calculatePrecisionMatrixDeterminate( + double[][] precision) { + try { + return new Matrix(precision).determinant(); + } catch (IllegalDimension e) { + throw new RuntimeException(e.getMessage()); + } + } + + public double logPdf(double[] x) { + return logPdf(x, mean, precision, getLogDet(), 1.0); + } + + public static double logPdf(double[] x, double[] mean, + double[][] precision, double logDet, double scale) { + + if (logDet == Double.NEGATIVE_INFINITY) + return logDet; + + final int dim = x.length; + final double[] delta = new double[dim]; + final double[] tmp = new double[dim]; + + for (int i = 0; i < dim; i++) { + delta[i] = x[i] - mean[i]; + } + + for (int i = 0; i < dim; i++) { + for (int j = 0; j < dim; j++) { + tmp[i] += delta[j] * precision[j][i]; + } + } + + double SSE = 0; + + for (int i = 0; i < dim; i++) + SSE += tmp[i] * delta[i]; + + return dim * logNormalize + 0.5 + * (logDet - dim * Math.log(scale) - SSE / scale); // There was + // an error + // here. + // Variance = (scale * Precision^{-1}) + } + + /* Equal precision, independent dimensions */ + public static double logPdf(double[] x, double[] mean, double precision, + double scale) { + + final int dim = x.length; + + double SSE = 0; + for (int i = 0; i < dim; i++) { + double delta = x[i] - mean[i]; + SSE += delta * delta; + } + + return dim + * logNormalize + + 0.5 + * (dim * (Math.log(precision) - Math.log(scale)) - SSE + * precision / scale); + } + + private static double[][] getInverse(double[][] x) { + return new SymmetricMatrix(x).inverse().toComponents(); + } + + private static double[][] getCholeskyDecomposition(double[][] variance) { + double[][] cholesky; + try { + cholesky = (new CholeskyDecomposition(variance)).getL(); + } catch (IllegalDimension illegalDimension) { + throw new RuntimeException( + ""Attempted Cholesky decomposition on non-square matrix""); + } + return cholesky; + } + + public static double[] nextMultivariateNormalPrecision(double[] mean, + double[][] precision) { + return nextMultivariateNormalVariance(mean, getInverse(precision)); + } + + public static double[] nextMultivariateNormalVariance(double[] mean, + double[][] variance) { + return nextMultivariateNormalVariance(mean, variance, 1.0); + } + + public static double[] nextMultivariateNormalVariance(double[] mean, + double[][] variance, double scale) { + return nextMultivariateNormalCholesky(mean, + getCholeskyDecomposition(variance), Math.sqrt(scale)); + } + + public static double[] nextMultivariateNormalCholesky(double[] mean, + double[][] cholesky) { + return nextMultivariateNormalCholesky(mean, cholesky, 1.0); + } + + public static double[] nextMultivariateNormalCholesky(double[] mean, + double[][] cholesky, double sqrtScale) { + + double[] result = new double[mean.length]; + nextMultivariateNormalCholesky(mean, cholesky, sqrtScale, result); + return result; + } + + public static void nextMultivariateNormalCholesky(double[] mean, + double[][] cholesky, double sqrtScale, double[] result) { + + final int dim = mean.length; + + System.arraycopy(mean, 0, result, 0, dim); + + double[] epsilon = new double[dim]; + for (int i = 0; i < dim; i++) + epsilon[i] = MathUtils.nextGaussian() * sqrtScale; + + for (int i = 0; i < dim; i++) { + for (int j = 0; j <= i; j++) { + result[i] += cholesky[i][j] * epsilon[j]; + // caution: decomposition returns lower triangular + } + } + } + + // TODO should be a junit test + public static void main(String[] args) { + testPdf(); + testRandomDraws(); + } + + public static void testPdf() { + double[] start = { 1, 2 }; + double[] stop = { 0, 0 }; + double[][] precision = { { 2, 0.5 }, { 0.5, 1 } }; + double scale = 0.2; + System.err.println(""logPDF = "" + + logPdf(start, stop, precision, Math + .log(calculatePrecisionMatrixDeterminate(precision)), + scale)); + System.err.println(""Should = -19.94863\n""); + + System.err.println(""logPDF = "" + logPdf(start, stop, 2, 0.2)); + System.err.println(""Should = -24.53529\n""); + } + + public static void testRandomDraws() { + + double[] start = { 1, 2 }; + double[][] precision = { { 2, 0.5 }, { 0.5, 1 } }; + int length = 100000; + + System.err.println(""Random draws (via precision) ...""); + double[] mean = new double[2]; + double[] SS = new double[2]; + double[] var = new double[2]; + double ZZ = 0; + for (int i = 0; i < length; i++) { + double[] draw = nextMultivariateNormalPrecision(start, precision); + for (int j = 0; j < 2; j++) { + mean[j] += draw[j]; + SS[j] += draw[j] * draw[j]; + } + ZZ += draw[0] * draw[1]; + } + + for (int j = 0; j < 2; j++) { + mean[j] /= length; + SS[j] /= length; + var[j] = SS[j] - mean[j] * mean[j]; + } + ZZ /= length; + ZZ -= mean[0] * mean[1]; + + System.err.println(""Mean: "" + new Vector(mean)); + System.err.println(""TRUE: [ 1 2 ]\n""); + System.err.println(""MVar: "" + new Vector(var)); + System.err.println(""TRUE: [ 0.571 1.14 ]\n""); + System.err.println(""Covv: "" + ZZ); + System.err.println(""TRUE: -0.286""); + } + + public static final double logNormalize = -0.5 * Math.log(2.0 * Math.PI); +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/GammaFunction.java",".java","7785","215","/* + * GammaFunction.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * gamma function + * + * @author Korbinian Strimmer + * @version $Id: GammaFunction.java,v 1.3 2005/05/24 20:26:01 rambaut Exp $ + */ +public class GammaFunction { + // + // Public stuff + // + + // Gamma function + + /** + * log Gamma function: ln(gamma(alpha)) for alpha>0, accurate to 10 decimal + * places + * + * @param alpha + * argument + * @return the log of the gamma function of the given alpha + */ + public static double lnGamma(double alpha) { + // Pike MC & Hill ID (1966) Algorithm 291: Logarithm of the gamma + // function. + // Communications of the Association for Computing Machinery, 9:684 + + double x = alpha, f = 0.0, z; + + if (x < 7) { + f = 1; + z = x - 1; + while (++z < 7) { + f *= z; + } + x = z; + f = -Math.log(f); + } + z = 1 / (x * x); + + return f + + (x - 0.5) + * Math.log(x) + - x + + 0.918938533204673 + + (((-0.000595238095238 * z + 0.000793650793651) * z - 0.002777777777778) + * z + 0.083333333333333) / x; + } + + /** + * Incomplete Gamma function Q(a,x) (a cleanroom implementation of Numerical + * Recipes gammq(a,x); in Mathematica this function is called + * GammaRegularized) + * + * @param a + * parameter + * @param x + * argument + * @return function value + */ + public static double incompleteGammaQ(double a, double x) { + return 1.0 - incompleteGamma(x, a, lnGamma(a)); + } + + /** + * Incomplete Gamma function P(a,x) = 1-Q(a,x) (a cleanroom implementation + * of Numerical Recipes gammp(a,x); in Mathematica this function is + * 1-GammaRegularized) + * + * @param a + * parameter + * @param x + * argument + * @return function value + */ + public static double incompleteGammaP(double a, double x) { + return incompleteGamma(x, a, lnGamma(a)); + } + + /** + * Incomplete Gamma function P(a,x) = 1-Q(a,x) (a cleanroom implementation + * of Numerical Recipes gammp(a,x); in Mathematica this function is + * 1-GammaRegularized) + * + * @param a + * parameter + * @param x + * argument + * @param lnGammaA + * precomputed lnGamma(a) + * @return function value + */ + public static double incompleteGammaP(double a, double x, double lnGammaA) { + return incompleteGamma(x, a, lnGammaA); + } + + /** + * Returns the incomplete gamma ratio I(x,alpha) where x is the upper limit + * of the integration and alpha is the shape parameter. + * + * @param x + * upper limit of integration + * @param alpha + * shape parameter + * @param ln_gamma_alpha + * the log gamma function for alpha + * @return the incomplete gamma ratio + */ + private static double incompleteGamma(double x, double alpha, + double ln_gamma_alpha) { + // (1) series expansion if (alpha>x || x<=1) + // (2) continued fraction otherwise + // RATNEST FORTRAN by + // Bhattacharjee GP (1970) The incomplete gamma integral. Applied + // Statistics, + // 19: 285-287 (AS32) + + double accurate = 1e-8, overflow = 1e30; + double factor, gin, rn, a, b, an, dif, term; + double pn0, pn1, pn2, pn3, pn4, pn5; + + if (x == 0.0) { + return 0.0; + } + if (x < 0.0 || alpha <= 0.0) { + throw new IllegalArgumentException(""Arguments out of bounds""); + } + + factor = Math.exp(alpha * Math.log(x) - x - ln_gamma_alpha); + + if (x > 1 && x >= alpha) { + // continued fraction + a = 1 - alpha; + b = a + x + 1; + term = 0; + pn0 = 1; + pn1 = x; + pn2 = x + 1; + pn3 = x * b; + gin = pn2 / pn3; + + do { + a++; + b += 2; + term++; + an = a * term; + pn4 = b * pn2 - an * pn0; + pn5 = b * pn3 - an * pn1; + + if (pn5 != 0) { + rn = pn4 / pn5; + dif = Math.abs(gin - rn); + if (dif <= accurate) { + if (dif <= accurate * rn) { + break; + } + } + + gin = rn; + } + pn0 = pn2; + pn1 = pn3; + pn2 = pn4; + pn3 = pn5; + if (Math.abs(pn4) >= overflow) { + pn0 /= overflow; + pn1 /= overflow; + pn2 /= overflow; + pn3 /= overflow; + } + } while (true); + gin = 1 - factor * gin; + } else { + // series expansion + gin = 1; + term = 1; + rn = alpha; + do { + rn++; + term *= x / rn; + gin += term; + } while (term > accurate); + gin *= factor / alpha; + } + return gin; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/NonSymmetricComponents.java",".java","1617","55","/* + * NonSymmetricComponents.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * @author Didier H. Besset + */ +public class NonSymmetricComponents extends Exception { + + /** + * + */ + private static final long serialVersionUID = 9046634992672041256L; + + /** + * DhbNonSymmetricComponents constructor comment. + */ + public NonSymmetricComponents() { + super(); + } + + /** + * DhbNonSymmetricComponents constructor comment. + * + * @param s + * java.lang.String + */ + public NonSymmetricComponents(String s) { + super(s); + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/MultivariateDistribution.java",".java","250","17","package com.spread.math; + +/** + * @author Marc A. Suchard + */ +public interface MultivariateDistribution { + + public double logPdf(double[] x); + + public double[][] getScaleMatrix(); + + public double[] getMean(); + + public String getType(); + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/LUPDecomposition.java",".java","11074","333","/* + * LUPDecomposition.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * Lower Upper Permutation (LUP) decomposition + * + * @author Didier H. Besset + */ +public class LUPDecomposition { + /** + * Rows of the system + */ + private double[][] rows; + /** + * Permutation + */ + private int[] permutation = null; + /** + * Permutation's parity + */ + private int parity = 1; + + /** + * Constructor method + * + * @param components + * double[][] + * @throws DhbMatrixAlgebra.DhbIllegalDimension + * the supplied matrix is not square + */ + public LUPDecomposition(double[][] components) throws IllegalDimension { + int n = components.length; + if (components[0].length != n) + throw new IllegalDimension(""Illegal system: a"" + n + "" by "" + + components[0].length + "" matrix is not a square matrix""); + rows = components; + initialize(); + } + + /** + * Constructor method. + * + * @param m + * DhbMatrixAlgebra.Matrix + * @throws DhbMatrixAlgebra.DhbIllegalDimension + * the supplied matrix is not square + */ + public LUPDecomposition(Matrix m) throws IllegalDimension { + if (!m.isSquare()) + throw new IllegalDimension(""Supplied matrix is not a square matrix""); + initialize(m.components); + } + + /** + * Constructor method. + * + * @param m + * DhbMatrixAlgebra.DhbSymmetricMatrix + */ + public LUPDecomposition(SymmetricMatrix m) { + initialize(m.components); + } + + /** + * @param xTilde + * double[] + * @return double[] + */ + private double[] backwardSubstitution(double[] xTilde) { + int n = rows.length; + double[] answer = new double[n]; + for (int i = n - 1; i >= 0; i--) { + answer[i] = xTilde[i]; + for (int j = i + 1; j < n; j++) + answer[i] -= rows[i][j] * answer[j]; + answer[i] /= rows[i][i]; + } + return answer; + } + + private void decompose() { + int n = rows.length; + permutation = new int[n]; + for (int i = 0; i < n; i++) + permutation[i] = i; + parity = 1; + try { + for (int i = 0; i < n; i++) { + swapRows(i, largestPivot(i)); + pivot(i); + } + } catch (ArithmeticException e) { + parity = 0; + } + } + + /** + * @return boolean true if decomposition was done already + */ + private boolean decomposed() { + if (parity == 1 && permutation == null) + decompose(); + return parity != 0; + } + + /** + * @param c + * double[] + * @return double[] + */ + public double determinant() { + if (!decomposed()) + return Double.NaN; + double determinant = parity; + for (int i = 0; i < rows.length; i++) + determinant *= rows[i][i]; + return determinant; + } + + public boolean isPD() { + for (int i = 0; i < rows.length; i++) { + if (rows[i][i] <= 0) + return false; + } + return true; + } + + /** + * @param c + * double[] + * @return double[] + */ + private double[] forwardSubstitution(double[] c) { + int n = rows.length; + double[] answer = new double[n]; + for (int i = 0; i < n; i++) { + answer[i] = c[permutation[i]]; + for (int j = 0; j <= i - 1; j++) + answer[i] -= rows[i][j] * answer[j]; + } + return answer; + } + + private void initialize() { + permutation = null; + parity = 1; + } + + /** + * @param components + * double[][] components obtained from constructor methods. + */ + private void initialize(double[][] components) { + int n = components.length; + rows = new double[n][n]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + rows[i][j] = components[i][j]; + } + initialize(); + } + + /** + * @param c + * double[] + * @return double[] + */ + public double[][] inverseMatrixComponents() { + if (!decomposed()) + return null; + int n = rows.length; + double[][] inverseRows = new double[n][n]; + double[] column = new double[n]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + column[j] = 0; + column[i] = 1; + column = solve(column); + for (int j = 0; j < n; j++) + inverseRows[i][j] = column[j]; + } + return inverseRows; + } + + /** + * @param k + * int + * @return int + */ + private int largestPivot(int k) { + double maximum = Math.abs(rows[k][k]); + double abs; + int index = k; + for (int i = k + 1; i < rows.length; i++) { + abs = Math.abs(rows[i][k]); + if (abs > maximum) { + maximum = abs; + index = i; + } + } + return index; + } + + /** + * @param k + * int + */ + private void pivot(int k) { + double inversePivot = 1 / rows[k][k]; + int k1 = k + 1; + int n = rows.length; + for (int i = k1; i < n; i++) { + rows[i][k] *= inversePivot; + for (int j = k1; j < n; j++) + rows[i][j] -= rows[i][k] * rows[k][j]; + } + } + + /** + * @param c + * double[] + * @return double[] + */ + public double[] solve(double[] c) { + return decomposed() ? backwardSubstitution(forwardSubstitution(c)) + : null; + } + + /** + * @param c + * double[] + * @return double[] + */ + public Vector solve(Vector c) { + double[] components = solve(c.components); + if (components == null) + return null; + return components == null ? null : new Vector(components); + } + + /** + * @param i + * int + * @param k + * int + */ + private void swapRows(int i, int k) { + if (i != k) { + double temp; + for (int j = 0; j < rows.length; j++) { + temp = rows[i][j]; + rows[i][j] = rows[k][j]; + rows[k][j] = temp; + } + int nTemp; + nTemp = permutation[i]; + permutation[i] = permutation[k]; + permutation[k] = nTemp; + parity = -parity; + } + } + + /** + * Make sure the supplied matrix components are those of a symmetric matrix + * + * @param components + * double + */ + public static void symmetrizeComponents(double[][] components) { + for (int i = 0; i < components.length; i++) { + for (int j = i + 1; j < components.length; j++) { + components[i][j] += components[j][i]; + components[i][j] *= 0.5; + components[j][i] = components[i][j]; + } + } + } + + /** + * Returns a String that represents the value of this object. + * + * @return a string representation of the receiver + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + char[] separator = { '[', ' ' }; + int n = rows.length; + for (int i = 0; i < n; i++) { + separator[0] = '{'; + for (int j = 0; j < n; j++) { + sb.append(separator); + sb.append(rows[i][j]); + separator[0] = ' '; + } + sb.append('}'); + sb.append('\n'); + } + if (permutation != null) { + sb.append(parity == 1 ? '+' : '-'); + sb.append(""( "" + permutation[0]); + for (int i = 1; i < n; i++) + sb.append("", "" + permutation[i]); + sb.append(')'); + sb.append('\n'); + } + return sb.toString(); + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/UnivariateFunction.java",".java","1540","55","/* + * UnivariateFunction.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * Interface for a function of one variable. + * + * @author Korbinian Strimmer + */ +public interface UnivariateFunction { + /** + * compute function value + * + * @param argument + * + * @return function value + */ + double evaluate(double argument); + + /** + * + * @return lower bound of argument + */ + double getLowerBound(); + + /** + * + * @return upper bound of argument + */ + double getUpperBound(); +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/Vector.java",".java","14514","381","/* + * Vector.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * Vector implementation + * + * @author Didier H. Besset + */ +public class Vector { + protected double[] components; + + /** + * Create a vector of given dimension. NOTE: The supplied array of + * components must not be changed. + * + * @param comp + * double[] + */ + public Vector(double comp[]) throws NegativeArraySizeException { + int n = comp.length; + if (n <= 0) + throw new NegativeArraySizeException( + ""Vector components cannot be empty""); + components = new double[n]; + System.arraycopy(comp, 0, components, 0, n); + } + + public Vector(int comp[]) throws NegativeArraySizeException { + int n = comp.length; + if (n <= 0) + throw new NegativeArraySizeException( + ""Vector components cannot be empty""); + components = new double[n]; + // System.arraycopy( comp, 0, components, 0, n); + for (int i = 0; i < n; i++) + components[i] = comp[i]; + + } + + /** + * Create a vector of given dimension. + * + * @param dimension + * int dimension of the vector; must be positive. + */ + public Vector(int dimension) throws NegativeArraySizeException { + if (dimension <= 0) + throw new NegativeArraySizeException(""Requested vector size: "" + + dimension); + components = new double[dimension]; + clear(); + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public void accumulate(double[] x) throws IllegalDimension { + if (this.dimension() != x.length) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + x.length + ""-dimension array""); + for (int i = 0; i < this.dimension(); i++) + components[i] += x[i]; + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public void accumulate(Vector v) throws IllegalDimension { + if (this.dimension() != v.dimension()) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + v.dimension() + + ""-dimension vector""); + for (int i = 0; i < this.dimension(); i++) + components[i] += v.components[i]; + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public void accumulateNegated(double[] x) throws IllegalDimension { + if (this.dimension() != x.length) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + x.length + ""-dimension array""); + for (int i = 0; i < this.dimension(); i++) + components[i] -= x[i]; + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public void accumulateNegated(Vector v) throws IllegalDimension { + if (this.dimension() != v.dimension()) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + v.dimension() + + ""-dimension vector""); + for (int i = 0; i < this.dimension(); i++) + components[i] -= v.components[i]; + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @return DHBmatrixAlgebra.DhbVector sum of the vector with the supplied + * vector + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public Vector add(Vector v) throws IllegalDimension { + if (this.dimension() != v.dimension()) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + v.dimension() + + ""-dimension vector""); + double[] newComponents = new double[this.dimension()]; + for (int i = 0; i < this.dimension(); i++) + newComponents[i] = components[i] + v.components[i]; + return new Vector(newComponents); + } + + /** + * Sets all components of the receiver to 0. + */ + public void clear() { + for (int i = 0; i < components.length; i++) + components[i] = 0; + } + + /** + * @param n + * int + * @return double + */ + public double component(int n) { + return components[n]; + } + + /** + * Returns the dimension of the vector. + * + * @return int + */ + public int dimension() { + return components.length; + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @return true if the supplied vector is equal to the receiver + */ + public boolean equals(Vector v) { + int n = this.dimension(); + if (v.dimension() != n) + return false; + for (int i = 0; i < n; i++) { + if (v.components[i] != components[i]) + return false; + } + return true; + } + + /** + * Computes the norm of a vector. + */ + public double norm() { + double sum = 0; + for (int i = 0; i < components.length; i++) + sum += components[i] * components[i]; + return Math.sqrt(sum); + } + + /** + * @param x + * double + */ + public Vector normalizedBy(double x) { + for (int i = 0; i < this.dimension(); i++) + components[i] /= x; + return this; + } + + /** + * Computes the product of the vector by a number. + * + * @param d + * double + * @return DHBmatrixAlgebra.DhbVector + */ + public Vector product(double d) { + double newComponents[] = new double[components.length]; + for (int i = 0; i < components.length; i++) + newComponents[i] = d * components[i]; + return new Vector(newComponents); + } + + /** + * Compute the scalar product (or dot product) of two vectors. + * + * @param v + * DHBmatrixAlgebra.DhbVector + * @return double the scalar product of the receiver with the argument + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the dimension of v is not the same. + */ + public double product(Vector v) throws IllegalDimension { + int n = v.dimension(); + if (components.length != n) + throw new IllegalDimension( + ""Dot product with mismatched dimensions: "" + + components.length + "", "" + n); + return secureProduct(v); + } + + /** + * Computes the product of the transposed vector with a matrix + * + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.DhbVector + */ + public Vector product(Matrix a) throws IllegalDimension { + int n = a.rows(); + int m = a.columns(); + if (this.dimension() != n) + throw new IllegalDimension(""Product error: transposed of a "" + + this.dimension() + + ""-dimension vector cannot be multiplied with a "" + n + + "" by "" + m + "" matrix""); + return secureProduct(a); + } + + /** + * @param x + * double + */ + public Vector scaledBy(double x) { + for (int i = 0; i < this.dimension(); i++) + components[i] *= x; + return this; + } + + /** + * Compute the scalar product (or dot product) of two vectors. No dimension + * checking is made. + * + * @param v + * DHBmatrixAlgebra.DhbVector + * @return double the scalar product of the receiver with the argument + */ + protected double secureProduct(Vector v) { + double sum = 0; + for (int i = 0; i < v.dimension(); i++) + sum += components[i] * v.components[i]; + return sum; + } + + /** + * Computes the product of the transposed vector with a matrix + * + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.DhbVector + */ + protected Vector secureProduct(Matrix a) { + int n = a.rows(); + int m = a.columns(); + double[] vectorComponents = new double[m]; + for (int j = 0; j < m; j++) { + vectorComponents[j] = 0; + for (int i = 0; i < n; i++) + vectorComponents[j] += components[i] * a.components[i][j]; + } + return new Vector(vectorComponents); + } + + /** + * @param v + * DHBmatrixAlgebra.DhbVector + * @return DHBmatrixAlgebra.DhbVector subtract the supplied vector to the + * receiver + * @throws DHBmatrixAlgebra.DhbIllegalDimension + * if the vector and supplied vector do not have the same + * dimension. + */ + public Vector subtract(Vector v) throws IllegalDimension { + if (this.dimension() != v.dimension()) + throw new IllegalDimension(""Attempt to add a "" + this.dimension() + + ""-dimension vector to a "" + v.dimension() + + ""-dimension vector""); + double[] newComponents = new double[this.dimension()]; + for (int i = 0; i < this.dimension(); i++) + newComponents[i] = components[i] - v.components[i]; + return new Vector(newComponents); + } + + /** + * @param v + * MatrixAlgebra.DhbVector second vector to build tensor product + * with. + * @return MatrixAlgebra.Matrix tensor product with the specified vector + */ + public Matrix tensorProduct(Vector v) { + int n = dimension(); + int m = v.dimension(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) + newComponents[i][j] = components[i] * v.components[j]; + } + return n == m ? new SymmetricMatrix(newComponents) : new Matrix( + newComponents); + } + + /** + * @return double[] a copy of the components of the receiver. + */ + public double[] toComponents() { + int n = dimension(); + double[] answer = new double[n]; + System.arraycopy(components, 0, answer, 0, n); + return answer; + } + + /** + * Returns a string representation of the vector. + * + * @return java.lang.String + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + char[] separator = { '[', ' ' }; + for (int i = 0; i < components.length; i++) { + sb.append(separator); + sb.append(components[i]); + separator[0] = ','; + } + sb.append(']'); + return sb.toString(); + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/ErrorFunction.java",".java","3762","113","/* + * ErrorFunction.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * error function and related stuff + * + * @version $Id: ErrorFunction.java,v 1.3 2005/05/24 20:26:00 rambaut Exp $ + * + * @author Korbinian Strimmer + */ +public class ErrorFunction { + // + // Public stuff + // + + /** + * error function + * + * @param x + * argument + * + * @return function value + */ + public static double erf(double x) { + if (x > 0.0) { + return GammaFunction.incompleteGammaP(0.5, x * x); + } else if (x < 0.0) { + return -GammaFunction.incompleteGammaP(0.5, x * x); + } else { + return 0.0; + } + } + + /** + * complementary error function = 1-erf(x) + * + * @param x + * argument + * + * @return function value + */ + public static double erfc(double x) { + return 1.0 - erf(x); + } + + /** + * inverse error function + * + * @param z + * argument + * + * @return function value + */ + public static double inverseErf(double z) { + return pointNormal(0.5 * z + 0.5) / Math.sqrt(2.0); + } + + // Private + + // Returns z so that Prob{x 0.0); + L[j][j] = Math.sqrt(Math.max(d, 0.0)); + /* + * for (int k = j+1; k < n; k++) { L[j][k] = 0.0; } + */ + } + + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/MathUtils.java",".java","13897","425","/* + * MathUtils.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +import java.text.NumberFormat; +import java.text.ParseException; + +import jebl.math.GammaFunction; +import com.spread.utils.NumberFormatter; + +/** + * Handy utility functions which have some Mathematical relavance. + * + * @author Matthew Goode + * @author Alexei Drummond + * @author Gerton Lunter + * @version $Id: MathUtils.java,v 1.13 2006/08/31 14:57:24 rambaut Exp $ + */ +public class MathUtils { + + private MathUtils() { + } + + /** + * A random number generator that is initialized with the clock when this + * class is loaded into the JVM. Use this for all random numbers. Note: This + * method or getting random numbers in not thread-safe. Since + * MersenneTwisterFast is currently (as of 9/01) not synchronized using this + * function may cause concurrency issues. Use the static get methods of the + * MersenneTwisterFast class for access to a single instance of the class, + * that has synchronization. + */ + private static final MersenneTwisterFast random = MersenneTwisterFast.DEFAULT_INSTANCE; + + // Chooses one category if a cumulative probability distribution is given + public static int randomChoice(double[] cf) { + + double U = random.nextDouble(); + + int s; + if (U <= cf[0]) { + s = 0; + } else { + for (s = 1; s < cf.length; s++) { + if (U <= cf[s] && U > cf[s - 1]) { + break; + } + } + } + + return s; + } + + /** + * @param pdf + * array of unnormalized probabilities + * @return a sample according to an unnormalized probability distribution + */ + public static int randomChoicePDF(double[] pdf) { + + double U = random.nextDouble() * getTotal(pdf); + for (int i = 0; i < pdf.length; i++) { + + U -= pdf[i]; + if (U < 0.0) { + return i; + } + + } + for (int i = 0; i < pdf.length; i++) { + System.out.println(i + ""\t"" + pdf[i]); + } + throw new Error( + ""randomChoiceUnnormalized falls through -- negative components in input distribution?""); + } + + /** + * @param array + * to normalize + * @return a new double array where all the values sum to 1. Relative ratios + * are preserved. + */ + public static double[] getNormalized(double[] array) { + double[] newArray = new double[array.length]; + double total = getTotal(array); + for (int i = 0; i < array.length; i++) { + newArray[i] = array[i] / total; + } + return newArray; + } + + /** + * @param array + * entries to be summed + * @param start + * start position + * @param end + * the index of the element after the last one to be included + * @return the total of a the values in a range of an array + */ + public static double getTotal(double[] array, int start, int end) { + double total = 0.0; + for (int i = start; i < end; i++) { + total += array[i]; + } + return total; + } + + /** + * @param array + * to sum over + * @return the total of the values in an array + */ + public static double getTotal(double[] array) { + return getTotal(array, 0, array.length); + + } + + // ===================== (Synchronized) Static access methods to the private + // random instance =========== + + /** + * Access a default instance of this class, access is synchronized + */ + public static long getSeed() { + synchronized (random) { + return random.getSeed(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static void setSeed(long seed) { + synchronized (random) { + random.setSeed(seed); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static byte nextByte() { + synchronized (random) { + return random.nextByte(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static boolean nextBoolean() { + synchronized (random) { + return random.nextBoolean(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static void nextBytes(byte[] bs) { + synchronized (random) { + random.nextBytes(bs); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static char nextChar() { + synchronized (random) { + return random.nextChar(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static double nextGaussian() { + synchronized (random) { + return random.nextGaussian(); + } + } + + // Mean = alpha / lambda + // Variance = alpha / (lambda*lambda) + + public static double nextGamma(double alpha, double lambda) { + synchronized (random) { + return random.nextGamma(alpha, lambda); + } + } + + /** + * Access a default instance of this class, access is synchronized + * + * @return a pseudo random double precision floating point number in [01) + */ + public static double nextDouble() { + synchronized (random) { + return random.nextDouble(); + } + } + + /** + * @return log of random variable in [0,1] + */ + public static double randomLogDouble() { + return Math.log(nextDouble()); + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static double nextExponential(double lambda) { + synchronized (random) { + return -1.0 * Math.log(1 - random.nextDouble()) / lambda; + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static double nextInverseGaussian(double mu, double lambda) { + synchronized (random) { + /* + * CODE TAKEN FROM WIKIPEDIA. TESTING DONE WITH RESULTS GENERATED IN + * R AND LOOK COMPARABLE + */ + double v = random.nextGaussian(); // sample from a normal + // distribution with a mean of 0 + // and 1 standard deviation + double y = v * v; + double x = mu + (mu * mu * y) / (2 * lambda) - (mu / (2 * lambda)) + * Math.sqrt(4 * mu * lambda * y + mu * mu * y * y); + double test = MathUtils.nextDouble(); // sample from a uniform + // distribution between 0 + // and 1 + if (test <= (mu) / (mu + x)) { + return x; + } else { + return (mu * mu) / x; + } + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static float nextFloat() { + synchronized (random) { + return random.nextFloat(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static long nextLong() { + synchronized (random) { + return random.nextLong(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static short nextShort() { + synchronized (random) { + return random.nextShort(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static int nextInt() { + synchronized (random) { + return random.nextInt(); + } + } + + /** + * Access a default instance of this class, access is synchronized + */ + public static int nextInt(int n) { + synchronized (random) { + return random.nextInt(n); + } + } + + /** + * + * @param low + * @param high + * @return uniform between low and high + */ + public static double uniform(double low, double high) { + return low + nextDouble() * (high - low); + } + + /** + * Shuffles an array. + */ + public static void shuffle(int[] array) { + synchronized (random) { + random.shuffle(array); + } + } + + /** + * Shuffles an array. Shuffles numberOfShuffles times + */ + public static void shuffle(int[] array, int numberOfShuffles) { + synchronized (random) { + random.shuffle(array, numberOfShuffles); + } + } + + /** + * Returns an array of shuffled indices of length l. + * + * @param l + * length of the array required. + */ + public static int[] shuffled(int l) { + synchronized (random) { + return random.shuffled(l); + } + } + + public static int[] sampleIndicesWithReplacement(int length) { + synchronized (random) { + int[] result = new int[length]; + for (int i = 0; i < length; i++) + result[i] = random.nextInt(length); + return result; + } + } + + /** + * Permutes an array. + */ + public static void permute(int[] array) { + synchronized (random) { + random.permute(array); + } + } + + /** + * Returns a uniform random permutation of 0,...,l-1 + * + * @param l + * length of the array required. + */ + public static int[] permuted(int l) { + synchronized (random) { + return random.permuted(l); + } + } + + public static double logHyperSphereVolume(int dimension, double radius) { + return dimension * (0.5723649429247001 + Math.log(radius)) + + -GammaFunction.lnGamma(dimension / 2.0 + 1.0); + } + + /** + * Returns sqrt(a^2 + b^2) without under/overflow. + */ + public static double hypot(double a, double b) { + double r; + if (Math.abs(a) > Math.abs(b)) { + r = b / a; + r = Math.abs(a) * Math.sqrt(1 + r * r); + } else if (b != 0) { + r = a / b; + r = Math.abs(b) * Math.sqrt(1 + r * r); + } else { + r = 0.0; + } + return r; + } + + /** + * return double *.???? + * + * @param value + * @param sf + * @return + */ + public static double round(double value, int sf) { + NumberFormatter formatter = new NumberFormatter(sf); + try { + return NumberFormat.getInstance().parse(formatter.format(value)) + .doubleValue(); + } catch (ParseException e) { + return value; + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/SymmetricMatrix.java",".java","14630","369","/* + * SymmetricMatrix.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * Symmetric matrix + * + * @author Didier H. Besset + */ +public class SymmetricMatrix extends Matrix { + + private static int lupCRLCriticalDimension = 36; + + /** + * Creates a symmetric matrix with given components. + * + * @param a + * double[][] + */ + public SymmetricMatrix(double[][] a) { + super(a); + } + + /** + * @param n + * int + * @throws java.lang.NegativeArraySizeException + * if n <= 0 + */ + public SymmetricMatrix(int n) throws NegativeArraySizeException { + super(n, n); + } + + /** + * Constructor method. + * + * @param n + * int + * @param m + * int + * @throws java.lang.NegativeArraySizeException + * if n,m <= 0 + */ + public SymmetricMatrix(int n, int m) throws NegativeArraySizeException { + super(n, m); + } + + /** + * @param a + * Matrix + * @return SymmetricMatrix sum of the matrix with the supplied matrix. + * @throws IllegalDimension + * if the supplied matrix does not have the same dimensions. + */ + public SymmetricMatrix add(SymmetricMatrix a) throws IllegalDimension { + return new SymmetricMatrix(addComponents(a)); + } + + /** + * Answers the inverse of the receiver computed via the CRL algorithm. + * + * @return MatrixAlgebra.SymmetricMatrix + * @throws java.lang.ArithmeticException + * if the matrix is singular. + */ + private SymmetricMatrix crlInverse() throws ArithmeticException { + if (rows() == 1) + return inverse1By1(); + else if (rows() == 2) + return inverse2By2(); + Matrix[] splitMatrices = split(); + SymmetricMatrix b1 = (SymmetricMatrix) splitMatrices[0].inverse(); + Matrix cb1 = splitMatrices[2].secureProduct(b1); + SymmetricMatrix cb1cT = new SymmetricMatrix(cb1 + .productWithTransposedComponents(splitMatrices[2])); + splitMatrices[1] = ((SymmetricMatrix) splitMatrices[1]).secureSubtract( + cb1cT).inverse(); + splitMatrices[2] = splitMatrices[1].secureProduct(cb1); + splitMatrices[0] = b1.secureAdd(new SymmetricMatrix(cb1 + .transposedProductComponents(splitMatrices[2]))); + return SymmetricMatrix.join(splitMatrices); + } + + /** + * @return MatrixAlgebra.SymmetricMatrix + * @throws matrixAlgebra.IllegalDimension + * The supplied components are not those of a square matrix. + * @throws matrixAlgebra.NonSymmetricComponents + * The supplied components are not symmetric. + * @param comp + * double[][] components of the matrix + */ + public static SymmetricMatrix fromComponents(double[][] comp) + throws IllegalDimension, NonSymmetricComponents { + if (comp.length != comp[0].length) + throw new IllegalDimension(""Non symmetric components: a "" + + comp.length + "" by "" + comp[0].length + + "" matrix cannot be symmetric""); + for (int i = 0; i < comp.length; i++) { + for (int j = 0; j < i; j++) { + if (comp[i][j] != comp[j][i]) + throw new NonSymmetricComponents( + ""Non symmetric components: a["" + i + ""]["" + j + + ""]= "" + comp[i][j] + "", a["" + j + ""]["" + + i + ""]= "" + comp[j][i]); + } + } + return new SymmetricMatrix(comp); + } + + /** + * @param n + * int + * @return SymmetricMatrix an identity matrix of size n + */ + public static SymmetricMatrix identityMatrix(int n) { + double[][] a = new double[n][n]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + a[i][j] = 0; + a[i][i] = 1; + } + return new SymmetricMatrix(a); + } + + /** + * @return Matrix inverse of the receiver. + * @throws java.lang.ArithmeticException + * if the receiver is a singular matrix. + */ + public Matrix inverse() throws ArithmeticException { + return rows() < lupCRLCriticalDimension ? new SymmetricMatrix( + (new LUPDecomposition(this)).inverseMatrixComponents()) + : crlInverse(); + } + + /** + * Compute the inverse of the receiver in the case of a 1 by 1 matrix. + * Internal use only: no check is made. + * + * @return MatrixAlgebra.SymmetricMatrix + */ + private SymmetricMatrix inverse1By1() { + double[][] newComponents = new double[1][1]; + newComponents[0][0] = 1 / components[0][0]; + return new SymmetricMatrix(newComponents); + } + + /** + * Compute the inverse of the receiver in the case of a 2 by 2 matrix. + * Internal use only: no check is made. + * + * @return MatrixAlgebra.SymmetricMatrix + */ + private SymmetricMatrix inverse2By2() { + double[][] newComponents = new double[2][2]; + double inverseDeterminant = 1 / (components[0][0] * components[1][1] - components[0][1] + * components[1][0]); + newComponents[0][0] = inverseDeterminant * components[1][1]; + newComponents[1][1] = inverseDeterminant * components[0][0]; + newComponents[0][1] = newComponents[1][0] = -inverseDeterminant + * components[1][0]; + return new SymmetricMatrix(newComponents); + } + + /** + * Build a matrix from 3 parts (inverse of split). + * + * @param a + * MatrixAlgebra.Matrix[] + * @return MatrixAlgebra.SymmetricMatrix + */ + private static SymmetricMatrix join(Matrix[] a) { + int p = a[0].rows(); + int n = p + a[1].rows(); + double[][] newComponents = new double[n][n]; + for (int i = 0; i < p; i++) { + for (int j = 0; j < p; j++) + newComponents[i][j] = a[0].components[i][j]; + for (int j = p; j < n; j++) + newComponents[i][j] = newComponents[j][i] = -a[2].components[j + - p][i]; + } + for (int i = p; i < n; i++) { + for (int j = p; j < n; j++) + newComponents[i][j] = a[1].components[i - p][j - p]; + } + return new SymmetricMatrix(newComponents); + } + + /** + * @param n + * int + * @return int + */ + private int largestPowerOf2SmallerThan(int n) { + int m = 2; + int m2; + while (true) { + m2 = 2 * m; + if (m2 >= n) + return m; + m = m2; + } + } + + /** + * @param a + * double + * @return MatrixAlgebra.SymmetricMatrix + */ + public Matrix product(double a) { + return new SymmetricMatrix(productComponents(a)); + } + + /** + * @param a + * Matrix + * @return Matrix product of the receiver with the supplied matrix + * @throws IllegalDimension + * If the number of columns of the receivers are not equal to + * the number of rows of the supplied matrix. + */ + public SymmetricMatrix product(SymmetricMatrix a) throws IllegalDimension { + return new SymmetricMatrix(productComponents(a)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix product of the receiver with the transpose + * of the supplied matrix + * @throws MatrixAlgebra.IllegalDimension + * If the number of columns of the receiver are not equal to the + * number of columns of the supplied matrix. + */ + public SymmetricMatrix productWithTransposed(SymmetricMatrix a) + throws IllegalDimension { + if (a.columns() != columns()) + throw new IllegalDimension(""Operation error: cannot multiply a "" + + rows() + "" by "" + columns() + + "" matrix with the transpose of a "" + a.rows() + "" by "" + + a.columns() + "" matrix""); + return new SymmetricMatrix(productWithTransposedComponents(a)); + } + + /** + * Same as add ( SymmetricMatrix a), but without dimension checking. + * + * @param a + * MatrixAlgebra.SymmetricMatrix + * @return MatrixAlgebra.SymmetricMatrix + */ + protected SymmetricMatrix secureAdd(SymmetricMatrix a) { + return new SymmetricMatrix(addComponents(a)); + } + + /** + * Same as product(SymmetricMatrix a), but without dimension checking. + * + * @param a + * MatrixAlgebra.SymmetricMatrix + * @return MatrixAlgebra.SymmetricMatrix + */ + protected SymmetricMatrix secureProduct(SymmetricMatrix a) { + return new SymmetricMatrix(productComponents(a)); + } + + /** + * Same as subtract ( SymmetricMatrix a), but without dimension checking. + * + * @param a + * MatrixAlgebra.SymmetricMatrix + * @return MatrixAlgebra.SymmetricMatrix + */ + protected SymmetricMatrix secureSubtract(SymmetricMatrix a) { + return new SymmetricMatrix(subtractComponents(a)); + } + + /** + * Divide the receiver into 3 matrices of approximately equal dimension. + * + * @return MatrixAlgebra.Matrix[] Array of splitted matrices + */ + private Matrix[] split() { + int n = rows(); + int p = largestPowerOf2SmallerThan(n); + int q = n - p; + double[][] a = new double[p][p]; + double[][] b = new double[q][q]; + double[][] c = new double[q][p]; + for (int i = 0; i < p; i++) { + for (int j = 0; j < p; j++) + a[i][j] = components[i][j]; + for (int j = p; j < n; j++) + c[j - p][i] = components[i][j]; + } + for (int i = p; i < n; i++) { + for (int j = p; j < n; j++) + b[i - p][j - p] = components[i][j]; + } + Matrix[] answer = new Matrix[3]; + answer[0] = new SymmetricMatrix(a); + answer[1] = new SymmetricMatrix(b); + answer[2] = new Matrix(c); + return answer; + } + + /** + * @param a + * matrixAlgebra.SymmetricMatrix + * @return matrixAlgebra.SymmetricMatrix + * @throws matrixAlgebra.IllegalDimension + * (from constructor). + */ + public SymmetricMatrix subtract(SymmetricMatrix a) throws IllegalDimension { + return new SymmetricMatrix(subtractComponents(a)); + } + + /** + * @return matrixAlgebra.Matrix the same matrix + */ + public Matrix transpose() { + return this; + } + + /** + * @param a + * MatrixAlgebra.SymmetricMatrix + * @return MatrixAlgebra.SymmetricMatrix product of the tranpose of the + * receiver with the supplied matrix + * @throws MatrixAlgebra.IllegalDimension + * If the number of rows of the receiver are not equal to the + * number of rows of the supplied matrix. + */ + public SymmetricMatrix transposedProduct(SymmetricMatrix a) + throws IllegalDimension { + if (a.rows() != rows()) + throw new IllegalDimension( + ""Operation error: cannot multiply a tranposed "" + rows() + + "" by "" + columns() + "" matrix with a "" + a.rows() + + "" by "" + a.columns() + "" matrix""); + return new SymmetricMatrix(transposedProductComponents(a)); + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/Matrix.java",".java","21413","558","/* + * Matrix.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +/** + * Class representing matrix + * + * @author Didier H. Besset + */ +public class Matrix { + protected double[][] components; + protected LUPDecomposition lupDecomposition = null; + + /** + * Creates a matrix with given components. NOTE: the components must not be + * altered after the definition. + * + * @param a + * double[][] + */ + public Matrix(double[][] a) { + components = a; + } + + /** + * Creates a matrix with given components. NOTE: the components must not be + * altered after the definition. + * + * @param a + * double[] + */ + public Matrix(double[] a, int n, int m) { + if (n <= 0 || m <= 0) + throw new NegativeArraySizeException(""Requested matrix size: "" + n + + "" by "" + m); + if (n * m != a.length) { + throw new IllegalArgumentException(""Requested matrix size: "" + n + + "" by "" + m + "" doesn't match array size: "" + a.length); + } + components = new double[n][m]; + int k = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + components[i][j] = a[k]; + k++; + } + + } + } + + /** + * Creates a null matrix of given dimensions. + * + * @param n + * int number of rows + * @param m + * int number of columns + * @throws NegativeArraySizeException + */ + public Matrix(int n, int m) throws NegativeArraySizeException { + if (n <= 0 || m <= 0) + throw new NegativeArraySizeException(""Requested matrix size: "" + n + + "" by "" + m); + components = new double[n][m]; + clear(); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @throws dr.math.matrixAlgebra.IllegalDimension + * if the supplied matrix does not have the same dimensions. + */ + public void accumulate(Matrix a) throws IllegalDimension { + if (a.rows() != rows() || a.columns() != columns()) + throw new IllegalDimension(""Operation error: cannot add a"" + + a.rows() + "" by "" + a.columns() + "" matrix to a "" + + rows() + "" by "" + columns() + "" matrix""); + int m = components[0].length; + for (int i = 0; i < components.length; i++) { + for (int j = 0; j < m; j++) + components[i][j] += a.component(i, j); + } + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix sum of the receiver with the supplied + * matrix. + * @throws dr.math.matrixAlgebra.IllegalDimension + * if the supplied matrix does not have the same dimensions. + */ + public Matrix add(Matrix a) throws IllegalDimension { + if (a.rows() != rows() || a.columns() != columns()) + throw new IllegalDimension(""Operation error: cannot add a"" + + a.rows() + "" by "" + a.columns() + "" matrix to a "" + + rows() + "" by "" + columns() + "" matrix""); + return new Matrix(addComponents(a)); + } + + /** + * Computes the components of the sum of the receiver and a supplied matrix. + * + * @param a + * MatrixAlgebra.Matrix + * @return double[][] + */ + protected double[][] addComponents(Matrix a) { + int n = this.rows(); + int m = this.columns(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + newComponents[i][j] = components[i][j] + a.components[i][j]; + } + return newComponents; + } + + public void clear() { + int m = components[0].length; + for (int i = 0; i < components.length; i++) { + for (int j = 0; j < m; j++) + components[i][j] = 0; + } + } + + /** + * @return int the number of columns of the matrix + */ + public int columns() { + return components[0].length; + } + + /** + * @param n + * int + * @param m + * int + * @return double + */ + public double component(int n, int m) { + return components[n][m]; + } + + /** + * @return double + * @throws dr.math.matrixAlgebra.IllegalDimension + * if the supplied matrix is not square. + */ + public double determinant() throws IllegalDimension { + return lupDecomposition().determinant(); + } + + public boolean isPD() throws IllegalDimension { + return lupDecomposition().isPD(); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return true if the supplied matrix is equal to the receiver. + */ + public boolean equals(Matrix a) { + int n = this.rows(); + if (a.rows() != n) + return false; + int m = this.columns(); + if (a.columns() != m) + return false; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (a.components[i][j] != components[i][j]) + return false; + } + } + return true; + } + + /** + * @return MatrixAlgebra.Matrix inverse of the receiver or pseudoinverse if + * the receiver is not a square matrix. + * @throws java.lang.ArithmeticException + * if the receiver is a singular matrix. + */ + public Matrix inverse() throws ArithmeticException { + try { + return new Matrix(lupDecomposition().inverseMatrixComponents()); + } catch (IllegalDimension e) { + return new Matrix(transposedProduct().inverse() + .productWithTransposedComponents(this)); + } + } + + /** + * @return boolean + */ + public boolean isSquare() { + return rows() == columns(); + } + + /** + * @return LUPDecomposition the LUP decomposition of the receiver. + * @throws IllegalDimension + * if the receiver is not a square matrix. + */ + protected LUPDecomposition lupDecomposition() throws IllegalDimension { + if (lupDecomposition == null) + lupDecomposition = new LUPDecomposition(this); + return lupDecomposition; + } + + /** + * @param a + * double multiplicand. + * @return MatrixAlgebra.Matrix product of the matrix with a supplied number + */ + public Matrix product(double a) { + return new Matrix(productComponents(a)); + } + + /** + * Computes the product of the matrix with a vector. + * + * @param v + * matrixAlgebra.Vector + * @return matrixAlgebra.Vector + */ + public Vector product(Vector v) throws IllegalDimension { + int n = this.rows(); + int m = this.columns(); + if (v.dimension() != m) + throw new IllegalDimension(""Product error: "" + n + "" by "" + m + + "" matrix cannot by multiplied with vector of dimension "" + + v.dimension()); + return secureProduct(v); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix product of the receiver with the supplied + * matrix + * @throws dr.math.matrixAlgebra.IllegalDimension + * If the number of columns of the receiver are not equal to the + * number of rows of the supplied matrix. + */ + public Matrix product(Matrix a) throws IllegalDimension { + if (a.rows() != columns()) + throw new IllegalDimension(""Operation error: cannot multiply a"" + + rows() + "" by "" + columns() + "" matrix with a "" + + a.rows() + "" by "" + a.columns() + "" matrix""); + return new Matrix(productComponents(a)); + } + + /** + * @param a + * double + * @return double[][] + */ + protected double[][] productComponents(double a) { + int n = this.rows(); + int m = this.columns(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) + newComponents[i][j] = a * components[i][j]; + } + return newComponents; + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return double[][] the components of the product of the receiver with the + * supplied matrix + */ + protected double[][] productComponents(Matrix a) { + int p = this.columns(); + int n = this.rows(); + int m = a.columns(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + double sum = 0; + for (int k = 0; k < p; k++) + sum += components[i][k] * a.components[k][j]; + newComponents[i][j] = sum; + } + } + return newComponents; + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix product of the receiver with the tranpose of + * the supplied matrix + * @throws dr.math.matrixAlgebra.IllegalDimension + * If the number of columns of the receiver are not equal to the + * number of columns of the supplied matrix. + */ + public Matrix productWithTransposed(Matrix a) throws IllegalDimension { + if (a.columns() != columns()) + throw new IllegalDimension(""Operation error: cannot multiply a "" + + rows() + "" by "" + columns() + + "" matrix with the transpose of a "" + a.rows() + "" by "" + + a.columns() + "" matrix""); + return new Matrix(productWithTransposedComponents(a)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return double[][] the components of the product of the receiver with the + * transpose of the supplied matrix + */ + protected double[][] productWithTransposedComponents(Matrix a) { + int p = this.columns(); + int n = this.rows(); + int m = a.rows(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + double sum = 0; + for (int k = 0; k < p; k++) + sum += components[i][k] * a.components[j][k]; + newComponents[i][j] = sum; + } + } + return newComponents; + } + + /** + * @return int the number of rows of the matrix + */ + public int rows() { + return components.length; + } + + /** + * Computes the product of the matrix with a vector. + * + * @param v + * matrixAlgebra.Vector + * @return matrixAlgebra.Vector + */ + protected Vector secureProduct(Vector v) { + int n = this.rows(); + int m = this.columns(); + double[] vectorComponents = new double[n]; + for (int i = 0; i < n; i++) { + vectorComponents[i] = 0; + for (int j = 0; j < m; j++) + vectorComponents[i] += components[i][j] * v.components[j]; + } + return new Vector(vectorComponents); + } + + /** + * Same as product(Matrix a), but without dimension checking. + * + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix product of the receiver with the supplied + * matrix + */ + protected Matrix secureProduct(Matrix a) { + return new Matrix(productComponents(a)); + } + + /** + * Same as subtract ( Marix a), but without dimension checking. + * + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix + */ + protected Matrix secureSubtract(Matrix a) { + return new Matrix(subtractComponents(a)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix subtract the supplied matrix to the + * receiver. + * @throws dr.math.matrixAlgebra.IllegalDimension + * if the supplied matrix does not have the same dimensions. + */ + public Matrix subtract(Matrix a) throws IllegalDimension { + if (a.rows() != rows() || a.columns() != columns()) + throw new IllegalDimension(""Product error: cannot subtract a"" + + a.rows() + "" by "" + a.columns() + "" matrix to a "" + + rows() + "" by "" + columns() + "" matrix""); + return new Matrix(subtractComponents(a)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return double[][] + */ + protected double[][] subtractComponents(Matrix a) { + int n = this.rows(); + int m = this.columns(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + newComponents[i][j] = components[i][j] - a.components[i][j]; + } + return newComponents; + } + + /** + * @return double[][] a copy of the components of the receiver. + */ + public double[][] toComponents() { + int n = rows(); + int m = columns(); + double[][] answer = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) + answer[i][j] = components[i][j]; + } + return answer; + } + + /** + * Returns a string representation of the system. + * + * @return java.lang.String + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + char[] separator = { '[', ' ' }; + int n = rows(); + int m = columns(); + for (int i = 0; i < n; i++) { + separator[0] = '{'; + for (int j = 0; j < m; j++) { + sb.append(separator); + sb.append(components[i][j]); + separator[0] = ' '; + } + sb.append('}'); + sb.append('\n'); + } + return sb.toString(); + } + + public String toStringOctave() { + StringBuffer sb = new StringBuffer(); + int n = rows(); + int m = columns(); + sb.append(""[ ""); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + sb.append(components[i][j]); + if (j == m - 1) { + if (i == n - 1) + sb.append("" ""); + else + sb.append(""; ""); + } else + sb.append("", ""); + } + } + sb.append(""]""); + return sb.toString(); + } + + /** + * @return MatrixAlgebra.Matrix transpose of the receiver + */ + public Matrix transpose() { + int n = rows(); + int m = columns(); + double[][] newComponents = new double[m][n]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) + newComponents[j][i] = components[i][j]; + } + return new Matrix(newComponents); + } + + /** + * @return MatrixAlgebra.SymmetricMatrix the transposed product of the + * receiver with itself. + */ + public SymmetricMatrix transposedProduct() { + return new SymmetricMatrix(transposedProductComponents(this)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return MatrixAlgebra.Matrix product of the tranpose of the receiver with + * the supplied matrix + * @throws dr.math.matrixAlgebra.IllegalDimension + * If the number of rows of the receiver are not equal to the + * number of rows of the supplied matrix. + */ + public Matrix transposedProduct(Matrix a) throws IllegalDimension { + if (a.rows() != rows()) + throw new IllegalDimension( + ""Operation error: cannot multiply a tranposed "" + rows() + + "" by "" + columns() + "" matrix with a "" + a.rows() + + "" by "" + a.columns() + "" matrix""); + return new Matrix(transposedProductComponents(a)); + } + + /** + * @param a + * MatrixAlgebra.Matrix + * @return double[][] the components of the product of the transpose of the + * receiver with the supplied matrix. + */ + protected double[][] transposedProductComponents(Matrix a) { + int p = this.rows(); + int n = this.columns(); + int m = a.columns(); + double[][] newComponents = new double[n][m]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + double sum = 0; + for (int k = 0; k < p; k++) + sum += components[k][i] * a.components[k][j]; + newComponents[i][j] = sum; + } + } + return newComponents; + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/math/DiscreteStatistics.java",".java","13684","437","/* + * DiscreteStatistics.java + * + * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut + * + * This file is part of BEAST. + * See the NOTICE file distributed with this work for additional + * information regarding copyright ownership and licensing. + * + * BEAST is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * BEAST is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with BEAST; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +package com.spread.math; + +import com.spread.utils.HeapSort; + +/** + * simple discrete statistics (mean, variance, cumulative probability, quantiles + * etc.) + * + * @author Korbinian Strimmer + * @author Alexei Drummond + * @version $Id: DiscreteStatistics.java,v 1.11 2006/07/02 21:14:53 rambaut Exp + * $ + */ +public class DiscreteStatistics { + /** + * compute mean + * + * @param x + * list of numbers + * @return mean + */ + public static double mean(double[] x) { + double m = 0; + int count = x.length; + for (double aX : x) { + if (Double.isNaN(aX)) { + count--; + } else { + m += aX; + } + } + + return m / (double) count; + } + + /** + * compute median + * + * @param x + * list of numbers + * @param indices + * index sorting x + * @return median + */ + public static double median(double[] x, int[] indices) { + + int pos = x.length / 2; + if (x.length % 2 == 1) { + return x[indices[pos]]; + } else { + return (x[indices[pos - 1]] + x[indices[pos]]) / 2.0; + } + } + + /** + * compute the mean squared error + * + * @param x + * list of numbers + * @param trueValue + * truth + * @return MSE + */ + + public static double meanSquaredError(double[] x, double trueValue) { + + if (x == null || x.length == 0) { + throw new IllegalArgumentException(); + } + + double total = 0; + for (double sample : x) { + total += (sample - trueValue) * (sample - trueValue); + } + total /= x.length; + return total; + } + + /** + * compute median + * + * @param x + * list of numbers + * @return median + */ + public static double median(double[] x) { + + if (x == null || x.length == 0) { + throw new IllegalArgumentException(); + } + + int[] indices = new int[x.length]; + HeapSort.sort(x, indices); + + return median(x, indices); + } + + /** + * compute variance (ML estimator) + * + * @param x + * list of numbers + * @param mean + * assumed mean of x + * @return variance of x (ML estimator) + */ + public static double variance(double[] x, double mean) { + double var = 0; + int count = x.length; + for (double aX : x) { + if (Double.isNaN(aX)) { + count--; + } else { + double diff = aX - mean; + var += diff * diff; + } + } + + if (count < 2) { + count = 1; // to avoid division by zero + } else { + count = count - 1; // for ML estimate + } + + return var / (double) count; + } + + /** + * compute covariance + * + * @param x + * list of numbers + * @param y + * list of numbers + * @return covariance of x and y + */ + + public static double covariance(double[] x, double[] y) { + + return covariance(x, y, mean(x), mean(y), stdev(x), stdev(y)); + } + + /** + * compute covariance + * + * @param x + * list of numbers + * @param y + * list of numbers + * @param xmean + * assumed mean of x + * @param ymean + * assumed mean of y + * @param xstdev + * assumed stdev of x + * @param ystdev + * assumed stdev of y + * @return covariance of x and y + */ + public static double covariance(double[] x, double[] y, double xmean, + double ymean, double xstdev, double ystdev) { + + if (x.length != y.length) + throw new IllegalArgumentException( + ""x and y arrays must be same length!""); + + int count = x.length; + double covar = 0.0; + for (int i = 0; i < x.length; i++) { + if (Double.isNaN(x[i]) || Double.isNaN(y[i])) { + count--; + } else { + covar += (x[i] - xmean) * (y[i] - ymean); + } + } + covar /= count; + covar /= (xstdev * ystdev); + return covar; + } + + /** + * compute fisher skewness + * + * @param x + * list of numbers + * @return skewness of x + */ + public static double skewness(double[] x) { + + double mean = mean(x); + double stdev = stdev(x); + double skew = 0.0; + double len = x.length; + + for (double xv : x) { + double diff = xv - mean; + diff /= stdev; + + skew += (diff * diff * diff); + } + + skew *= (len / ((len - 1) * (len - 2))); + + return skew; + } + + /** + * compute standard deviation + * + * @param x + * list of numbers + * @return standard deviation of x + */ + public static double stdev(double[] x) { + return Math.sqrt(variance(x)); + } + + /** + * compute variance (ML estimator) + * + * @param x + * list of numbers + * @return variance of x (ML estimator) + */ + public static double variance(double[] x) { + final double m = mean(x); + return variance(x, m); + } + + /** + * compute variance of sample mean (ML estimator) + * + * @param x + * list of numbers + * @param mean + * assumed mean of x + * @return variance of x (ML estimator) + */ + public static double varianceSampleMean(double[] x, double mean) { + return variance(x, mean) / (double) x.length; + } + + /** + * compute variance of sample mean (ML estimator) + * + * @param x + * list of numbers + * @return variance of x (ML estimator) + */ + public static double varianceSampleMean(double[] x) { + return variance(x) / (double) x.length; + } + + /** + * compute the q-th quantile for a distribution of x (= inverse cdf) + * + * @param q + * quantile (0 < q <= 1) + * @param x + * discrete distribution (an unordered list of numbers) + * @param indices + * index sorting x + * @return q-th quantile + */ + public static double quantile(double q, double[] x, int[] indices) { + if (q < 0.0 || q > 1.0) + throw new IllegalArgumentException(""Quantile out of range""); + + if (q == 0.0) { + // for q==0 we have to ""invent"" an entry smaller than the smallest x + + return x[indices[0]] - 1.0; + } + + return x[indices[(int) Math.ceil(q * indices.length) - 1]]; + } + + /** + * compute the q-th quantile for a distribution of x (= inverse cdf) + * + * @param q + * quantile (0 <= q <= 1) + * @param x + * discrete distribution (an unordered list of numbers) + * @return q-th quantile + */ + public static double quantile(double q, double[] x) { + int[] indices = new int[x.length]; + HeapSort.sort(x, indices); + + return quantile(q, x, indices); + } + + /** + * compute the q-th quantile for a distribution of x (= inverse cdf) + * + * @param q + * quantile (0 <= q <= 1) + * @param x + * discrete distribution (an unordered list of numbers) + * @param count + * use only first count entries in x + * @return q-th quantile + */ + public static double quantile(double q, double[] x, int count) { + int[] indices = new int[count]; + HeapSort.sort(x, indices); + + return quantile(q, x, indices); + } + + /** + * Determine the highest posterior density for a list of values. The HPD is + * the smallest interval containing the required amount of elements. + * + * @param proportion + * of elements inside the interval + * @param x + * values + * @param indices + * index sorting x + * @return the interval, an array of {low, high} values. + */ + public static double[] HPDInterval(double proportion, double[] x, + int[] indices) { + + double minRange = Double.MAX_VALUE; + int hpdIndex = 0; + + final int diff = (int) Math.round(proportion * (double) x.length); + for (int i = 0; i <= (x.length - diff); i++) { + final double minValue = x[indices[i]]; + final double maxValue = x[indices[i + diff - 1]]; + final double range = Math.abs(maxValue - minValue); + if (range < minRange) { + minRange = range; + hpdIndex = i; + } + } + + return new double[] { x[indices[hpdIndex]], + x[indices[hpdIndex + diff - 1]] }; + } + + /** + * compute the cumulative probability Pr(x <= z) for a given z and a + * distribution of x + * + * @param z + * threshold value + * @param x + * discrete distribution (an unordered list of numbers) + * @param indices + * index sorting x + * @return cumulative probability + */ + public static double cdf(double z, double[] x, int[] indices) { + int i; + for (i = 0; i < x.length; i++) { + if (x[indices[i]] > z) + break; + } + + return (double) i / (double) x.length; + } + + /** + * compute the cumulative probability Pr(x <= z) for a given z and a + * distribution of x + * + * @param z + * threshold value + * @param x + * discrete distribution (an unordered list of numbers) + * @return cumulative probability + */ + public static double cdf(double z, double[] x) { + int[] indices = new int[x.length]; + HeapSort.sort(x, indices); + + return cdf(z, x, indices); + } + + public static double max(double[] x) { + double max = x[0]; + for (int i = 1; i < x.length; i++) { + if (x[i] > max) + max = x[i]; + } + return max; + } + + public static double min(double[] x) { + double min = x[0]; + for (int i = 1; i < x.length; i++) { + if (x[i] < min) + min = x[i]; + } + return min; + } + + public static double geometricMean(double[] x) { + double gm = 0; + int len = x.length; + for (int i = 0; i < len; i++) { + gm += Math.log(x[i]); + } + + return Math.exp(gm / (double) len); + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/KernelDensityEstimator2D.java",".java","6901","269","package com.spread.contouring; + +import java.util.Arrays; + +import com.spread.math.DiscreteStatistics; +import com.spread.math.Matrix; +import com.spread.math.NormalDistribution; +import com.spread.math.Vector; +import cern.colt.list.DoubleArrayList; +import cern.jet.stat.Descriptive; + +/** + * KernelDensityEstimator2D creates a bi-variate kernel density smoother for + * data + * + * @author Marc A. Suchard + * @author Philippe Lemey + */ + +public class KernelDensityEstimator2D implements ContourMaker { + + // kde2d = + // function (x, y, h, n = 25, lims = c(range(x), range(y))) + // { + // nx <- length(x) + // if (length(y) != nx) + // stop(""data vectors must be the same length"") + // if (any(!is.finite(x)) || any(!is.finite(y))) + // stop(""missing or infinite values in the data are not allowed"") + // if (any(!is.finite(lims))) + // stop(""only finite values are allowed in 'lims'"") + // gx <- seq.int(lims[1], lims[2], length.out = n) + // gy <- seq.int(lims[3], lims[4], length.out = n) + // if (missing(h)) + // h <- c(bandwidth.nrd(x), bandwidth.nrd(y)) + // h <- h/4 + // ax <- outer(gx, x, ""-"")/h[1] + // ay <- outer(gy, y, ""-"")/h[2] + // z <- matrix(dnorm(ax), n, nx) %*% t(matrix(dnorm(ay), n, + // nx))/(nx * h[1] * h[2]) + // return(list(x = gx, y = gy, z = z)) + // } + + /* + * @param x x-coordinates of observations + * + * @param y y-coordinates of observations + * + * @param h bi-variate smoothing bandwidths + * + * @param n smoothed grid size + * + * @param lims bi-variate min/max for grid + */ + public KernelDensityEstimator2D(final double[] x, final double[] y, + final double[] h, final int n, final double[] lims) { + this.x = x; + this.y = y; + if (x.length != y.length) + throw new RuntimeException(""data vectors must be the same length""); + + this.nx = x.length; + + if (n <= 0) + throw new RuntimeException( + ""must have a positive number of grid points""); + this.n = n; + + if (lims != null) + this.lims = lims; + else + setupLims(); + + if (h != null) + this.h = h; + else + setupH(); + + doKDE2D(); + } + + public KernelDensityEstimator2D(final double[] x, final double[] y) { + this(x, y, null, 50, null); + } + + public KernelDensityEstimator2D(final double[] x, final double[] y, + final int n) { + this(x, y, null, n, null); + } + + public void doKDE2D() { + gx = makeSequence(lims[0], lims[1], n); + gy = makeSequence(lims[2], lims[3], n); + double[][] ax = outerMinusScaled(gx, x, h[0]); + double[][] ay = outerMinusScaled(gy, y, h[1]); + normalize(ax); + normalize(ay); + z = new double[n][n]; + double scale = nx * h[0] * h[1]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + double value = 0; + for (int k = 0; k < nx; k++) { + value += ax[i][k] * ay[j][k]; + } + z[i][j] = value / scale; + } + } + } + + public double findLevelCorrespondingToMass(double probabilityMass) { + double level = 0; + double[] sz = new double[n * n]; + double[] c1 = new double[n * n]; + for (int i = 0; i < n; i++) + System.arraycopy(z[i], 0, sz, i * n, n); + Arrays.sort(sz); + final double dx = gx[1] - gx[0]; + final double dy = gy[1] - gy[0]; + final double dxdy = dx * dy; + c1[0] = sz[0] * dxdy; + final double criticalValue = 1.0 - probabilityMass; + if (criticalValue < c1[0] || criticalValue >= 1.0) + throw new RuntimeException(); + // do linearInterpolation on density (y) as function of cumulative sum + // (x) + for (int i = 1; i < n * n; i++) { + c1[i] = sz[i] * dxdy + c1[i - 1]; + if (c1[i] > criticalValue) { // first largest point + final double diffC1 = c1[i] - c1[i - 1]; + final double diffSz = sz[i] - sz[i - 1]; + level = sz[i] - (c1[i] - criticalValue) / diffC1 * diffSz; + break; + } + } + return level; + } + + public ContourPath[] getContourPaths(double hpdValue) { + + double thresholdDensity = findLevelCorrespondingToMass(hpdValue); + ContourGenerator contour = new ContourGenerator(getXGrid(), getYGrid(), + getKDE(), new ContourAttrib[] { new ContourAttrib( + thresholdDensity) }); + + ContourPath[] paths = null; + try { + paths = contour.getContours(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return paths; + } + + public double[][] getKDE() { + return z; + } + + public double[] getXGrid() { + return gx; + } + + public double[] getYGrid() { + return gy; + } + + public void normalize(double[][] X) { + for (int i = 0; i < X.length; i++) { + for (int j = 0; j < X[0].length; j++) + X[i][j] = NormalDistribution.pdf(X[i][j], 0, 1); + } + } + + public double[][] outerMinusScaled(double[] X, double[] Y, double scale) { + double[][] A = new double[X.length][Y.length]; + for (int indexX = 0; indexX < X.length; indexX++) { + for (int indexY = 0; indexY < Y.length; indexY++) { + A[indexX][indexY] = (X[indexX] - Y[indexY]) / scale; + } + } + return A; + } + + public double[] makeSequence(double start, double end, int length) { + double[] seq = new double[length]; + double by = (end - start) / (length - 1); + double value = start; + for (int i = 0; i < length; i++, value += by) { + seq[i] = value; + } + return seq; + } + + private double margin = 0.1; + + private void setupLims() { + lims = new double[4]; + lims[0] = DiscreteStatistics.min(x); + lims[1] = DiscreteStatistics.max(x); + lims[2] = DiscreteStatistics.min(y); + lims[3] = DiscreteStatistics.max(y); + + double xDelta = (lims[1] - lims[0]) * margin; + double yDelta = (lims[3] - lims[2]) * margin; + lims[0] -= xDelta; + lims[1] += xDelta; + lims[2] -= yDelta; + lims[3] += yDelta; + } + + private void setupH() { + h = new double[2]; + h[0] = bandwidthNRD(x) / 4; + h[1] = bandwidthNRD(y) / 4; + } + + // bandwidth.nrd = + // function (x) + // { + // r <- quantile(x, c(0.25, 0.75)) + // h <- (r[2] - r[1])/1.34 + // 4 * 1.06 * min(sqrt(var(x)), h) * length(x)^(-1/5) + + // } + public double bandwidthNRD(double[] in) { + + DoubleArrayList inList = new DoubleArrayList(in.length); + for (double d : in) + inList.add(d); + inList.sort(); + + final double h = (Descriptive.quantile(inList, 0.75) - Descriptive + .quantile(inList, 0.25)) / 1.34; + + return 4 * 1.06 + * Math.min(Math.sqrt(DiscreteStatistics.variance(in)), h) + * Math.pow(in.length, -0.2); + } + + public static void main(String[] arg) { + + double[] x = { 3.4, 1.2, 5.6, 2.2, 3.1 }; + double[] y = { 1.0, 2.0, 1.0, 2.0, 1.0 }; + + KernelDensityEstimator2D kde = new KernelDensityEstimator2D(x, y, 4); + + System.out.println(new Vector(kde.getXGrid())); + System.out.println(new Vector(kde.getYGrid())); + System.out.println(new Matrix(kde.getKDE())); + System.exit(-1); + + } + + public double[] getLims() { + return lims; + } + + private final double[] x; // x coordinates + private final double[] y; // y coordinates + private double[] h; // h[0] x-bandwidth, h[1] y-bandwidth + private final int n; // grid size + private double[] lims; // x,y limits + private int nx; // length of vectors + private double[] gx; // x-grid points + private double[] gy; // y-grid points + private double[][] z; // KDE estimate; + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/ContourPath.java",".java","2876","131","package com.spread.contouring; + +/** + *

+ * This object represents a single contour line or path and all the data that is + * associated with it. + *

+ * + *

+ * Modified by: Joseph A. Huwaldt + *

+ * + * @author Joseph A. Huwaldt Date: November 11, 2000 + * @version November 17, 2000 + * + * + * @author Marc Suchard + **/ +@SuppressWarnings(""serial"") +public class ContourPath implements Cloneable, java.io.Serializable { + + // Tolerance for path closure. + private static final double kSmallX = 0.001; + private static final double kSmallY = kSmallX; + + // X & Y coordinate arrays. + private double[] xArr, yArr; + + // The level index for this contour path. + private int levelIndex; + + // Indicates if this path is open or closed. + private boolean closed = false; + + // The attributes assigned to this contour level. + private ContourAttrib attributes; + + /** + * Construct a contour path or line using the given arrays of X & Y values. + * + * @param attr + * Attributes assigned to this contour path. + * @param levelIndex + * The index to then level this path belongs to. + * @param x + * Array of X coordinate values. + * @param y + * Array of Y coordinate values. + **/ + public ContourPath(ContourAttrib attr, int levelIndex, double[] x, + double[] y) { + + xArr = x; + yArr = y; + this.levelIndex = levelIndex; + attributes = attr; + int np = xArr.length; + + // Determine if the contour path is open or closed. + if (Math.abs(x[0] - x[np - 1]) < kSmallX + && Math.abs(y[0] - y[np - 1]) < kSmallY) { + closed = true; + x[np - 1] = x[0]; + y[np - 1] = y[0]; // Guarantee closure. + } else + closed = false; // Contour not closed. + + } + + /** + * Return the X coordinate values for this contour path. + **/ + public double[] getAllX() { + return xArr; + } + + /** + * Return the Y coordinate values for this contour path. + **/ + public double[] getAllY() { + return yArr; + } + + /** + * Return the level index for this contour path. The level index is an index + * to the level that this path belongs to: the i'th level. + **/ + public int getLevelIndex() { + return levelIndex; + } + + /** + * Return the attributes assigned to this contour path. + **/ + public ContourAttrib getAttributes() { + return attributes; + } + + /** + * Returns true if this contour path is closed (loops back on itself) or + * false if it is not. + **/ + public boolean isClosed() { + return closed; + } + + /** + * Make a copy of this ContourPath object. + * + * @return Returns a clone of this object. + **/ + public Object clone() { + ContourPath newObject = null; + + try { + // Make a shallow copy of this object. + newObject = (ContourPath) super.clone(); + + // There is no ""deep"" data to be cloned. + + } catch (CloneNotSupportedException e) { + // Can't happen. + e.printStackTrace(); + } + + // Output the newly cloned object. + return newObject; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/ContourMaker.java",".java","147","12","package com.spread.contouring; + +/** + * @author Marc Suchard + */ + +public interface ContourMaker { + + ContourPath[] getContourPaths(double level); + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/ContourAttrib.java",".java","1547","77","package com.spread.contouring; + +/** + *

+ * This object represents the attributes assigned to a contour path. Typically, + * the same attributes are assigned to all the contour paths of a given contour + * level. + *

+ * + *

+ * Right now, the only attribute used is ""level"", but in the future I may add + * more. + *

+ * + *

+ * Modified by: Joseph A. Huwaldt + *

+ * + * @author Joseph A. Huwaldt Date: November 11, 2000 + * @version November 17, 2000 + * + * + * @author Marc Suchard + **/ +@SuppressWarnings(""serial"") +public class ContourAttrib implements Cloneable, java.io.Serializable { + + // The level (altitude) of a contour path. + private double level; + + /** + * Create a contour attribute object where only the contour level is + * specified. + **/ + public ContourAttrib(double level) { + this.level = level; + } + + /** + * Return the level stored in this contour attribute. + **/ + public double getLevel() { + return level; + } + + /** + * Set or change the level stored in this contour attribute. + **/ + public void setLevel(double level) { + this.level = level; + } + + /** + * Make a copy of this ContourAttrib object. + * + * @return Returns a clone of this object. + **/ + public Object clone() { + ContourAttrib newObject = null; + + try { + // Make a shallow copy of this object. + newObject = (ContourAttrib) super.clone(); + + // There is no ""deep"" data to be cloned. + + } catch (CloneNotSupportedException e) { + // Can't happen. + e.printStackTrace(); + } + + // Output the newly cloned object. + return newObject; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/SnyderContour.java",".java","14370","518","package com.spread.contouring; + +import java.awt.Dimension; +import java.awt.geom.Point2D; +import java.util.LinkedList; +import java.util.List; + +/* This class provides 2D contouring functionality. This code is adapted from + * ContourPlot.java by David Rand (1997) ""Contour Plotting in Java"" MacTech, volume 13. + * Rand, in turn, ported to Java from Fortan: + * + * Snyder WV (1978) ""Algorithm 531, Contour Plotting [J6]"", ACM Trans. Math. Softw., 4, 290-294. + * + * @author Marc Suchard + */ + +public class SnyderContour { + + // Below, constant data members: + final static boolean SHOW_NUMBERS = true; + final static int BLANK = 32, OPEN_SUITE = (int) '{', + CLOSE_SUITE = (int) '}', BETWEEN_ARGS = (int) ',', N_CONTOURS = 1, + PLOT_MARGIN = 20, WEE_BIT = 3, NUMBER_LENGTH = 3; + final static double Z_MAX_MAX = 1.0E+10, Z_MIN_MIN = -Z_MAX_MAX; + final static String EOL = System.getProperty(""line.separator""); + + // Below, data members which store the grid steps, + // the z values, the interpolation flag, the dimensions + // of the contour plot and the increments in the grid: + int xSteps, ySteps; + float z[][]; + boolean logInterpolation = false; + Dimension d; + double deltaX, deltaY; + + // Below, data members, most of which are adapted from + // Fortran variables in Snyder's code: + int ncv = N_CONTOURS; + int l1[] = new int[4]; + int l2[] = new int[4]; + int ij[] = new int[2]; + int i1[] = new int[2]; + int i2[] = new int[2]; + int i3[] = new int[6]; + int ibkey, icur, jcur, ii, jj, elle, ix, iedge, iflag, ni, ks; + int cntrIndex, prevIndex; + int idir, nxidir, k; + double z1, z2, cval, zMax, zMin; + double intersect[] = new double[4]; + double xy[] = new double[2]; + double prevXY[] = new double[2]; + float cv[] = new float[ncv]; + boolean jump; + + // ------------------------------------------------------- + // A constructor method. + // ------------------------------------------------------- + public SnyderContour(int x, int y) { + super(); + xSteps = x; + ySteps = y; + } + + public void setDeltas(double xDelta, double yDelta) { + this.deltaX = xDelta; + this.deltaY = yDelta; + } + + double offsetX, offsetY; + + public void setOffsets(double xOffset, double yOffset) { + this.offsetX = xOffset; + this.offsetY = yOffset; + } + + // ------------------------------------------------------- + int sign(int a, int b) { + a = Math.abs(a); + if (b < 0) + return -a; + else + return a; + } + + // ------------------------------------------------------- + // ""DrawKernel"" is the guts of drawing and is called + // directly or indirectly by ""ContourPlotKernel"" in order + // to draw a segment of a contour or to set the pen + // position ""prevXY"". Its action depends on ""iflag"": + // + // iflag == 1 means Continue a contour + // iflag == 2 means Start a contour at a boundary + // iflag == 3 means Start a contour not at a boundary + // iflag == 4 means Finish contour at a boundary + // iflag == 5 means Finish closed contour not at boundary + // iflag == 6 means Set pen position + // + // If the constant ""SHOW_NUMBERS"" is true then when + // completing a contour (""iflag"" == 4 or 5) the contour + // index is drawn adjacent to where the contour ends. + // ------------------------------------------------------- + + void DrawKernel(List> allPaths) { + double // prevU,prevV, + u, v; + + if ((iflag == 1) || (iflag == 4) || (iflag == 5)) { // continue drawing + // ... + if (cntrIndex != prevIndex) { // Must change colour + // SetColour(g); + prevIndex = cntrIndex; + } + // prevU = ((prevXY[0] - 1.0) * deltaX); + // prevV = ((prevXY[1] - 1.0) * deltaY); + u = ((xy[0] - 1.0) * deltaX) + offsetX; + v = ((xy[1] - 1.0) * deltaY) + offsetY; + + // Interchange horizontal & vertical + // g.drawLine(PLOT_MARGIN+prevV,PLOT_MARGIN+prevU, + // PLOT_MARGIN+v, PLOT_MARGIN+u); + LinkedList path = allPaths.get(allPaths.size() - 1); + path.add(new Point2D.Double(u, v)); + // if ((SHOW_NUMBERS) && ((iflag==4) || (iflag==5))) { + // if (u == 0) u = u - WEE_BIT; + // else if (u == d.width) u = u + PLOT_MARGIN/2; + // else if (v == 0) v = v - PLOT_MARGIN/2; + // else if (v == d.height) v = v + WEE_BIT; + // g.drawString(Integer.toString(cntrIndex), + // PLOT_MARGIN+v, PLOT_MARGIN+u); + // } + // TODO If end at boundary, close path. + } + if ((iflag == 2) || (iflag == 3)) { // start new path + u = ((xy[0] - 1.0) * deltaX) + offsetX; + v = ((xy[1] - 1.0) * deltaY) + offsetY; + LinkedList path = new LinkedList(); + path.add(new Point2D.Double(u, v)); + allPaths.add(path); + } + prevXY[0] = xy[0]; + prevXY[1] = xy[1]; + } + + // ------------------------------------------------------- + // ""DetectBoundary"" + // ------------------------------------------------------- + void DetectBoundary() { + ix = 1; + if (ij[1 - elle] != 1) { + ii = ij[0] - i1[1 - elle]; + jj = ij[1] - i1[elle]; + if (z[ii - 1][jj - 1] <= Z_MAX_MAX) { + ii = ij[0] + i2[elle]; + jj = ij[1] + i2[1 - elle]; + if (z[ii - 1][jj - 1] < Z_MAX_MAX) + ix = 0; + } + if (ij[1 - elle] >= l1[1 - elle]) { + ix = ix + 2; + return; + } + } + ii = ij[0] + i1[1 - elle]; + jj = ij[1] + i1[elle]; + if (z[ii - 1][jj - 1] > Z_MAX_MAX) { + ix = ix + 2; + return; + } + if (z[ij[0]][ij[1]] >= Z_MAX_MAX) + ix = ix + 2; + } + + // ------------------------------------------------------- + // ""Routine_label_020"" corresponds to a block of code + // starting at label 20 in Synder's subroutine ""GCONTR"". + // ------------------------------------------------------- + boolean Routine_label_020() { + l2[0] = ij[0]; + l2[1] = ij[1]; + l2[2] = -ij[0]; + l2[3] = -ij[1]; + idir = 0; + nxidir = 1; + k = 1; + ij[0] = Math.abs(ij[0]); + ij[1] = Math.abs(ij[1]); + if (z[ij[0] - 1][ij[1] - 1] > Z_MAX_MAX) { + elle = idir % 2; + ij[elle] = sign(ij[elle], l1[k - 1]); + return true; + } + elle = 0; + return false; + } + + // ------------------------------------------------------- + // ""Routine_label_050"" corresponds to a block of code + // starting at label 50 in Synder's subroutine ""GCONTR"". + // ------------------------------------------------------- + boolean Routine_label_050() { + while (true) { + if (ij[elle] >= l1[elle]) { + if (++elle <= 1) + continue; + elle = idir % 2; + ij[elle] = sign(ij[elle], l1[k - 1]); + if (Routine_label_150()) + return true; + continue; + } + ii = ij[0] + i1[elle]; + jj = ij[1] + i1[1 - elle]; + if (z[ii - 1][jj - 1] > Z_MAX_MAX) { + if (++elle <= 1) + continue; + elle = idir % 2; + ij[elle] = sign(ij[elle], l1[k - 1]); + if (Routine_label_150()) + return true; + continue; + } + break; + } + jump = false; + return false; + } + + // ------------------------------------------------------- + // ""Routine_label_150"" corresponds to a block of code + // starting at label 150 in Synder's subroutine ""GCONTR"". + // ------------------------------------------------------- + boolean Routine_label_150() { + while (true) { + // ------------------------------------------------ + // Lines from z[ij[0]-1][ij[1]-1] + // to z[ij[0] ][ij[1]-1] + // and z[ij[0]-1][ij[1]] + // are not satisfactory. Continue the spiral. + // ------------------------------------------------ + if (ij[elle] < l1[k - 1]) { + ij[elle]++; + if (ij[elle] > l2[k - 1]) { + l2[k - 1] = ij[elle]; + idir = nxidir; + nxidir = idir + 1; + k = nxidir; + if (nxidir > 3) + nxidir = 0; + } + ij[0] = Math.abs(ij[0]); + ij[1] = Math.abs(ij[1]); + if (z[ij[0] - 1][ij[1] - 1] > Z_MAX_MAX) { + elle = idir % 2; + ij[elle] = sign(ij[elle], l1[k - 1]); + continue; + } + elle = 0; + return false; + } + if (idir != nxidir) { + nxidir++; + ij[elle] = l1[k - 1]; + k = nxidir; + elle = 1 - elle; + ij[elle] = l2[k - 1]; + if (nxidir > 3) + nxidir = 0; + continue; + } + + if (ibkey != 0) + return true; + ibkey = 1; + ij[0] = icur; + ij[1] = jcur; + if (Routine_label_020()) + continue; + return false; + } + } + + // ------------------------------------------------------- + // ""Routine_label_200"" corresponds to a block of code + // starting at label 200 in Synder's subroutine ""GCONTR"". + // It has return values 0, 1 or 2. + // ------------------------------------------------------- + short Routine_label_200(// Graphics g + List> allPaths, boolean workSpace[]) { + while (true) { + xy[elle] = 1.0 * ij[elle] + intersect[iedge - 1]; + xy[1 - elle] = 1.0 * ij[1 - elle]; + workSpace[2 + * (xSteps * (ySteps * cntrIndex + ij[1] - 1) + ij[0] - 1) + + elle] = true; + DrawKernel(allPaths); + if (iflag >= 4) { + icur = ij[0]; + jcur = ij[1]; + return 1; + } + ContinueContour(); + if (!workSpace[2 + * (xSteps * (ySteps * cntrIndex + ij[1] - 1) + ij[0] - 1) + + elle]) + return 2; + iflag = 5; // 5. Finish a closed contour + iedge = ks + 2; + if (iedge > 4) + iedge = iedge - 4; + intersect[iedge - 1] = intersect[ks - 1]; + } + } + + // ------------------------------------------------------- + // ""CrossedByContour"" is true iff the current segment in + // the grid is crossed by one of the contour values and + // has not already been processed for that value. + // ------------------------------------------------------- + boolean CrossedByContour(boolean workSpace[]) { + ii = ij[0] + i1[elle]; + jj = ij[1] + i1[1 - elle]; + z1 = z[ij[0] - 1][ij[1] - 1]; + z2 = z[ii - 1][jj - 1]; + for (cntrIndex = 0; cntrIndex < ncv; cntrIndex++) { + int i = 2 * (xSteps * (ySteps * cntrIndex + ij[1] - 1) + ij[0] - 1) + + elle; + + if (!workSpace[i]) { + float x = cv[cntrIndex]; + if ((x > Math.min(z1, z2)) && (x <= Math.max(z1, z2))) { + workSpace[i] = true; + return true; + } + } + } + return false; + } + + // ------------------------------------------------------- + // ""ContinueContour"" continues tracing a contour. Edges + // are numbered clockwise, the bottom edge being # 1. + // ------------------------------------------------------- + void ContinueContour() { + short local_k; + + ni = 1; + if (iedge >= 3) { + ij[0] = ij[0] - i3[iedge - 1]; + ij[1] = ij[1] - i3[iedge + 1]; + } + for (local_k = 1; local_k < 5; local_k++) + if (local_k != iedge) { + ii = ij[0] + i3[local_k - 1]; + jj = ij[1] + i3[local_k]; + z1 = z[ii - 1][jj - 1]; + ii = ij[0] + i3[local_k]; + jj = ij[1] + i3[local_k + 1]; + z2 = z[ii - 1][jj - 1]; + if ((cval > Math.min(z1, z2) && (cval <= Math.max(z1, z2)))) { + if ((local_k == 1) || (local_k == 4)) { + double zz = z2; + + z2 = z1; + z1 = zz; + } + intersect[local_k - 1] = (cval - z1) / (z2 - z1); + ni++; + ks = local_k; + } + } + if (ni != 2) { + // ------------------------------------------------- + // The contour crosses all 4 edges of cell being + // examined. Choose lines top-to-left & bottom-to- + // right if interpolation point on top edge is + // less than interpolation point on bottom edge. + // Otherwise, choose the other pair. This method + // produces the same results if axes are reversed. + // The contour may close at any edge, but must not + // cross itself inside any cell. + // ------------------------------------------------- + ks = 5 - iedge; + if (intersect[2] >= intersect[0]) { + ks = 3 - iedge; + if (ks <= 0) + ks = ks + 4; + } + } + // ---------------------------------------------------- + // Determine whether the contour will close or run + // into a boundary at edge ks of the current cell. + // ---------------------------------------------------- + elle = ks - 1; + iflag = 1; // 1. Continue a contour + jump = true; + if (ks >= 3) { + ij[0] = ij[0] + i3[ks - 1]; + ij[1] = ij[1] + i3[ks + 1]; + elle = ks - 3; + } + } + + void ContourKernel(double[][] data, List> allPaths, + double level) { + + ncv = 1; + cv[0] = (float) level; + + int workLength = 2 * xSteps * ySteps * ncv; + boolean workSpace[]; // Allocate below if data valid + + z = new float[data.length][data[0].length]; + for (int i = 0; i < data.length; i++) { + for (int j = 0; j < data[i].length; j++) + z[i][j] = (float) data[i][j]; + } + + workSpace = new boolean[workLength]; + ContourPlotKernel(allPaths, workSpace); + + } + + // ------------------------------------------------------- + // ""ContourPlotKernel"" is the guts of this class and + // corresponds to Synder's subroutine ""GCONTR"". + // ------------------------------------------------------- + void ContourPlotKernel(List> allPaths, + boolean workSpace[]) { + short val_label_200; + + l1[0] = xSteps; + l1[1] = ySteps; + l1[2] = -1; + l1[3] = -1; + i1[0] = 1; + i1[1] = 0; + i2[0] = 1; + i2[1] = -1; + i3[0] = 1; + i3[1] = 0; + i3[2] = 0; + i3[3] = 1; + i3[4] = 1; + i3[5] = 0; + prevXY[0] = 0.0; + prevXY[1] = 0.0; + xy[0] = 1.0; + xy[1] = 1.0; + cntrIndex = 0; + prevIndex = -1; + iflag = 6; + // DrawKernel(g); + icur = Math.max(1, Math.min((int) Math.floor(xy[0]), xSteps)); + jcur = Math.max(1, Math.min((int) Math.floor(xy[1]), ySteps)); + ibkey = 0; + ij[0] = icur; + ij[1] = jcur; + if (Routine_label_020() && Routine_label_150()) + return; + if (Routine_label_050()) + return; + while (true) { + DetectBoundary(); + if (jump) { + if (ix != 0) + iflag = 4; // Finish contour at boundary + iedge = ks + 2; + if (iedge > 4) + iedge = iedge - 4; + intersect[iedge - 1] = intersect[ks - 1]; + val_label_200 = Routine_label_200(allPaths, workSpace); + if (val_label_200 == 1) { + if (Routine_label_020() && Routine_label_150()) + return; + if (Routine_label_050()) + return; + continue; + } + if (val_label_200 == 2) + continue; + return; + } + if ((ix != 3) && (ix + ibkey != 0) && CrossedByContour(workSpace)) { + // + // An acceptable line segment has been found. + // Follow contour until it hits a + // boundary or closes. + // + iedge = elle + 1; + cval = cv[cntrIndex]; + if (ix != 1) + iedge = iedge + 2; + iflag = 2 + ibkey; + intersect[iedge - 1] = (cval - z1) / (z2 - z1); + val_label_200 = Routine_label_200(allPaths, workSpace); + if (val_label_200 == 1) { + if (Routine_label_020() && Routine_label_150()) + return; + if (Routine_label_050()) + return; + continue; + } + if (val_label_200 == 2) + continue; + return; + } + if (++elle > 1) { + elle = idir % 2; + ij[elle] = sign(ij[elle], l1[k - 1]); + if (Routine_label_150()) + return; + } + if (Routine_label_050()) + return; + } + } +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/ContourWithSnyder.java",".java","1658","63","package com.spread.contouring; + +import java.awt.geom.Point2D; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +/** + * @author Marc A. Suchard + */ +public class ContourWithSnyder extends KernelDensityEstimator2D { + + public ContourWithSnyder(final double[] x, final double[] y, + final double[] h, final int n, final double[] lims) { + super(x, y, h, n, lims); + } + + public ContourWithSnyder(final double[] x, final double[] y) { + super(x, y); + } + + public ContourWithSnyder(final double[] x, final double[] y, int n) { + super(x, y, n); + } + + public ContourPath[] getContourPaths(double hpdValue) { + + if (contourPaths == null) { + + double thresholdDensity = findLevelCorrespondingToMass(hpdValue); + + SnyderContour contourPlot = new SnyderContour(getXGrid().length, + getYGrid().length); + contourPlot.setDeltas(getXGrid()[1] - getXGrid()[0], getYGrid()[1] + - getYGrid()[0]); + contourPlot.setOffsets(getXGrid()[0], getYGrid()[0]); + + List> allPaths = new ArrayList>(); + contourPlot.ContourKernel(getKDE(), allPaths, thresholdDensity); + + contourPaths = new ContourPath[allPaths.size()]; + for (int i = 0; i < allPaths.size(); i++) { + LinkedList path = allPaths.get(i); + int len = path.size(); + double[] x = new double[len]; + double[] y = new double[len]; + for (int j = 0; j < len; j++) { + Point2D pt = path.get(j); + x[j] = pt.getX(); + y[j] = pt.getY(); + } + contourPaths[i] = new ContourPath(new ContourAttrib( + thresholdDensity), 1, x, y); + } + } + + return contourPaths; + } + + private ContourPath[] contourPaths = null; + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/contouring/ContourGenerator.java",".java","24108","931","package com.spread.contouring; + +import java.util.ArrayList; +import java.util.List; + +/** + *

+ * An object used to generate a list of contour lines or paths from a set of + * gridded three dimensional data. + *

+ * + *

+ * Based on contour_plot.c from NeXTcontour1.4 by Thomas H. Pulliam, + * pulliam@rft29.nas.nasa.gov, MS 202A-1 NASA Ames Research Center, Moffett + * Field, CA 94035. I don't know how the original Fortran code looked like or + * where it came from, other than that NeXTcontour1.4 is based on Pieter + * Bunings' PLOT3D package for Computational Fluid Dynamics. + *

+ * + *

+ * Ported from C to Java by Joseph A. Huwaldt, November 16, 2000. + *

+ * + *

+ * Modified by: Joseph A. Huwaldt + *

+ * + * @author Joseph A. Huwaldt Date: November 11, 2000 + * @version November 23, 2000 + * + * @author Marc Suchard + * + **/ +public class ContourGenerator { + + // Debug flag. + private static final boolean DEBUG = false; + + // Error messages. + private static final String kCancelMsg = ""Method ContourGenerator.getContours() canceled by user.""; + private static final String kInconsistantArrMsg = ""Inconsistant array sizes.""; + private static final String kArrSizeMsg = ""Data arrays must have more than one row or column.""; + private static final String kNegLogDataMsg = ""Function data must be > 0 for logarithmic intervals.""; + + // Path buffer size. + private static final int kBufSize = 1000; + + // The minimum number of points allowed in a contour path. + private static final int kMinNumPoints = 3; + + // A list of contour paths. + private List pathList = new ArrayList(); + + // A flag to indicate that the contours have been computed or not. + private boolean cCalculated = false; + + // Data arrays used for generating the contours. + private double[][] xArray, yArray, funcArray; + + // Data arrays used when generating contours for 1D X & Y arrays. + private double[] xArr1D, yArr1D; + + // Array of contour attributes, one for each contour level. + private ContourAttrib[] cAttr; + + // The fraction of the task that is completed. + private float fracComplete = 0; + + /** + * Used to indicate that the user wishes to cancel the calculation of + * contours. + **/ + private boolean isCanceled = false; + + // Variables in the original FORTRAN program. + private double[] pathbufxt, pathbufyt; + private int[] pathbufia; + private int lnstrt; // lnstrt=1 indicates starting a new line. + private int ignext; + private int icont; // Current contour level index. + private double cont; // The current contour level. + private int iss, iee, jss, jee; // i & j start and end index values. + private int ima; // ima tells which boundary region we are on. + private int iae; // Index to last element in the IA list. + private int ibeg, jbeg; + private int gi, gj; // Indexes into data arrays. + private double fij; // Data value at i,j in data array. + private int idir; // Indicates current direction. + private int np = 0; // Number of points in current contour line. + private double wx = 0, wy = 0; // Starting point of a contour line. + + /** + * Construct a ContourGenerator object using the specified data arrays and + * the specified attribute array. This constructor allows you to use data on + * an uneven X, Y grid. + * + * @param xArr + * 2D array containing the grid x coordinate data. + * @param yArr + * 2D array containing the grid y coordinate data. + * @param fArr + * 2D array containing the grid function (z) data. + * @param cAttr + * Array containing attributes of the contour levels. + **/ + public ContourGenerator(double[][] xArr, double[][] yArr, double[][] fArr, + ContourAttrib[] cAttr) { + + // Make sure input data is reasonable. + if (yArr.length != xArr.length || yArr.length != fArr.length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (yArr[0].length != xArr[0].length + || yArr[0].length != fArr[0].length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (xArr.length <= 1 || xArr[0].length <= 1) + throw new IllegalArgumentException(kArrSizeMsg); + + this.cAttr = cAttr; + xArray = xArr; + yArray = yArr; + funcArray = fArr; + + } + + /** + * Construct a ContourGenerator object using the specified data arrays and + * the specified attribute array. This constructor allows you to use data on + * an evenly spaced grid where ""X"" values are invarient with ""Y"" and ""Y"" + * values are invarient with ""X"". This often occures where the data is on an + * evenly spaced cartesian grid. + * + * @param xArr + * 1D array containing the grid x coordinate data. + * @param yArr + * 1D array containing the grid y coordinate data. + * @param fArr + * 2D array containing the grid function (z) data. + * @param cAttr + * Array containing attributes of the contour levels. + **/ + public ContourGenerator(double[] xArr, double[] yArr, double[][] fArr, + ContourAttrib[] cAttr) { + + // Make sure input data is reasonable. + if (yArr.length != fArr.length || xArr.length != fArr[0].length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (xArr.length <= 1) + throw new IllegalArgumentException(kArrSizeMsg); + + this.cAttr = cAttr; + xArr1D = xArr; + yArr1D = yArr; + funcArray = fArr; + } + + /** + * Construct a ContourGenerator object using the specified data arrays. + * Contour attributes, including the interval, are generated automatically. + * This constructor allows you to use data on an uneven X, Y grid. + * + * @param xArr + * 2D array containing the grid x coordinate data. + * @param yArr + * 2D array containing the grid y coordinate data. + * @param fArr + * 2D array containing the grid function (z) data. + * @param nc + * The number of contour levels to generate. + * @param logInterval + * Uses a logarithmic contour interval if true, and uses a linear + * interval if false. + **/ + public ContourGenerator(double[][] xArr, double[][] yArr, double[][] fArr, + int nc, boolean logInterval) { + + // Make sure input data is reasonable. + if (yArr.length != xArr.length || yArr.length != fArr.length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (yArr[0].length != xArr[0].length + || yArr[0].length != fArr[0].length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (xArr.length <= 1 || xArr[0].length <= 1) + throw new IllegalArgumentException(kArrSizeMsg); + + xArray = xArr; + yArray = yArr; + funcArray = fArr; + + if (logInterval) + findLogIntervals(nc); + else + findLinearIntervals(nc); + } + + /** + * Construct a ContourGenerator object using the specified data arrays. + * Contour attributes, including the interval, are generated automatically. + * This constructor allows you to use data on an evenly spaced grid where + * ""X"" values are invarient with ""Y"" and ""Y"" values are invarient with ""X"". + * This often occures where the data is on an evenly spaced cartesian grid. + * + * @param xArr + * 1D array containing the grid x coordinate data. + * @param yArr + * 1D array containing the grid y coordinate data. + * @param fArr + * 2D array containing the grid function (z) data. + * @param nc + * The number of contour levels to generate. + * @param logInterval + * Uses a logarithmic contour interval if true, and uses a linear + * interval if false. + **/ + public ContourGenerator(double[] xArr, double[] yArr, double[][] fArr, + int nc, boolean logInterval) { + + // Make sure input data is reasonable. + if (yArr.length != fArr.length || xArr.length != fArr[0].length) + throw new IllegalArgumentException(kInconsistantArrMsg); + if (xArr.length <= 1) + throw new IllegalArgumentException(kArrSizeMsg); + + xArr1D = xArr; + yArr1D = yArr; + funcArray = fArr; + + if (logInterval) + findLogIntervals(nc); + else + findLinearIntervals(nc); + } + + /** + * Generate the contour paths and return them as an array of ContourPath + * objects. If there is a lot of data, this method method may take a long + * time, so be patient. Progress can be checked from another thread by + * calling ""getProgress()"". + * + * @return An array of contour path objects. + * @throws InterruptedException + * if the user cancels this process (by calling ""cancel()"" from + * another thread). + **/ + public ContourPath[] getContours() throws InterruptedException { + + if (!cCalculated) { + isCanceled = false; + pathList.clear(); + + // Go off an compute the contour paths. + computeContours(); + + // Now turn loose all our data arrays to be garbage collected. + cAttr = null; + xArray = yArray = funcArray = null; + xArr1D = yArr1D = null; + + // Set our ""done"" flags. + cCalculated = true; + fracComplete = 1; + } + + // Turn our pathList into an array and return the array. + int size = pathList.size(); + ContourPath[] arr = new ContourPath[size]; + for (int i = 0; i < size; ++i) + arr[i] = (ContourPath) pathList.get(i); + + return arr; + } + + /** + * Returns true if the contour generation process is done. False if it is + * not. + **/ + public boolean done() { + return cCalculated; + } + + /** + * Call this method to cancel the generation of contours. + **/ + public void cancel() { + isCanceled = true; + } + + /** + * Returns the progress of the currently executing contour generation + * process: 0.0 (just starting) to 1.0 (done). + **/ + public float getProgress() { + return fracComplete; + } + + /** + * Find contour intervals that are linearly spaced through the data. + **/ + private void findLinearIntervals(int nc) { + + // Find min and max Z values. + double zMin = Double.MAX_VALUE; + double zMax = -zMin; + int ni = funcArray.length; + for (int i = 0; i < ni; ++i) { + int nj = funcArray[i].length; + for (int j = 0; j < nj; ++j) { + double zVal = funcArray[i][j]; + zMin = Math.min(zMin, zVal); + zMax = Math.max(zMax, zVal); + } + } + + // Allocate memory for contour attribute array. + cAttr = new ContourAttrib[nc]; + + // Determine contour levels. + double delta = (zMax - zMin) / (nc + 1); + for (int i = 0; i < nc; i++) { + cAttr[i] = new ContourAttrib(zMin + (i + 1) * delta); + if (DEBUG) + System.out.println(""level["" + i + ""] = "" + + (zMin + (i + 1) * delta)); + } + + } + + /** + * Find contour intervals that are logarithmically spaced through the data. + **/ + private void findLogIntervals(int nc) { + + // Find min and max Z values. + double zMin = Double.MAX_VALUE; + double zMax = -zMin; + int ni = funcArray.length; + for (int i = 0; i < ni; ++i) { + int nj = funcArray[i].length; + for (int j = 0; j < nj; ++j) { + double zVal = funcArray[i][j]; + zMin = Math.min(zMin, zVal); + zMax = Math.max(zMax, zVal); + } + } + + if (zMin < 0) + throw new IllegalArgumentException(kNegLogDataMsg); + + // Allocate memory for contour attribute array. + cAttr = new ContourAttrib[nc]; + + // Determine contour levels. + double temp = Math.log(zMin); + double delta = (Math.log(zMax) - temp) / (nc + 1); + for (int i = 0; i < nc; i++) + cAttr[i] = new ContourAttrib(Math.exp(temp + (i + 1) * delta)); + + } + + /** + * Computes contour lines for gridded data and stores information about + * those contours. The result of this routine is a list of contour lines or + * paths. + **/ + private void computeContours() throws InterruptedException { + + int ncont = cAttr.length; // Number of contour levels. + + // Find the number of data points in ""I"" and ""J"" directions. + int nx = 0, ny = 0; + if (xArray != null) { + ny = xArray.length; + nx = xArray[0].length; + } else { + nx = xArr1D.length; + ny = yArr1D.length; + } + + // Allocate temporary storage space for path buffers. + pathbufxt = new double[kBufSize]; + pathbufyt = new double[kBufSize]; + pathbufia = new int[kBufSize * 3]; + + // lnstrt=1 (line start) means we're starting a new line. + lnstrt = 1; + ignext = 0; + + // Loop through each contour level. + for (icont = 0; icont < ncont; ++icont) { + + // Check to see if the user has canceled. + if (isCanceled) + throw new InterruptedException(kCancelMsg); + + // Begin working on this contour level. + cont = cAttr[icont].getLevel(); + iss = 1; + iee = nx; + jss = 1; + jee = ny; + + boolean subDivFlg = false; + /* L110 */do { + // Find where function increases through the contour level. + FlagContourPassings(); + + boolean L10flg = false; + /* L210 */do { + + if (!L10flg) { + /* + * Search along the boundaries for contour line starts. + * IMA tells which boundary of the region we're on. + */ + ima = 1; + ibeg = iss - 1; + jbeg = jss; + } + + /* L6 */imaLoop: do { + + if (!L10flg) { + boolean imb = false; + boolean doneFlg = false; + do { + + switch (ima) { + case 1: + ++ibeg; + if (ibeg == iee) + ima = 2; + break; + + case 2: + ++jbeg; + if (jbeg == jee) + ima = 3; + break; + + case 3: + --ibeg; + if (ibeg == iss) + ima = 4; + break; + + case 4: + --jbeg; + if (jbeg == jss) + ima = 5; + break; + + case 5: + continue imaLoop; + } + + if (funcArray[jbeg - 1][ibeg - 1] <= cont) { + imb = true; + doneFlg = false; + + } else if (imb == true) + doneFlg = true; + + } while (!doneFlg); + + // Got a start point. + gi = ibeg; // x index of starting point. + gj = jbeg; // y index of starting point. + fij = funcArray[jbeg - 1][ibeg - 1]; // z value of + // starting + // point. + + // Round the corner if necessary. + /* + * Look different directions to see which way the + * contour line went: 4 1-|-3 2 + */ + switch (ima) { + case 1: + Routine_L21(); + break; + + case 2: + if (gj != jss) { + if (!Routine_L31()) + Routine_L21(); + } else + Routine_L21(); + break; + + case 3: + if (gi != iee) { + if (!Routine_L41()) + Routine_L21(); + } else { + if (!Routine_L31()) + Routine_L21(); + } + break; + + case 4: + if (gj != jee) { + if (!Routine_L51()) + Routine_L21(); + } else { + if (!Routine_L41()) + Routine_L21(); + } + break; + + case 5: + if (!Routine_L51()) + Routine_L21(); + break; + } + + } // end if(!L10flg) + + // This is the end of a contour line. After this, we'll + // start a + // new line. + L10flg = false; + /* L90 */lnstrt = 1; // Contour line start flag. + ignext = 0; + accumContour(np, icont, pathbufxt, pathbufyt, + cAttr[icont]); + + // If we're not done looking along the boundaries, + // go look there some more. + } while (ima != 5); + + // Otherwise, get the next start out of IA. + /* L91 */if (iae != 0) { + int ntmp3 = iae; + for (int iia = 1; iia <= ntmp3; ++iia) { + if (pathbufia[iia - 1] != 0) { + // This is how we start in the middle of the + // region, using IA. + gi = pathbufia[iia - 1] / 1000; + gj = pathbufia[iia - 1] - gi * 1000; + fij = funcArray[gj - 1][gi - 1]; + pathbufia[iia - 1] = 0; + + Routine_L21(); + + L10flg = true; + break; + } + } + } + + } while (L10flg); + + /* + * And if there are no more of these, we're done with this + * region. If we've subdivided, update the region pointers and + * go back for more. + */ + subDivFlg = false; + if (iee == nx) { + if (jee != ny) { + jss = jee; + jee = ny; + subDivFlg = true; + } + } else { + iss = iee; + iee = nx; + subDivFlg = true; + } + + } while (subDivFlg); + + // Update progress information. + fracComplete = (float) (icont + 1) / (float) (ncont); + + // Loop back for the next contour level. + } // Next icont + + // Turn loose temporary arrays used to generate contours. + pathbufxt = null; + pathbufyt = null; + pathbufia = null; + + } + + /** + * Flag points in IA where the the function increases through the contour + * level, not including the boundaries. This is so we have a list of at + * least one point on each contour line that doesn't intersect a boundary. + **/ + private void FlagContourPassings() { + + iae = 0; + int ntmp2 = jee - 1; + for (int j = jss + 1; j <= ntmp2; ++j) { + boolean imb = false; + int iaend = iae; + int ntmp3 = iee; + for (int i = iss; i <= ntmp3; ++i) { + if (funcArray[j - 1][i - 1] <= cont) + imb = true; + else if (imb == true) { + ++iae; + pathbufia[iae - 1] = i * 1000 + j; + imb = false; + + /* + * Check if the IA array is full. If so, the subdividing + * algorithm goes like this: if we've marked at least one J + * row, drop back to the last completed J and call that the + * region. If we haven't even finished one J row, our region + * just extends to this I location. + */ + if (iae == kBufSize * 3) { + if (j > jss + 1) { + iae = iaend; + jee = j; + } else { + // Compute minimum. + jee = Math.min(j + 1, jee); + iee = i; + } + + // Break out of i & j loops. + return; + } + } + } // Next i + } // Next j + + } + + /** + * This function represents the block of code in the original FORTRAN + * program that comes after line 21. + **/ + private void Routine_L21() { + while (true) { + --gi; + if (gi < iss) + return; // Goto L90. + + idir = 1; + if (funcArray[gj - 1][gi - 1] <= cont) { + // Wipe this point out of IA if it's in the list. + /* L52 */if (iae != 0) { + int ij = gi * 1000 + gj + 1000; + int ntmp3 = iae; + for (int iia = 1; iia <= ntmp3; ++iia) { + if (pathbufia[iia - 1] == ij) { + pathbufia[iia - 1] = 0; + break; + } + } + } + doInterpolation(); + return; // Goto L90. + } + + fij = funcArray[gj - 1][gi - 1]; + + if (Routine_L31()) + return; // Goto L90 + } + } + + /** + * This function represents the block of code in the original FORTRAN + * program that comes after line 31. + **/ + private boolean Routine_L31() { + --gj; + if (gj < jss) + return true; + + idir = 2; + if (funcArray[gj - 1][gi - 1] <= cont) { + doInterpolation(); + return true; + } + + fij = funcArray[gj - 1][gi - 1]; + + return (Routine_L41()); + } + + /** + * This function represents the block of code in the original FORTRAN + * program that comes after line 41. + **/ + private boolean Routine_L41() { + ++gi; + if (gi > iee) + return true; + + idir = 3; + if (funcArray[gj - 1][gi - 1] <= cont) { + doInterpolation(); + return true; + } + + fij = funcArray[gj - 1][gi - 1]; + + return (Routine_L51()); + } + + /** + * This function represents the block of code in the original FORTRAN + * program that comes after line 51. + **/ + private boolean Routine_L51() { + ++gj; + idir = 4; + if (gj > jee) + return true; + + if (funcArray[gj - 1][gi - 1] <= cont) { + doInterpolation(); + return true; + } + + fij = funcArray[gj - 1][gi - 1]; + + return false; + } + + /** + * Do interpolation for X, Y coordinates. + * + * This function represents the block of code in the original FORTRAN + * program that comes after line 60. + **/ + private void doInterpolation() { + + // Do interpolation for X,Y coordinates. + double func = funcArray[gj - 1][gi - 1]; + double xyf = (cont - func) / (fij - func); + + /* + * This tests for a contour point coinciding with a grid point. In this + * case the contour routine comes up with the same physical coordinate + * twice. If If we don't trap it, it can (in some cases significantly) + * increase the number of points in a contour line. Also, if this + * happens on the first point in a line, the second point could be + * misinterpreted as the end of a (circling) contour line. + */ + if (xyf == 0) + ++ignext; + + double wxx = 0, wyy = 0; + double xVal = 0, yVal = 0; + if (xArray != null) { + // We have 2D arrays for the X & Y grid points. + xVal = xArray[gj - 1][gi - 1]; + yVal = yArray[gj - 1][gi - 1]; + switch (idir) { + case 1: // East + wxx = xVal + xyf * (xArray[gj - 1][gi + 1 - 1] - xVal); + wyy = yVal + xyf * (yArray[gj - 1][gi + 1 - 1] - yVal); + break; + + case 2: // North + wxx = xVal + xyf * (xArray[gj + 1 - 1][gi - 1] - xVal); + wyy = yVal + xyf * (yArray[gj + 1 - 1][gi - 1] - yVal); + break; + + case 3: // West + wxx = xVal + xyf * (xArray[gj - 1][gi - 1 - 1] - xVal); + wyy = yVal + xyf * (yArray[gj - 1][gi - 1 - 1] - yVal); + break; + + case 4: // South + wxx = xVal + xyf * (xArray[gj - 1 - 1][gi - 1] - xVal); + wyy = yVal + xyf * (yArray[gj - 1 - 1][gi - 1] - yVal); + break; + } + + } else { + // We have 1D arrays for the X & Y grid points. + xVal = xArr1D[gi - 1]; + yVal = yArr1D[gj - 1]; + switch (idir) { + case 1: // East + wxx = xVal + xyf * (xArr1D[gi + 1 - 1] - xVal); + wyy = yVal; + break; + + case 2: // North + wxx = xVal; + wyy = yVal + xyf * (yArr1D[gj + 1 - 1] - yVal); + break; + + case 3: // West + wxx = xVal + xyf * (xArr1D[gi - 1 - 1] - xVal); + wyy = yVal; + break; + + case 4: // South + wxx = xVal; + wyy = yVal + xyf * (yArr1D[gj - 1 - 1] - yVal); + break; + } + } + + if (DEBUG) { + System.out.println(""i, j = "" + gi + "","" + gj); + System.out.println(""cont = "" + (float) cont + "", fij = "" + + (float) fij + "", func = "" + (float) func + "", xyf = "" + + (float) xyf); + System.out.println(""xVal = "" + (float) xVal + "", yVal = "" + + (float) yVal); + System.out.println(""wxx = "" + (float) wxx + "", wyy = "" + + (float) wyy); + } + + // Figure out what to do with this point. + if (lnstrt == 1) { + // This is the 1st point in the contour line. + + np = 1; + pathbufxt[np - 1] = wxx; + pathbufyt[np - 1] = wyy; + + // Save starting point as wx, wy. + wx = wxx; + wy = wyy; + + // Clear the first point flag, we've got one now. + lnstrt = 0; + + } else { + + boolean skipFlg = false; + + // Second point and after comes here. + // Add a point to this line. Check for duplicate point first. + if (ignext == 2) { + if (wxx == pathbufxt[np - 1] && wyy == pathbufyt[np - 1]) { + ignext = 0; + skipFlg = true; + + } else + ignext = 1; + } + + if (!skipFlg) { + + // Increment # of points in contour. + ++np; + pathbufxt[np - 1] = wxx; + pathbufyt[np - 1] = wyy; + + // See if the temporary array xt, yt are full. + if (np == kBufSize) { + accumContour(np, icont, pathbufxt, pathbufyt, cAttr[icont]); + + // Last point becomes 1st point to continue. + pathbufxt[0] = pathbufxt[np - 1]; + pathbufyt[0] = pathbufyt[np - 1]; + np = 1; + } + + // Check to see if we're back to the intial point. + if (wxx == wx && wyy == wy) + return; + } + + } + + // Search for the next point on this line. + /* L67 */switch (idir) { + case 1: + ++gi; + if (!Routine_L51()) + Routine_L21(); + break; + + case 2: + ++gj; + Routine_L21(); + break; + + case 3: + --gi; + if (!Routine_L31()) + Routine_L21(); + break; + + case 4: + --gj; + if (!Routine_L41()) + Routine_L21(); + break; + } + + return; + } + + /** + * Accumulate contour paths, as they are generated, into an overall list of + * contours. + * + * @param np + * The number of points in the contour path buffers. + * @param icont + * The index to the current contour level. + * @param x + * ,y Buffers containing x & y coordinates of contour points. + * @param cAttr + * The attributes for this particular contour level. + **/ + private void accumContour(int np, int icont, double[] x, double[] y, + ContourAttrib cAttr) { + + // To few points for a contour line. + if (np < kMinNumPoints) + return; + + // Copy over coordinate points from buffers to their own arrays. + double[] xArr = new double[np]; + double[] yArr = new double[np]; + System.arraycopy(x, 0, xArr, 0, np); + System.arraycopy(y, 0, yArr, 0, np); + + // Create a new contour path and add it to the list. + ContourPath path = new ContourPath(cAttr, icont, xArr, yArr); + pathList.add(path); + + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/DiscreteTreeParser.java",".java","21237","540","package com.spread.parsers; + +import java.io.IOException; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.stream.Collectors; + +import com.google.gson.GsonBuilder; +import com.spread.data.Attribute; +import com.spread.data.AxisAttributes; +import com.spread.data.Location; +import com.spread.data.SpreadData; +import com.spread.data.Timeline; +import com.spread.data.attributable.Line; +import com.spread.data.attributable.Point; +import com.spread.data.primitive.Coordinate; +import com.spread.exceptions.SpreadException; +import com.spread.progress.IProgressObserver; +import com.spread.progress.IProgressReporter; +import com.spread.utils.ParsersUtils; + +import jebl.evolution.graphs.Node; +import jebl.evolution.io.ImportException; +import jebl.evolution.trees.RootedTree; +import lombok.Setter; + +public class DiscreteTreeParser implements IProgressReporter { + + public static final String COUNT = ""count""; + private static final Integer UNRESOLVED_INDEX = Integer.MAX_VALUE; + + @Setter + private String treeFilePath; + @Setter + private String locationsFilePath; + @Setter + private String locationTraitAttributeName; + @Setter + private double timescaleMultiplier; + @Setter + private String mostRecentSamplingDate; + private IProgressObserver progressObserver; + + public DiscreteTreeParser() { + } + + public DiscreteTreeParser(String treeFilePath, + String locationsFilePath, + String locationTraitAttributeName, + double timescaleMultiplier, + String mostRecentSamplingDate) { + this.treeFilePath = treeFilePath; + this.locationsFilePath = locationsFilePath; + this.locationTraitAttributeName = locationTraitAttributeName; + this.timescaleMultiplier = timescaleMultiplier; + this.mostRecentSamplingDate = mostRecentSamplingDate; + } + + public String parse() throws IOException, ImportException, SpreadException { + + double progress = 0; + double progressStepSize = 0; + this.updateProgress(progress); + + RootedTree rootedTree = ParsersUtils.importRootedTree(this.treeFilePath); + TimeParser timeParser = new TimeParser(this.mostRecentSamplingDate); + Timeline timeline = timeParser.getTimeline(rootedTree.getHeight(rootedTree.getRootNode())); + + LinkedList locationsList = new DiscreteLocationsParser(this.locationsFilePath, false).parseLocations(); + + LinkedList uniqueBranchAttributes = new LinkedList(); + LinkedList uniqueNodeAttributes = new LinkedList(); + + LinkedList linesList = new LinkedList(); + LinkedList pointsList = new LinkedList(); + LinkedList countsList = new LinkedList(); + + HashMap pointsMap = new HashMap(); + + double rootHeight = rootedTree.getHeight(rootedTree.getRootNode()); + Double[] sliceHeights = createSliceHeights(rootHeight, 10); + int[][] locationCounts = new int[sliceHeights.length][locationsList.size()]; + + Location dummy; + progressStepSize = 0.25 / (double) rootedTree.getNodes().size(); + for (Node node : rootedTree.getNodes()) { + if (!rootedTree.isRoot(node)) { + + progress += progressStepSize; + this.updateProgress(progress); + + // node parsed first + String nodeState = getNodeState(node, this.locationTraitAttributeName); + + dummy = new Location(nodeState); + int locationIndex = UNRESOLVED_INDEX; + if (locationsList.contains(dummy)) { + locationIndex = locationsList.indexOf(dummy); + } else { + String message1 = ""Location "" + dummy.getId() + "" could not be found in the locations file.""; + String message2 = ""Resulting file may be incomplete!""; + System.out.println(message1 + "" "" + message2); + continue; + } + + Location nodeLocation = locationsList.get(locationIndex); + + // parent node parsed second + Node parentNode = rootedTree.getParent(node); + String parentState = getNodeState(parentNode, this.locationTraitAttributeName); + + dummy = new Location(parentState); + locationIndex = UNRESOLVED_INDEX; + if (locationsList.contains(dummy)) { + + locationIndex = locationsList.indexOf(dummy); + + } else { + + String message = ""Parent location "" + dummy.getId() + "" could not be found in the locations file.""; + throw new SpreadException(message); + } + + Location parentLocation = locationsList.get(locationIndex); + + if (!parentLocation.equals(nodeLocation)) { + + Point parentPoint = pointsMap.get(parentNode); + if (parentPoint == null) { + + parentPoint = createPoint(parentNode, parentLocation, rootedTree, timeParser); + pointsMap.put(parentNode, parentPoint); + + } // END: null check + + Point nodePoint = pointsMap.get(node); + if (nodePoint == null) { + + nodePoint = createPoint(node, nodeLocation, rootedTree, timeParser); + pointsMap.put(node, nodePoint); + + } // END: null check + + Line line = new Line(parentPoint.getId(), // + nodePoint.getId(), // + parentPoint.getStartTime(), // + nodePoint.getStartTime(), // + nodePoint.getAttributes() // + ); + + linesList.add(line); + + } else { + + // count lineages holding state + for (int i = 0; i < sliceHeights.length; i++) { + + double sliceHeight = sliceHeights[i]; + for (Location location : locationsList) { + + if ((rootedTree.getHeight(node) <= sliceHeight) + && (rootedTree.getHeight(parentNode) > sliceHeight)) { + + if (nodeLocation.equals(parentLocation) && parentLocation.equals(location)) { + int j = locationsList.lastIndexOf(location); + locationCounts[i][j]++; + } + + } + } + } + } + + } else { + + String rootState = getNodeState(node, this.locationTraitAttributeName); + dummy = new Location(rootState); + int locationIndex = UNRESOLVED_INDEX; + if (locationsList.contains(dummy)) { + locationIndex = locationsList.indexOf(dummy); + } else { + + String message1 = ""Location "" + dummy.getId() + "" of the root node could not be found in the locations file.""; + String message2 = ""Resulting file may be incomplete!""; + System.out.println(message1 + "" "" + message2); + continue; + + } + + Location location = locationsList.get(locationIndex); + Point rootPoint = createPoint(node, location, rootedTree, timeParser); + pointsMap.put(node, rootPoint); + } + } + + pointsList.addAll(pointsMap.values()); + + // create Points list with count attributes + Double[] countRange = new Double[2]; + countRange[Attribute.MIN_INDEX] = Double.MAX_VALUE; + countRange[Attribute.MAX_INDEX] = Double.NEGATIVE_INFINITY; + + progressStepSize = 0.25 / (double) locationCounts.length; + for (int sliceIndex = 0; sliceIndex < locationCounts.length; sliceIndex++) { + + progress += progressStepSize; + this.updateProgress(progress); + + double height = sliceHeights[sliceIndex]; + double nextHeight = sliceIndex < locationCounts.length - 1 ? sliceHeights[sliceIndex + 1] : 0.0; + + for (int locationIndex = 0; locationIndex < locationCounts[0].length; locationIndex++) { + + Double count = (double) locationCounts[sliceIndex][locationIndex]; + if (count > 0) { + + Location location = locationsList.get(locationIndex); + String startTime = timeParser.getNodeDate(height); + String endTime = timeParser.getNodeDate(nextHeight); + + Map attributes = new LinkedHashMap(); + attributes.put(COUNT, locationCounts[sliceIndex][locationIndex]); + + Point point = new Point(location.getId(), startTime, endTime, attributes); + countsList.add(point); + + if (count < countRange[Attribute.MIN_INDEX]) { + countRange[Attribute.MIN_INDEX] = count; + } // END: min check + + if (count > countRange[Attribute.MAX_INDEX]) { + countRange[Attribute.MAX_INDEX] = count; + } // END: max check + + } + + } // END: locations loop + } // END: slice loop + + Attribute countAttribute = new Attribute(COUNT, countRange); + + // collect attributes from lines + Map branchAttributesMap = new HashMap(); + progressStepSize = 0.25 / (double) linesList.size(); + for (Line line : linesList) { + + progress += progressStepSize; + this.updateProgress(progress); + for (Entry entry : line.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (branchAttributesMap.containsKey(attributeId)) { + + Attribute attribute = branchAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + attribute.getDomain().add(attributeValue); + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + attribute = new Attribute(attributeId, range); + } else { + HashSet domain = new HashSet(); + domain.add(attributeValue); + attribute = new Attribute(attributeId, domain); + } // END: isNumeric check + + branchAttributesMap.put(attributeId, attribute); + } + } + } + + uniqueBranchAttributes.addAll(branchAttributesMap.values()); + + // collect attributes from nodes + Map nodeAttributesMap = new HashMap(); + progressStepSize = 0.24 / (double) pointsList.size(); + for (Point point : pointsList) { + + progress += progressStepSize; + this.updateProgress(progress); + for (Entry entry : point.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (nodeAttributesMap.containsKey(attributeId)) { + + Attribute attribute = nodeAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + + attribute.getDomain().add(attributeValue); + + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + + attribute = new Attribute(attributeId, domain); + + } // END: isNumeric check + + nodeAttributesMap.put(attributeId, attribute); + + } + } + } + + uniqueNodeAttributes.addAll(branchAttributesMap.values()); + // we dump it here with node attributes + uniqueNodeAttributes.add(countAttribute); + + // --- LAYERS --- // + + LinkedList rangeAttributes = getCoordinateRangeAttributes(locationsList); + Attribute xCoordinate = rangeAttributes.get(ParsersUtils.X_INDEX); + Attribute yCoordinate = rangeAttributes.get(ParsersUtils.Y_INDEX); + + uniqueNodeAttributes.add(xCoordinate); + uniqueNodeAttributes.add(yCoordinate); + AxisAttributes axis = new AxisAttributes(xCoordinate.getId(), + yCoordinate.getId()); + + SpreadData spreadData = new SpreadData.Builder() + .withAnalysisType(ParsersUtils.DISCRETE_TREE) + .withTimeline(timeline) + .withAxisAttributes(axis) + .withLineAttributes(uniqueBranchAttributes) + .withPointAttributes(uniqueNodeAttributes) + .withLocations(locationsList) + .withPoints (pointsList) + .withLines (linesList) + .withCounts (countsList) + .build(); + + this.updateProgress(1.0); + return new GsonBuilder().create().toJson(spreadData); + }// END: parse + + private LinkedList getCoordinateRangeAttributes(LinkedList locationsList) throws SpreadException { + + LinkedList coordinateRange = new LinkedList(); + + Double[] xCoordinateRange = new Double[2]; + xCoordinateRange[Attribute.MIN_INDEX] = Double.MAX_VALUE; + xCoordinateRange[Attribute.MAX_INDEX] = Double.NEGATIVE_INFINITY; + + Double[] yCoordinateRange = new Double[2]; + yCoordinateRange[Attribute.MIN_INDEX] = Double.MAX_VALUE; + yCoordinateRange[Attribute.MAX_INDEX] = Double.NEGATIVE_INFINITY; + + for (Location location : locationsList) { + + Coordinate coordinate = location.getCoordinate(); + if (coordinate == null) { + throw new SpreadException(""Location "" + location.getId() + + "" has no coordinates set.""); + } + + Double latitude = coordinate.getYCoordinate(); + Double longitude = coordinate.getXCoordinate(); + + // update coordinates range + + if (latitude < yCoordinateRange[Attribute.MIN_INDEX]) { + yCoordinateRange[Attribute.MIN_INDEX] = latitude; + } // END: min check + + if (latitude > yCoordinateRange[Attribute.MAX_INDEX]) { + yCoordinateRange[Attribute.MAX_INDEX] = latitude; + } // END: max check + + if (longitude < xCoordinateRange[Attribute.MIN_INDEX]) { + xCoordinateRange[Attribute.MIN_INDEX] = longitude; + } // END: min check + + if (longitude > xCoordinateRange[Attribute.MAX_INDEX]) { + xCoordinateRange[Attribute.MAX_INDEX] = longitude; + } // END: max check + + } + + Attribute xCoordinate = new Attribute(ParsersUtils.X_COORDINATE, xCoordinateRange); + Attribute yCoordinate = new Attribute(ParsersUtils.Y_COORDINATE, yCoordinateRange); + + coordinateRange.add(ParsersUtils.X_INDEX, xCoordinate); + coordinateRange.add(ParsersUtils.Y_INDEX, yCoordinate); + + return coordinateRange; + }// END: getCoordinateRange + + private Double[] createSliceHeights(double rootHeight, int intervals) { + // double rootHeight = rootedTree.getHeight(rootedTree.getRootNode()); + double delta = rootHeight / (double) intervals; + + Double[] sliceHeights = new Double[intervals - 1]; + for (int i = 0; i < (intervals - 1); i++) { + sliceHeights[i] = rootHeight - ((i + 1) * delta); + } + + return sliceHeights; + }// END: createSliceHeights + + private String getNodeState(Node node, String locationTraitAttributeName) throws SpreadException { + try { + String nodeState = (String) ParsersUtils.getObjectNodeAttribute(node, locationTraitAttributeName); + if (nodeState.contains(""+"")) { + String message = ""Found tied state "" + nodeState; + nodeState = ParsersUtils.breakTiesRandomly(nodeState); + message += ("" randomly choosing "" + nodeState); + System.out.println(message); + } + return nodeState; + } catch (Exception e) { + throw new SpreadException(""Can't get a discrete node state for attribute name "" + locationTraitAttributeName); + } + } + + private Point createPoint(Node node, Location location, RootedTree rootedTree, TimeParser timeParser) throws SpreadException { + + Double height = ParsersUtils.getNodeHeight(rootedTree, node) * timescaleMultiplier; + String startTime = timeParser.getNodeDate(height); + + Map attributes = new LinkedHashMap(); + for (String attributeName : node.getAttributeNames()) { + + Object nodeAttribute = node.getAttribute(attributeName); + + if (!(nodeAttribute instanceof Object[])) { + + // remove invalid characters + attributeName = attributeName.replaceAll(""%"", """"); + attributeName = attributeName.replaceAll(""!"", """"); + + attributes.put(attributeName, nodeAttribute); + + } // END: multivariate check + + } // END: attributes loop + + // annotate with node name + Object value; + if (rootedTree.isExternal(node)) { + value = rootedTree.getTaxon(node).toString(); + } else if(rootedTree.isRoot(node)) { + value = ""root""; + } else { + value = ""internal""; + } + + String attributeName = ""nodeName""; + attributes.put(attributeName, value); + + // external nodes have no posterior annotated, so fix that + if (rootedTree.isExternal(node)) { + attributes.put(ParsersUtils.POSTERIOR, 1.0); + } + + Point point = new Point(location.getId(), startTime, attributes); + + return point; + }// END: createPoint + + // return attributes set + public String parseAttributes() throws IOException, ImportException { + + RootedTree tree = ParsersUtils.importRootedTree(this.treeFilePath); + + Set uniqueAttributes = tree.getNodes().stream().filter(node -> !tree.isRoot(node)) + .flatMap(node -> node.getAttributeNames().stream()).map(name -> { + return name; + }).collect(Collectors.toSet()); + + return new GsonBuilder().create().toJson(uniqueAttributes); + } + + @Override + public void registerProgressObserver(IProgressObserver observer) { + this.progressObserver = observer; + } + + @Override + public void updateProgress(double progress) { + if (this.progressObserver != null) { + this.progressObserver.handleProgress(progress); + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/TimeSlicerParser.java",".java","13008","360","package com.spread.parsers; + +import java.io.BufferedInputStream; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.stream.Collectors; + +import com.google.gson.GsonBuilder; +import com.spread.contouring.ContourMaker; +import com.spread.contouring.ContourPath; +import com.spread.contouring.ContourWithSnyder; +import com.spread.data.Attribute; +import com.spread.data.SpreadData; +import com.spread.data.Timeline; +import com.spread.data.attributable.Area; +import com.spread.data.primitive.Coordinate; +import com.spread.data.primitive.Polygon; +import com.spread.exceptions.SpreadException; +import com.spread.progress.IProgressObserver; +import com.spread.progress.IProgressReporter; +import com.spread.utils.ParsersUtils; + +import jebl.evolution.io.ImportException; +import jebl.evolution.io.NexusImporter; +import jebl.evolution.trees.RootedTree; +import lombok.Setter; + +public class TimeSlicerParser implements IProgressReporter { + + @Setter + private String treesFilePath; + @Setter + private String sliceHeightsFilePath; + @Setter + private int numberOfIntervals; + @Setter + private double burnIn; + @Setter + private String traitName; + @Setter + private String rrwRateName; + @Setter + private double hpdLevel; + @Setter + private int gridSize; + @Setter + private String mostRecentSamplingDate; + @Setter + private double timescaleMultiplier; + + private IProgressObserver progressObserver; + + public TimeSlicerParser() { + } + + public TimeSlicerParser(String treesFilePath, // path to the trees file + double burnIn, // ignore first n trees + String sliceHeightsFilePath, + String traitName, // 2D trait for contouring + String rrwRateName, // relaxed random walk rate attribute name + double hpdLevel, + int gridSize, + String mostRecentSamplingDate, + double timescaleMultiplier + ) { + this.treesFilePath = treesFilePath; + this.sliceHeightsFilePath = sliceHeightsFilePath; + this.burnIn = burnIn; + this.traitName = traitName; + this.rrwRateName = rrwRateName; + this.hpdLevel = hpdLevel; + this.gridSize = gridSize; + this.mostRecentSamplingDate = mostRecentSamplingDate; + this.timescaleMultiplier = timescaleMultiplier; + } + + public TimeSlicerParser(String treesFilePath, + double burnIn, + int numberOfIntervals, + String traitName, + String rrwRateName, + double hpdLevel, + int gridSize, + String mostRecentSamplingDate, + double timescaleMultiplier + ) { + this.treesFilePath = treesFilePath; + this.burnIn = burnIn; + this.numberOfIntervals = numberOfIntervals; + this.traitName = traitName; + this.rrwRateName = rrwRateName; + this.hpdLevel = hpdLevel; + this.gridSize = gridSize; + this.mostRecentSamplingDate = mostRecentSamplingDate; + this.timescaleMultiplier = timescaleMultiplier; + } + + private SpreadData parseContours() + throws IOException, ImportException, SpreadException { + + double progress = 0; + double progressStepSize = 0; + this.updateProgress(progress); + + // --- parse trees ---// + + Double sliceHeights[] = null; + if (this.sliceHeightsFilePath == null) { + sliceHeights = generateSliceHeights(this.treesFilePath, this.numberOfIntervals); + } else { + SliceHeightsParser sliceHeightsParser = new SliceHeightsParser(this.sliceHeightsFilePath); + sliceHeights = sliceHeightsParser.parseSliceHeights(); + } + // sort them in ascending order + Arrays.sort(sliceHeights); + + NexusImporter treesImporter = new NexusImporter(new FileReader(this.treesFilePath)); + HashMap> slicesMap = new HashMap>(sliceHeights.length); + RootedTree currentTree; + int treesReadCounter = 0; + int totalTreesCount = getTreesCount(this.treesFilePath); + int treesToSkip = (int) (burnIn * totalTreesCount); + progressStepSize = 0.33 / totalTreesCount; + + while (treesImporter.hasTree()) { + currentTree = (RootedTree) treesImporter.importNextTree(); + if (treesReadCounter >= treesToSkip) { + new TimeSliceTree(slicesMap, // + currentTree, // + sliceHeights, // + this.traitName, // + this.rrwRateName).call(); + } // END: burnin check + treesReadCounter++; + progress += progressStepSize; + this.updateProgress(progress); + } + + // --- make contours ---// + + TimeParser timeParser = new TimeParser(this.mostRecentSamplingDate); + LinkedList areasList = new LinkedList(); + + progressStepSize = 0.33 / (double) slicesMap.size(); + for (Double sliceHeight : slicesMap.keySet()) { + + progress += progressStepSize; + this.updateProgress(progress); + + List coords = slicesMap.get(sliceHeight); + int n = coords.size(); + + double[] x = new double[n]; + double[] y = new double[n]; + + for (int i = 0; i < n; i++) { + x[i] = coords.get(i)[ParsersUtils.LONGITUDE_INDEX]; + y[i] = coords.get(i)[ParsersUtils.LATITUDE_INDEX]; + } // END: i loop + + ContourMaker contourMaker = new ContourWithSnyder(x, y, gridSize); + ContourPath[] paths = contourMaker.getContourPaths(hpdLevel); + + for (ContourPath path : paths) { + + double[] longitude = path.getAllX(); + double[] latitude = path.getAllY(); + + List coordinateList = new ArrayList(); + + for (int i = 0; i < latitude.length; i++) { + coordinateList.add(new Coordinate(latitude[i], longitude[i])); + } + + Polygon polygon = new Polygon(coordinateList); + + String startTime = timeParser.getNodeDate(sliceHeight * timescaleMultiplier); + + HashMap areaAttributesMap = new HashMap(); + areaAttributesMap.put(ParsersUtils.HPD.toUpperCase(), hpdLevel); + + Area area = new Area(polygon, startTime, areaAttributesMap); + areasList.add(area); + } + } + + // --- collect attributes from areas --- // + + Map areasAttributesMap = new HashMap(); + + progressStepSize = 0.33 / (double) areasList.size(); + for (Area area : areasList) { + + progress += progressStepSize; + this.updateProgress(progress); + for (Entry entry : area.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (areasAttributesMap.containsKey(attributeId)) { + + Attribute attribute = areasAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + attribute.getDomain().add(attributeValue); + } else { + + double value = ParsersUtils + .round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + attribute = new Attribute(attributeId, domain); + } // END: isNumeric check + + areasAttributesMap.put(attributeId, attribute); + + } // END: key check + } // END: attributes loop + } // END: points loop + + LinkedList uniqueAreaAttributes = new LinkedList(); + uniqueAreaAttributes.addAll(areasAttributesMap.values()); + + Timeline timeline = timeParser.getTimeline(sliceHeights[sliceHeights.length - 1]); + + return new SpreadData.Builder() + .withAnalysisType(ParsersUtils.TIME_SLICER) + .withTimeline(timeline) + .withAreaAttributes(uniqueAreaAttributes) + .withAreas (areasList) + .build(); + } + + public String parse() throws IOException, ImportException, SpreadException { + SpreadData contours = this.parseContours(); + this.updateProgress(1.0); + return new GsonBuilder().create().toJson(contours); + } + + private int getTreesCount(String file) throws IOException { + InputStream is = new BufferedInputStream(new FileInputStream(file)); + try { + + String mark = "";""; + int markCount = 0; + int markBorder = 6; + + byte[] c = new byte[1024]; + int count = 0; + int readChars = 0; + boolean empty = true; + + while ((readChars = is.read(c)) != -1) { + + empty = false; + for (int i = 0; i < readChars; i++) { + if (String.valueOf((char) c[i]).equalsIgnoreCase(mark)) { + markCount++; + } + + if (c[i] == '\n' && markCount > markBorder) { + count++; + } + } + } + + count = count - 1; + return (count == 0 && !empty) ? 1 : count; + } finally { + is.close(); + } + } + + private Double[] generateSliceHeights(String treesFilePath, int numberOfIntervals) + throws IOException, ImportException { + + Double[] timeSlices = new Double[numberOfIntervals]; + NexusImporter treesImporter = new NexusImporter(new FileReader(this.treesFilePath)); + double maxRootHeight = 0; + RootedTree currentTree = null; + + while (treesImporter.hasTree()) { + currentTree = (RootedTree) treesImporter.importNextTree(); + double rootHeight = currentTree.getHeight(currentTree.getRootNode()); + if (rootHeight > maxRootHeight) { + maxRootHeight = rootHeight; + } + } + + for (int i = 0; i < numberOfIntervals; i++) { + timeSlices[i] = maxRootHeight - (maxRootHeight / (double) numberOfIntervals) * ((double) i); + } + + return timeSlices; + } + + public String parseAttributes() throws IOException, ImportException, SpreadException { + + if (this.treesFilePath == null) { + throw new SpreadException(""treesFilePath parameter is not set"", null); + } + + NexusImporter treesImporter = new NexusImporter(new FileReader(this.treesFilePath)); + RootedTree tree = (RootedTree) treesImporter.importNextTree(); + + Set uniqueAttributes = tree.getNodes().stream().filter(node -> !tree.isRoot(node)) + .flatMap(node -> node.getAttributeNames().stream()).map(name -> name).collect(Collectors.toSet()); + + return new GsonBuilder().create().toJson(uniqueAttributes); + } + + @Override + public void registerProgressObserver(IProgressObserver observer) { + this.progressObserver = observer; + } + + @Override + public void updateProgress(double progress) { + if (this.progressObserver != null) { + this.progressObserver.handleProgress(progress); + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/SliceHeightsParser.java",".java","654","29","package com.spread.parsers; + +import java.io.IOException; + +import com.spread.utils.ParsersUtils; + +public class SliceHeightsParser { + + private String sliceHeights; + + public SliceHeightsParser(String sliceHeights) { + this.sliceHeights = sliceHeights; + } + + public Double[] parseSliceHeights() throws IOException { + + String[] lines = ParsersUtils.readLines(sliceHeights, ParsersUtils.HASH_COMMENT); + int nrow = lines.length; + + Double[] sliceHeights = new Double[nrow]; + for (int i = 0; i < nrow; i++) { + sliceHeights[i] = Double.parseDouble(lines[i]); + } + + return sliceHeights; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/TimeSliceTree.java",".java","7618","208","package com.spread.parsers; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import com.spread.exceptions.SpreadException; +import com.spread.math.MultivariateNormalDistribution; +import com.spread.utils.ParsersUtils; +import com.spread.utils.Trait; + +import jebl.evolution.graphs.Node; +import jebl.evolution.trees.RootedTree; + +public class TimeSliceTree { + + private Map> sliceMap; + private RootedTree currentTree; + private Double[] sliceHeights; + private String traitName; + private String rrwRateName; + + public TimeSliceTree(HashMap> sliceMap, // + RootedTree currentTree, // + Double[] sliceHeights, // + String traitName, // + String rrwRateName // + ) { + + this.sliceMap = sliceMap; + this.currentTree = currentTree; + this.sliceHeights = sliceHeights; + this.traitName = traitName; + this.rrwRateName = rrwRateName; + } + + public void call() throws SpreadException { + + // parse the values once per tree + + Double[] precisionArray = ParsersUtils.getDoubleArrayTreeAttribute(currentTree, ParsersUtils.PRECISION); + + int dim = (int) Math.sqrt(1 + 8 * precisionArray.length) / 2; + + double treeNormalization = getTreeLength(currentTree, + currentTree.getRootNode()); + + for (Node node : currentTree.getNodes()) { + if (!currentTree.isRoot(node)) { + + // parse the values once per node + Node parentNode = currentTree.getParent(node); + Double parentHeight = ParsersUtils.getNodeHeight(currentTree, parentNode); + Double nodeHeight = ParsersUtils.getNodeHeight(currentTree, node); + + Double rate = 1.0; + if (rrwRateName != null) { + rate = (Double) ParsersUtils.getObjectNodeAttribute(node, rrwRateName); + } + + Trait trait = getNodeTrait(node, traitName); + Trait parentTrait = getNodeTrait(parentNode, traitName); + + if (!trait.isNumber() || !parentTrait.isNumber()) { + throw new SpreadException(""Trait "" + traitName + "" is not numeric!""); + } else { + + if (trait.getDim() != dim || parentTrait.getDim() != dim) { + throw new SpreadException(""Trait "" + traitName + "" is not "" + dim + "" dimensional!""); + } + } + + for (int i = 0; i < sliceHeights.length; i++) { + + double sliceHeight = sliceHeights[i]; + + if (nodeHeight < sliceHeight + && sliceHeight <= parentHeight) { + + double[] imputedLocation = imputeValue(trait.getValue(), // + parentTrait.getValue(), // + sliceHeight, // + nodeHeight, // + parentHeight, // + rate, // + treeNormalization, // + precisionArray); + + + double latitude = imputedLocation[ParsersUtils.LATITUDE_INDEX]; + double longitude = imputedLocation[ParsersUtils.LONGITUDE_INDEX]; + double[] coordinate = new double[2]; + coordinate[ParsersUtils.LATITUDE_INDEX] = latitude; + coordinate[ParsersUtils.LONGITUDE_INDEX] = longitude; + + if (sliceMap.containsKey(sliceHeight)) { + sliceMap.get(sliceHeight).add(coordinate); + } else { + LinkedList coords = new LinkedList(); + coords.add(coordinate); + sliceMap.put(sliceHeight, coords); + } // END: key check + + } // END: sliceTime check + + } // END: i loop + + } // END: root node check + } // END: node loop + + } + + private double[] imputeValue(double[] trait, // + double[] parentTrait, // + double sliceHeight, // + double nodeHeight, // + double parentHeight, // + double rate, // + double treeNormalization, // + Double[] precisionArray // + ) { + + int dim = (int) Math.sqrt(1 + 8 * precisionArray.length) / 2; + + double[][] precision = new double[dim][dim]; + int c = 0; + for (int i = 0; i < dim; i++) { + for (int j = i; j < dim; j++) { + precision[j][i] = precision[i][j] = precisionArray[c++] + * treeNormalization; + } + } + + double[] nodeValue = new double[dim]; + double[] parentValue = new double[dim]; + + for (int i = 0; i < dim; i++) { + nodeValue[i] = trait[i]; + parentValue[i] = parentTrait[i]; + } + + final double scaledTimeChild = (sliceHeight - nodeHeight) * rate; + final double scaledTimeParent = (parentHeight - sliceHeight) * rate; + final double scaledWeightTotal = (1.0 / scaledTimeChild) + + (1.0 / scaledTimeParent); + + if (scaledTimeChild == 0) { + return trait; + } + + if (scaledTimeParent == 0) { + return parentTrait; + } + // Find mean value, weighted average + double[] mean = new double[dim]; + double[][] scaledPrecision = new double[dim][dim]; + + for (int i = 0; i < dim; i++) { + mean[i] = (nodeValue[i] / scaledTimeChild + parentValue[i] + / scaledTimeParent) + / scaledWeightTotal; + + for (int j = i; j < dim; j++) + scaledPrecision[j][i] = scaledPrecision[i][j] = precision[i][j] + * scaledWeightTotal; + } + + mean = MultivariateNormalDistribution.nextMultivariateNormalPrecision(mean, + scaledPrecision); + + double[] result = new double[dim]; + for (int i = 0; i < dim; i++) { + result[i] = mean[i]; + } + + return result; + } + + private Trait getNodeTrait(Node node, String traitName) throws SpreadException { + + Object nodeAttribute = node.getAttribute(traitName); + + if (nodeAttribute == null) { + throw new SpreadException(""Attribute "" + traitName + "" missing from the node. \n""); + } + + return new Trait(nodeAttribute); + } + + private double getTreeLength(RootedTree tree, Node node) { + + int childCount = tree.getChildren(node).size(); + if (childCount == 0) + return tree.getLength(node); + + double length = 0; + for (int i = 0; i < childCount; i++) { + length += getTreeLength(tree, tree.getChildren(node).get(i)); + } + if (node != tree.getRootNode()) + length += tree.getLength(node); + + return length; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/ContinuousTreeParser.java",".java","23160","575","package com.spread.parsers; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.stream.Collectors; + +import com.google.gson.GsonBuilder; +import com.spread.data.Attribute; +import com.spread.data.AxisAttributes; +import com.spread.data.SpreadData; +import com.spread.data.Timeline; +import com.spread.data.attributable.Area; +import com.spread.data.attributable.Line; +import com.spread.data.attributable.Point; +import com.spread.data.primitive.Coordinate; +import com.spread.data.primitive.Polygon; +import com.spread.exceptions.SpreadException; +import com.spread.progress.IProgressObserver; +import com.spread.progress.IProgressReporter; +import com.spread.utils.ParsersUtils; + +import jebl.evolution.graphs.Node; +import jebl.evolution.io.ImportException; +import jebl.evolution.trees.RootedTree; +import lombok.Setter; + +public class ContinuousTreeParser implements IProgressReporter { + + @Setter + private String treeFilePath; + @Setter + private String xCoordinateAttributeName; + @Setter + private String yCoordinateAttributeName; + @Setter + private double timescaleMultiplier; + @Setter + private String mostRecentSamplingDate; + private IProgressObserver progressObserver; + + public ContinuousTreeParser() { + } + + public ContinuousTreeParser(String treeFilePath, + String xCoordinateAttributeName, + String yCoordinateAttributeName, + double timescaleMultiplier, + String mostRecentSamplingDate) { + this.treeFilePath = treeFilePath; + this.xCoordinateAttributeName = xCoordinateAttributeName; + this.yCoordinateAttributeName = yCoordinateAttributeName; + this.timescaleMultiplier = timescaleMultiplier; + this.mostRecentSamplingDate = mostRecentSamplingDate; + } + + protected SpreadData parseMccTree() throws IOException, ImportException, SpreadException { + + double progress = 0; + double progressStepSize = 0; + this.updateProgress(progress); + + RootedTree rootedTree = ParsersUtils.importRootedTree(treeFilePath); + TimeParser timeParser = new TimeParser(this.mostRecentSamplingDate); + Timeline timeline = timeParser.getTimeline(rootedTree.getHeight(rootedTree.getRootNode())); + + LinkedList linesList = new LinkedList(); + LinkedList pointsList = new LinkedList(); + LinkedList areasList = new LinkedList(); + LinkedList uniqueBranchAttributes = new LinkedList(); + LinkedList uniqueNodeAttributes = new LinkedList(); + LinkedList uniqueAreaAttributes = new LinkedList(); + + HashMap pointsMap = new HashMap(); + + Set modalityAttributeNames = this.parseHpdAttributesSet(); + + progressStepSize = 0.25 / (double) rootedTree.getNodes().size(); + for (Node node : rootedTree.getNodes()) { + + progress += progressStepSize; + this.updateProgress(progress); + + if (!rootedTree.isRoot(node)) { + + // node parsed first + Coordinate nodeCoordinate = null; + Double nodeCoordinateX = null; + Double nodeCoordinateY = null; + int tryingCoordinate = 0; + + try { + + tryingCoordinate = ParsersUtils.X_INDEX; + nodeCoordinateX = (Double) ParsersUtils.getObjectNodeAttribute(node, xCoordinateAttributeName); + + tryingCoordinate = ParsersUtils.Y_INDEX; + nodeCoordinateY = (Double) ParsersUtils.getObjectNodeAttribute(node, yCoordinateAttributeName); + + } catch (SpreadException e) { + String coordinateName = (tryingCoordinate == ParsersUtils.X_INDEX ? xCoordinateAttributeName : yCoordinateAttributeName); + String nodeType = (rootedTree.isExternal(node) ? ""external"" : ""internal""); + String message = coordinateName + "" attribute could not be found on the "" + nodeType + + "" child node. Resulting visualisation may be incomplete!""; + System.out.println (message); + continue; + } + + nodeCoordinate = new Coordinate(nodeCoordinateY, // latitude + nodeCoordinateX // longitude + ); + + // ---POINTS PARSED FIRST DO NOT CHANGE ORDER---// + + Point nodePoint = pointsMap.get(node); + if (nodePoint == null) { + nodePoint = createPoint(node, nodeCoordinate, rootedTree, timeParser); + pointsMap.put(node, nodePoint); + } + + // parent node parsed second + + // this spills to the root node, resulting in exception if not anotated + // root node will be annotated with locations but not with e.g. rate (facepalm) + Node parentNode = rootedTree.getParent(node); + + Double parentCoordinateX = null; + Double parentCoordinateY = null; + tryingCoordinate = 0; + + try { + tryingCoordinate = ParsersUtils.X_INDEX; + parentCoordinateX = (Double) ParsersUtils.getObjectNodeAttribute(parentNode, xCoordinateAttributeName); + + tryingCoordinate = ParsersUtils.Y_INDEX; + parentCoordinateY = (Double) ParsersUtils.getObjectNodeAttribute(parentNode, yCoordinateAttributeName); + } catch (SpreadException e) { + String coordinateName = (tryingCoordinate == ParsersUtils.X_INDEX ? xCoordinateAttributeName : yCoordinateAttributeName); + String nodeType = (rootedTree.isExternal(parentNode) ? ""external"" : ""internal""); + String message = coordinateName + "" attribute was found on the "" + nodeType + + "" child node but could not be found on the "" + nodeType + + "" parent node. Resulting visualisation may be incomplete!""; + System.out.println (message); + continue; + } + + Coordinate parentCoordinate = new Coordinate(parentCoordinateY, // lat + parentCoordinateX // long + ); + Point parentPoint = pointsMap.get(parentNode); + if (parentPoint == null) { + parentPoint = createPoint(parentNode, parentCoordinate, rootedTree, timeParser); + pointsMap.put(parentNode, parentPoint); + } + + // ---LINES PARSED SECOND DO NOT CHANGE ORDER---// + + Line line = new Line(parentPoint.getId(), // + nodePoint.getId(), // + parentPoint.getStartTime(), // + nodePoint.getStartTime(), // + nodePoint.getAttributes()); + + linesList.add(line); + + // ---AREAS PARSED LAST DO NOT CHANGE ORDER---// + + for (String modalityAttributeName : modalityAttributeNames) { + + Integer modality = 0; + try { + modality = (Integer) ParsersUtils.getObjectNodeAttribute(node, modalityAttributeName); + } catch (SpreadException e) { + continue; + } + + String hpd = modalityAttributeName.replaceAll(""\\D+"", """"); + + for (int m = 1; m <= modality; m++) { + + // trait1_80%HPD_1 + String xCoordinateHPDName = xCoordinateAttributeName.concat(""_"").concat(hpd).concat(""%"") + .concat(ParsersUtils.HPD.toUpperCase() + ""_"" + m); + + String yCoordinateHPDName = yCoordinateAttributeName.concat(""_"").concat(hpd).concat(""%"") + .concat(ParsersUtils.HPD.toUpperCase() + ""_"" + m); + + Object[] xCoordinateHPD = null; + Object[] yCoordinateHPD = null; + tryingCoordinate = 0; + + try { + + tryingCoordinate = ParsersUtils.X_INDEX; + xCoordinateHPD = ParsersUtils.getObjectArrayNodeAttribute(node, xCoordinateHPDName); + + tryingCoordinate = ParsersUtils.Y_INDEX; + yCoordinateHPD = ParsersUtils.getObjectArrayNodeAttribute(node, yCoordinateHPDName); + + } catch (SpreadException e) { + String coordinateName = (tryingCoordinate == ParsersUtils.X_INDEX ? xCoordinateHPDName + : yCoordinateHPDName); + String message = coordinateName + + "" attribute could not be found on the child node. Resulting visualisation may be incomplete!""; + System.out.println(message); + continue; + } + + List coordinateList = new ArrayList(); + for (int c = 0; c < xCoordinateHPD.length; c++) { + Double xCoordinate = (Double) xCoordinateHPD[c]; + Double yCoordinate = (Double) yCoordinateHPD[c]; + + Coordinate coordinate = new Coordinate(yCoordinate, // lat + xCoordinate // long + ); + coordinateList.add(coordinate); + } + + Polygon polygon = new Polygon(coordinateList); + + HashMap areaAttributesMap = new HashMap(); + areaAttributesMap.putAll(nodePoint.getAttributes()); + areaAttributesMap.put(ParsersUtils.HPD.toUpperCase(), hpd); + + Area area = new Area(polygon, nodePoint.getStartTime(), areaAttributesMap); + areasList.add(area); + + } + } + + } else { + + Double rootCoordinateX = null; + Double rootCoordinateY = null; + int tryingCoordinate = 0; + + try { + + tryingCoordinate = ParsersUtils.X_INDEX; + rootCoordinateX = (Double) ParsersUtils.getObjectNodeAttribute(node, xCoordinateAttributeName); + + tryingCoordinate = ParsersUtils.Y_INDEX; + rootCoordinateY = (Double) ParsersUtils.getObjectNodeAttribute(node, yCoordinateAttributeName); + + } catch (SpreadException e) { + String coordinateName = (tryingCoordinate == ParsersUtils.X_INDEX ? xCoordinateAttributeName : yCoordinateAttributeName); + String message = coordinateName + "" attribute was found on the root node."" + + ""Resulting visualisation may be incomplete!""; + System.out.println (message); + continue; + } + + Coordinate rootCoordinate = new Coordinate(rootCoordinateY, // lat + rootCoordinateX // long + ); + + Point rootPoint = createPoint(node, rootCoordinate, rootedTree, timeParser); + pointsMap.put(node, rootPoint); + + } + } + + pointsList.addAll(pointsMap.values()); + + // ---collect attributes from lines---// + + Map branchAttributesMap = new HashMap(); + + progressStepSize = 0.25 / (double) linesList.size(); + for (Line line : linesList) { + + progress += progressStepSize; + this.updateProgress(progress); + + for (Entry entry : line.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (branchAttributesMap.containsKey(attributeId)) { + + Attribute attribute = branchAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + + attribute.getDomain().add(attributeValue); + + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + + attribute = new Attribute(attributeId, domain); + + } // END: isNumeric check + + branchAttributesMap.put(attributeId, attribute); + + } // END: key check + + } // END: attributes loop + } // END: lines loop + + uniqueBranchAttributes.addAll(branchAttributesMap.values()); + + // ---collect attributes from nodes---// + + Map nodeAttributesMap = new HashMap(); + + progressStepSize = 0.25 / (double) pointsList.size(); + for (Point point : pointsList) { + + progress += progressStepSize; + this.updateProgress(progress); + + for (Entry entry : point.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (nodeAttributesMap.containsKey(attributeId)) { + + Attribute attribute = nodeAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + + attribute.getDomain().add(attributeValue); + + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + + attribute = new Attribute(attributeId, domain); + + } // END: isNumeric check + + nodeAttributesMap.put(attributeId, attribute); + + } // END: key check + + } // END: attributes loop + + } // END: points loop + + uniqueNodeAttributes.addAll(nodeAttributesMap.values()); + + // ---collect attributes from areas---// + + Map areasAttributesMap = new HashMap(); + + progressStepSize = 0.24 / (double) areasList.size(); + for (Area area : areasList) { + + progress += progressStepSize; + this.updateProgress(progress); + + for (Entry entry : area.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (areasAttributesMap.containsKey(attributeId)) { + + Attribute attribute = areasAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + + attribute.getDomain().add(attributeValue); + + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + + attribute = new Attribute(attributeId, domain); + + } // END: isNumeric check + + areasAttributesMap.put(attributeId, attribute); + + } // END: key check + + } // END: attributes loop + + } // END: areas loop + + uniqueAreaAttributes.addAll(areasAttributesMap.values()); + + AxisAttributes axis = new AxisAttributes(this.xCoordinateAttributeName, + this.yCoordinateAttributeName); + + this.updateProgress(0.90); + + return new SpreadData.Builder() + .withAnalysisType(ParsersUtils.CONTINUOUS_TREE) + .withTimeline(timeline) + .withAxisAttributes(axis) + .withLineAttributes(uniqueBranchAttributes) + .withPointAttributes(uniqueNodeAttributes) + .withAreaAttributes(uniqueAreaAttributes) + .withPoints (pointsList) + .withLines (linesList) + .withAreas (areasList) + .build(); + } + + public String parse() throws IOException, ImportException, SpreadException { + SpreadData data = this.parseMccTree(); + this.updateProgress(1.0); + return new GsonBuilder().create().toJson(data); + } + + public Set parseHpdAttributesSet() throws IOException, ImportException { + + RootedTree tree = ParsersUtils.importRootedTree(this.treeFilePath); + + Set hpdAttributes = tree.getNodes().stream() + .filter(node -> !tree.isRoot(node)) + .flatMap(node -> node.getAttributeNames().stream()) + .filter(attributeName -> attributeName.contains(""HPD_modality"")) + .collect(Collectors.toSet()); + + return hpdAttributes; + } + + public Set parseAllAttributesSet() throws IOException, ImportException { + RootedTree tree = ParsersUtils.importRootedTree(this.treeFilePath); + Set uniqueAttributes = tree.getNodes().stream().filter(node -> !tree.isRoot(node)) + .flatMap(node -> node.getAttributeNames().stream()) + .map(name -> name) + .collect(Collectors.toSet()); + return uniqueAttributes; + } + + public String parseAttributes() throws IOException, ImportException { + return new GsonBuilder().create().toJson(this.parseAllAttributesSet()); + } + + private Point createPoint(Node node, Coordinate coordinate, RootedTree rootedTree, TimeParser timeParser) + throws SpreadException { + + Double height = ParsersUtils.getNodeHeight(rootedTree, node) * this.timescaleMultiplier; + String startTime = timeParser.getNodeDate(height); + + Map attributes = new LinkedHashMap(); + for (String attributeName : node.getAttributeNames()) { + + Object nodeAttribute = node.getAttribute(attributeName); + if (!(nodeAttribute instanceof Object[])) { + // remove invalid characters + attributeName = attributeName.replaceAll(""%"", """").replaceAll(""!"", """"); + attributes.put(attributeName, nodeAttribute); + } // END: multivariate check + + } // END: attributes loop + + // annotate with node name + Object value; + if (rootedTree.isExternal(node)) { + value = rootedTree.getTaxon(node).toString(); + } else if (rootedTree.isRoot(node)) { + value = ""root""; + } else { + value = ""internal""; + } + + attributes.put(""nodeName"", value); + attributes.put(""xCoordinate"",coordinate.getX()); + attributes.put(""yCoordinate"",coordinate.getY()); + // external nodes have no posterior annotated, need to fix that + if (rootedTree.isExternal(node)) { + attributes.put(ParsersUtils.POSTERIOR, 1.0); + } + + return new Point(coordinate, startTime, attributes); + } + + @Override + public void registerProgressObserver(IProgressObserver observer) { + this.progressObserver = observer; + } + + @Override + public void updateProgress(double progress) { + if (this.progressObserver != null) { + this.progressObserver.handleProgress(progress); + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/BayesFactorParser.java",".java","17884","481","package com.spread.parsers; + +import java.io.IOException; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.Map.Entry; + +import com.google.gson.GsonBuilder; +import com.spread.data.Attribute; +import com.spread.data.AxisAttributes; +import com.spread.data.Location; +import com.spread.data.SpreadData; +import com.spread.data.attributable.Line; +import com.spread.data.attributable.Point; +import com.spread.data.primitive.Coordinate; +import com.spread.exceptions.SpreadException; +import com.spread.progress.IProgressObserver; +import com.spread.progress.IProgressReporter; +import com.spread.utils.ParsersUtils; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +public class BayesFactorParser implements IProgressReporter { + + public static final String BAYES_FACTOR = ""bayesFactor""; + public static final String POSTERIOR_PROBABILITY = ""posteriorProbability""; + + @Setter + private String logFilePath; + @Setter + private Double burnIn; + @Setter + private String locationsFilePath; + @Setter + private Integer numberOfLocations; + + private IProgressObserver progressObserver; + + public class BayesFactorParserOutput { + public LinkedList bayesFactors; + public SpreadData spreadData; + + BayesFactorParserOutput (LinkedList bayesFactors, + SpreadData spreadData) { + this.bayesFactors = bayesFactors; + this.spreadData = spreadData; + } + } + + @EqualsAndHashCode + @ToString(includeFieldNames=true) + public static class BayesFactor { + + @Getter + private String from; + @Getter + private String to; + @Getter + private Double bayesFactor; + @Getter + private Double posteriorProbability; + + public BayesFactor(String from, + String to, + Double bayesFactor, + Double posteriorProbability) { + this.from = from; + this.to = to; + this.bayesFactor = bayesFactor; + this.posteriorProbability = posteriorProbability; + } + } + + public BayesFactorParser() { + } + + public BayesFactorParser(String logFilePath, + Double burnIn, + String locationsFilePath) { + this.logFilePath = logFilePath; + this.burnIn = burnIn; + this.locationsFilePath = locationsFilePath; + } + + public BayesFactorParser(String logFilePath, + Double burnIn, + Integer numberOfLocations) { + this.logFilePath = logFilePath; + this.burnIn = burnIn; + this.numberOfLocations = numberOfLocations; + } + + public String parse() throws IOException, SpreadException { + + double progress = 0; + double progressStepSize = 0; + this.updateProgress(progress); + + Double[][] indicators = new LogParser(this.logFilePath, this.burnIn).parseIndicators(); + LinkedList locationsList = null; + + if (this.locationsFilePath != null) { + locationsList = new DiscreteLocationsParser(this.locationsFilePath, false) + .parseLocations(); + } else if (this.numberOfLocations != null) { + locationsList = this.generateDummyLocations(this.numberOfLocations); + } else { + throw new SpreadException (""Specify one of: numberOfLocations or locationsFilePath""); + } + + int numberOfLocations = locationsList.size(); + int poissonPriorOffset = numberOfLocations - 1; + double poissonPriorMean = Math.log(2); + int nrow = indicators.length; + int ncol = indicators[0].length; + + Boolean symmetrical = null; + if (ncol == numberOfLocations * (numberOfLocations - 1)) { + symmetrical = false; + } else if (ncol == (numberOfLocations * (numberOfLocations - 1)) / 2) { + symmetrical = true; + } else { + int n1 = (int) ((Math.sqrt(4 * ncol + 1) + 1) / 2); + int n2 = (int) ((Math.sqrt(8 * ncol + 1) + 1) / 2); + throw new SpreadException(""Number of rate indicators ("" + ncol + "")"" + "" does not match the number of locations!"" + "" Specify "" + + n2 + "" locations if the location exchange models is a symmetrical one, or "" + n1 + + "" for a non-symmetrical one.""); + } + + double qk = Double.NaN; + if (symmetrical) { + qk = (poissonPriorMean + poissonPriorOffset) / ((numberOfLocations * (numberOfLocations - 1)) / 2); + } else { + qk = (poissonPriorMean + poissonPriorOffset) / ((numberOfLocations * (numberOfLocations - 1)) / 1); + } + + double priorOdds = qk / (1 - qk); + double[] pk = getColumnMeans(indicators); + this.updateProgress(0.1); + + LinkedList bayesFactors = new LinkedList(); + LinkedList posteriorProbabilities = new LinkedList(); + + progressStepSize = 0.2 / (double) pk.length; + for (int row = 0; row < pk.length; row++) { + + progress += progressStepSize; + this.updateProgress(progress); + + double bf = (pk[row] / (1 - pk[row])) / priorOdds; + // correcting for infinite bf + if (bf == Double.POSITIVE_INFINITY) { + bf = ((pk[row] - (double) (1.0 / nrow)) / (1 - (pk[row] - (double) (1.0 / nrow)))) / priorOdds; + } + + bayesFactors.add(bf); + posteriorProbabilities.add(pk[row]); + } + + LinkedList from = new LinkedList(); + LinkedList to = new LinkedList(); + + String[] locations = new String[locationsList.size()]; + int ii = 0; + for (Location location : locationsList) { + locations[ii] = location.getId(); + ii++; + } + + for (int row = 0; row < numberOfLocations - 1; row++) { + String[] subset = this.subset(locations, row, numberOfLocations - row); + for (int i = 1; i < subset.length; i++) { + from.add(locations[row]); + to.add(subset[i]); + } + } + + if (!symmetrical) { + from.addAll(to); + to.addAll(from); + } + + HashMap pointsMap = new HashMap(); + LinkedList linesList = new LinkedList(); + progressStepSize = 0.2 / (double) bayesFactors.size(); + for (int i = 0; i < bayesFactors.size(); i++) { + + progress += progressStepSize; + this.updateProgress(progress); + + // from is parsed first + Location dummy = new Location(from.get(i)); + int fromLocationIndex = Integer.MAX_VALUE; + if (locationsList.contains(dummy)) { + fromLocationIndex = locationsList.indexOf(dummy); + } else { + System.out.println(""Location "" + dummy.getId() + "" could not be found in the locations file. Resulting file may be incomplete!""); + continue; + } + + Location fromLocation = locationsList.get(fromLocationIndex); + Point fromPoint = pointsMap.get(fromLocation); + if (fromPoint == null) { + fromPoint = createPoint(fromLocation); + pointsMap.put(fromLocation, fromPoint); + } + + // to is parsed second + dummy = new Location(to.get(i)); + int toLocationIndex = Integer.MAX_VALUE; + if (locationsList.contains(dummy)) { + toLocationIndex = locationsList.indexOf(dummy); + } else { + String message = ""Parent location "" + dummy.getId() + "" could not be found in the locations file.""; + throw new SpreadException(message); + } + + Location toLocation = locationsList.get(toLocationIndex); + Point toPoint = pointsMap.get(toLocation); + if (toPoint == null) { + toPoint = createPoint(toLocation); + pointsMap.put(toLocation, toPoint); + } + + LinkedHashMap attributes = new LinkedHashMap(); + + Double bayesFactor = bayesFactors.get(i); + attributes.put(BAYES_FACTOR, bayesFactor); + + Double posteriorProbability = posteriorProbabilities.get(i); + attributes.put(POSTERIOR_PROBABILITY, posteriorProbability); + + if (!fromLocation.hasCoordinate()) { + System.out.println(""Coordinate values could not be found for the location "" + fromLocation.getId() + + "" Resulting visualisation may be incomplete!""); + continue; + } + + if (!toLocation.hasCoordinate()) { + System.out.println(""Coordinate values could not be found for the location "" + toLocation.getId() + + "" Resulting visualisation may be incomplete!""); + continue; + } + + Line line = new Line(fromPoint.getId(), // + toPoint.getId(), // + null, // + null, // + attributes // + ); + + linesList.add(line); + } + + LinkedList pointsList = new LinkedList(pointsMap.values()); + + // collect attributes from lines + HashMap branchAttributesMap = new HashMap(); + progressStepSize = 0.2 / (double) linesList.size(); + for (Line line : linesList) { + + progress += progressStepSize; + this.updateProgress(progress); + for (Entry entry : line.getAttributes().entrySet()) { + + String attributeId = entry.getKey(); + Object attributeValue = entry.getValue(); + + if (branchAttributesMap.containsKey(attributeId)) { + + Attribute attribute = branchAttributesMap.get(attributeId); + + if (attribute.getScale().equals(Attribute.ORDINAL)) { + + attribute.getDomain().add(attributeValue); + + } else { + + double value = ParsersUtils.round(Double.valueOf(attributeValue.toString()), 100); + + if (value < attribute.getRange()[Attribute.MIN_INDEX]) { + attribute.getRange()[Attribute.MIN_INDEX] = value; + } // END: min check + + if (value > attribute.getRange()[Attribute.MAX_INDEX]) { + attribute.getRange()[Attribute.MAX_INDEX] = value; + } // END: max check + + } // END: scale check + + } else { + + Attribute attribute; + if (attributeValue instanceof Double) { + Double[] range = new Double[2]; + range[Attribute.MIN_INDEX] = (Double) attributeValue; + range[Attribute.MAX_INDEX] = (Double) attributeValue; + + attribute = new Attribute(attributeId, range); + } else { + + HashSet domain = new HashSet(); + domain.add(attributeValue); + + attribute = new Attribute(attributeId, domain); + } // END: isNumeric check + + branchAttributesMap.put(attributeId, attribute); + } + } + } + + LinkedList uniqueLineAttributes = new LinkedList(branchAttributesMap.values()); + + LinkedList rangeAttributes = getCoordinateRangeAttributes(locationsList); + Attribute xCoordinate = rangeAttributes.get(ParsersUtils.X_INDEX); + Attribute yCoordinate = rangeAttributes.get(ParsersUtils.Y_INDEX); + + LinkedList uniquePointAttributes = new LinkedList(); + uniquePointAttributes.add(xCoordinate); + uniquePointAttributes.add(yCoordinate); + + SpreadData spreadData = new SpreadData.Builder() + .withAnalysisType(ParsersUtils.BAYES_FACTOR) + .withAxisAttributes(new AxisAttributes(xCoordinate.getId(), + yCoordinate.getId())) + .withLineAttributes(uniqueLineAttributes) + .withPointAttributes(uniquePointAttributes) + .withLocations(locationsList) + .withPoints (pointsList) + .withLines (linesList) + .build(); + + LinkedList bayesFactorsData = new LinkedList(); + progressStepSize = 0.2 / (double) bayesFactors.size(); + for (int i = 0; i < bayesFactors.size(); i++) { + progress += progressStepSize; + this.updateProgress(progress); + bayesFactorsData.add(new BayesFactor(from.get(i), + to.get(i), + bayesFactors.get(i), + posteriorProbabilities.get(i))); + } + + this.updateProgress(1.0); + + return new GsonBuilder() + .create() + .toJson(new BayesFactorParserOutput (bayesFactorsData, spreadData)); + } + + private LinkedList getCoordinateRangeAttributes(LinkedList locationsList) throws SpreadException { + + LinkedList coordinateRange = new LinkedList(); + + Double[] xCoordinateRange = new Double[2]; + xCoordinateRange[Attribute.MIN_INDEX] = Double.MAX_VALUE; + xCoordinateRange[Attribute.MAX_INDEX] = Double.NEGATIVE_INFINITY; + + Double[] yCoordinateRange = new Double[2]; + yCoordinateRange[Attribute.MIN_INDEX] = Double.MAX_VALUE; + yCoordinateRange[Attribute.MAX_INDEX] = Double.NEGATIVE_INFINITY; + + for (Location location : locationsList) { + + Coordinate coordinate = location.getCoordinate(); + if (coordinate == null) { + throw new SpreadException(""Location "" + location.getId() + + "" has no coordinates set.""); + } + + Double latitude = coordinate.getXCoordinate(); + Double longitude = coordinate.getYCoordinate(); + + // update coordinates range + + if (latitude < xCoordinateRange[Attribute.MIN_INDEX]) { + xCoordinateRange[Attribute.MIN_INDEX] = latitude; + } // END: min check + + if (latitude > xCoordinateRange[Attribute.MAX_INDEX]) { + xCoordinateRange[Attribute.MAX_INDEX] = latitude; + } // END: max check + + if (longitude < yCoordinateRange[Attribute.MIN_INDEX]) { + yCoordinateRange[Attribute.MIN_INDEX] = longitude; + } // END: min check + + if (longitude > yCoordinateRange[Attribute.MAX_INDEX]) { + yCoordinateRange[Attribute.MAX_INDEX] = longitude; + } // END: max check + + } + + Attribute xCoordinate = new Attribute(ParsersUtils.X_COORDINATE, xCoordinateRange); + Attribute yCoordinate = new Attribute(ParsersUtils.Y_COORDINATE, yCoordinateRange); + + coordinateRange.add(ParsersUtils.X_INDEX, xCoordinate); + coordinateRange.add(ParsersUtils.Y_INDEX, yCoordinate); + + return coordinateRange; + } + + private Point createPoint(Location location) { + return new Point(location.getId()); + } + + private String[] subset(String line[], int start, int length) { + String output[] = new String[length]; + System.arraycopy(line, start, output, 0, length); + return output; + } + + private double getColumnMean(Double a[][], int col) { + double sum = 0; + int nrows = a.length; + for (int row = 0; row < nrows; row++) { + sum += a[row][col]; + } + return sum / nrows; + } + + private double[] getColumnMeans(Double a[][]) { + int ncol = a[0].length; + double[] b = new double[ncol]; + for (int c = 0; c < ncol; c++) { + b[c] = getColumnMean(a, c); + } + return b; + } + + /* + * Generates locations distributed uniformly on a circle with fixed radius of 1000 KM + */ + private LinkedList generateDummyLocations(int numberOfLocations) { + + double radius = 1000; + + Double centroidLatitude = 0.0; + Double centroidLongitude = 0.0; + + double dLongitude = Math.toDegrees((radius / ParsersUtils.EARTH_RADIUS)); + double dLatitude = dLongitude + / Math.cos(Math.toRadians(centroidLatitude)); + + LinkedList locationsList = new LinkedList(); + for (int i = 0; i < numberOfLocations; i++) { + + String locationId = ""location"" + (i + 1); + + double theta = 2.0 * Math.PI * (i / (double) numberOfLocations); + Double cLatitude = centroidLatitude + + (dLongitude * Math.cos(theta)); + Double cLongitude = centroidLongitude + + (dLatitude * Math.sin(theta)); + + locationsList.add(new Location (locationId, new Coordinate(cLatitude, cLongitude))); + } + + return locationsList; + } + + @Override + public void registerProgressObserver(IProgressObserver observer) { + this.progressObserver = observer; + } + + @Override + public void updateProgress(double progress) { + if (this.progressObserver != null) { + this.progressObserver.handleProgress(progress); + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/LogParser.java",".java","3264","114","package com.spread.parsers; + +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import com.spread.exceptions.SpreadException; +import com.spread.utils.ParsersUtils; + +/** + * @author fbielejec + */ +public class LogParser { + + // two commented lines and header. This is a hack off course + private static final int SKIPPED_LINES = 3; + private static final int HEADER_ROW = 0; + private String logFilename; + private Double burnin; + + private String[] columnNames; + + /* + * Parameters: + * @log: path to the log file + * @burnin: burnin [0,1] + */ + public LogParser(String log, Double burnin) { + this.logFilename = log; + this.burnin = burnin; + } + + public Double[][] parseIndicators() throws IOException, SpreadException { + + String[] lines = ParsersUtils.readLines(logFilename, ParsersUtils.HASH_COMMENT); + columnNames = lines[HEADER_ROW].split(""\\s+""); + + int nrow = lines.length - 1; + + // Find columns with indicators + List columns = new LinkedList(); + Pattern pattern = Pattern.compile(ParsersUtils.INDICATORS); + for (int i = 0; i < columnNames.length; i++) { + + // Look for matches in column names + Matcher matcher = pattern.matcher(columnNames[i]); + if (matcher.find()) { + columns.add(i); + } + + } // END: column names loop + + int ncol = columns.size(); + // this should be enough when sth silly is parsed + if (ncol == 0) { + throw new SpreadException(""No "" + ParsersUtils.INDICATORS + "" columns found. I suspect wrong or malformed log file.""); + } + + int skip = (int) (burnin * nrow); + + // parse indicator columns + Double[][] indicators = new Double[nrow - skip][ncol]; + int i = 0; + for (int row = 1; row <= nrow; row++) { + + if (row > skip) { + + String[] line = lines[row].split(ParsersUtils.BLANK_SPACE); + + for (int col = 0; col < ncol; col++) { + + if (columns.get(col) > line.length) { + System.out.println(""Empty or malformed input at line "" + (row + SKIPPED_LINES) + + "" inside log file. Resulting output may not be correct!""); + + // copy array with one less row + indicators = cloneArray(indicators, i); + break; + } else { + indicators[i][col] = Double.valueOf(line[columns.get(col)]); + } + + } // END: col loop + + i++; + } // END: burn-in check + + } // END: row loop + + return indicators; + } + + /* + * Make a copy of array up to and a row number nrow + */ + private Double[][] cloneArray(Double[][] src, int nrow) { + + Double[][] target = new Double[nrow][src[0].length]; + + for (int i = 0; i < nrow; i++) { + System.arraycopy(src[i], 0, target[i], 0, src[i].length); + } + + return target; + } + + public String[] getColumnNames() { + return columnNames; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/TimeParser.java",".java","4750","161","package com.spread.parsers; + +import com.spread.data.Timeline; +import com.spread.exceptions.SpreadException; +import com.spread.utils.ParsersUtils; + +import org.joda.time.LocalDate; +import org.joda.time.format.DateTimeFormat; +import org.joda.time.format.DateTimeFormatter; + +public class TimeParser { + + public static final String separator = ""/""; + private static final String dateRegex = ""\\d{4}"" + separator + ""\\d{2}"" + separator + ""\\d{2}""; + + private String mrsd; + private LocalDate endDate; + private DateTimeFormatter dateFormatter; + + public TimeParser(String mrsd) throws SpreadException { + this.mrsd = mrsd; + this.dateFormatter = DateTimeFormat.forPattern(""yyyy"" + separator + ""MM"" + separator + ""dd""); + + parseTime(); + } + + private void parseTime() throws SpreadException { + + Integer year = 0; + Integer month = 0; + Integer day = 0; + + String[] endDateFields; + if (mrsd.contains(""."")) { + + // negative dates + int decimalDateSign = 1; + if (mrsd.contains(ParsersUtils.NEGATIVE_SIGN)) { + decimalDateSign = -1; + mrsd = mrsd.split(separator)[1]; + } + + endDateFields = convertToYearMonthDay(Double.valueOf(mrsd)); + + year = decimalDateSign * Integer.valueOf(endDateFields[ParsersUtils.YEAR_INDEX]); + month = Integer.valueOf(endDateFields[ParsersUtils.MONTH_INDEX]); + day = Integer.valueOf(endDateFields[ParsersUtils.DAY_INDEX]); + + } else if (mrsd.contains(separator)) { + + endDateFields = mrsd.split(separator); + if (endDateFields.length == 3) { + + year = Integer.valueOf(endDateFields[ParsersUtils.YEAR_INDEX]); + month = Integer.valueOf(endDateFields[ParsersUtils.MONTH_INDEX]); + day = Integer.valueOf(endDateFields[ParsersUtils.DAY_INDEX]); + + } else if (endDateFields.length == 2) { + + year = Integer.valueOf(endDateFields[ParsersUtils.YEAR_INDEX]); + month = Integer.valueOf(endDateFields[ParsersUtils.MONTH_INDEX]); + + } else if (endDateFields.length == 1) { + + year = Integer.valueOf(endDateFields[ParsersUtils.YEAR_INDEX]); + + } else { + throw new SpreadException(""Unrecognised date format "" + this.mrsd); + } + + } else { + throw new SpreadException(""Unrecognised MRSD format "" + this.mrsd); + } + + // joda monthOfYear must be [1,12] + if (month == 0) { + month = 1; + } + + // joda dayOfMonth must be [1,31] + if (day == 0) { + day = 1; + } + + this.endDate = new LocalDate(year, month, day); + } + + public Timeline getTimeline(double rootNodeHeight) { + + String startDate = this.getNodeDate(rootNodeHeight); + String endDate = dateFormatter.print(this.endDate); + + Timeline timeLine = new Timeline(startDate, endDate); + + return timeLine; + } + + public String getNodeDate(double nodeHeight) { + + String[] fields = convertToYearMonthDay(nodeHeight); + Integer years = Integer.valueOf(fields[ParsersUtils.YEAR_INDEX]); + Integer months = Integer.valueOf(fields[ParsersUtils.MONTH_INDEX]); + Integer days = Integer.valueOf(fields[ParsersUtils.DAY_INDEX]); + LocalDate date = endDate.minusYears(years).minusMonths(months).minusDays(days); + String stringDate = dateFormatter.print(date); + + return stringDate; + } + + public static Boolean isParseableDate(String dateString) { + return dateString.matches(dateRegex); + } + + public String[] convertToYearMonthDay(double fractionalDate) { + + String[] yearMonthDay = new String[3]; + + int year = (int) fractionalDate; + String yearString; + + if (year < 10) { + yearString = ""000"" + year; + } else if (year < 100) { + yearString = ""00"" + year; + } else if (year < 1000) { + yearString = ""0"" + year; + } else { + yearString = """" + year; + } + + yearMonthDay[0] = yearString; + + double fractionalMonth = fractionalDate - year; + + int month = (int) (12.0 * fractionalMonth); + String monthString; + + if (month < 10) { + monthString = ""0"" + month; + } else { + monthString = """" + month; + } + + yearMonthDay[1] = monthString; + + int day = (int) Math.round(30 * (12 * fractionalMonth - month)); + String dayString; + + if (day < 10) { + dayString = ""0"" + day; + } else { + dayString = """" + day; + } + + yearMonthDay[2] = dayString; + + return yearMonthDay; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/parsers/DiscreteLocationsParser.java",".java","2325","72","package com.spread.parsers; + +import java.io.IOException; +import java.util.Arrays; +import java.util.LinkedList; + +import com.spread.data.Location; +import com.spread.data.primitive.Coordinate; +import com.spread.utils.ParsersUtils; +import com.spread.exceptions.SpreadException; + +public class DiscreteLocationsParser { + + private static final int LATITUDE_COLUMN = 1; + private static final int LONGITUDE_COLUMN = 2; + + private String locationsFilename; + private boolean header; + + public DiscreteLocationsParser(String locationsFilename, boolean header) { + this.locationsFilename = locationsFilename; + this.header = header; + } + + public LinkedList parseLocations() throws IOException, SpreadException { + + LinkedList locationsList = new LinkedList(); + + // create list from the coordinates file + String[] lines = ParsersUtils.readLines(locationsFilename, ParsersUtils.HASH_COMMENT); + + if (header) { + lines = Arrays.copyOfRange(lines, 1, lines.length); + } + + int nrow = lines.length; + for (int i = 0; i < nrow; i++) { + + String[] line = lines[i].split(""\\s+""); + if (line.length != 3) { + throw new SpreadException(""Incorrect number of columns in locations file. Expecting 3, found "" + + line.length); + } + + String locationName = line[0]; + // remove trailing spaces from + locationName = locationName.trim(); + + String illegalCharacter = ""+""; + if (locationName.contains(illegalCharacter)) { + + throw new SpreadException(""Location "" + locationName + + "" contains illegal character "" + illegalCharacter); + + } + + Double yCoordinate = Double.valueOf(line[LATITUDE_COLUMN]); + Double xCoordinate = Double.valueOf(line[LONGITUDE_COLUMN]); + + Coordinate coordinate = new Coordinate(yCoordinate, xCoordinate); + + // create Location and add to the list of Locations + Location location = new Location(locationName, coordinate); + locationsList.add(location); + + } // END: i loop + + return locationsList; + }// END: parseLocations + +}// END: class +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/exceptions/SpreadException.java",".java","749","36","package com.spread.exceptions; + +import org.joda.time.Instant; + +public class SpreadException extends Exception { + + private static final long serialVersionUID = -1258021836219278875L; + private final String message; + private final String[][] meta; + + public SpreadException(String message, String[][] meta) { + this.message = message; + this.meta = meta; + } + + public SpreadException(String message) { + this.message = message; + this.meta = new String[][] { + {""timestamp"", Instant.now().toString()}, + }; + } + + /** + * @return the meta + */ + public String[][] getMeta() { + return meta; + } + + @Override + public String getMessage() { + return message; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/Location.java",".java","1753","86","package com.spread.data; + +import com.spread.data.primitive.Coordinate; +import com.spread.data.primitive.Polygon; + +import lombok.ToString; + +@ToString(includeFieldNames=true) +public class Location { + + private final String id; + // private final Polygon polygon; + private final Coordinate coordinate; + + public Location(String id) { + this.id = id; + this.coordinate = null; + // this.polygon = null; + } + + public Location(String id, + Polygon polygon) { + + super(); + + this.id = id; + this.coordinate = null; + // this.polygon = polygon; + } + + public Location(String id, + Coordinate coordinate) { + + super(); + + this.id = id; + this.coordinate = coordinate; + // this.polygon = null; + + } + + public String getId() { + return id; + } + + // public Polygon getPolygon() { + // return polygon; + // } + + public boolean hasCoordinate() { + return coordinate == null ? false : true; + } + + public Coordinate getCoordinate() { + return coordinate; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((id == null) ? 0 : id.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (obj == null) { + return false; + } + if (obj == this) { + return true; + } + if (!(obj instanceof Location)) { + return false; + } + Location location = (Location) obj; + if (location.getId().equalsIgnoreCase(this.id)) { + return true; + } else { + return false; + } + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/Layer.java",".java","1499","69","package com.spread.data; + +import java.util.List; + +import com.spread.data.attributable.Area; +import com.spread.data.attributable.Line; +import com.spread.data.attributable.Point; + +import lombok.Getter; +import lombok.ToString; + +@ToString(includeFieldNames=true) +public class Layer { + + @Getter + private final List points; + @Getter + private final List lines; + @Getter + private final List areas; + @Getter + private final List counts; + + public static class Builder { + + private List points; + private List lines; + private List areas; + private List counts; + + public Builder() { + } + + public Builder withCounts(List counts) { + this.counts = counts; + return this; + } + + public Builder withPoints(List points) { + this.points = points; + return this; + } + + public Builder withLines(List lines) { + this.lines = lines; + return this; + } + + public Builder withAreas(List areas) { + this.areas = areas; + return this; + } + + public Layer build() { + Layer layer = new Layer (this); + return layer; + } + + } + + private Layer(Builder builder) { + this.counts = builder.counts; + this.points = builder.points; + this.lines = builder.lines; + this.areas = builder.areas; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/SpreadData.java",".java","3735","139","package com.spread.data; + +import java.util.List; + +import com.spread.data.attributable.Area; +import com.spread.data.attributable.Line; +import com.spread.data.attributable.Point; + +import lombok.Getter; +import lombok.ToString; + +/** + * @author Filip Bielejec + */ +@ToString(includeFieldNames=true) +public class SpreadData { + + @Getter + private String analysisType; + @Getter + private final Timeline timeline; + @Getter + private final AxisAttributes axisAttributes; + + // TODO : use Set for unique attributes below + @Getter + private final List lineAttributes; + @Getter + private final List pointAttributes; + @Getter + private final List areaAttributes; + @Getter + private final List locations; + + @Getter + private final List points; + @Getter + private final List lines; + @Getter + private final List areas; + @Getter + private final List counts; + + public static class Builder { + + private String analysisType; + private Timeline timeline; + private AxisAttributes axisAttributes; + private List lineAttributes; + private List pointAttributes; + private List areaAttributes; + private List locations; + + private List points; + private List lines; + private List areas; + private List counts; + + public Builder() { + } + + public Builder withCounts(List counts) { + this.counts = counts; + return this; + } + + public Builder withPoints(List points) { + this.points = points; + return this; + } + + public Builder withLines(List lines) { + this.lines = lines; + return this; + } + + public Builder withAreas(List areas) { + this.areas = areas; + return this; + } + + public Builder withAnalysisType(String analysisType) { + this.analysisType = analysisType; + return this; + } + + public Builder withTimeline(Timeline timeline) { + this.timeline = timeline; + return this; + } + + public Builder withAxisAttributes(AxisAttributes axisAttributes) { + this.axisAttributes = axisAttributes; + return this; + } + + public Builder withLineAttributes(List lineAttributes) { + this.lineAttributes = lineAttributes; + return this; + } + + public Builder withPointAttributes(List pointAttributes) { + this.pointAttributes = pointAttributes; + return this; + } + + public Builder withAreaAttributes(List areaAttributes) { + this.areaAttributes = areaAttributes; + return this; + } + + public Builder withLocations(List locations) { + this.locations = locations; + return this; + } + + public SpreadData build() { + SpreadData data = new SpreadData (this); + return data; + } + + } + + private SpreadData(Builder builder) { + this.analysisType = builder.analysisType; + this.timeline = builder.timeline; + this.axisAttributes = builder.axisAttributes; + this.lineAttributes = builder.lineAttributes; + this.pointAttributes = builder.pointAttributes; + this.areaAttributes = builder.areaAttributes; + this.locations = builder.locations; + this.points = builder.points; + this.lines = builder.lines; + this.counts = builder.counts; + this.areas = builder.areas; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/Timeline.java",".java","619","28","package com.spread.data; + +public class Timeline { + + private final String startTime; + private final String endTime; + + public Timeline(String startTime, String endTime) { + + this.startTime = startTime; + this.endTime = endTime; + + }// END: Constructor + + public String getStartTime() { + return startTime; + }// END: getStartTime + + public String getEndTime() { + return endTime; + }// END: getEndTime + + public String toString() { + return startTime + "" "" + endTime; + } + +}// END: class +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/Attribute.java",".java","1019","42","package com.spread.data; + +import java.util.HashSet; + +import lombok.ToString; +import lombok.EqualsAndHashCode; +import lombok.Getter; + +@EqualsAndHashCode +@ToString(includeFieldNames=true) +public class Attribute { + + public static int MIN_INDEX = 0; + public static int MAX_INDEX = 1; + public static String LINEAR = ""linear""; + public static String ORDINAL = ""ordinal""; + + @Getter + private final String id; + @Getter + private final String scale; + @Getter + private Double[] range; + @Getter + private HashSet domain; + + public Attribute(String id, Double[] range) { + this.id = id; + this.scale = LINEAR; + this.range = range; + this.domain = null; + } + + public Attribute(String id, HashSet domain) { + this.id = id; + this.scale = ORDINAL; + this.range = null; + this.domain = domain; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/AxisAttributes.java",".java","430","23","package com.spread.data; + +import lombok.ToString; +import lombok.Getter; + +/** + * @author Filip Bielejec + */ +@ToString(includeFieldNames=true) +public class AxisAttributes { + + @Getter + private final String xCoordinate; + @Getter + private final String yCoordinate; + + public AxisAttributes(String xCoordinate, String yCoordinate) { + this.xCoordinate = xCoordinate; + this.yCoordinate = yCoordinate; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/primitive/Polygon.java",".java","326","19","package com.spread.data.primitive; + +import java.util.List; + +import lombok.ToString; +import lombok.Getter; + +@ToString(includeFieldNames=true) +public class Polygon { + + @Getter + private final List coordinates; + + public Polygon(List coordinates) { + this.coordinates = coordinates; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/primitive/Coordinate.java",".java","655","34","package com.spread.data.primitive; + +import lombok.ToString; +import lombok.EqualsAndHashCode; +import lombok.Getter; + +@EqualsAndHashCode(onlyExplicitlyIncluded = true) +@ToString(includeFieldNames=true) +public class Coordinate { + + @Getter + @EqualsAndHashCode.Include + private final Double xCoordinate; + @Getter + @EqualsAndHashCode.Include + private final Double yCoordinate; + + public Coordinate(Double latitude, + Double longitude) { + this.xCoordinate = longitude; + this.yCoordinate = latitude; + } + + public Double getX(){ + return xCoordinate; + } + + public Double getY(){ + return yCoordinate; + } + + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/attributable/Area.java",".java","618","29","package com.spread.data.attributable; + +import java.util.Map; + +import com.spread.data.primitive.Polygon; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; + +@EqualsAndHashCode +@ToString(includeFieldNames=true) +public class Area { + + @Getter + private final String startTime; + @Getter + private final Map attributes; + @Getter + private final Polygon polygon; + + public Area (Polygon polygon, String startTime, Map attributes) { + this.polygon = polygon; + this.startTime = startTime; + this.attributes = attributes; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/attributable/Point.java",".java","2871","120","package com.spread.data.attributable; + +import java.util.LinkedHashMap; +import java.util.Map; + +import com.spread.data.Location; +import com.spread.data.primitive.Coordinate; + +import lombok.ToString; +import lombok.Getter; + +@ToString(includeFieldNames=true) +public class Point { + + @Getter + private final String id; + @Getter + private final String locationId; + @Getter + private final Coordinate coordinate; + @Getter + private final String startTime; + @Getter + private final String endTime; + @Getter + private final Map attributes = new LinkedHashMap(); + + public Point(String locationId) { + this.locationId = locationId; + this.coordinate = null; + this.startTime = null; + this.endTime = null; + + this.id = String.valueOf(Math.abs(locationId.hashCode())); + + } + + public Point(String locationId, String startTime, Map attributes) { + + this.locationId = locationId; + this.coordinate = null; + this.startTime = startTime; + this.endTime = null; + + this.id = String.valueOf(Math.abs(locationId.hashCode() + startTime.hashCode())); + + if (attributes != null) { + this.attributes.putAll(attributes); + } + + } + + public Point(String locationId, String startTime, String endTime, Map attributes) { + + this.locationId = locationId; + this.coordinate = null; + this.startTime = startTime; + this.endTime = endTime; + + this.id = String.valueOf(Math.abs(locationId.hashCode() + startTime.hashCode() + endTime.hashCode())); + + if (attributes != null) { + this.attributes.putAll(attributes); + } + + } + + public Point(Coordinate coordinate, String startTime, Map attributes) { + + this.coordinate = coordinate; + this.locationId = null; + this.startTime = startTime; + this.endTime = null; + + this.id = String.valueOf(Math.abs(coordinate.hashCode() + startTime.hashCode())); + + if (attributes != null) { + this.attributes.putAll(attributes); + } + } + + public boolean hasLocationId() { + boolean hasLocation = false; + if (this.locationId != null) { + hasLocation = true; + } + + return hasLocation; + } + + public void addAttribute(String name, Object value) { + attributes.put(name, value); + } + + @Override + public boolean equals(Object obj) { + + if (obj == null) { + return false; + } + + if (obj == this) { + return true; + } + + if (!(obj instanceof Location)) { + return false; + } + + Point point = (Point) obj; + if (point.getId().equals(this.id)) { + return true; + } else { + return false; + } + + } + +} +","Java" +"Pathogens","phylogeography/spread","src/main/java/com/spread/data/attributable/Line.java",".java","1507","60","package com.spread.data.attributable; + +import java.util.LinkedHashMap; +import java.util.Map; + +import lombok.ToString; +import lombok.EqualsAndHashCode; +import lombok.Getter; + +@EqualsAndHashCode +@ToString(includeFieldNames=true) +public class Line { + + @Getter + private final String startPointId; + @Getter + private final String endPointId; + @Getter + private final String startTime; + @Getter + private final String endTime; + @Getter + private final Map attributes = new LinkedHashMap(); + + public Line(String startPointId, + String endPointId, + String startTime, + String endTime, + Map attributes) { + this.startPointId = startPointId; + this.endPointId = endPointId; + this.startTime = startTime; + this.endTime = endTime; + if (attributes != null) { + this.attributes.putAll(attributes); + } + } + + public Line(String startPointId, + String endPointId, + Map attributes) { + this.startPointId = startPointId; + this.endPointId = endPointId; + this.startTime = null; + this.endTime = null; + if (attributes != null) { + this.attributes.putAll(attributes); + } + } + + public boolean hasTime() { + boolean hasTime = false; + if (startTime != null) { + hasTime = true; + } + return hasTime; + } + +} +","Java" +"Pathogens","phylogeography/spread","src/test/java/com/spread/BayesFactorParserTest.java",".java","6665","105","package com.spread; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import com.google.gson.Gson; +import com.spread.data.Attribute; +import com.spread.data.SpreadData; +import com.spread.exceptions.SpreadException; +import com.spread.parsers.BayesFactorParser; +import com.spread.parsers.BayesFactorParser.BayesFactor; +import com.spread.utils.ParsersUtils; + +import org.junit.Test; + +public class BayesFactorParserTest { + + @Test + public void runTest() throws IOException, SpreadException { + + String logFilename = ""bayesFactor/H5N1_HA_discrete_rateMatrix.log""; + File logFile = new File(getClass().getClassLoader().getResource(logFilename).getFile()); + + String locationsFilename = ""bayesFactor/locationCoordinates_H5N1""; + File locationsFile = new File(getClass().getClassLoader().getResource(locationsFilename).getFile()); + + BayesFactorParser parser = new BayesFactorParser(logFile.getAbsolutePath(), + 0.1, + locationsFile.getAbsolutePath()); + + ConsoleProgressObserver progressObserver = new ConsoleProgressObserver(); + parser.registerProgressObserver(progressObserver); + progressObserver.start (); + + LinkedList expected = + new LinkedList(Arrays.asList(new BayesFactor (""Fujian"", ""Guangdong"", 19.014687619229807, 0.8989450305385897), + new BayesFactor (""Fujian"", ""Guangxi"", 2.914568793008483, 0.5769017212659634), + new BayesFactor (""Fujian"", ""Hebei"", 5.381417549046571, 0.7157134925041644), + new BayesFactor (""Fujian"", ""Henan"", 2.8620793773994855, 0.572459744586341), + new BayesFactor (""Fujian"", ""HongKong"", 0.43579473603211477, 0.1693503609106052), + new BayesFactor (""Fujian"", ""Hunan"", 0.7591555160396912, 0.2620766240977235), + new BayesFactor (""Guangdong"", ""Guangxi"", 5.751202221591034, 0.7290394225430317), + new BayesFactor (""Guangdong"", ""Hebei"", 0.5046759684413089, 0.19100499722376457), + new BayesFactor (""Guangdong"", ""Henan"", 0.49024749921100813, 0.18656302054414214), + new BayesFactor (""Guangdong"", ""HongKong"", 0.7289591633549846, 0.2543031649083842), + new BayesFactor (""Guangdong"", ""Hunan"", 0.3020727841804354, 0.12382009994447529), + new BayesFactor (""Guangxi"", ""Hebei"", 0.5811807357716423, 0.21377012770682954), + new BayesFactor (""Guangxi"", ""Henan"", 0.5433155798506233, 0.20266518600777345), + new BayesFactor (""Guangxi"", ""HongKong"", 3.599727763150519, 0.6274292059966685), + new BayesFactor (""Guangxi"", ""Hunan"", 1.3275435166126814, 0.38312048861743475), + new BayesFactor (""Hebei"", ""Henan"", 1.7787442947654648, 0.45419211549139366), + new BayesFactor (""Hebei"", ""HongKong"", 0.08643998969094537, 0.03886729594669628), + new BayesFactor (""Hebei"", ""Hunan"", 0.9897614555920281, 0.3164908384230983), + new BayesFactor (""Henan"", ""HongKong"", 0.05602662286635096, 0.025541365907828985), + new BayesFactor (""Henan"", ""Hunan"", 4.6163308990686085, 0.6835091615769017), + new BayesFactor (""HongKong"", ""Hunan"", 0.06103762019867277, 0.0277623542476402))); + + String json = parser.parse(); + Gson gson = new Gson(); + BayesFactorParser.BayesFactorParserOutput output = gson.fromJson(json, BayesFactorParser.BayesFactorParserOutput.class); + SpreadData data = output.spreadData; + + assertEquals(""returns correct type"", ParsersUtils.BAYES_FACTOR, data.getAnalysisType()); + + List bayesFactors = output.bayesFactors; + assertEquals(""Bayes Factors"", expected, bayesFactors); + + assertEquals(""xCoordinate"", data.getAxisAttributes().getXCoordinate()); + assertEquals(""yCoordinate"", data.getAxisAttributes().getYCoordinate()); + + Set locationIds = data.getLocations().stream().map(location -> location.getId()).collect(Collectors.toSet()); + Set expectedLocationIds = new HashSet<>(Arrays.asList(""Fujian"", ""Guangxi"", ""Guangdong"", ""Hebei"", ""Hunan"", ""Henan"", ""HongKong"")); + assertEquals(""all locations present"", expectedLocationIds, locationIds); + + Attribute bayesFactorAttribute = data.getLineAttributes().stream() + .filter(att -> att.getId().equals(BayesFactorParser.BAYES_FACTOR)).findAny().orElse(null); + assertArrayEquals(""returns correct bayesFactor attribute range"", new Double[]{0.06, 19.014687619229807}, bayesFactorAttribute.getRange()); + + Attribute posteriorProbabilityAttribute = data.getLineAttributes().stream() + .filter(att -> att.getId().equals(BayesFactorParser.POSTERIOR_PROBABILITY)).findAny().orElse(null); + assertArrayEquals(""returns correct posteriorProbability attribute range"", new Double[]{0.03, 0.8989450305385897}, posteriorProbabilityAttribute.getRange()); + + Attribute xCoordinatePointAttribute = + data.getPointAttributes().stream().filter(att -> att.getId().equals(ParsersUtils.X_COORDINATE)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{108.1, 118.283}, xCoordinatePointAttribute.getRange()); + + Attribute yCoordinatePointAttribute = + data.getPointAttributes().stream().filter(att -> att.getId().equals(ParsersUtils.Y_COORDINATE)).findAny().orElse(null); + + assertArrayEquals(""returns correct Y coord range"", new Double[]{22.3, 39.3583}, yCoordinatePointAttribute.getRange()); + + } + +} +","Java" +"Pathogens","phylogeography/spread","src/test/java/com/spread/ConsoleProgressObserver.java",".java","2159","76","package com.spread; + +import com.spread.progress.IProgressObserver; + +public class ConsoleProgressObserver extends Thread implements IProgressObserver { + + private static final String anim = ""|/-\\""; + + private boolean showProgress; + private double progress; + private final int barLength; + + public ConsoleProgressObserver() { + this.barLength = 100; + this.showProgress = true; + this.progress = 0.0; + } + + @Override + public void handleProgress(double progress) { + assert ((progress >= 0.0) && (progress <= 1.0)) : ""Got progress value "" + progress + "". Make sure that 0 ≤ progress ≤ 1""; + this.progress = progress; + } + + public void start() { + System.out.println(""0 25 50 75 100%""); + System.out.println(""|------------------------|------------------------|------------------------|------------------------|""); + super.start (); + } + + public void run() { + int i = 0; + while (showProgress) { + + int column = (int) (progress * barLength); + int j = 0; + + String progressIndicator = ""\r[""; + for (; j < column - 1; j++) { + progressIndicator += (""*""); + } + + String whitespace = """"; + for (; j < barLength - 2; j++) { + whitespace += ("" ""); + } + whitespace += (""]""); + + System.out.print(progressIndicator + anim.charAt(i++ % anim.length()) + whitespace); + + if (progress >= 1) { + showCompleted(); + this.showProgress = false; + } else { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + // do nothing + } + } + + } + } + + private void showCompleted() { + String progress = ""\r[""; + for (int i = 0; i < barLength - 1; i++) { + progress += (""*""); + } + progress += (""]""); + System.out.print(progress); + // System.out.print(""\n""); + } + +} +","Java" +"Pathogens","phylogeography/spread","src/test/java/com/spread/TimeSlicerParserTest.java",".java","2901","71","package com.spread; + +import org.junit.Test; + +import jebl.evolution.io.ImportException; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import com.spread.data.SpreadData; +import com.spread.exceptions.SpreadException; +import com.spread.data.Attribute; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import com.spread.parsers.TimeSlicerParser; +import com.spread.utils.ParsersUtils; + +public class TimeSlicerParserTest { + + @Test + public void runTest() throws IOException, ImportException, SpreadException { + + Gson gson = new Gson(); + + String mostRecentSamplingDate = ""2021/01/12""; + double hpdLevel = 0.8; + String path = ""timeSlicer/WNV_small.trees""; + File treesfile = new File(getClass().getClassLoader().getResource(path).getFile()); + + TimeSlicerParser parser = new TimeSlicerParser (treesfile.getAbsolutePath(), + 0.1, + 10, + ""location"", + ""rate"", // pass null for a rate of 1 + hpdLevel, + 100, + mostRecentSamplingDate, + 1.0); + + Set expectedAttributes = new HashSet<>(Arrays.asList(""rate"", ""location"")); + Set uniqueAttributes = gson.fromJson(parser.parseAttributes(), new TypeToken>(){}.getType()); + + assertEquals(""attributes are parsed"", expectedAttributes, uniqueAttributes); + + ConsoleProgressObserver progressObserver = new ConsoleProgressObserver(); + parser.registerProgressObserver(progressObserver); + progressObserver.start (); + + String json = parser.parse(); + SpreadData data = gson.fromJson(json, SpreadData.class); + + assertEquals(""returns correct type"", ParsersUtils.TIME_SLICER, data.getAnalysisType()); + + assertEquals(""returns correct mrsd"", mostRecentSamplingDate, data.getTimeline().getEndTime()); + assertEquals(""returns correct root date"", ""2011/04/28"", data.getTimeline().getStartTime()); + + Attribute hpdAreaAttribute = data.getAreaAttributes().stream().filter(att -> att.getId().equals(ParsersUtils.HPD.toUpperCase())).findAny().orElse(null); + + assertArrayEquals(""returns correct HPD attribute range"", new Double[]{hpdLevel, hpdLevel}, hpdAreaAttribute.getRange()); + assertTrue(""Areas are generated"", data.getAreas().size() > 0); + } +} +","Java" +"Pathogens","phylogeography/spread","src/test/java/com/spread/DiscreteTreeParserTest.java",".java","3721","81","package com.spread; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.io.IOException; + +import com.google.gson.Gson; +import com.spread.data.Attribute; +import com.spread.data.Location; +import com.spread.data.SpreadData; +import com.spread.exceptions.SpreadException; +import com.spread.parsers.DiscreteTreeParser; +import com.spread.utils.ParsersUtils; + +import org.junit.Test; + +import jebl.evolution.io.ImportException; + +public class DiscreteTreeParserTest { + + @Test + public void runTest() throws IOException, ImportException, SpreadException { + + String treeFilename = ""discrete/H5N1_HA_discrete_MCC.tree""; + File treeFile = new File(getClass().getClassLoader().getResource(treeFilename).getFile()); + + String locationsFilename = ""discrete/locationCoordinates_H5N1""; + File locationsFile = new File(getClass().getClassLoader().getResource(locationsFilename).getFile()); + + String mostRecentSamplingDate = ""2019/02/12""; + String locationTraitAttributeName = ""states""; + + DiscreteTreeParser parser = new DiscreteTreeParser(treeFile.getAbsolutePath(), + locationsFile.getAbsolutePath(), + locationTraitAttributeName, + 1.0, + mostRecentSamplingDate); + + ConsoleProgressObserver progressObserver = new ConsoleProgressObserver(); + parser.registerProgressObserver(progressObserver); + progressObserver.start (); + + String json = parser.parse(); + Gson gson = new Gson(); + SpreadData data = gson.fromJson(json, SpreadData.class); + + assertEquals(""returns correct type"", ParsersUtils.DISCRETE_TREE, data.getAnalysisType()); + + assertEquals(""returns correct mrsd"", mostRecentSamplingDate, data.getTimeline().getEndTime()); + assertEquals(""returns correct root date"", ""2007/11/17"", data.getTimeline().getStartTime()); + + Attribute xCoordinatePointAttribute = + data.getPointAttributes().stream().filter(att -> att.getId().equals(ParsersUtils.X_COORDINATE)).findAny().orElse(null); + + Attribute yCoordinatePointAttribute = + data.getPointAttributes().stream().filter(att -> att.getId().equals(ParsersUtils.Y_COORDINATE)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{108.1, 118.283}, xCoordinatePointAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{22.3, 39.3583}, yCoordinatePointAttribute.getRange()); + + Attribute countPointAttribute = + data.getPointAttributes().stream().filter(att -> att.getId().equals(DiscreteTreeParser.COUNT)).findAny().orElse(null); + + assertArrayEquals(""returns correct count attribute range"", new Double[]{1.0, 16.0}, countPointAttribute.getRange()); + + assertEquals(""returns correct number of locations"", 7, data.getLocations().size()); + + Location loc = data.getLocations().get(0); + assertEquals(""returns correct id"", ""Fujian"", loc.getId()); + assertEquals(""returns correct x coordinate"", 118.283, loc.getCoordinate().getXCoordinate(), 0.0); + assertEquals(""returns correct x coordinate"", 25.917, loc.getCoordinate().getYCoordinate(), 0.0); + + assertEquals(""returns correct number of counts"", 20, data.getCounts().size ()); + assertEquals(""returns correct number of points"", 51, data.getPoints().size()); + assertEquals(""returns correct number of lines"", 30, data.getLines().size()); + } + +} +","Java" +"Pathogens","phylogeography/spread","src/test/java/com/spread/ContinuousTreeParserTest.java",".java","8449","148","package com.spread; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; + +import java.io.File; +import java.io.IOException; +import java.util.Set; +import java.util.stream.Collectors; + +import com.google.gson.Gson; +import com.spread.data.Attribute; +import com.spread.data.SpreadData; +import com.spread.data.attributable.Area; +import com.spread.exceptions.SpreadException; +import com.spread.parsers.ContinuousTreeParser; +import com.spread.utils.ParsersUtils; + +import org.junit.Test; + +import jebl.evolution.io.ImportException; + +public class ContinuousTreeParserTest { + + @Test + public void testMultipleHpd() throws IOException, ImportException, SpreadException { + + // contains 80% and 95% HPD + String filename = ""continuous/EBOV_cauchy_2_full_rPol.MCC.2HPD.tre""; + File treefile = new File(getClass().getClassLoader().getResource(filename).getFile()); + String mostRecentSamplingDate = ""2019/02/12""; + String xCoordinate = ""coordinates2""; + String yCoordinate = ""coordinates1""; + + ContinuousTreeParser parser = new ContinuousTreeParser (treefile.getAbsolutePath(), + xCoordinate, + yCoordinate, + 1.0, + mostRecentSamplingDate); + + ConsoleProgressObserver progressObserver = new ConsoleProgressObserver(); + parser.registerProgressObserver(progressObserver); + progressObserver.start (); + + String json = parser.parse(); + Gson gson = new Gson(); + SpreadData data = gson.fromJson(json, SpreadData.class); + + assertEquals(""returns correct type"", ParsersUtils.CONTINUOUS_TREE, data.getAnalysisType()); + + assertEquals(""returns correct mrsd"", mostRecentSamplingDate, data.getTimeline().getEndTime()); + assertEquals(""returns correct root date"", ""2017/04/08"", data.getTimeline().getStartTime()); + + assertEquals(""returns correct X attribute"", xCoordinate, data.getAxisAttributes().getXCoordinate()); + assertEquals(""returns correct Y attribute"", yCoordinate, data.getAxisAttributes().getYCoordinate()); + + Attribute xCoordinateLineAttribute = data.getLineAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinateLineAttribute = data.getLineAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{-14.05, -7.61}, xCoordinateLineAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{4.67, 11.77}, yCoordinateLineAttribute.getRange()); + + Attribute xCoordinatePointAttribute = data.getPointAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinatePointAttribute = data.getPointAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{-14.05, -7.61}, xCoordinatePointAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{4.67, 11.77}, yCoordinatePointAttribute.getRange()); + + Attribute xCoordinateAreaAttribute = data.getAreaAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinateAreaAttribute = data.getAreaAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{-13.7, -8.13}, xCoordinateAreaAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{4.84, 10.6}, yCoordinateAreaAttribute.getRange()); + + Set areasHPD80 = data.getAreas().stream() + .filter(area -> area.getAttributes().get(ParsersUtils.HPD.toUpperCase()).equals(""80"")) + .collect(Collectors.toSet()); + + assertEquals(""returns correct number of areas with 80% HPD interval"", 978, areasHPD80.size()); + + Set areasHPD95 = data.getAreas().stream() + .filter(area -> area.getAttributes().get(ParsersUtils.HPD.toUpperCase()).equals(""95"")) + .collect(Collectors.toSet()); + + assertEquals(""returns correct number of areas with 95% HPD interval"", 1832, areasHPD95.size()); + + assertEquals(""returns correct number of areas"", areasHPD80.size() + areasHPD95.size(), data.getAreas().size()); + assertEquals(""returns correct number of lines"", 1476, data.getLines().size()); + assertEquals(""returns correct number of points"", 1477, data.getPoints().size()); + } + + @Test + public void testSingleHpd() throws IOException, ImportException, SpreadException { + + String filename = ""continuous/speciesDiffusion.MCC.tre""; + File treefile = new File(getClass().getClassLoader().getResource(filename).getFile()); + String mostRecentSamplingDate = ""2019/02/12""; + String xCoordinate = ""trait2""; + String yCoordinate = ""trait1""; + + ContinuousTreeParser parser = new ContinuousTreeParser (treefile.getAbsolutePath(), + xCoordinate, + yCoordinate, + 1.0, + mostRecentSamplingDate); + + ConsoleProgressObserver progressObserver = new ConsoleProgressObserver(); + parser.registerProgressObserver(progressObserver); + progressObserver.start (); + + String json = parser.parse(); + Gson gson = new Gson(); + SpreadData data = gson.fromJson(json, SpreadData.class); + + assertEquals(""returns correct type"", ParsersUtils.CONTINUOUS_TREE, data.getAnalysisType()); + + assertEquals(""returns correct mrsd"", mostRecentSamplingDate, data.getTimeline().getEndTime()); + assertEquals(""returns correct root date"", ""2016/10/24"", data.getTimeline().getStartTime()); + + assertEquals(""returns correct X attribute"", xCoordinate, data.getAxisAttributes().getXCoordinate()); + assertEquals(""returns correct Y attribute"", yCoordinate, data.getAxisAttributes().getYCoordinate()); + + Attribute xCoordinateLineAttribute = data.getLineAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinateLineAttribute = data.getLineAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{33.16, 176.0}, xCoordinateLineAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{-39.0, -0.84}, yCoordinateLineAttribute.getRange()); + + Attribute xCoordinatePointAttribute = data.getPointAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinatePointAttribute = data.getPointAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{33.16, 176.0}, xCoordinatePointAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{-39.0, -0.84}, yCoordinatePointAttribute.getRange()); + + Attribute xCoordinateAreaAttribute = data.getAreaAttributes().stream().filter(att -> att.getId().equals(xCoordinate)).findAny().orElse(null); + Attribute yCoordinateAreaAttribute = data.getAreaAttributes().stream().filter(att -> att.getId().equals(yCoordinate)).findAny().orElse(null); + + assertArrayEquals(""returns correct X coord range"", new Double[]{33.16, 142.71}, xCoordinateAreaAttribute.getRange()); + assertArrayEquals(""returns correct Y coord range"", new Double[]{-28.25, -0.84}, yCoordinateAreaAttribute.getRange()); + + assertEquals(""returns correct number of lines"", 24, data.getLines().size()); + assertEquals(""returns correct number of points"", 25, data.getPoints().size()); + assertEquals(""returns correct number of areas"", 34, data.getAreas().size()); + + } + +} +","Java" +"Pathogens","phylogeography/spread","services/analysis-viewer/build.sh",".sh","668","51","#!/bin/bash + +set -e + +NAME=analysis-viewer-service + +while getopts b:p:t: flag +do + case ""${flag}"" in + b) BUILD=${OPTARG};; + p) PUSH=${OPTARG};; + esac +done + +# defaults + +if [ -z ${BUILD+x} ]; +then + BUILD=true +fi + +if [ -z ${PUSH+x} ]; +then + PUSH=false +fi + +# BUILD + +if [ $BUILD = true ] +then + cd ../../ + yarn deps + yarn shadow-cljs release analysis-viewer +fi + +# PUSH + +if [ $PUSH = true ] +then + + DISTRIBUTION_ID=E1H7C6SLAJ6XK7 + # push new content to S3 + aws s3 sync analysis-viewer/ s3://view.spreadviz.org --acl public-read + # invalidate CF cache + aws cloudfront create-invalidation --distribution-id $DISTRIBUTION_ID --paths '/*' + +fi + +echo ""Done"" +exit $? +","Shell" +"Pathogens","phylogeography/spread","services/api/build.sh",".sh","995","63","#!/bin/bash + +set -e + +NAME=api-service + +while getopts b:p:t: flag +do + case ""${flag}"" in + b) BUILD=${OPTARG};; + p) PUSH=${OPTARG};; + t) TAG=${OPTARG};; + esac +done + +# defaults + +if [ -z ${TAG+x} ]; +then + TAG=latest +fi + +if [ -z ${BUILD+x} ]; +then + BUILD=true +fi + +if [ -z ${PUSH+x} ]; +then + PUSH=false +fi + +# BUILD + +IMG=$NAME:$TAG + +if [ $BUILD = true ] +then + cd ../../ + clojure -T:uberjar api-service + docker build --tag $IMG -f services/api/Dockerfile . +fi + +# PUSH + +if [ $PUSH = true ]; then + + REGISTRY=a8p1v4e1 + echo ""Pushing $IMG to the registry $REGISTRY"" + + # authenticate docker to use AWS registry + aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/$REGISTRY + # tag image + docker tag $IMG public.ecr.aws/$REGISTRY/$NAME:$TAG + # docker tag $IMG public.ecr.aws/$REGISTRY/$NAME:$CIRCLE_SHA1 + # push tagged image to the registry + docker push public.ecr.aws/$REGISTRY/$NAME:$TAG + +fi + +echo ""Done"" +exit $? +","Shell" +"Pathogens","phylogeography/spread","services/worker/build.sh",".sh","933","63","#!/bin/bash + +set -e + +NAME=worker-service + +while getopts b:p:t: flag +do + case ""${flag}"" in + b) BUILD=${OPTARG};; + p) PUSH=${OPTARG};; + t) TAG=${OPTARG};; + esac +done + +# defaults + +if [ -z ${TAG+x} ]; +then + TAG=latest +fi + +if [ -z ${BUILD+x} ]; +then + BUILD=true +fi + +if [ -z ${PUSH+x} ]; +then + PUSH=false +fi + +# BUILD + +IMG=$NAME:$TAG + +if [ $BUILD = true ] +then + cd ../../ + clojure -T:uberjar worker-service + docker build --tag $IMG -f services/worker/Dockerfile . +fi + +# PUSH + +if [ $PUSH = true ] +then + + REGISTRY=a8p1v4e1 + echo ""Pushing $IMG to the registry $REGISTRY"" + + # authenticate docker to use AWS registry + aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/$REGISTRY + # tag image + docker tag $IMG public.ecr.aws/$REGISTRY/$NAME:$TAG + # push tagged image to the registry + docker push public.ecr.aws/$REGISTRY/$NAME:$TAG + +fi + +echo ""Done"" +exit $? +","Shell" +"Pathogens","phylogeography/spread","services/ui/build.sh",".sh","604","48","#!/bin/bash + +set -e + +NAME=ui-service + +while getopts b:p:t: flag +do + case ""${flag}"" in + b) BUILD=${OPTARG};; + p) PUSH=${OPTARG};; + esac +done + +if [ -z ${BUILD+x} ]; +then + BUILD=true +fi + +if [ -z ${PUSH+x} ]; +then + PUSH=false +fi + +# BUILD + +if [ $BUILD = true ]; then + cd ../../ + yarn deps + yarn release +fi + +# PUSH + +if [ $PUSH = true ] +then + + DISTRIBUTION_ID=E290TKZB4KVQPC + # push new content to S3 + aws s3 sync ui/ s3://spreadviz.org --acl public-read + # invalidate CF cache + aws cloudfront create-invalidation --distribution-id $DISTRIBUTION_ID --paths '/*' + +fi + +echo ""Done"" +exit $? +","Shell" +"Pathogens","phylogeography/spread","services/db-migration/src/main/java/com/spread/Handler.java",".java","3507","75","package com.spread; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Optional; + +import com.amazonaws.services.lambda.runtime.Context; +import com.amazonaws.services.lambda.runtime.LambdaLogger; +import com.amazonaws.services.lambda.runtime.RequestHandler; + +import liquibase.Contexts; +import liquibase.LabelExpression; +import liquibase.Liquibase; +import liquibase.database.Database; +import liquibase.database.DatabaseFactory; +import liquibase.database.jvm.JdbcConnection; +import liquibase.exception.LiquibaseException; +import liquibase.resource.ClassLoaderResourceAccessor; + +public class Handler implements RequestHandler { + + public String handleRequest(Object input, Context context) { + final LambdaLogger logger = context.getLogger(); + Connection connection = null; + + try { + Class.forName(""com.mysql.cj.jdbc.Driver""); + + final String API_DB_HOST = Optional.ofNullable(System.getenv(""DB_HOST"")).orElse(""localhost""); + final String API_DB_DATABASE = Optional.ofNullable(System.getenv(""DB_DATABASE"")).orElse(""spread""); + final String API_DB_PORT = Optional.ofNullable(System.getenv(""DB_PORT"")).orElse(""3306""); + final String API_DB_USER = Optional.ofNullable(System.getenv(""DB_USER"")).orElse(""root""); + final String API_DB_PASSWORD = Optional.ofNullable(System.getenv(""DB_PASSWORD"")).orElse(""Pa55w0rd""); + + logger.log(""[INFO] Connecting to database "" + "" DB_HOST="" + API_DB_HOST + ""\n""); + + connection = DriverManager.getConnection(""jdbc:mysql://"" + + API_DB_HOST + "":"" + API_DB_PORT + ""/"" + API_DB_DATABASE + + ""?createDatabaseIfNotExist=true"", + API_DB_USER, + API_DB_PASSWORD); + logger.log(""[INFO] Database connection established \n""); + + Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(new JdbcConnection(connection)); + Liquibase liquibase = new Liquibase(""liquibase/db.changelog-master.xml"", + new ClassLoaderResourceAccessor(), + database); + + liquibase.update(new Contexts(), new LabelExpression()); + liquibase.close(); + logger.log(""[INFO] Done \n""); + return ""Done""; + } catch (SQLException e) { + logger.log(""[ERROR] "" + Optional.ofNullable(e.getMessage()).orElse(""SQL exception"") + ""\n""); + } catch (LiquibaseException e) { + logger.log(""[ERROR] "" + Optional.ofNullable(e.getMessage()).orElse(""Liquibase exception"") + ""\n""); + } catch (ClassNotFoundException e) { + logger.log(""[ERROR] "" + Optional.ofNullable(e.getMessage()).orElse(""MySQL driver is missing"") + ""\n""); + } catch (Exception e) { + logger.log(""[ERROR] "" + Optional.ofNullable(e.getMessage()).orElse(""Unknown exception"") + ""\n""); + } finally { + try { + if (!connection.isClosed() || connection != null) { + connection.close(); + } + } catch (Exception e) { + logger.log(""[ERROR] Exception when closing db connection \n""); + } + } + System.exit(-1); + return null; + } +} +","Java" +"Pathogens","dhelekal/ResistPhy","run/synthetic_usage.R",".R","716","20","set.seed(2) +ts <- c(1:20) +l <- 4 +mvar <- 0.4 +dist_m <- as.matrix(dist(ts,""manhattan"",T,T)) +cov_m <- apply(dist_m, c(1,2), function(d) mvar*exp(-0.5*(d/l)^2)) +diag(cov_m) <- diag(cov_m) + 1e-6 #Jitter to ensure positive semi-definiteness on some systems + +mean_func <- function(x) 0.2+(0.2/2)*max(min(x-8,2),0) + max(min(x-10, 4),0)*(-0.25/4) + max(min(x-14, 1),0)*(0.01/1) + max(min(x-16, 1),0)*(-0.05/1) +logi <- function(x) 1/(1+exp(-x)) + +mu <- sapply(ts, mean_func) +log_odds_mu <- sapply(mu, function(x) log(x/(1-x))) + +phi <- rnorm(20, 0, 1) +M<-chol(cov_m) + +logit_usage <- log_odds_mu + M %*% phi +usage_df <- data.frame(time=ts, usage=sapply(logit_usage,logi)) +write.table(usage_df, ""synthetic_usage.csv"", sep="","")","R" +"Pathogens","dhelekal/ResistPhy","run/sim_traj.R",".R","2450","82","library(ggplot2) +library(reshape2) +library(viridis) +library(ResistPhy) +library(ape) +library(latex2exp) + +source(""simu_phylo.R"") + +#Simulate phylogenies and trajectories for a given subset of nruns simulations +sim_n_traj <- function (idx_begin, extent, n_runs, plot_traj=FALSE){ + out <- list() + + run_idx <- c(idx_begin:(idx_begin + extent - 1)) + + usage_df <- simulated_usage() + set.seed(123456) + traj_seeds <- sample.int(n=100000, n_runs, F) + set.seed(457869) + phy_seeds <- sample.int(n=100000, n_runs, F) + + q_u <- seq(from=0.0, to = 1.3, length.out=n_runs) + q_t <- seq(from=0.0, to = -3.3, length.out=n_runs) + + t0 <- min(usage_df$time) + tmax <- max(usage_df$time) + gamma_sus <- 1/60.0*365.0 + n_tip <- 200 + + gamma_u <- gamma_sus+q_u + gamma_t <- gamma_sus+q_t + + phys <- list() + most_recent_samp <- list() + + if (plot_traj) { + traj_df <- data.frame(t=c(), y=c(), strain=c(), para_idx=c()) + facet_labs <- sapply(c(1:n_runs), function(i) TeX(sprintf(""$q_{u}$: %.3f $q_{t}$: %.3f"", q_u[i], q_t[i]))) + } + + for (i in c(1:extent)) { + idx <- run_idx[i] + + sim_out <- sample_phylo(gamma_sus, gamma_u[idx], gamma_t[idx], n_tip, traj_seeds[idx], phy_seeds[idx]) + + phys[[i]] <- sim_out$phys + most_recent_samp[[i]] <- sim_out$most_recent_samp + + if (plot_traj) #Downsample and retain trajectories + { + sim_df <- sim_out$traj + n <- nrow(sim_df) + sub_idx <- seq.int(from=1, to=n, length.out=1e3) + sim_df <- sim_df[sub_idx,] + sim_df$Ne_s <- sim_df$I_2/2/sim_df$inf_rate + sim_df$Ne_r <- sim_df$I_3/2/sim_df$inf_rate + + append_df <- melt(sim_df[,c(""t"",""I_2"",""I_3"")], ""t"", variable.name=""strain"", value.name=""y"") + + append_df$para_idx <- i + traj_df <- rbind(traj_df, append_df) + } + } + + out$run_idx <- run_idx + out$phys <- phys + out$most_recent_samp <- most_recent_samp + out$q_u <- q_u + out$q_t <- q_t + + if(plot_traj) { + tplt <- ggplot(traj_df) + + geom_line(aes(x=t, y=y, color=strain)) + + scale_color_manual(values = c(I_3 = ""red"", I_2 = ""blue""), labels=c(""Resistant"", ""Susceptible"")) + + facet_wrap(~para_idx, nrow=10, labeller=label_parsed) + + labs(x=""Time"", y=""Population Size"") + + theme_bw() + out$tplt <- tplt + } + + return(out) +}","R" +"Pathogens","dhelekal/ResistPhy","run/simu_phylo.R",".R","2504","76","sample_phylo <- function(gamma_sus, gamma_u, gamma_t, n_tip, traj_seed, phy_seed) { + set.seed(traj_seed) + + usage_df <- simulated_usage() + usage_f <- yearly_usg_stepfunc(usage_df$usage, usage_df$time) + + t0 <- min(usage_df$time) + tmax <- max(usage_df$time) + + n_step <- (tmax-t0)/1e-4 + + N_0 <- 3e6 + n_strains <- 3 + + t0 <- min(usage_df$time) + tmax <- max(usage_df$time) + usage_f <- yearly_usg_stepfunc(usage_df$usage, usage_df$time) + + + incidence <- 1.5e5 / N_0 + mu <- incidence+gamma_sus + r0 <- mu/(gamma_sus) + end_eq <- 1-1/r0 + + N_f <- function(t) N_0*exp(log(2)*(t-t0)/(tmax-t0)) + + t_change <- (t0 + floor(0.33*(tmax-t0))) + + beta_f <- function (t) if (t < t_change) 1.02*mu else + mu*(0.98 + 0.06*(t-t_change)/(tmax-t_change)) + + I_0 <- rep(0, n_strains) + while(!all(I_0 >= 100) || !(sum(I_0) < N_0)){ + Itmp <- floor(end_eq*N_0*rlnorm(n_strains-1, -4,.3)) + I_0 <- c(N_0*end_eq-sum(Itmp), Itmp) + } + + S_0 <- N_0 - sum(I_0) + i <- 1 + + stopifnot(S_0 > 1) + + gamma_u_ext <- c(gamma_sus, gamma_sus, gamma_u) + gamma_t_ext <- c(gamma_sus, gamma_sus, gamma_t) + + df <- simulate_epi_nstrain(t0, tmax, n_step, n_strains, S_0, I_0, usage_f, beta_f, N_f, gamma_u_ext, gamma_t_ext) + while (!all(df[,paste0(""I_"", c(1:n_strains))] > 0)) { + if (i > 10) stop(""Stopping after 10 resampling attempts"") + i <- i+1 + df <- simulate_epi_nstrain(t0, tmax, n_step, n_strains, S_0, I_0, usage_f, beta_f, N_f, gamma_u_ext, gamma_t_ext) + } + + set.seed(phy_seed) + + sampled_sus <- sample_phy_incidence(df, 2, n_tip, c(0:5), t0, tmax) + sampled_res <- sample_phy_incidence(df, 3, n_tip, c(0:5), t0, tmax) + + phys <- list(sampled_sus$phy, sampled_res$phy) + most_recent_samp <- list(sampled_sus$mr, sampled_res$mr) + + return(list(phys=phys, traj=df, most_recent_samp=most_recent_samp)) +} + +sample_phy_incidence <- function(df, strain_idx, n_tips, samp_yrs, t0, tmax) { + I_col <- paste0(""I_"", strain_idx) + inci_col <- paste0(""births_"", strain_idx) + incidence_yr <- rev(sapply(c(t0:(tmax-1)), function(t) sum(df[which((df$t >= t) & (df$t < (t+1))), inci_col]))) + + n_samp <- rmultinom(1,n_tips, incidence_yr[samp_yrs]/sum(incidence_yr[samp_yrs])) + samp_times <- samp_yrs[which(n_samp>0)] + n_samp <- n_samp[which(n_samp>0)] + mr <- min(samp_times) + + phy <- simulate_phylos_nstrain(df, strain_idx, list(samp_times), list(n_samp)) + return(list(phy=phy[[1]],mr=mr)) +}","R" +"Pathogens","dhelekal/ResistPhy","run/run_multi_det_sd03.R",".R","1934","74","library(ggplot2) +library(reshape2) +library(viridis) +library(ResistPhy) +library(ape) +library(posterior) +library(cmdstanr) +library(bayesplot) +library(phylodyn) +library(latex2exp) + +source(""sim_traj.R"") + +# test if there is at least one argument: if not, return an error +args <- commandArgs(TRUE) +print(args) +if (length(args)!=2) { + stop(""Need 3 arguments."", call.=FALSE) +} + +idx_begin <- as.numeric(args[1]) +extent <- as.numeric(args[2]) + +n_runs <- 50 +usage_df <- simulated_usage() +gamma_sus <- 1/60.0*365.0 +t0 <- min(usage_df$time) +tmax <- max(usage_df$time) + +n_warmup <- 2000 +n_it <- 2000 +recovery_data <- data.frame(variable=c(), value=c(), para_idx=c()) +converged <- c() + +sim<-sim_n_traj(idx_begin, extent, n_runs, plot_traj=FALSE) + +for (i in c(1:extent)) { + out <- infer_costs2(sim$phys[[i]], + sim$most_recent_samp[[i]], + usage_df$usage, + usage_df$time, + t0, + tmax, + gamma_sus/365, + 365, + n_iter=n_it, + n_warmup=n_warmup, + K=60, + L=6.5, + gamma_log_sd=0.3, + seed=sim$run_idx[i], + stan_control=list(adapt_delta=.99, + max_treedepth=13, + parallel_chains=4, + chains=4, + refresh=0 + )) + dnames <- c(""q_u[1]"", ""q_t[1]"") + vnames <- c(""q_u"",""q_t"") + + temp_df <- out$draws_df[,dnames] + colnames(temp_df) <- vnames + + temp_df <- melt(temp_df, measure.vars=vnames, + variable.name=""variable"", value.name=""value"") + + temp_df$para_idx <- sim$run_idx[i] + recovery_data <- rbind(recovery_data, temp_df) + converged <- c(converged, out$converged) +} + +saveRDS(recovery_data, paste0(""det_para_"",idx_begin,""_"",extent, ""_sd03.rds"")) +saveRDS(converged, paste0(""det_conv_"",idx_begin,""_"",extent, ""_sd03.rds"")) +","R" +"Pathogens","dhelekal/ResistPhy","run/run_multi_det_sd01.R",".R","1939","75","library(ggplot2) +library(reshape2) +library(viridis) +library(ResistPhy) +library(ape) +library(posterior) +library(cmdstanr) +library(bayesplot) +library(phylodyn) +library(latex2exp) + +source(""sim_traj.R"") + +# test if there is at least one argument: if not, return an error +args <- commandArgs(TRUE) +print(args) +if (length(args)!=2) { + stop(""Need 3 arguments."", call.=FALSE) +} + +idx_begin <- as.numeric(args[1]) +extent <- as.numeric(args[2]) + +n_runs <- 50 +usage_df <- simulated_usage() +gamma_sus <- 1/60.0*365.0 +t0 <- min(usage_df$time) +tmax <- max(usage_df$time) + +n_warmup <- 2000 +n_it <- 2000 +recovery_data <- data.frame(variable=c(), value=c(), para_idx=c()) +converged <- c() + +sim<-sim_n_traj(idx_begin, extent, n_runs, plot_traj=FALSE) + +for (i in c(1:extent)) { + out <- infer_costs2(sim$phys[[i]], + sim$most_recent_samp[[i]], + usage_df$usage, + usage_df$time, + t0, + tmax, + gamma_sus/365, + 365, + n_iter=n_it, + n_warmup=n_warmup, + K=60, + L=6.5, + gamma_log_sd=0.1, + seed=sim$run_idx[i], + stan_control=list(adapt_delta=.99, + max_treedepth=13, + parallel_chains=4, + chains=4, + refresh=0 + )) + + dnames <- c(""q_u[1]"", ""q_t[1]"") + vnames <- c(""q_u"",""q_t"") + + temp_df <- out$draws_df[,dnames] + colnames(temp_df) <- vnames + + temp_df <- melt(temp_df, measure.vars=vnames, + variable.name=""variable"", value.name=""value"") + + temp_df$para_idx <- sim$run_idx[i] + recovery_data <- rbind(recovery_data, temp_df) + converged <- c(converged, out$converged) +} + +saveRDS(recovery_data, paste0(""det_para_"",idx_begin,""_"",extent, ""_sd01.rds"")) +saveRDS(converged, paste0(""det_conv_"",idx_begin,""_"",extent, ""_sd01.rds"")) +","R" +"Pathogens","dhelekal/ResistPhy","run/Figures/figure4.R",".R","441","24","library(ResistPhy) +library(ggplot2) +library(reshape2) +library(patchwork) +library(hexbin) + +ddf <- out$draws_df + +lin1_names <- paste0(""q_"", c(""u"",""t""),""[1]"") +lin2_names <- paste0(""q_"", c(""u"",""t""),""[2]"") + +lin1_df <- ddf[,lin1_names] +colnames(lin1_df) <- c(""q_u"",""q_t"") +lin1_df$lineage <- ""1"" + +lin2_df <- ddf[,lin2_names] +colnames(lin2_df) <- c(""q_u"",""q_t"") +lin2_df$lineage <- ""2"" + +plot_df <- rbind(lin1_df,lin2_df) + +h1 <- ggplot(plot_df, aes) + +","R" +"Pathogens","dhelekal/ResistPhy","run/Figures/figure2.R",".R","3762","87","library(ggplot2) +library(latex2exp) +library(viridis) +library(hexbin) +library(patchwork) + +thm1 <- function() { + thm1 <- theme(axis.title.x=element_blank(), + axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + axis.text.x=element_text(size=rel(0.7), angle = 45, hjust=1), + aspect.ratio=1, + plot.margin = margin(0, 0, 0, 0, ""cm""), + panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), + axis.line = element_line(size=rel(0.2), colour = ""grey80""), + plot.title = element_text(hjust = 0.5,size=rel(1.0))) + return(thm1) +} + +#' GGPlot theme 2 +thm2 <- function() { + thm2 <- theme(axis.title.x=element_blank(), + axis.title.y=element_blank(), + axis.text.x=element_text(size=rel(0.7), angle = 45, hjust=1), + axis.text.y=element_text(size=rel(0.7)), + aspect.ratio=1, + plot.margin = margin(0, 0, 0, 0, ""cm""), + legend.position=""none"", + panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), + axis.line = element_line(size=rel(0.2), colour = ""grey90""), + plot.title = element_text(hjust = 0.5,size=rel(1.0))) + return(thm2) +} + +blank <- plot_spacer() +sc <- out$time_scale + + +gamma_sus_hist <- ggplot(out$draws_df, aes(x=gamma_sus)) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=30, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dlnorm(x, meanlog = log(out$gamma_guess*sc), sdlog = out$gamma_log_sd), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$\\gamma$"")) + + geom_vline(xintercept=gamma_sus,color=""red"")+ + theme_minimal() + thm1() +q_u_hist <- ggplot(out$draws_df, aes_(x=as.name(""q_u[1]""))) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=30, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dnorm(x, mean = 0, sd = 0.3 * out$gamma_guess * sc), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$q_U$"")) + + geom_vline(xintercept=q_u,color=""red"")+ + theme_minimal() + thm1() +q_t_hist <- ggplot(out$draws_df, aes_(x=as.name(""q_t[1]""))) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=30, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dnorm(x, mean = 0, sd = 0.3 * out$gamma_guess * sc), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$q_T$"")) + + geom_vline(xintercept=q_t,color=""red"")+ + theme_minimal() + thm1() +p1 <- ggplot(out$draws_df, aes_(x=as.name(""gamma_sus""), y=as.name(""q_u[1]""))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + geom_vline(xintercept=gamma_sus,color=""red"")+ + geom_hline(yintercept=q_u,color=""red"")+ + theme_minimal() + + thm2() +p2 <- ggplot(out$draws_df, aes_(x=as.name(""gamma_sus""), y=as.name(""q_t[1]""))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + geom_vline(xintercept=gamma_sus,color=""red"")+ + geom_hline(yintercept=q_t, color=""red"")+ + theme_minimal() + + thm2() +p3 <- ggplot(out$draws_df, aes_(x=as.name(""q_u[1]""), y=as.name(""q_t[1]""))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + geom_vline(xintercept=q_u,color=""red"")+ + geom_hline(yintercept=q_t,color=""red"")+ + theme_minimal() + + thm2() + +fig2 <- gamma_sus_hist + blank + blank + + p1 + q_u_hist + blank + + p2 + p3 + q_t_hist + + plot_layout(ncol = 3) + +","R" +"Pathogens","dhelekal/ResistPhy","run/Figures/figure1.R",".R","1633","40","library(ggplot2) +library(latex2exp) +library(viridis) +library(hexbin) +library(patchwork) + +p1 <- plot_epi_dynamic(out, 1, n_draws=20) + geom_line(data=df,aes(x=t, y=I_2), color=""red"") + ggtitle(""Susceptible Lineage"") +p1 <- p1 + (p1$theme %+replace% theme(legend.position=""none"", + axis.title.x=element_blank(), + axis.text.x=element_blank(), + axis.ticks.x=element_blank())) +p2 <- plot_epi_dynamic(out, 2, n_draws=20) + geom_line(data=df,aes(x=t, y=I_3), color=""red"") + ggtitle(""Resistant Lineage"") +p2 <- p2 + (p2$theme %+replace% theme(axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + axis.title.x=element_blank(), + axis.text.x=element_blank(), + axis.ticks.x=element_blank())) + +y1_min <- min(layer_scales(p1)$y$range$range, layer_scales(p2)$y$range$range) +y1_max <- max(layer_scales(p1)$y$range$range, layer_scales(p2)$y$range$range) + +p1 <- p1+ylim(y1_min,y1_max) +p2 <- p2+ylim(y1_min,y1_max) + +p3 <- plot_rt(out, 1, n_draws=20) + geom_line(data=df,aes(x=t, y=Rt_2), color=""red"") +p3 <- p3 + (p3$theme %+replace% theme(legend.position=""none"",plot.title=element_blank())) +p4 <- plot_rt(out, 2, n_draws=20) + geom_line(data=df,aes(x=t, y=Rt_3), color=""red"") +p4 <- p4 + (p4$theme %+replace% theme(axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + plot.title=element_blank())) + +y2_min <- min(layer_scales(p3)$y$range$range, layer_scales(p4)$y$range$range) +y2_max <- max(layer_scales(p3)$y$range$range, layer_scales(p4)$y$range$range) + +p3 <- p3+ylim(y2_min,y2_max) +p4 <- p4+ylim(y2_min,y2_max) + +fig1 <- (p1 | p2) / (p3 | p4) ","R" +"Pathogens","dhelekal/ResistPhy","run/Figures/figure5.R",".R","1328","25","fig5a <- plot_rr_map(out, 1, n_breaks = 100, min_disp_prob=0.5) + ggtitle(""Resistant Lineage 1"") +fig5a <- fig5a + (fig5a$theme %+replace% theme(legend.position=""bottom"", + legend.direction = ""horizontal"", + legend.text = element_text(angle=45, vjust=0.5, hjust=0.5, size=rel(1.0)))) + + guides(fill=guide_coloursteps(label.position = ""bottom"", title.position=""top"", label.hjust = 0.8, title.hjust=0.5,nrow=1)) + +fig5b <- plot_rr_map(out, 2, n_breaks = 100, min_disp_prob=0.5) + ggtitle(""Resistant Lineage 2"") +fig5b <- fig5b + (fig5b$theme %+replace% theme(axis.ticks.y=element_blank(), + legend.position=""none"", + axis.text.y=element_blank(), + axis.title.y=element_blank())) + +y_min <- max(min(layer_scales(fig5a)$y$range$range), min(layer_scales(fig5b)$y$range$range)) +y_max <- min(max(layer_scales(fig5a)$y$range$range), max(layer_scales(fig5b)$y$range$range)) + +fig5a <- fig5a+ylim(y_min,y_max) +fig5b <- fig5b+ylim(y_min,y_max) + +x_min <- max(min(layer_scales(fig5a)$x$range$range), min(layer_scales(fig5b)$x$range$range)) +x_max <- min(max(layer_scales(fig5a)$x$range$range), max(layer_scales(fig5b)$x$range$range)) + +fig5a <- fig5a+xlim(x_min,x_max) +fig5b <- fig5b+xlim(x_min,x_max) + +fig5 <- (fig5a | fig5b) + plot_annotation(title = TeX(sprintf(""Posterior Probability of $r_s(t) - r_r(t) > c$ given usage level""))) ","R" +"Pathogens","dhelekal/ResistPhy","run/Figures/figure3.R",".R","1487","43","library(ggplot2) +library(patchwork) +p1 <- plot_epi_dynamic(out, 2) + + scale_x_continuous(breaks = seq(t0, tmax, by =2)) + + ggtitle(""Resistant Lineage 1"") +p1 <- p1 + (p1$theme %+replace% theme(legend.position=""none"", + axis.title.x=element_blank(), + axis.text.x=element_blank(), + axis.ticks.x=element_blank())) + +p2 <- plot_epi_dynamic(out, 3) + + scale_x_continuous(breaks = seq(t0, tmax, by =2)) + + ggtitle(""Resistant Lineage 2"") +p2 <- p2 + (p2$theme %+replace% theme(axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + axis.title.x=element_blank(), + axis.text.x=element_blank(), + axis.ticks.x=element_blank())) + +y1_min <- min(layer_scales(p1)$y$range$range, layer_scales(p2)$y$range$range) +y1_max <- max(layer_scales(p1)$y$range$range, layer_scales(p2)$y$range$range) + +p1 <- p1+ylim(y1_min,y1_max) +p2 <- p2+ylim(y1_min,y1_max) + + +p3 <- plot_rt(out, 2) + + scale_x_continuous(breaks = seq(t0, tmax, by =2)) +p3 <- p3 + (p3$theme %+replace% theme(legend.position=""none"",plot.title=element_blank(), + axis.text.x = element_text(angle = 45, vjust = 0.5, hjust=0.5))) + +p4 <- plot_rt(out, 3) + + scale_x_continuous(breaks = seq(t0, tmax, by =2)) +p4 <- p4 + (p4$theme %+replace% theme(axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + plot.title=element_blank(), + axis.text.x = element_text(angle = 45, vjust = 0.5, hjust=0.5))) + +fig3 <- (p1 | p2)/(p3 | p4) + +","R" +"Pathogens","dhelekal/ResistPhy","src/simulate.cpp",".cpp","9514","284","#include +#include +#include +#include +using namespace Rcpp; + +//' Simulate SIS epidemic process +//' @param u0 Vector u0 +//' @param usage_vals Vector of usage values +//' @param beta_vals Vector of beta values +//' @param times Vector of times +//' @param gamma_sus Recovery rate for sus +//' @param gamma_res_u Recovery rate for res untreated +//' @param gamma_res_t Recovery rate for res treated +//' @param dt dt +//' @param N N +// [[Rcpp::export]] +DataFrame simulate_fast(NumericVector u0, + NumericVector usage_vals, + NumericVector beta_vals, + NumericVector times, + double gamma_sus, + double gamma_res_u, + double gamma_res_t, + double dt, + double N) { + + int n = times.length(); + NumericVector S_v(n, 0.0); + NumericVector I_s_v(n, 0.0); + NumericVector I_r_v(n, 0.0); + NumericVector births_I_s_v(n, 0.0); + NumericVector births_I_r_v(n, 0.0); + NumericVector inf_rate_v(n, 0.0); + NumericVector rt_s_v(n,0.0); + NumericVector rt_r_v(n,0.0); + I_s_v.at(0) = u0.at(0); + I_r_v.at(0) = u0.at(1); + S_v.at(0) = u0.at(2); + inf_rate_v.at(0) = beta_vals.at(0)*S_v.at(0)/N; + + rt_s_v.at(0) = inf_rate_v.at(0)-gamma_sus; + rt_r_v.at(0) = inf_rate_v.at(0)-((1.0-usage_vals.at(0))*gamma_res_u + usage_vals.at(0)*gamma_res_t); + + for (int i = 1; i < n; i++) { + double gamma_res = (1.0-usage_vals.at(i-1))*gamma_res_u + usage_vals.at(i-1)*gamma_res_t; + double deaths_I_s = R::rpois(I_s_v.at(i-1)*gamma_sus*dt); + double deaths_I_r = R::rpois(I_r_v.at(i-1)*gamma_res*dt); + double births_I_s = R::rpois(I_s_v.at(i-1)*inf_rate_v.at(i-1)*dt); + double births_I_r = R::rpois(I_r_v.at(i-1)*inf_rate_v.at(i-1)*dt); + I_s_v.at(i) = I_s_v.at(i-1) + births_I_s-deaths_I_s; + I_r_v.at(i) = I_r_v.at(i-1) + births_I_r-deaths_I_r; + S_v.at(i) = S_v.at(i-1) + deaths_I_r + deaths_I_s - births_I_s - births_I_r; + births_I_s_v.at(i) = births_I_s; + births_I_r_v.at(i) = births_I_r; + + inf_rate_v.at(i) = beta_vals.at(i)*S_v.at(i)/N; + rt_s_v.at(i) = inf_rate_v.at(i)-gamma_sus; + rt_r_v.at(i) = inf_rate_v.at(i)-((1.0-usage_vals.at(i))*gamma_res_u + usage_vals.at(i)*gamma_res_t); + } + DataFrame out = DataFrame::create(Named(""t"") = times, + Named(""I_s"") = I_s_v, + Named(""I_r"") = I_r_v, + Named(""S"") = S_v, + Named(""births_I_s"") = births_I_s_v, + Named(""births_I_r"") = births_I_r_v, + Named(""inf_rate"") = inf_rate_v, + Named(""Rt_s"") = rt_s_v, + Named(""Rt_r"") = rt_r_v); + return out; +} + +//' Simulate SIS epidemic process +//' @param n_strains Number of strains +//' @param I0 Vector of initial infecteds +//' @param S0 Initial susceptibles +//' @param usage_vals Vector of usage values +//' @param beta_vals Vector of beta values +//' @param N_vals Vector N_vals +//' @param gamma_u recovery rates when not treated with ABX of interest +//' @param gamma_t recovery rates when treated with ABX of interest +//' @param times Vector of times +//' @param dt dt +// [[Rcpp::export]] +DataFrame simulate_fast_nstrain( + int n_strains, + NumericVector I0, + double S0, + NumericVector usage_vals, + NumericVector beta_vals, + NumericVector N_vals, + NumericVector gamma_u, + NumericVector gamma_t, + NumericVector times, + double dt) { + + int n = times.length(); + + NumericVector S_v(n, 0.0); + NumericVector inf_rate_v(n, 0.0); + std::vector I_v; + std::vector births_v; + std::vector rt_v; + + S_v.at(0) = S0; + inf_rate_v.at(0) = beta_vals.at(0)*S_v.at(0)/N_vals.at(0); + + for (int i = 0; i < n_strains; i++) { + I_v.push_back(NumericVector(n, 0.0)); + I_v.at(i).at(0) = I0.at(i); + births_v.push_back(NumericVector(n, 0.0)); + rt_v.push_back(NumericVector(n, 0.0)); + rt_v.at(i).at(0) = inf_rate_v.at(0)-((1.0-usage_vals.at(0))*gamma_u.at(i) + usage_vals.at(0)*gamma_t.at(i)); + } + + for (int i = 1; i < n; i++) { + std::vector b_I(n_strains); + std::vector d_I(n_strains); + std::vector gamma(n_strains); + + for (int j = 0; j < n_strains; j++) { + gamma.at(j) = ((1.0-usage_vals.at(i))*gamma_u.at(j) + usage_vals.at(i)*gamma_t.at(j)); + b_I.at(j) = R::rpois(I_v.at(j).at(i-1)*inf_rate_v.at(i-1)*dt); + d_I.at(j) = R::rpois(I_v.at(j).at(i-1)*gamma.at(j)*dt); + } + + S_v.at(i) = S_v.at(i-1) + std::accumulate(d_I.begin(), d_I.end(), 0.0) - std::accumulate(b_I.begin(), b_I.end(), 0.0); + S_v.at(i) += N_vals.at(i)-N_vals.at(i-1); + inf_rate_v.at(i) = beta_vals.at(i)*S_v.at(i)/N_vals.at(i); + + for (int j = 0; j < n_strains; j++) { + births_v.at(j).at(i) = b_I.at(j); + I_v.at(j).at(i) = I_v.at(j).at(i-1) + b_I.at(j) - d_I.at(j); + rt_v.at(j).at(i) = inf_rate_v.at(i)-gamma.at(j); + } + } + + CharacterVector namevec; + DataFrame out; + namevec.push_back(""t""); + namevec.push_back(""S""); + namevec.push_back(""inf_rate""); + + out.push_back(times); + out.push_back(S_v); + out.push_back(inf_rate_v); + + for (int i=0; i 0); + + NumericVector coal_times(samp_total-1, 0.0); + +/* std::function Ne_func = [Ne_vals, t_min, t_max, f_min, dt, n](double t) { + assert(t >= 0.0); + double out; + const double upper = t_max-t_min; + if (t >= upper) { + out = f_min; + } else { + const int index = n-1-int(t/dt); + if (index >= n || index < 0) throw + std::logic_error(""Ne index out of bounds! Index: "" + std::to_string(index) + "" Extent: "" + std::to_string(n) + "" t: "" +std::to_string(t) + "" dt: "" + std::to_string(dt)); + assert(index < n); + assert(index >= 0); + out = Ne_vals.at(index); + } + return out; + };*/ + + int ne_idx = n-2; + + int s_idx = 0; + int c_idx = 0; + int lin_count = n_samp.at(s_idx); + double t_curr = samp_times.at(s_idx); + + const double upper = t_max-t_min; + + s_idx++; + + while (lin_count > 1 || s_idx < m) { + if (lin_count == 1) { + t_curr = samp_times.at(s_idx); + lin_count += n_samp.at(s_idx); + s_idx++; + } + assert(lin_count > 1); + double s = R::rexp(f_min/(0.5*(lin_count)*(lin_count-1))); + if (s_idx < m && t_curr+s >= samp_times.at(s_idx)) { + t_curr = samp_times.at(s_idx); + lin_count += n_samp.at(s_idx); + s_idx++; + } else { + t_curr += s; + + double ne_val; + + if (t_curr >= upper) + { + ne_val = f_min; + } else + { + const double tr = t_max-t_curr; + while (ne_idx > 1 && tr < Ne_times.at(ne_idx)) + { + ne_idx--; + } + + if (!(tr > Ne_times.at(ne_idx) && tr <= Ne_times.at(ne_idx+1))) + std::logic_error(""Ne index localisation failed: "" + std::to_string(ne_idx)); + + ne_val = Ne_vals.at(ne_idx+1); + } + + double r = R::runif(0.0,1.0); + if (r <= f_min/ne_val) { + coal_times.at(c_idx) = t_curr; + lin_count--; + c_idx++; + } + } + } + return coal_times; +} + + + + + +","C++" +"Pathogens","dhelekal/ResistPhy","src/RcppExports.cpp",".cpp","5514","96","// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#include + +using namespace Rcpp; + +#ifdef RCPP_USE_GLOBAL_ROSTREAM +Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); +Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); +#endif + +// simulate_fast +DataFrame simulate_fast(NumericVector u0, NumericVector usage_vals, NumericVector beta_vals, NumericVector times, double gamma_sus, double gamma_res_u, double gamma_res_t, double dt, double N); +RcppExport SEXP _ResistPhy_simulate_fast(SEXP u0SEXP, SEXP usage_valsSEXP, SEXP beta_valsSEXP, SEXP timesSEXP, SEXP gamma_susSEXP, SEXP gamma_res_uSEXP, SEXP gamma_res_tSEXP, SEXP dtSEXP, SEXP NSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< NumericVector >::type u0(u0SEXP); + Rcpp::traits::input_parameter< NumericVector >::type usage_vals(usage_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type beta_vals(beta_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type times(timesSEXP); + Rcpp::traits::input_parameter< double >::type gamma_sus(gamma_susSEXP); + Rcpp::traits::input_parameter< double >::type gamma_res_u(gamma_res_uSEXP); + Rcpp::traits::input_parameter< double >::type gamma_res_t(gamma_res_tSEXP); + Rcpp::traits::input_parameter< double >::type dt(dtSEXP); + Rcpp::traits::input_parameter< double >::type N(NSEXP); + rcpp_result_gen = Rcpp::wrap(simulate_fast(u0, usage_vals, beta_vals, times, gamma_sus, gamma_res_u, gamma_res_t, dt, N)); + return rcpp_result_gen; +END_RCPP +} +// simulate_fast_nstrain +DataFrame simulate_fast_nstrain(int n_strains, NumericVector I0, double S0, NumericVector usage_vals, NumericVector beta_vals, NumericVector N_vals, NumericVector gamma_u, NumericVector gamma_t, NumericVector times, double dt); +RcppExport SEXP _ResistPhy_simulate_fast_nstrain(SEXP n_strainsSEXP, SEXP I0SEXP, SEXP S0SEXP, SEXP usage_valsSEXP, SEXP beta_valsSEXP, SEXP N_valsSEXP, SEXP gamma_uSEXP, SEXP gamma_tSEXP, SEXP timesSEXP, SEXP dtSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< int >::type n_strains(n_strainsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type I0(I0SEXP); + Rcpp::traits::input_parameter< double >::type S0(S0SEXP); + Rcpp::traits::input_parameter< NumericVector >::type usage_vals(usage_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type beta_vals(beta_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type N_vals(N_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type gamma_u(gamma_uSEXP); + Rcpp::traits::input_parameter< NumericVector >::type gamma_t(gamma_tSEXP); + Rcpp::traits::input_parameter< NumericVector >::type times(timesSEXP); + Rcpp::traits::input_parameter< double >::type dt(dtSEXP); + rcpp_result_gen = Rcpp::wrap(simulate_fast_nstrain(n_strains, I0, S0, usage_vals, beta_vals, N_vals, gamma_u, gamma_t, times, dt)); + return rcpp_result_gen; +END_RCPP +} +// sim_coal_fast +NumericVector sim_coal_fast(NumericVector samp_times, IntegerVector n_samp, NumericVector Ne_vals, NumericVector Ne_times, int samp_total, double dt, int n); +RcppExport SEXP _ResistPhy_sim_coal_fast(SEXP samp_timesSEXP, SEXP n_sampSEXP, SEXP Ne_valsSEXP, SEXP Ne_timesSEXP, SEXP samp_totalSEXP, SEXP dtSEXP, SEXP nSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< NumericVector >::type samp_times(samp_timesSEXP); + Rcpp::traits::input_parameter< IntegerVector >::type n_samp(n_sampSEXP); + Rcpp::traits::input_parameter< NumericVector >::type Ne_vals(Ne_valsSEXP); + Rcpp::traits::input_parameter< NumericVector >::type Ne_times(Ne_timesSEXP); + Rcpp::traits::input_parameter< int >::type samp_total(samp_totalSEXP); + Rcpp::traits::input_parameter< double >::type dt(dtSEXP); + Rcpp::traits::input_parameter< int >::type n(nSEXP); + rcpp_result_gen = Rcpp::wrap(sim_coal_fast(samp_times, n_samp, Ne_vals, Ne_times, samp_total, dt, n)); + return rcpp_result_gen; +END_RCPP +} +// compute_At +DataFrame compute_At(NumericVector samp_times, IntegerVector n_samp, NumericVector coal_times, double t_max); +RcppExport SEXP _ResistPhy_compute_At(SEXP samp_timesSEXP, SEXP n_sampSEXP, SEXP coal_timesSEXP, SEXP t_maxSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< NumericVector >::type samp_times(samp_timesSEXP); + Rcpp::traits::input_parameter< IntegerVector >::type n_samp(n_sampSEXP); + Rcpp::traits::input_parameter< NumericVector >::type coal_times(coal_timesSEXP); + Rcpp::traits::input_parameter< double >::type t_max(t_maxSEXP); + rcpp_result_gen = Rcpp::wrap(compute_At(samp_times, n_samp, coal_times, t_max)); + return rcpp_result_gen; +END_RCPP +} + +static const R_CallMethodDef CallEntries[] = { + {""_ResistPhy_simulate_fast"", (DL_FUNC) &_ResistPhy_simulate_fast, 9}, + {""_ResistPhy_simulate_fast_nstrain"", (DL_FUNC) &_ResistPhy_simulate_fast_nstrain, 10}, + {""_ResistPhy_sim_coal_fast"", (DL_FUNC) &_ResistPhy_sim_coal_fast, 7}, + {""_ResistPhy_compute_At"", (DL_FUNC) &_ResistPhy_compute_At, 4}, + {NULL, NULL, 0} +}; + +RcppExport void R_init_ResistPhy(DllInfo *dll) { + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} +","C++" +"Pathogens","dhelekal/ResistPhy","src/utils.cpp",".cpp","2090","68","#include +#include +using namespace Rcpp; + +//' Compute A(t), lineages through time +//' @param samp_times a vector of sampling times +//' @param n_samp a vector containing the numbers of samples taken at corresponding sampling time +//' @param coal_times vector of coalescent times +//' @param t_max maximum time +// [[Rcpp::export]] + +DataFrame compute_At(NumericVector samp_times, + IntegerVector n_samp, + NumericVector coal_times, + double t_max){ + DataFrame out; + + NumericVector vals = NumericVector::create(); + NumericVector times = NumericVector::create(); + + bool in_bounds = true; + long int s_idx = 0; + long int c_idx = 0; + double lin_count = 0; + + while (in_bounds && (s_idx < samp_times.length() || c_idx < coal_times.length())) { + double next_t; + double prev_val = lin_count; + if ((s_idx < samp_times.length()) && + (c_idx < coal_times.length()) && + (samp_times.at(s_idx) <= coal_times.at(c_idx))) { + + next_t = samp_times.at(s_idx); + lin_count += n_samp.at(s_idx); + s_idx++; + } else if ((s_idx < samp_times.length()) && + (c_idx < coal_times.length()) && + (samp_times.at(s_idx) > coal_times.at(c_idx))) { + + next_t = coal_times.at(c_idx); + lin_count -= 1; + c_idx++; + } else if (s_idx < samp_times.length()) { + + next_t = samp_times.at(s_idx); + lin_count += n_samp.at(s_idx); + s_idx++; + } else { + + next_t = coal_times.at(c_idx); + lin_count -= 1; + c_idx++; + } + + if (next_t <= t_max) { + times.push_back(next_t); + vals.push_back(lin_count); + } else { + times.push_back(t_max); + vals.push_back(prev_val); + in_bounds=false; + } + } + + out = DataFrame::create(Named(""t"") = times, + Named(""At"") = vals); + return out; +}","C++" +"Pathogens","dhelekal/ResistPhy","R/costs_fit2.R",".R","16448","422","costs_fit2 <- function(fit, + n_lineages, + time_vecs, + phys, + idx_begin, + idx_end, + time_scale, + gamma_guess, + gamma_log_sd, + n_iter, + n_warmup, + model) { + + draws_a <- as_draws_array(fit$draws()) + ddf <- as.data.frame(as_draws_df(fit$draws())) + np_cp <- nuts_params(fit) + + sampler_diagnostics <- fit$sampler_diagnostics() + sampler_diagnostics <- as_draws_df(sampler_diagnostics) + + if (model == ""nodecay"") { + fit_summary <- fit$summary(c(""alpha"", + ""rho"", + ""f_tilde"", + ""gamma_sus_tilde"", + ""q_tilde"", + ""I_0_hat"")) + } else { + stop(""Unsupported model"") + } + + converged <- TRUE + ess_bulk <- fit_summary$ess_bulk + + if(!all(fit_summary$rhat < 1.05)) { + warning(""Poor convergence detected: unsatisfactory rhat"") + converged <- FALSE + } + if (!all(ess_bulk > 500)) { + warning(""Poor convergence detected: Bulk ESS lower than 500"") + converged <- FALSE + } + if(length(which(sampler_diagnostics$divergent__ > 1e-8))>1) { + warning(sprintf(""%d/%d divergent transitions detected"", + length(which(sampler_diagnostics$divergent__ > 1e-8)), + length(sampler_diagnostics$divergent__))) + converged <- FALSE + } + + out <- list( + draws_arr=draws_a, + draws_df=ddf, + n_lineages=n_lineages, + time_vecs=time_vecs, + phys=phys, + idx_begin=idx_begin, + idx_end=idx_end, + gamma_log_sd=gamma_log_sd, + gamma_guess=gamma_guess, + time_scale=time_scale, + n_iter=n_iter, + n_warmup=n_warmup, + stan_fit=fit, + model=model, + converged=converged + ) + + attr(out, ""class"") <- ""costsFit2"" + return(out) +} + +#' Print fit summary +#' @param x costsFit2 object +#' @param ... Additional parameters +#' @export +print.costsFit2 <- function (x, ...) { + cat(paste(""\nResistPhy NUTS posterior fit\n\n"")) + cat(paste(""\nFields: "", names(x), ""\n"")) + cat(paste(""\nNumber of strains: "", x$n_lineages)) + cat(paste(""\nNumber of iterations: "", x$n_iter)) + cat(paste(""\nNumber of warmup iterations: "", x$n_warmup,""\n"")) + cat(paste(""\nConvergence: "", x$converged,""\n"")) +} + +#' Plot traces for a subset of parameters using bayesplot +#' @param o costsFit2 object +#' @param ... Additional parameters +#' @export +plot_traces <- function(o, ...) { + + rp <- c(""I_0_hat.*"", ""q_tilde.*"") + + mcmc_trace(o$draws_arr, pars = c(""alpha"", ""rho"", ""gamma_sus_tilde""), regex_pars=rp, + facet_args = list(ncol = 1, strip.position = ""left"")) +} + +#' Plot posterior marginals for GP hyperparameters +#' @param o costsFit2 object +#' @param ... Additional parameters +#' @export +plot_hyperpar_pairs <- function(o, ...) { + blank <- plot_spacer() + alpha_hist <- ggplot(o$draws_df, aes(x=alpha)) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=50, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dgamma(x, shape=4, rate=4), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$\\alpha$"")) + + theme_minimal() + thm1() + rho_hist <- ggplot(o$draws_df, aes(x=rho)) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=50, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dgamma(1/x, shape=4.63, rate=2.21)/(x^2), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$\\rho$"")) + + theme_minimal() + thm1() + + p1 <- ggplot(o$draws_df, aes(x=alpha, y=rho)) + + geom_hex(bins = 20) + + scale_fill_viridis() + + theme_minimal() + + thm2() + + alpha_hist + blank + + p1 + rho_hist + + plot_layout(ncol = 2) +} + +#' Plot posterior marginals and scatter plots for recovery rates using bayesplot +#' @param res_lineage_idx index of resistant lineage to display +#' @param o costsFit2 object +#' @param ... Additional parameters +#' @export +plot_epi_pairs <- function(o, res_lineage_idx, ...) { + + blank <- plot_spacer() + + q_u_name <- paste0(""q_u["",res_lineage_idx,""]"") + q_t_name <- paste0(""q_t["",res_lineage_idx,""]"") + + sc = o$time_scale + + gamma_sus_hist <- ggplot(o$draws_df, aes_(x=as.name(""gamma_sus""))) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=50, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dlnorm(x, meanlog = log(o$gamma_guess*sc), sdlog = o$gamma_log_sd), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(""$\\gamma$"")) + + theme_minimal() + thm1() + + + q_u_hist <- ggplot(o$draws_df, aes_(x=as.name(q_u_name))) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=50, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dnorm(x, mean = 0, sd = 0.3 * o$gamma_guess * sc), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(paste0(""$"",q_u_name,""$""))) + + theme_minimal() + thm1() + q_t_hist <- ggplot(o$draws_df, aes_(x=as.name(q_t_name))) + + geom_histogram(aes(y = ..density..), position=""identity"", bins=50, fill=""lightsteelblue3"") + + geom_function(fun = function(x) dnorm(x, mean = 0, sd = 0.3 * o$gamma_guess * sc), linetype=""longdash"", color=""steelblue4"") + + labs(x="""", y="""", title=TeX(paste0(""$"",q_t_name,""$""))) + + theme_minimal() + thm1() + + p1 <- ggplot(o$draws_df, aes_(x=as.name(""gamma_sus""), y=as.name(q_u_name))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + theme_minimal() + + thm2() + p2 <- ggplot(o$draws_df, aes_(x=as.name(""gamma_sus""), y=as.name(q_t_name))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + theme_minimal() + + thm2() + p3 <- ggplot(o$draws_df, aes_(x=as.name(q_u_name), y=as.name(q_t_name))) + + geom_hex(bins = 20) + + scale_fill_viridis() + + theme_minimal() + + thm2() + + gamma_sus_hist + blank + blank + + p1 + q_u_hist + blank + + p2 + p3 + q_t_hist + + plot_layout(ncol = 3) +} + +#' Plot q parameter marginals for all resistant strains +#' @param o costsFit2 object +#' @param ... Additional parameters +#' @export +plot_qpairs <- function(o, ...) { + blank <- plot_spacer() + + ddf <- o$draws_df + n_lineages <- o$n_lineages + + lin_data <- list() + + for (i in c(1:(n_lineages-1))) { + lin_names <- paste0(""q_"", c(""u"",""t""),""["",i,""]"") + lin_df <- ddf[,lin_names] + colnames(lin_df) <- c(""q_u"",""q_t"") + lin_df$lineage <- i + lin_data[[i]] <- lin_df + } + + plot_df <- do.call(rbind, lin_data) + plot_df$lineage <- factor(plot_df$lineage) + h1 <- ggplot(plot_df, aes(x=q_u, color=lineage, fill=lineage, group=lineage)) + + geom_density(alpha=0.4,lwd=0.8) + + labs(x="""", y="""", title=TeX(paste0(""$"",""q_U"",""$""))) + + scale_color_brewer(palette=""Paired"") + + scale_fill_brewer(palette=""Paired"") + + theme_minimal() + (thm1() %+replace% theme(legend.position=""none"")) + h2 <- ggplot(plot_df, aes(x=q_t, color=lineage, fill=lineage, group=lineage)) + + geom_density(alpha=0.4, lwd=0.8) + + scale_color_brewer(palette=""Paired"") + + scale_fill_brewer(palette=""Paired"") + + labs(x="""", y="""", fill = ""Resistant Lineage"", color=""Resistant Lineage"", title=TeX(paste0(""$"",""q_T"",""$""))) + + theme_minimal() + thm1() + + p <- ggplot(plot_df, aes(x=q_u, q_t, color=lineage, fill=lineage, group=lineage)) + + geom_density_2d(bins=10, alpha=.5) + + scale_color_brewer(palette=""Paired"") + + theme_minimal() + thm2() + + h1 + blank + + p + h2 + + plot_layout(ncol = 2) +} + +#' Plot epidemic trajectory credible intervals and posterior draws +#' @param o costsFit2 object +#' @param lineage_index index of lineage to display, '1' indicates susceptible +#' @param n_draws Number of posterior epidemic trajectory draws to sample +#' @param ... Additional parameters +#' @export +plot_epi_dynamic <- function(o, lineage_index, n_draws=40, ...) { + ts <- o$time_vecs[[lineage_index]] + + lineage_indices <- c(o$idx_begin[lineage_index]:o$idx_end[lineage_index]) + I_names <- sapply(lineage_indices,function(i) paste0(""traj_vec["",i,""]"")) + ytitle <- ""Prevalence"" + plot_timeseries(o, lineage_index, ts, I_names, ytitle, n_draws) +} + +#' Plot Ne trajectories credible intervals and posterior draws +#' @param o costsFit2 object +#' @param lineage_index index of lineage to display, '1' indicates susceptible +#' @param n_draws Number of posterior Ne trajectory draws to sample +#' @param ... Additional parameters +#' @export +plot_Ne <- function(o, lineage_index, n_draws=40, ...) { + ts <- o$time_vecs[[lineage_index]] + + lineage_indices <- c(o$idx_begin[lineage_index]:o$idx_end[lineage_index]) + I_names <- sapply(lineage_indices,function(i) paste0(""Ne["",i,""]"")) + ytitle <- ""Ne(t)"" + plot_timeseries(o, lineage_index, ts, I_names, ytitle, n_draws) +} + +#' Plot growth rate r(t) credible intervals and posterior draws +#' @param o costsFit2 object +#' @param lineage_index index of lineage to display, '1' indicates susceptible +#' @param n_draws Number of posterior r(t) draws to sample +#' @param ... Additional parameters +#' @export +plot_rt <- function(o, lineage_index, n_draws=40, ...) { + ts <- o$time_vecs[[lineage_index]] + + lineage_indices <- c(o$idx_begin[lineage_index]:o$idx_end[lineage_index]) + I_names <- sapply(lineage_indices,function(i) paste0(""r_t["",i,""]"")) + ytitle <- ""r(t)"" + plot_timeseries(o, lineage_index, ts, I_names, ytitle, n_draws) +} + +#' Plot Rt_res / Rt_sus ratio posterior probability curve for a given threshold +#' @description f(U) = P[rt_sus - rt_res > c | u(t) = U] +#' @param o costsFit2 object +#' @param res_lineage_idx index of resistant lineage to display +#' @param rr_threshold r_t ratio for which to plot the curve +#' @param n_breaks number of usage discretisation breaks +#' @export +plot_rr_curve <- function(o, res_lineage_idx, rr_threshold=0.0, n_breaks = 100) { + q_names <- paste0(c(""q_u["", ""q_t[""), res_lineage_idx, ""]"") + q_df <- o$draws_df[,q_names] + n_samp <- nrow(q_df) + usage_thresholds <- apply(q_df, 1, function(x) (rr_threshold - x[1])/(x[2]-x[1])) + usage_breaks <- seq(from=0, to=1, length.out=n_breaks) + probs <- sapply(usage_breaks, function(x) length(which(usage_thresholds > x))/n_samp) + + p_df <- data.frame(usage=usage_breaks, prob=probs) + + ggplot(p_df) + + geom_step(aes(x=usage, y=prob), fill=""lightsteelblue3"", color=""lightsteelblue3"") + + labs(x=""Usage"", y=""Posterior Probability"", title=TeX(sprintf(""Posterior Probability of $r_r(t) - r_s(t) < %.2f$"", rr_threshold))) + + theme_minimal() + + thm3(aspect.ratio=1) +} + +#' Plot rt_sus - rt_res difference posterior probability heatmap +#' @description f(U, c) = P[rt_sus - rt_res > c | u(t) = U] +#' @param o costsFit2 object +#' @param res_lineage_idx index of resistant lineage to display +#' @param n_breaks number of usage discretisation breaks +#' @param min_disp_prob minimum probability display cutoff +#' @export +plot_rr_map <- function(o, res_lineage_idx, n_breaks = 100, min_disp_prob=0.5) { + q_names <- paste0(c(""q_u["", ""q_t[""), res_lineage_idx, ""]"") + q_df <- o$draws_df[,q_names] + n_samp <- nrow(q_df) + usage_breaks <- seq(from=0, to=1, length.out=n_breaks) + max_cost <- max(q_df$q_u) + + if (max_cost <= 0) { + warning(""Posterior difference between resistant and susceptible growth rates r(t) never drops below 0. + This suggests no transmission cost to resistance"") + } + + rr_breaks <- seq(from = 0, to = max_cost, length.out = n_breaks) + p_df <- data.frame(prob=c(), usage=c(), rr=c()) + + for (rr in rr_breaks) { + usage_thresholds <- apply(q_df, 1, function(x) (rr - x[1])/(x[2]-x[1])) + probs <- sapply(usage_breaks, function(x) length(which(usage_thresholds > x))/n_samp) + tmp_df <- data.frame(prob = probs, usage=usage_breaks, rr=rr) + p_df <- rbind(p_df, tmp_df) + } + + x_upper <- max(p_df$usage[which(p_df$prob >= min_disp_prob)]) + y_lower <- min(p_df$rr[which(p_df$prob >= min_disp_prob)]) + + breaks <- c(0, 0.50, 0.75, 0.90, 0.95, 0.99, 0.999, 1) + + ggplot(p_df) + + geom_contour_filled(aes(x=usage, y=rr, z=prob), breaks=breaks) + + #geom_tile(aes(x=usage, y=rr, fill=prob)) + + scale_color_viridis() + + labs(x=""Usage"", y=""C"", fill=""Posterior Probability"", title=TeX(sprintf(""Posterior Probability of $r_s(t) - r_r(t) > c$ given usage level""))) + + xlim(0, x_upper) + + ylim(y_lower, 1) + + theme_minimal() + + thm3(aspect.ratio=1) +} + +#' Plot posterior predictive draws and data overlay for the lineages through time function +#' @param o costsFit2 object +#' @param lineage_index index of lineage to display, '1' indicates susceptible +#' @param n_draws number of trajectories to simulate and overlay +#' @param ... Additional parameters +#' @export +plot_ppcheck_At <- function(o, lineage_index, n_draws=40, ...) { + ts <- o$time_vecs[[lineage_index]] + t_max <- max(ts)-min(ts) + n <- length(ts) + + phy <- o$phys[[lineage_index]] + + lineage_indices <- c(o$idx_begin[lineage_index]:o$idx_end[lineage_index]) + Ne_names <- sapply(lineage_indices,function(i) paste0(""Ne["",i,""]"")) + + row_count <- nrow(o$draws_df) + stopifnot(""n_draws must not exceed the number of MCMC draws""=n_draws <= row_count) + draws <- sample.int(row_count, n_draws) + + pp_df <- draw_At_samples(phy, draws, o$draws_df, Ne_names, ts, t_max, 1.0) + + data_df <- compute_At(phy$samp_times, phy$n_samp, phy$coal_times, t_max) + + ggplot(pp_df) + geom_step(aes(x=t, y=At, group=draw, color=draw), alpha=0.3, color=""gray"", size=0.4) + + geom_step(data=data_df, aes(x=t, y=At), color=""black"", size=0.7, linetype=""dashed"") + + labs(x=""Time"", y=""A(t)"") + + scale_color_brewer(""PuBu"")+ + scale_y_log10() + + theme_minimal() + + thm3() + +} + +draw_At_samples <- function(phy, draws, draws_df, Ne_names, eval_ts, t_max, time_scale) { + pp_df <- data.frame(t=c(), At=c(), draw=c()) + n_draws <- length(draws) + for (i in c(1:n_draws)) { + draw_idx <- draws[i] + sample_phy <- sim_coal(phy$samp_times, phy$n_samp, unlist(draws_df[draw_idx,Ne_names])/time_scale, eval_ts) + temp_df <- compute_At(sample_phy$samp_times, sample_phy$n_samp, sample_phy$coal_times, + t_max) + temp_df$draw <- i; + pp_df <- rbind(pp_df,temp_df) + + } + return(pp_df) +} + + +plot_timeseries <- function(o, lineage_index, times, varnames, ytitle, n_draws) { + ts <- times + n <- length(ts) + + ddf <- o$draws_df + + # Compute CIs + y_lo <- sapply(varnames, function (i) quantile(ddf[[i]],c(0.025))) + y_hi <- sapply(varnames, function (i) quantile(ddf[[i]],c(0.975))) + y_m <- sapply(varnames, function (i) median(ddf[[i]])) + + p_df <- data.frame(t=ts, + y=y_m, + y_hi=y_lo, + y_lo=y_hi) + + # Compute posterior draws + draw_idx <- sample.int(nrow(ddf), n_draws) + names(ts) <- unlist(regmatches(varnames, regexec(""\\d+"",varnames))) + + traj_draws <- ddf[draw_idx, varnames] + traj_draws$draw <- if(n_draws > 0) c(1:n_draws) else c() + traj_draws <- melt(traj_draws, ""draw"", variable.name = ""ID"", value.name=""y"") + draw_idx <- as.character(unlist(regmatches(traj_draws$ID, regexec(""\\d+"",traj_draws$ID)))) + traj_draws$t <- sapply(draw_idx, function(i) ts[[i]]) + + ggplot(p_df)+geom_ribbon(aes(x=t, ymin=y_lo, ymax=y_hi), fill=""lightgray"", alpha=0.4) + + geom_line(data=traj_draws, aes(x=t, y=y, color=draw, group=factor(draw)), alpha=0.4, size=0.1) + + geom_line(aes(x=t, y=y), color=""black"", linetype=""longdash"") + + scale_color_viridis() + + labs(title = paste(""Lineage "", lineage_index), y=ytitle, x=""Time"") + + theme_minimal() + (thm3() %+replace% theme(legend.position=""none"")) +} + +","R" +"Pathogens","dhelekal/ResistPhy","R/ResistPhy.R",".R","426","10","#' @import ape cmdstanr ggplot2 viridis RColorBrewer patchwork Rcpp graphics stats +#' @importFrom posterior as_draws_df as_draws_array +#' @importFrom bayesplot mcmc_trace color_scheme_set mcmc_pairs nuts_params mcmc_areas +#' @importFrom reshape2 melt +#' @importFrom latex2exp TeX +#' @importFrom utils capture.output read.csv +#' @importFrom phylodyn coalsim sample_tree +#' @importFrom treeio nodeid +#' @useDynLib ResistPhy +NULL","R" +"Pathogens","dhelekal/ResistPhy","R/infer.R",".R","12847","366","#' Run fitness cost inference +#' @param phys A list of phylogenies. First phylogeny is assumed to susceptible +#' @param mrsts A list of most recent sampling times (in coalescent time) relative to t_begin +#' @param ABX_usage AMR usage values as a proportion of primary treatment +#' @param ABX_times AMR usage time points +#' @param t_begin Analysis start date in natural time +#' @param t_end Analysis end date in natural time +#' @param gamma_guess Average recovery rate per day +#' @param time_scale_d The scale of one time unit for phylogenies and AMR data, in days +#' @param gamma_log_sd Log sd for strongly informative log-normal prior on average recovery rates +#' @param n_iter Number of sampling iterations +#' @param n_warmup Number of warmup iterations# +#' @param L HSGP approximation boundary factor +#' @param K HSGP approximation basis function count +#' @param seed RNG seed used by sampler +#' @param max_dt Maximum interval width for likelihood approximation on [-1,1] scale +#' @param stan_control List of additional arguments to pass to cmdstan. Accepted keywords: 'adapt_delta', 'max_treedepth', 'refresh', 'init', 'chains', 'parallel_chains'. See stan_defaults() for default values. +#' @export +#' +infer_costs2 <- function(phys, + mrsts, + ABX_usage, + ABX_times, + t_begin, + t_end, + gamma_guess, + time_scale_d, + gamma_log_sd=0.1, + n_iter = 2000, + n_warmup = 2000, + L = 6.5, + K = 65, + seed = 1, + max_dt=1e-3, + stan_control=stan_defaults()) { + model <- ""nodecay"" + old_int <- c(t_begin, t_end) + new_int <- c(-1,1) + ABX_times <- rescale_times(ABX_times, old_int, new_int) + scale_factor <- (old_int[2]-old_int[1])/2.0 + time_scale_new <- time_scale_d*scale_factor + + n_lineages <- length(phys) + stopifnot(length(mrsts)==n_lineages) + + obs_total <- 0 + coal_total <- 0 + + time_vecs <- list() + obs_counts <- c() + coal_counts <- c() + + all_times <- c() + all_coal_idx <- c() + all_w_t <- c() + all_lineage_counts <- c() + + idx_begin <- c() + idx_end <- c() + + obs_pos <- 1 + + for (i in c(1:n_lineages)) { + poi <- phy2poi(phys[[i]], mrsts[[i]], t_begin, t_end, max_dt) + + coal_idx_tmp <- which(poi$poi_counts > .5) + times_tmp <- poi$process_times + + n_coal <- length(coal_idx_tmp) + n_obs <- length(times_tmp) + + w_t_tmp <- poi$holding_times + lineage_counts_tmp <- poi$lineage_counts + + all_times <- c(all_times, times_tmp) + all_w_t <- c(all_w_t, w_t_tmp) + all_lineage_counts <- c(all_lineage_counts, lineage_counts_tmp) + all_coal_idx <- c(all_coal_idx,coal_idx_tmp) + + idx_begin <- c(idx_begin, obs_pos) + idx_end <- c(idx_end, obs_pos+n_obs-1) + + coal_counts <- c(coal_counts, n_coal) + obs_counts <- c(obs_counts, n_obs) + + obs_total <- obs_total + n_obs + coal_total <- coal_total + n_coal + + obs_pos <- obs_pos + n_obs + time_vecs[[i]] <- rescale_times(times_tmp, new_int, old_int) + } + + data_list <- list( + M=length(ABX_times), + N_lineages=n_lineages, + obs_total=obs_total, + coal_total=coal_total, + obs_counts=obs_counts, + coal_counts=coal_counts, + times=all_times, + w_t=all_w_t, + coal_index=all_coal_idx, + lineage_counts=all_lineage_counts, + usage_ts=ABX_times, + ABX_usage=ABX_usage, + time_scale=time_scale_new, + unit_scale=time_scale_d, + gamma_guess=gamma_guess, + gamma_log_sd=gamma_log_sd, + K=K, + L=L + ) + + include_dir <- system.file('stan',package='ResistPhy',mustWork=T) + + if(model==""nodecay"") { + f <- system.file('stan', + 'n_strain_model_v8_deterministic.stan', + package='ResistPhy', + mustWork = T) + } else { + stop(""Invalid Model"") + } + mod <- cmdstan_model(f, include_paths=include_dir, stanc_options = list(""O1"")) + + fit <- mod$sample(data=data_list, + adapt_delta=stan_control$adapt_delta, + max_treedepth=stan_control$max_treedepth, + chains=stan_control$chains, + parallel_chains=stan_control$parallel_chains, + refresh=stan_control$refresh, + init=stan_control$init, + iter_warmup=n_warmup, + iter_sampling=n_iter, + seed=seed) + + phys_extracted <- list() + + for (i in c(1:n_lineages)) { + phys_extracted[[i]] <- offset_extracted(extract_phy(phys[[i]]), mrsts[[i]]) + } + + out <- costs_fit2(fit, + n_lineages, + time_vecs, + phys_extracted, + idx_begin, + idx_end, + time_scale_d, + gamma_guess, + gamma_log_sd, + n_iter, + n_warmup, + model) + return(out) +} + + +phy2poi <- function(phy, mrst, t_begin, t_end, max_dt=1e-3) { + # Convert ape phylo to lists of: + # - coalescent times + # - sampling times + # - sampling counts + extracted <- extract_phy(phy) + height_last_sam <- max(extracted$coal_times) - max(extracted$samp_times) + # Offset times by most recent sampling time + offset_phy <- offset_extracted(extracted, mrst) + # Convert phylogeny to a list of event times, a list of event types, and list of lineage counts + processed <- process_events(offset_phy$samp_times, offset_phy$n_samp, offset_phy$coal_times) + # Truncate phylogeny to the usage data span + # if MRCA exceeds the span + span <- t_end-t_begin + truncated <- truncate_phy(processed$event_times, processed$lineage_counts, processed$event_types, span) + stopifnot(truncated$len > 2) + # add P[No coalescence] (=sampling with 0 samples taken) event at t_begin (span in coalescent time) + # with lineage count equal to lineage count before truncation point + truncated$event_times <- c(truncated$event_times, span) + truncated$lineages <- c(truncated$lineages, truncated$lineages_last) + truncated$event_types <- c(truncated$event_types, 0) + # reverse time to transform from coalescent time to natural time + truncated$event_times <- t_end - truncated$event_times + # rescale from t_begin to t_end interval to -1 to 1 interval + old_int <- c(t_begin, t_end) + new_int <- c(-1, 1) + event_times_scaled <- rescale_times(truncated$event_times, old_int, new_int) + stopifnot(max(abs(event_times_scaled[order(-event_times_scaled)] - event_times_scaled)) < 1e-8) + # Reorder to natural time + ord <- order(event_times_scaled) + lineages <- truncated$lineages[ord] + event_types <- truncated$event_types[ord] + event_times <- event_times_scaled[ord] + # Finally approximate phylogeny as a compound PPP, adding P[no event] intervals whenever inter-event times exceed max_dt + n <- length(event_times_scaled) + stopifnot(length(truncated$lineages)==n) + stopifnot(length(truncated$event_types)==n) + new_times <- c(event_times[1]) + new_lineages <- c(lineages[1]) + new_events <- c(event_types[1]) + stopifnot(event_types[1]==0) + stopifnot(event_types[n]==0) + stopifnot(lineages[n]==0) + + tol <- 1e-8 + + for (i in c(2:n)) { + next_t <- event_times[i] + prev_t <- event_times[i-1] + dt <- next_t - prev_t + stopifnot(dt >= 0) + if (dt > max_dt) { + + q <- (next_t-prev_t)/max_dt + + if (abs(trunc(q)-q) < tol) { + n_step <- trunc(q) + } else { + n_step <- ceiling(q) + } + time_steps <- seq(from=prev_t, to=next_t, length.out=n_step+1)[-1] + lins <- c(rep(lineages[i-1], n_step-1), lineages[i]) + evts <- c(rep(0, n_step-1),event_types[i]) + new_times <- c(new_times, time_steps) + new_lineages <- c(new_lineages, lins) + new_events <- c(new_events, evts) + } else { + new_times <- c(new_times, event_times[i]) + new_lineages <- c(new_lineages, lineages[i]) + new_events <- c(new_events, event_types[i]) + } + } + + m <- length(new_times) + holding_times <- new_times[2:m] - new_times[1:(m-1)] + process_times <- new_times[1:(m-1)] + poi_counts <- new_events[1:(m-1)] + lineage_counts <- new_lineages[1:(m-1)] + + return(list(holding_times=holding_times, + process_times=process_times, + poi_counts=poi_counts, + lineage_counts=lineage_counts, + height_last_sam=height_last_sam)) +} + +rescale_times <- function(times, old_interval, new_interval){ + span_old <- old_interval[2]-old_interval[1] + span_new <- new_interval[2]-new_interval[1] + times_01 <- (times-old_interval[1])/span_old + times_resc <- times_01*span_new + new_interval[1] + stopifnot(all(times_resc <= new_interval[2])) + stopifnot(all(times_resc >= new_interval[1])) + return(times_resc) +} + +#' Default stan arguments +#' @export +stan_defaults <- function() { + return(list(adapt_delta=.99, + max_treedepth=13, + parallel_chains=4, + chains=4, + init=NULL)) +} + +offset_extracted <- function(extracted_phy, most_recent_sample) { + # most recent sample as measured in time before present + offset <- most_recent_sample + return(list(coal_times=extracted_phy$coal_times+offset, + samp_times=extracted_phy$samp_times+offset, + n_samp=extracted_phy$n_samp)) +} + +extract_phy <- function(phy, merge_sam_threshold=1e-6) { + phy_l <- makeNodeLabel(phy) + labs <- c(phy_l$node.label, phy_l$tip.label) + nodes <- nodeid(phy_l, labs) + is_tip <- c(rep(FALSE, length(phy_l$node.label)), rep(TRUE, length(phy_l$tip.label))) + + times <- node.depth.edgelength(phy_l) + times <- -times + times <- times - min(times) + times <- times[nodes] + + nodes.df <- data.frame(id=nodes, times=times, is_tip=is_tip, lab=labs) + nodes.df <- nodes.df[order(nodes.df$times), ] + + coal_times <- c() + samp_times <- c() + n_samp <- c() + i <- 1 + n <- nrow(nodes.df) + + while(i <= n) { + time <- nodes.df$times[i] + if (nodes.df$is_tip[i]) { + k <- 1 + while(i < n && + nodes.df$is_tip[i+1] && + abs(time-nodes.df$times[i+1]) < merge_sam_threshold) { + + k <- k + 1 + i <- i + 1 + } + i <- i + 1 + samp_times <- c(samp_times, time) + n_samp <- c(n_samp, k) + } else { + i <- i + 1 + coal_times <- c(coal_times, time) + } + } + + return(list(coal_times=coal_times, + samp_times=samp_times, + n_samp=n_samp)) +} + +truncate_phy <- function(event_times, lineages, event_types, span) { + in_bounds <- which(event_times <= span) + events_past_threshold <- which(event_times > span) + if(length(events_past_threshold)>0) { + lineages_last <- lineages[min(events_past_threshold)] + } else { + lineages_last <- 1 + } + lineages_trunc <- lineages[in_bounds] + event_types_trunc <- event_types[in_bounds] + len <- length(lineages_trunc) + times_trunc <- event_times[in_bounds] + + return(list(event_times=times_trunc, + lineages=lineages_trunc, + event_types=event_types_trunc, + len=len, + lineages_last=lineages_last)) +} + +process_events <- function(samp_times, n_samp, coal_times) { + stopifnot(samp_times == samp_times[order(samp_times)]) + stopifnot(coal_times == coal_times[order(coal_times)]) + + event_types <- c(rep(0, length(samp_times)), rep(1, length(coal_times))) + all_events <- c(samp_times, coal_times) + lineage_counts <- rep(0, length(all_events)) + + event_types <- event_types[order(all_events)] + all_events <- all_events[order(all_events)] + + lin_count <- 0 + samp_idx <- 1 + + for (i in c(1:length(all_events))) { + lineage_counts[i] <- lin_count + if (event_types[i] > 0.5) { + ## coalescent event + lin_count <- lin_count - 1 + } else { + ## sampling event + lin_count <- lin_count + n_samp[samp_idx] + samp_idx <- samp_idx + 1 + } + } + return(list(event_times=all_events, + event_types=event_types, + lineage_counts=lineage_counts)) +}","R" +"Pathogens","dhelekal/ResistPhy","R/coal.R",".R","3601","82","#' Simulate coalescent process times using Poisson Process Thinning +#' Note: Ne function is interpolated as a step function +#' @param samp_t a vector of sampling times +#' @param n_samp a vector containing the numbers of samples taken at corresponding sampling time. +#' @param Ne_vals a vector of Ne(t) values. +#' @param Ne_times a vector of time points corresponding to Ne(t) values. +#' @export +sim_coal <- function(samp_t, n_samp, Ne_vals, Ne_times) { + n <- length(Ne_times) + samp_total <- sum(n_samp) + dt <- Ne_times[2]-Ne_times[1] + stopifnot(""Ne_vals and Ne_times must have same length""=length(Ne_vals)==n) + coal_times <- sim_coal_fast(samp_t, n_samp, Ne_vals, Ne_times, samp_total, dt, n) + return(list(samp_times=samp_t, n_samp=n_samp, coal_times=coal_times)) +} + +#' Generate a Newick string representation of a tree corresponding to a realisation of a coalescent process. +#' Note: the topology is RANDOM, If you wish for the topology to be consistent, use set.seed before calling this function. +#' @param samp_t sampling times. +#' @param n_samp a vector containing the numbers of samples taken at corresponding sampling time. +#' @param coal_t times of coalescent events / internal nodes. +#' @param node_name_prefix Prefix given to node names. +#' @return an ape phylogeny with appropriate times +#' @export +build_coal_tree <- function(samp_t, n_samp, coal_t, node_name_prefix=""N"") { + n_leaves <- sum(n_samp) + samp_t_expanded <- c() + + for(i in 1:length(samp_t)) { + samp_t_expanded <- c(samp_t_expanded, rep(samp_t[i], n_samp[i])) + } + + samp_t_expanded <- samp_t_expanded + + tree_nodes <- seq(1, n_leaves) + tree_nodes <- sapply(tree_nodes, function (x) return (paste0(""S"", x))) + + extant_entries <- c(1) + extant_times <- c(samp_t_expanded[1]) + + coal_idx <- 1 + s_idx <- 1 + t <- samp_t_expanded[1] + if (length(coal_t) > 0) { + while (coal_idx <= length(coal_t)) { + if (s_idx < length(samp_t_expanded) && (samp_t_expanded[s_idx + 1] < coal_t[coal_idx])) { + s_idx <- s_idx + 1 + t <- samp_t_expanded[s_idx] + extant_entries <- c(extant_entries, s_idx) + extant_times <- c(extant_times, t) + } else { + t <- coal_t[coal_idx] + coal_node1_idx <- trunc(runif(1, 1, length(extant_entries) + 1)) + + coal_node1 <- extant_entries[coal_node1_idx] + ct1 <- extant_times[coal_node1_idx] + + extant_times <- extant_times[-coal_node1_idx] + extant_entries <- extant_entries[-coal_node1_idx] + + br_len_1 <- t - ct1 + entry1 <- tree_nodes[coal_node1] + + coal_node2_idx <- trunc(runif(1, 1, length(extant_entries) + 1)) + coal_node2 <- extant_entries[coal_node2_idx] + ct2 <- extant_times[coal_node2_idx] + br_len_2 <- t - ct2 + entry2 <- tree_nodes[coal_node2] + + tree_nodes[coal_node2] <- paste0(""("", entry1, + "":"", br_len_1, + "","", + entry2, + "":"", br_len_2, "")"",node_name_prefix,coal_idx) + extant_times[coal_node2_idx] <- t + coal_idx <- coal_idx + 1 + } + } + } + tree_str <- paste0(tree_nodes[extant_entries[1]], "";"") + return(read.tree(text=tree_str)) +} ","R" +"Pathogens","dhelekal/ResistPhy","R/RcppExports.R",".R","2444","54","# Generated by using Rcpp::compileAttributes() -> do not edit by hand +# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#' Simulate SIS epidemic process +#' @param u0 Vector u0 +#' @param usage_vals Vector of usage values +#' @param beta_vals Vector of beta values +#' @param times Vector of times +#' @param gamma_sus Recovery rate for sus +#' @param gamma_res_u Recovery rate for res untreated +#' @param gamma_res_t Recovery rate for res treated +#' @param dt dt +#' @param N N +simulate_fast <- function(u0, usage_vals, beta_vals, times, gamma_sus, gamma_res_u, gamma_res_t, dt, N) { + .Call('_ResistPhy_simulate_fast', PACKAGE = 'ResistPhy', u0, usage_vals, beta_vals, times, gamma_sus, gamma_res_u, gamma_res_t, dt, N) +} + +#' Simulate SIS epidemic process +#' @param n_strains Number of strains +#' @param I0 Vector of initial infecteds +#' @param S0 Initial susceptibles +#' @param usage_vals Vector of usage values +#' @param beta_vals Vector of beta values +#' @param N_vals Vector N_vals +#' @param gamma_u recovery rates when not treated with ABX of interest +#' @param gamma_t recovery rates when treated with ABX of interest +#' @param times Vector of times +#' @param dt dt +simulate_fast_nstrain <- function(n_strains, I0, S0, usage_vals, beta_vals, N_vals, gamma_u, gamma_t, times, dt) { + .Call('_ResistPhy_simulate_fast_nstrain', PACKAGE = 'ResistPhy', n_strains, I0, S0, usage_vals, beta_vals, N_vals, gamma_u, gamma_t, times, dt) +} + +#' Simulate coalescent tree using thinning +#' @param samp_times a vector of sampling times +#' @param n_samp a vector containing the numbers of samples taken at corresponding sampling time. +#' @param Ne_vals a vector of Ne(t) values. +#' @param Ne_times a vector of time points corresponding to Ne(t) values. +#' @param samp_total samp_total +#' @param dt dt +#' @param n n +sim_coal_fast <- function(samp_times, n_samp, Ne_vals, Ne_times, samp_total, dt, n) { + .Call('_ResistPhy_sim_coal_fast', PACKAGE = 'ResistPhy', samp_times, n_samp, Ne_vals, Ne_times, samp_total, dt, n) +} + +#' Compute A(t), lineages through time +#' @param samp_times a vector of sampling times +#' @param n_samp a vector containing the numbers of samples taken at corresponding sampling time +#' @param coal_times vector of coalescent times +#' @param t_max maximum time +compute_At <- function(samp_times, n_samp, coal_times, t_max) { + .Call('_ResistPhy_compute_At', PACKAGE = 'ResistPhy', samp_times, n_samp, coal_times, t_max) +} + +","R" +"Pathogens","dhelekal/ResistPhy","R/utils.R",".R","2510","77","#' Interpolate usage data using a step function +#' @param usage usage values +#' @param usage_ts usage time points +#' @export +yearly_usg_stepfunc <- function(usage, usage_ts) { + k <- length(usage) + stopifnot(!is.na(usage)) + stopifnot(!is.na(usage_ts)) + stopifnot(k == length(usage_ts)) + out <- function(t) { + if(t==usage_ts[k]) { + return(usage[k]) + } + idx <- min(which(usage_ts > t))-1 + stopifnot(idx >= 1) + stopifnot(idx <= length(usage)) + return(usage[idx]) + } + + return(out) +} + +#' Load synthetic usage data +#' @export +simulated_usage <- function() { + f <- system.file('extdata', + 'synthetic_usage.csv', + package='ResistPhy', + mustWork = T) + out <- as.data.frame(read.csv(f, header=T)) + return(out) +} + +# GGPlot theme 1 +thm1 <- function(...) { + thm1 <- theme(axis.title.x=element_blank(), + axis.title.y=element_blank(), + axis.text.y=element_blank(), + axis.ticks.y=element_blank(), + axis.text.x=element_text(size=rel(0.7), angle = 45, hjust=1), + aspect.ratio=1, + plot.margin = margin(0, 0, 0, 0, ""cm""), + panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), + axis.line = element_line(size=rel(0.2), colour = ""grey80""), + plot.title = element_text(hjust = 0.5,size=rel(1.0)), ...) + return(thm1) +} + +# GGPlot theme 2 +thm2 <- function(...) { + thm2 <- theme(axis.title.x=element_blank(), + axis.title.y=element_blank(), + axis.text.x=element_text(size=rel(0.7), angle = 45, hjust=1), + axis.text.y=element_text(size=rel(0.7)), + aspect.ratio=1, + plot.margin = margin(0, 0, 0, 0, ""cm""), + legend.position=""none"", + panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), + axis.line = element_line(size=rel(0.2), colour = ""grey90""), + plot.title = element_text(hjust = 0.5,size=rel(1.0)), ...) + return(thm2) +} + +# GGPlot theme 3 +thm3 <- function(...) { + thm3 <- theme( + axis.text.x=element_text(size=rel(0.7), angle = 45, hjust=1), + axis.text.y=element_text(size=rel(0.7)), + plot.margin = margin(0, 0, 0, 0, ""cm""), + panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), + axis.line = element_line(size=rel(0.2), colour = ""grey90""), + plot.title = element_text(hjust = 0.5,size=rel(1.0)), ...) + return(thm3) +}","R" +"Pathogens","dhelekal/ResistPhy","R/simulate.R",".R","5738","159","#' Simulate tau-leaped trajectories from n-strain stochastic SIS +#' @param t0 start time +#' @param tmax end time +#' @param nstep number of tau-leaped steps +#' @param n_strains number of strains to simulate +#' @param S_0 initial susceptible population +#' @param I_0 initial infected populations, 1 per strain +#' @param usage_func abx of interest usage function +#' @param beta_func force of infection function +#' @param N_func population size function +#' @param gamma_u recovery rates when not treated with ABX of interest +#' @param gamma_t recovery rates when treated with ABX of interest +#' @export +simulate_epi_nstrain <- function(t0, tmax, nstep, n_strains, S_0, I_0, usage_func, beta_func, N_func, gamma_u, gamma_t) { + times <- seq(from=t0,to=tmax, length.out=nstep) + usage_data <- sapply(times, usage_func) + beta_data <- sapply(times, beta_func) + N_data <- sapply(times, N_func) + dt <- times[2]-times[1] + + DF_out <- simulate_fast_nstrain( + n_strains, + I_0, + S_0, + usage_data, + beta_data, + N_data, + gamma_u, + gamma_t, + times, + dt) + return(DF_out) +} + +#' Simulate coalescent trees based on supplied trajectory +#' @param DF_in Simulated trajectory generated by simulate_epi +#' @param strain_idx Vector of strain indexes +#' @param samp_times Sampling times given as a time before present measured from simulation end point +#' @param n_samp number of samples taken at each sampling time +#' @export +simulate_phylos_nstrain <- function(DF_in, strain_idx, samp_times, n_samp) { + phys <- list() + + stopifnot(length(n_samp)==length(strain_idx)) + stopifnot(length(samp_times)==length(strain_idx)) + + for (i in c(1:length(strain_idx))) { + j <- strain_idx[i] + DF_s <- DF_in[,c(paste0(""I_"", j), ""inf_rate"", ""t"")] + colnames(DF_s) <- c(""I"", ""inf_rate"", ""t"") + phy <- simulate_coal_times2(DF_s, samp_times[[i]], n_samp[[i]]) + phys[[i]] <- build_coal_tree(phy$samp_times, phy$n_samp, phy$coal_times) + } + + return(phys) +} + +#' Simulate coalescent trees based on supplied trajectory +#' @param DF_in Simulated trajectory generated by simulate_epi +#' @param samp_times Sampling times given as a time before present measured from simulation end point +#' @param n_samp number of samples taken at each sampling time +#' @export +simulate_phylos <- function(DF_in, samp_times, n_samp) { + phys <- simulate_coal_times(DF_in, samp_times, n_samp) + + p_sus <- phys$phy_s + p_res <- phys$phy_r + + phy_sus <- build_coal_tree(p_sus$samp_times, p_sus$n_samp, p_sus$coal_times) + phy_res <- build_coal_tree(p_res$samp_times, p_res$n_samp, p_res$coal_times) + return(list(phy_sus=phy_sus, phy_res=phy_res)) +} + +#' Simulate coalescent process event times based on supplied trajectory +#' @param DF_in Dataframe with columns: I - the trajectory, inf_rate - the per capita infection rate, t - time +#' @param samp_times Sampling times given as a time before present measured from simulation end point +#' @param n_samp number of samples taken at each sampling time +#' @export +simulate_coal_times2 <- function(DF_in, samp_times, n_samp) { + t_min <- min(DF_in$t) + t_max <- max(DF_in$t) + + stopifnot(length(samp_times) == length(n_samp)) + + stopifnot(samp_times>=0) + stopifnot(samp_times<=(t_max-t_min)) + stopifnot(n_samp>0) + + eval_times <- DF_in$t + dt <- eval_times[2]-eval_times[1] + + Neg <- sapply((1:length(eval_times)), function(i) (DF_in$I[i])/(2*DF_in$inf_rate[i])) + + stopifnot(all(Neg>0)) + phy <- sim_coal(samp_times, n_samp, Neg, eval_times) + + return(phy) +} + + +#' Simulate coalescent process event times based on supplied trajectory +#' @param DF_in Simulated trajectory generated by simulate_epi +#' @param samp_times Sampling times given as a time before present measured from simulation end point +#' @param n_samp number of samples taken at each sampling time +#' @export +simulate_coal_times <- function(DF_in, samp_times, n_samp) { + t_min <- min(DF_in$t) + t_max <- max(DF_in$t) + + stopifnot(length(samp_times$sus) == length(n_samp$sus)) + stopifnot(length(samp_times$res) == length(n_samp$res)) + + stopifnot(samp_times$sus>=0) + stopifnot(samp_times$sus<=(t_max-t_min)) + stopifnot(samp_times$res>=0) + stopifnot(samp_times$res<=(t_max-t_min)) + stopifnot(n_samp$sus >0) + stopifnot(n_samp$res >0) + + + eval_times <- DF_in$t + dt <- eval_times[2]-eval_times[1] + + Neg_s <- sapply((1:length(eval_times)), function(i) (DF_in$I_s[i])/(2*DF_in$inf_rate[i])) + Neg_r <- sapply((1:length(eval_times)), function(i) (DF_in$I_r[i])/(2*DF_in$inf_rate[i])) + + stopifnot(all(Neg_s>0)) + stopifnot(all(Neg_r>0)) + phy_s <- sim_coal(samp_times$sus, n_samp$sus, Neg_s, eval_times) + phy_r <- sim_coal(samp_times$res, n_samp$res, Neg_r, eval_times) + + #phy_s <- coalsim(samp_times$sus, n_samp$sus, rev_time_step_func(Neg_s, t_min, t_max, dt), method=""thin"", lower_bound = min(Neg_s)) + #phy_r <- coalsim(samp_times$res, n_samp$res, rev_time_step_func(Neg_r, t_min, t_max, dt), method=""thin"", lower_bound = min(Neg_r)) + + return(list(phy_s=phy_s, phy_r=phy_r)) +} + +#Backwards time step function relative to t_max +#Arr should be in natural (forwards) time +rev_time_step_func <- function(arr, t_min, t_max, dt) { + upper <- t_max-t_min + n <- length(arr) + stopifnot(""t_max must be greater than t_min""=(upper > 0)) + stopifnot(abs(upper/dt+1-n) < 1e-6) + func_out <- function(t) { + if(t >= 0 && t < upper) { + index <- n-floor(t/dt) + stopifnot(index >= 1) + stopifnot(index <= n) + out <- arr[index] + } else { + out <- min(arr) + } + return(out) + } + return(func_out) +} + +","R" +"Pathogens","dhelekal/ResistPhy","tests/testthat/test.R",".R","10287","287","context(""Coalescent"") +test_that(""Native poisson thinning method agrees with phylodyn"",{ + set.seed(2) + samp_times <- seq(from=0.0, to=2, by=0.1) + n_samp <- 1+rbinom(length(samp_times), 20, 0.2) + t0 <- 1 + tmax <- 20 + Ne_func <- function(t) exp(0.3*t) * 0.1 + Ne_times <- seq(from=t0, to=tmax,length.out=1000) + Ne_vals <- sapply(Ne_times, Ne_func) + + dt <- Ne_times[2]-Ne_times[1] + ne_step_func <- rev_time_step_func(Ne_vals, t0, tmax, dt) + + set.seed(2) + res_phyd <- coalsim(samp_times, n_samp, ne_step_func, method=""thin"", lower_bound = min(Ne_vals)) + set.seed(2) + res_native <- sim_coal(samp_times, n_samp, Ne_vals, Ne_times) + + expect_equal(res_phyd$coal_times, res_native$coal_times) +}) + +context(""Utils"") +test_that(""Phylogeny exttraction and offsetting agrees on simulated data"", + { + set.seed(1) + samp_times <- seq(from=1.2, to=2, by=0.1) + n_samp <- 1+rbinom(length(samp_times), 20, 0.2) + mrt <- min(samp_times) + Ne_times <- seq(from=1, to=20, length.out=1000) + Ne_vals <- sapply(Ne_times, function(t) exp(0.3*t) * 0.1) + phy_sim <- sim_coal(samp_times, n_samp, Ne_vals, Ne_times) + tre <- build_coal_tree(phy_sim$samp_times, phy_sim$n_samp, phy_sim$coal_times) + phy_ext <- extract_phy(tre) + + expect_equal(phy_sim$samp_times, phy_ext$samp_times+mrt) + expect_equal(phy_sim$coal_times, phy_ext$coal_times+mrt) + expect_equal(phy_sim$n_samp, phy_ext$n_samp) + + phy_offs <- offset_extracted(phy_ext, mrt) + + expect_equal(phy_sim$samp_times, phy_offs$samp_times) + expect_equal(phy_sim$coal_times, phy_offs$coal_times) + expect_equal(phy_sim$n_samp, phy_offs$n_samp) + } +) + +test_that(""phy2poi correctly extracts coalescent times."", +{ + set.seed(34567) + t_begin <- 0 + t_end <- 10 + + samp_times <- seq(from=0, to=4, length.out=5) + mrst <- min(samp_times) + n_samp <- rnbinom(5, 5, 0.4) + offset <- .1 + phy <- sim_coal(samp_times, n_samp, c(10,10), c(t_begin, t_end)) + + tr <- build_coal_tree(phy$samp_times, phy$n_samp, phy$coal_times) + + ppp <- phy2poi(tr, mrst+offset, t_begin, t_end, max_dt=1e-2) + + At <- compute_At(phy$samp_times, + phy$n_samp, phy$coal_times, t_end) + + coal_idx <- which(ppp$poi_counts > 0) + process_times <- ppp$process_times + + process_times_scaled <- t_end-rescale_times(process_times, c(-1,1), c(t_begin, t_end)) + coal_times_scaled <- process_times_scaled[coal_idx] + coal_times_scaled <- coal_times_scaled[order(coal_times_scaled)] + phy_coal_truncated <- phy$coal_times[which(phy$coal_times <= t_end-t_begin)]+t_begin+offset + + expect_equal(coal_times_scaled, phy_coal_truncated) +}) + +test_that(""phy2poi correctly agrees on precomputed phylogeny"", +{ + t_begin <- 0 + t_end <- 4 + samp_times <- c(1,2,3.5) + n_samp <- c(4,6,2) + coal_times <- c(1.5, 2.5, 2.8, 3) + + At_vals <- c(4, 4, 3, 3, 9, 9, 8, 8, 7, 6, 6, 8, 8) + At_times <- c(1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.65, 2.8, 3, 3.25, 3.5, 3.75, 4) + poi_emits <- c(0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0) + wt <- c(.25, .25, .25, .25, .25, .25, .15, .15, .2, .25, .25, .25, .25) + + tr <- build_coal_tree(samp_times, n_samp, c(coal_times, seq(from=4.1, to=6, length.out=7))) + ppp <- phy2poi(tr, 1.0, t_begin, t_end, max_dt=0.125) + + + ppp$process_times <- t_end - rescale_times(ppp$process_times, c(-1,1), c(0,4)) + ppp$lineage_counts <- ppp$lineage_counts[order(ppp$process_times)] + ppp$poi_counts <- ppp$poi_counts[order(ppp$process_times)] + ppp$holding_times <- ppp$holding_times[order(ppp$process_times)]*2 + ppp$process_times <- ppp$process_times [order(ppp$process_times)] + + expect_equal(ppp$process_times , At_times) + expect_equal(ppp$lineage_counts, At_vals) + expect_equal(ppp$poi_counts, poi_emits) + expect_equal(ppp$holding_times, wt) +}) + +test_that(""Approximate model likelihood equals exact likelihood for constant eff. pop. size"", +{ + set.seed(34567) + t_begin <- 0 + t_end <- 10 + + span <- t_end-t_begin + + samp_times <- seq(from=0, to=4, length.out=5) + mrst <- min(samp_times) + n_samp <- rnbinom(5, 5, 0.4) + phy <- sim_coal(samp_times, n_samp, c(10,10), c(t_begin, t_end)) + + log_lh_coal <- 0 + inv_Ne <- 5 + s_idx <- 2 + c_idx <- 1 + n <- length(phy$samp_times) + m <- length(phy$coal_times) + t <- phy$samp_times[1] + lins <- phy$n_samp[1] + + scale_factor <- (t_end-t_begin)/2 + + while (c_idx <= m) { + if (s_idx <= n && + phy$samp_times[s_idx] < phy$coal_times[c_idx]){ + + t_next <- phy$samp_times[s_idx] + lins_next <- lins + n_samp[s_idx] + s_idx_next <- s_idx + 1 + c_idx_next <- c_idx + sampling_evt <- TRUE + } else { + t_next <- phy$coal_times[c_idx] + lins_next <- lins - 1 + s_idx_next <- s_idx + c_idx_next <- c_idx + 1 + sampling_evt <- FALSE + } + + if (t_next < span) { + log_lh_coal <- log_lh_coal - 0.5*lins*(lins-1)*(t_next-t)*inv_Ne + if (!sampling_evt) { + log_lh_coal <- log_lh_coal + log(0.5*lins*(lins-1)*inv_Ne) + } + s_idx <- s_idx_next + c_idx <- c_idx_next + lins <- lins_next + t <- t_next + } else { + log_lh_coal <- log_lh_coal - 0.5*lins*(lins-1)*(span-t)*inv_Ne + break + } + } + tr <- build_coal_tree(phy$samp_times, phy$n_samp, phy$coal_times) + ppp <- phy2poi(tr, mrst, t_begin, t_end, max_dt=1e-3) + + n1 <- length(ppp$lineage_counts) + + rates_ppp <- sapply(c(1:n1), function(i) (log(0.5*(ppp$lineage_counts[i])*(ppp$lineage_counts[i]-1))+log(inv_Ne))) + log_lh_ppp <- -sum(exp(rates_ppp+log(ppp$holding_times)+log(scale_factor))) + sum(rates_ppp[which(ppp$poi_counts > 0.5)]) + + expect_equal(log_lh_ppp, log_lh_coal) +}) + +test_that(""Approximate model likelihood is invariant to mesh refinement under constant rate"", +{ + set.seed(34567) + t_begin <- 0 + t_end <- 10 + + samp_times <- seq(from=0, to=4, length.out=5) + mrst <- min(samp_times) + n_samp <- rnbinom(5, 5, 0.4) + offset <- .1 + phy <- sim_coal(samp_times, n_samp, c(10,10), c(t_begin, t_end)) + + tr <- build_coal_tree(phy$samp_times, phy$n_samp, phy$coal_times) + + ppp1 <- phy2poi(tr, mrst+offset, t_begin, t_end, max_dt=1e-3) + ppp2 <- phy2poi(tr, mrst+offset, t_begin, t_end, max_dt=1e-4) + + n1 <- length(ppp1$lineage_counts) + n2 <- length(ppp2$lineage_counts) + C <- 5 + + rates1 <- sapply(c(1:n1), function(i) log(0.5*(ppp1$lineage_counts[i])*(ppp1$lineage_counts[i]-1))+log(C)) + log_lh1 <- -sum(exp(rates1+log(ppp1$holding_times))) + sum(rates1[which(ppp1$poi_counts > 0.5)]) + + rates2 <- sapply(c(1:n2), function(i) log(0.5*(ppp2$lineage_counts[i])*(ppp2$lineage_counts[i]-1))+log(C)) + log_lh2 <- -sum(exp(rates2+log(ppp2$holding_times))) + sum(rates2[which(ppp2$poi_counts > 0.5)]) + + expect_equal(log_lh1, log_lh2) +}) + +test_that(""Trajectory interpolation returns correct values"", { + usage_df <- simulated_usage() + t0 <- min(usage_df$time) + tmax <- max(usage_df$time) + usage_f <- yearly_usg_stepfunc(usage_df$usage, usage_df$time) + + N <- 3e7 + incidence <- 1.8e6 / N + gamma_sus <- 1/12.0*365.0 + mu <- incidence+gamma_sus + r0 <- mu/(gamma_sus) + gamma_res_u <- 1/11.8*365.0 + gamma_res_t <- 1/12.3*365.0 + + end_eq <- (1-1/r0)*N + I_s0 <- 1*end_eq/11 + I_r0 <- 1*end_eq/11 + u0 <- list(S=N-I_s0-I_r0, I_s=I_s0, I_r=I_r0) + + beta_func <- function (t) if(t < (t0+(tmax-t0)/2)) mu*0.998 else mu * 1.002 + n_step <- 1e3 + df <- simulate_epi_nstrain(t0, tmax, n_step, n_strains=2, S_0 = unlist(u0[1]), I_0 = unlist(u0[2:3]), usage_f, beta_func, function(t) N, gamma_u=c(gamma_sus, gamma_res_u), gamma_t=c(gamma_sus, gamma_res_t)) + + eval_times <- df$t + dt <- eval_times[2]-eval_times[1] + + span <- max(eval_times) - min(eval_times) + + k <- length(eval_times) + Neg_s <- sapply((1:k), function(i) (df$I_s[i]^2)/(2*df$births_I_s[i]/dt)) + Neg_r <- sapply((1:k), function(i) (df$I_r[i]^2)/(2*df$births_I_r[i]/dt)) + + test_times <- eval_times-min(eval_times)+0.5*dt ## times to test against. + ## Add 0.5dt so that these don't precisely correspond to knots + ## Backwards time relative to present, i.e. 0 = present + ## Should have the f(test_times[i]) == Neg[k-i+1] + + f1 <- rev_time_step_func(Neg_s, t0, tmax, dt) + f2 <- rev_time_step_func(Neg_r, t0, tmax, dt) + + a1 <- sapply((1:(k-1)), function(i) Neg_s[k-i+1]) + a2 <- sapply((1:(k-1)), function(i) Neg_r[k-i+1]) + + s1 <- sapply(test_times[1:(k-1)], f1) + s2 <- sapply(test_times[1:(k-1)], f2) + + expect_equal(a1, s1, tolerance=1e-10) + expect_equal(a2, s2, tolerance=1e-10) +}) + +test_that(""Simulation usage interpolation function agrees with model interpolation"", { + + stan_mod <- cmdstan_model(system.file('stan', + 'test_interpolation.stan', + package='ResistPhy', + mustWork = T), + include_paths=system.file('stan',package='ResistPhy'), + compile=F) + + stan_mod$compile() + usage_df <- simulated_usage() + + N <- 1000 + t0 <- min(usage_df$time) + tmax <- max(usage_df$time) + + t_eval <- seq(from=t0, to=tmax, length.out=N) + + usage_f <- yearly_usg_stepfunc(usage_df$usage, usage_df$time) + + dat <- list(M=length(usage_df$time), + N=N, + ABX_usage=usage_df$usage, + usage_ts=usage_df$time, + eval_ts=t_eval) + + stan_interp <- stan_mod$sample(data=dat, + iter_warmup=0, iter_sampling=1, chains=1, seed=494838, + fixed_param =T, refresh=1) + + ddf<-as_draws_df(stan_interp$draws()) + stan_res <- sapply(c(1:N), function(i) ddf[[paste0(""usage_interp["",i,""]"")]]) + r_res <- sapply(t_eval, usage_f) + expect_equal(stan_res,r_res, tolerance=1e-6) +})","R" +"Pathogens","cov-lineages/pangolin","setup.py",".py","1091","37","from setuptools import setup, find_packages +import glob +import os +import pkg_resources + +from pangolin import __version__, _program + +setup(name='pangolin', + version=__version__, + packages=find_packages(), + scripts=[ + 'pangolin/scripts/pangolearn.smk', + 'pangolin/scripts/usher.smk', + 'pangolin/scripts/preprocessing.smk' + ], + package_data={""pangolin"":[""data/*""]}, + install_requires=[ + ""biopython>=1.70"", + 'pandas>=1.0.1', + ""wheel>=0.34"", + 'joblib>=0.11', + # 'tabulate==0.8.10', + 'scikit-learn>=0.23.1', + ""PuLP>=2"" + ], + description='phylogenetic assignment of named global outbreak lineages', + url='https://github.com/cov-lineages/pangolin', + author='Aine OToole & Emily Scher', + author_email='aine.otoole@ed.ac.uk', + entry_points="""""" + [console_scripts] + {program} = pangolin.command:main + """""".format(program = _program), + include_package_data=True, + keywords=[], + zip_safe=False) +","Python" +"Pathogens","cov-lineages/pangolin","TESTING.md",".md","957","18","### Notes on Pangolin Testing + +The pangolin repository uses [Github Actions](https://github.com/features/actions) to provide continuous +integration testing. The files for this are in [.github/workflows]. + +#### Testing philosophy + +The [.github/workflows/pangolin.yml] workflow does an install of pangolin followed by a simple run to +test that the tool is working. Tests can be added to that file to validate the output of the pangolin command. +This is essentially a functional test for the tool. + +The test currently runs on every single pull request or push. It could be optimised, for example, to only +respond to action on some branches, or to do a check of which files have been changed before firing off the +complete testing workflow. For example, one should not need to test the pangolin tool if the only thing that +has changed is the README.md. + +Also left as work for the future is a unit testing framework to test the components that make up pangolin. +","Markdown" +"Pathogens","cov-lineages/pangolin","CODE_OF_CONDUCT.md",".md","3352","77","# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at aine.otoole@ed.ac.uk. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq +","Markdown" +"Pathogens","cov-lineages/pangolin","pangolin/command.py",".py","15536","262","#!/usr/bin/env python3 +from . import _program +from pangolin import __version__ +from pangolin.utils import data_checks +try: + import pangolin_data +except ImportError: + data_checks.install_error(""pangolin_data"", ""https://github.com/cov-lineages/pangolin-data.git"") + +try: + import scorpio +except ImportError: + data_checks.install_error(""scorpio"", ""https://github.com/cov-lineages/scorpio.git"") + +try: + import constellations +except ImportError: + data_checks.install_error(""constellations"", ""https://github.com/cov-lineages/constellations.git"") + +import os +import sys +import argparse + +try: + import snakemake +except: + sys.stderr.write(cyan(f'Error: package `{snakemake}` not found, please install snakemake or update pangolin environment.\n')) + sys.exit(-1) + + +from pangolin.utils.log_colours import green,cyan +from pangolin.utils import dependency_checks + +from pangolin.utils import update + + +from pangolin.utils.config import * +from pangolin.utils.initialising import * +import pangolin.utils.io_parsing as io + +from pangolin.utils.report_collation import generate_final_report,get_voc_list + +thisdir = os.path.abspath(os.path.dirname(__file__)) +cwd = os.getcwd() + + +def main(sysargs = sys.argv[1:]): + parser = argparse.ArgumentParser(prog = _program, + description='pangolin: Phylogenetic Assignment of Named Global Outbreak LINeages', + usage='''pangolin [options]''') + + io_group = parser.add_argument_group('Input-Output options') + io_group.add_argument('query', nargs=""*"", help='Query fasta file of sequences to analyse.') + io_group.add_argument('-o','--outdir', action=""store"",help=""Output directory. Default: current working directory"") + io_group.add_argument('--outfile', action=""store"",help=""Optional output file name. Default: lineage_report.csv"") + io_group.add_argument('--tempdir',action=""store"",help=""Specify where you want the temp stuff to go. Default: $TMPDIR"") + io_group.add_argument(""--no-temp"",action=""store_true"",help=""Output all intermediate files, for dev purposes."") + io_group.add_argument('--alignment', action=""store_true"",help=""Output multiple sequence alignment."") + io_group.add_argument('--alignment-file', action=""store"",help=""Multiple sequence alignment file name."") + io_group.add_argument('--expanded-lineage', action=""store_true"", default=False, help=""Optional expanded lineage from alias.json in report."") + + + a_group = parser.add_argument_group('Analysis options') + a_group.add_argument('--analysis-mode', action=""store"",help=""""""Pangolin includes multiple analysis engines: UShER and pangoLEARN. +Scorpio is used in conjunction with pangoLEARN to curate variant of concern (VOC)-related lineage calls. +UShER is the default and is selected using option ""usher"" or ""accurate"". +pangoLEARN has been depreciated, but older models can be run using ""pangolearn"" or ""fast"" with ""--datadir"" provided. +Finally, it is possible to skip the UShER/ pangoLEARN step by selecting ""scorpio"" mode, but in this case only VOC-related lineages will be assigned. +"""""") + + a_group.add_argument(""--skip-designation-cache"", action='store_true', default=False, help=""Developer option - do not use designation cache to assign lineages."",dest=""skip_designation_cache"") + a_group.add_argument(""--skip-scorpio"", action='store_true', default=False, help=""Developer option - do not use scorpio to check VOC/VUI lineage assignments."",dest=""skip_scorpio"") + + a_group.add_argument('--max-ambig', action=""store"", type=float,help=""Maximum proportion of Ns allowed for pangolin to attempt assignment. Default: 0.3"",dest=""maxambig"") + a_group.add_argument('--min-length', action=""store"", type=int,help=""Minimum query length allowed for pangolin to attempt assignment. Default: 25000"",dest=""minlen"") + a_group.add_argument('--usher', action='store_true', default=False, help=argparse.SUPPRESS) + + d_group = parser.add_argument_group('Data options') + d_group.add_argument(""--update"", action='store_true', default=False, help=""Automatically updates to latest release of pangolin, pangolin-data, scorpio and constellations (and pangolin-assignment if it has been installed using --add-assignment-cache), then exits."") + d_group.add_argument(""--update-data"", action='store_true',dest=""update_data"", default=False, help=""Automatically updates to latest release of constellations and pangolin-data, including the pangoLEARN model, UShER tree file and alias file (also pangolin-assignment if it has been installed using --add-assignment-cache), then exits."") + d_group.add_argument('--add-assignment-cache', action='store_true', dest=""add_assignment_cache"", default=False, help=""Install the pangolin-assignment repository for use with --use-assignment-cache. This makes updates slower and makes pangolin slower for small numbers of input sequences but much faster for large numbers of input sequences."") + d_group.add_argument('--use-assignment-cache', action='store_true', dest=""use_assignment_cache"", default=False, help=""Use assignment cache from optional pangolin-assignment repository. NOTE: the repository must be installed by --add-assignment-cache before using --use-assignment-cache."") + d_group.add_argument('-d', '--datadir', action='store',dest=""datadir"",help=""Data directory minimally containing the pangoLEARN model and header files or UShER tree. Default: Installed pangolin-data package."") + d_group.add_argument('--use-old-datadir', action='store_true', default=False, help=""Use the data from data directory even if older than data installed via Python packages. Default: False"") + d_group.add_argument('--usher-tree', action='store', dest='usher_protobuf', help=""UShER Mutation Annotated Tree protobuf file to use instead of default from pangolin-data repository or --datadir."") + d_group.add_argument('--assignment-cache', action='store', dest='assignment_cache', help=""Cached precomputed assignment file to use instead of default from pangolin-assignment repository. Does not require installation of pangolin-assignment."") + + m_group = parser.add_argument_group('Misc options') + m_group.add_argument(""--aliases"", action='store_true', default=False, help=""Print Pango alias_key.json and exit."") + m_group.add_argument(""-v"",""--version"", action='version', version=f""pangolin {__version__}"") + m_group.add_argument(""-pv"",""--pangolin-data-version"", action='version', version=f""pangolin-data {pangolin_data.__version__}"",help=""show version number of pangolin data files (UShER tree and pangoLEARN model files) and exit."") + m_group.add_argument(""--all-versions"", action='store_true',dest=""all_versions"", default=False, help=""Print all tool, dependency, and data versions then exit."") + m_group.add_argument(""--verbose"",action=""store_true"",help=""Print lots of stuff to screen"") + m_group.add_argument(""-t"",""--threads"",action=""store"",default=1,type=int, help=""Number of threads"") + + + if len(sysargs)<1: + parser.print_help() + sys.exit(-1) + else: + args = parser.parse_args(sysargs) + + # Initialise config dict + config = setup_config_dict(cwd) + data_checks.check_install(config) + set_up_verbosity(config) + config[KEY_ANALYSIS_MODE] = set_up_analysis_mode(args.analysis_mode, config[KEY_ANALYSIS_MODE]) + + if args.usher: + sys.stderr.write(cyan(f""--usher is a pangolin v3 option and is deprecated in pangolin v4. UShER is now the default analysis mode. Use --analysis-mode to explicitly set mode.\n"")) + if config[KEY_ANALYSIS_MODE] == ""pangolearn"" or config[KEY_ANALYSIS_MODE] == ""fast"": + if args.datadir: + args.use_old_datadir = True + else: + sys.stderr.write(cyan(f""pangoLEARN is deprecated in pangolin v4.3. UShER is now the only updated analysis mode. Use --datadir to provide an older pangoLEARN model.\n"")) + config[KEY_ANALYSIS_MODE] = ""usher"" + + setup_data(args.datadir,config[KEY_ANALYSIS_MODE], config, args.use_old_datadir) + + if args.add_assignment_cache: + update.install_pangolin_assignment(config[KEY_PANGOLIN_ASSIGNMENT_VERSION], args.datadir) + + if args.update: + version_dictionary = {'pangolin': __version__, + 'pangolin-data': config[KEY_PANGOLIN_DATA_VERSION], + 'constellations': config[KEY_CONSTELLATIONS_VERSION], + 'scorpio': config[KEY_SCORPIO_VERSION]} + if config[KEY_PANGOLIN_ASSIGNMENT_VERSION] is not None: + version_dictionary['pangolin-assignment'] = config[KEY_PANGOLIN_ASSIGNMENT_VERSION] + update.update(version_dictionary) + + if args.update_data: + version_dictionary = {'pangolin-data': config[KEY_PANGOLIN_DATA_VERSION], + 'constellations': config[KEY_CONSTELLATIONS_VERSION]} + if config[KEY_PANGOLIN_ASSIGNMENT_VERSION] is not None: + version_dictionary['pangolin-assignment'] = config[KEY_PANGOLIN_ASSIGNMENT_VERSION] + update.update(version_dictionary, args.datadir) + + # install_pangolin_assignment doesn't exit so that --update/--update-data can be given at the + # same time (or a query file). If --add-assignment-cache is the only arg, exit without error. + if args.add_assignment_cache and not args.query: + sys.exit(0) + + # add flag to config for whether to run scorpio + if args.skip_scorpio: + print(green(f""****\nPangolin skipping scorpio steps.\n****"")) + config[KEY_SKIP_SCORPIO] = True + + if args.expanded_lineage: + print(green(f""****\nAdding expanded lineage column to output.\n****"")) + config[KEY_EXPANDED_LINEAGE] = True + + snakefile = get_snakefile(thisdir,config[KEY_ANALYSIS_MODE]) + + config[KEY_DESIGNATION_CACHE],config[KEY_ALIAS_FILE] = data_checks.find_designation_cache_and_alias(config[KEY_DATADIR],DESIGNATION_CACHE_FILE,ALIAS_FILE) + if args.aliases: + print_alias_file_exit(config[KEY_ALIAS_FILE]) + + if args.all_versions: + print_versions_exit(config) + + # to enable not having to pass a query if running update + # by allowing query to accept 0 to many arguments + + print(green(f""****\nPangolin running in {config[KEY_ANALYSIS_MODE]} mode.\n****"")) + if config[KEY_ANALYSIS_MODE] == ""scorpio"": + print(cyan(f""Warning: in `scorpio` mode only variants of concern (VOCs) defined in constellations can be assigned. `Version` column corresponds to constellation_version.\n"")) + + print_ram_warning(config[KEY_ANALYSIS_MODE]) + +# setup outdir and outfiles + config[KEY_OUTDIR] = io.set_up_outdir(args.outdir,cwd,config[KEY_OUTDIR]) + config[KEY_OUTFILE] = io.set_up_outfile(args.outfile, config[KEY_OUTFILE],config[KEY_OUTDIR]) + io.set_up_tempdir(args.tempdir,args.no_temp,cwd,config[KEY_OUTDIR], config) + config[KEY_ALIGNMENT_FILE],config[KEY_ALIGNMENT_OUT] = io.parse_alignment_options(args.alignment, config[KEY_OUTDIR], config[KEY_TEMPDIR],args.alignment_file, config[KEY_ALIGNMENT_FILE]) + parse_qc_thresholds(args.maxambig, args.minlen, config[KEY_REFERENCE_FASTA], config) + config[KEY_QUERY_FASTA] = io.find_query_file(cwd, config[KEY_TEMPDIR], args.query) + + config[KEY_INPUT_COMPRESSION_TYPE] = io.quick_check_query_file(cwd, args.query, config[KEY_QUERY_FASTA]) + + if config[KEY_ANALYSIS_MODE] == ""usher"": + # Find usher protobuf file (and if specified, assignment cache file too) + data_checks.get_datafiles(config[KEY_DATADIR],usher_files,config) + if args.usher_protobuf: + config[KEY_USHER_PB] = data_checks.check_file_arg(args.usher_protobuf, cwd, '--usher-tree') + print(green(f""Using usher tree file {args.usher_protobuf}"")) + if args.assignment_cache: + config[KEY_ASSIGNMENT_CACHE] = data_checks.check_file_arg(args.assignment_cache, cwd, '--assignment-cache') + print(green(f""Using assignment cache file {args.assignment_cache}"")) + elif args.use_assignment_cache: + config[KEY_ASSIGNMENT_CACHE] = data_checks.get_assignment_cache(USHER_ASSIGNMENT_CACHE_FILE, config) + print(green(""Using pangolin-assignment cache"")) + else: + config[KEY_ASSIGNMENT_CACHE] = """" + + elif config[KEY_ANALYSIS_MODE] == ""pangolearn"": + # find designation cache and the model files + data_checks.get_datafiles(config[KEY_DATADIR],pangolearn_files,config) + if args.use_assignment_cache or args.assignment_cache: + sys.stderr.write(cyan(f""Warning: --use-assignment-cache and --assignment-cache are ignored when --analysis-mode is 'fast' or 'pangolearn'.\n"")) + + preprocessing_snakefile = get_snakefile(thisdir,""preprocessing"") + + if args.verbose: + print(green(""\n**** CONFIG ****"")) + for k in sorted(config): + print(green(k), config[k]) + + status = snakemake.snakemake(preprocessing_snakefile, printshellcmds=True, forceall=True, force_incomplete=True, + workdir=config[KEY_TEMPDIR],config=config, cores=args.threads,lock=False + ) + else: + logger = custom_logger.Logger() + status = snakemake.snakemake(preprocessing_snakefile, printshellcmds=False, forceall=True,force_incomplete=True,workdir=config[KEY_TEMPDIR], + config=config, cores=args.threads,lock=False,quiet=True,log_handler=logger.log_handler + ) + if status: + if config[KEY_ANALYSIS_MODE] != ""scorpio"": + if config[KEY_VERBOSE]: + print(green(""\n**** CONFIG ****"")) + for k in sorted(config): + print(green(k), config[k]) + + status = snakemake.snakemake(snakefile, printshellcmds=True, forceall=True, force_incomplete=True, + workdir=config[KEY_TEMPDIR],config=config, cores=args.threads,lock=False + ) + else: + logger = custom_logger.Logger() + status = snakemake.snakemake(snakefile, printshellcmds=False, forceall=True,force_incomplete=True,workdir=config[KEY_TEMPDIR], + config=config, cores=args.threads,lock=False,quiet=True,log_handler=logger.log_handler + ) + else: + status = True + + if status: + + ## Collate the report here + + preprocessing_csv = os.path.join(config[KEY_TEMPDIR],""preprocessing.csv"") + inference_csv = os.path.join(config[KEY_TEMPDIR],""inference_report.csv"") + cached_csv = os.path.join(config[KEY_TEMPDIR],""cache_assigned.csv"") + constellation_list = get_voc_list(os.path.join(config[KEY_TEMPDIR], ""get_constellations.txt""), config[KEY_ALIAS_FILE]) + + generate_final_report(preprocessing_csv, inference_csv, cached_csv, config[KEY_ALIAS_FILE], constellation_list, config[KEY_PANGOLIN_DATA_VERSION],config[KEY_ANALYSIS_MODE], args.skip_designation_cache, config[KEY_OUTFILE],config) + + print(green(f""****\nOutput file written to: "") + config[KEY_OUTFILE]) + + if config[KEY_ALIGNMENT_OUT]: + print(green(f""****\nOutput alignment written to: "") + config[KEY_ALIGNMENT_FILE]) + + io.cleanup(args.no_temp,config[KEY_TEMPDIR]) + + return 0 + + io.cleanup(args.no_temp,config[KEY_TEMPDIR]) + return 1 + io.cleanup(args.no_temp,config[KEY_TEMPDIR]) + return 1 + +if __name__ == '__main__': + main() +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/__init__.py",".py","108","9","_program = ""pangolin"" +__version__ = ""4.3.4"" + + +__all__ = [""pangolearn"", + ""utils""] + +from pangolin import * +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/data_checks.py",".py","5292","127","#!/usr/bin/env python3 +import pkg_resources +from pangolin.utils.log_colours import green,cyan,red +import sys +import os +import gzip + +from pangolin.utils.config import * + +def package_data_check(filename,directory,key,config): + try: + package_datafile = os.path.join(directory,filename) + data = pkg_resources.resource_filename('pangolin', package_datafile) + config[key] = data + except: + sys.stderr.write(cyan(f'Error: Missing package data.')+f'\n\t- {filename}\nPlease install the latest pangolin version with `pangolin --update`.\n') + sys.exit(-1) + + +def check_install(config): + resources = [ + {""key"":""reference_fasta"", + ""directory"":""data"", + ""filename"":""reference.fasta""} + ] + for resource in resources: + package_data_check(resource[""filename""],resource[""directory""],resource[""key""],config) + +def find_designation_cache_and_alias(datadir,designation_cache_file,alias_file): + designation_cache = """" + alias = """" + for r,d,f in os.walk(datadir): + for fn in f: + if fn == designation_cache_file: + designation_cache = os.path.join(r, fn) + elif fn == alias_file: + alias = os.path.join(r, fn) + if designation_cache == """": + sys.stderr.write(cyan(f'Error: Missing designation cache file. Either supply a datadir with a {designation_cache_file} file, or specify `--skip-designation-cache`\n')) + sys.exit(-1) + elif alias == """": + sys.stderr.write(cyan(f'Error: Missing alias file. Please supply a datadir with a {alias_file} file or check installation of pangolin-data dependency.\n')) + sys.exit(-1) + return designation_cache,alias + +def check_file_arg(arg_file, cwd, description): + if arg_file: + file_path = os.path.join(cwd, arg_file) + if not os.path.exists(file_path): + sys.stderr.write(f""Error: cannot find {description} file at {file_path}\n"") + sys.exit(-1) + return file_path + +def get_datafiles(datadir,file_dict,config): + datafiles = {} + for r,d,f in os.walk(datadir): + for fn in f: + if fn in file_dict: + datafiles[file_dict[fn]] = os.path.join(r, fn) + for fn in datafiles: + config[fn] = datafiles[fn] + for fn in file_dict: + if file_dict[fn] not in config: + sys.stderr.write(cyan(f'Error: Cannot find {fn} in datadir. Please supply a datadir with required files or specify an alternative analysis mode.\nPlease see https://cov-lineages.org/pangolin.html for full installation and updating instructions.')) + sys.exit(-1) + + print(green(""****\nData files found:"")) + for fn in datafiles: + print(f""{fn}:\t{datafiles[fn]}"") + config[fn] = datafiles[fn] + print(green(""****"")) + + +def install_error(package, url): + sys.stderr.write(cyan(f'Error: please install `{package}` with \n') + + f""pip install git+{url}\n"") + sys.exit(-1) + + +def get_assignment_cache(cache_file, config): + cache = """" + if config[KEY_PANGOLIN_ASSIGNMENT_VERSION] is not None: + pangolin_assignment_dir = config[KEY_PANGOLIN_ASSIGNMENT_PATH] + for r, d, f in os.walk(pangolin_assignment_dir): + for fn in f: + if fn == cache_file and cache == """": + cache = os.path.join(r, fn) + if not os.path.exists(cache): + sys.stderr.write(cyan(f'Error: cannot find assignment cache file {cache_file} in pangolin_assignment\n')) + sys.exit(-1) + else: + sys.stderr.write(cyan('\nError: ""pangolin --add-assignment-cache"" is required before ' + '""pangolin --use-assignment-cache"", in order to install optional ' + 'pangolin-assignment repository (that will make future data updates slower).\n')) + sys.exit(-1) + + # Check versions of pangolin-data and pangolin-assignment to make sure they are consistent. + if config[KEY_PANGOLIN_ASSIGNMENT_VERSION].lstrip('v') != config[KEY_PANGOLIN_DATA_VERSION].lstrip('v'): + print(cyan(f'Error: pangolin_assignment cache version {config[KEY_PANGOLIN_ASSIGNMENT_VERSION]} ' + f'does not match pangolin_data version {config[KEY_PANGOLIN_DATA_VERSION]}. ' + 'Run ""pangolin --update-data"" to fetch latest versions of both.')) + sys.exit(-1) + + try: + with gzip.open(cache, 'rt') as f: + line = f.readline() + except: + with open(cache, 'r') as f: + line = f.readline() + if ""git-lfs.github.com"" in line: + sys.stderr.write(cyan( + 'Error: Git LFS file not pulled successfully. Please install git-lfs \nusing conda or an alternative (not pip) then re-install pangolin-assignment \nwith pip install git+https://github.com/cov-lineages/pangolin-assignment.git\n') + ) + sys.exit(-1) + return cache + +def get_constellation_files(path): + constellation_files = [] + for r, _, f in os.walk(path): + for fn in f: + if (r.endswith('/constellations') or r.endswith('/constellations/definitions')) and fn.endswith('.json'): + constellation_files.append(os.path.join(r, fn)) + return constellation_files + +# config={} +# check_install() +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/update.py",".py","6811","157","#!/usr/bin/env python + +import os +import sys +import json +import shutil +import tarfile +import subprocess +from urllib import request +from distutils.version import LooseVersion +from tempfile import TemporaryDirectory, tempdir + +from pangolin.utils.log_colours import green,cyan,red + +version_dict_keys = ['pangolin', 'scorpio', 'pangolin-data', 'constellations', 'pangolin-assignment'] + + +def get_latest_release(dependency): + """""" + Using the github releases API check for the latest release of dependency and its tarball + """""" + try: + latest_release = request.urlopen( + f""https://api.github.com/repos/cov-lineages/{dependency}/releases"") + # to catch and give a useful error message when people try to run this + # either update option on clusters without external connectivity + # or have exceeded the github API limit temporarily + # this may also catch genuine bugs when version and release tags diverge + # so if this is thrown and there is definitely connectivity then + # double check the version labels + except Exception as e: + sys.stderr.write(cyan(""Unable to connect to reach github API "" + ""--update/--data_update requires internet "" + ""connectivity so may not work on certain "" + ""systems or if your IP has exceeded the "" + f""5,000 request per hour limit\n{e}\n"")) + sys.exit(-1) + + latest_release = json.load(latest_release) + try: + # Find the latest stable release + latest_release_dict = next(x for x in latest_release if not x['draft'] and not x['prerelease']) + except: + # All releases to date are prerelease or draft, just take the latest + latest_release_dict = latest_release[0] + latest_release_tarball = latest_release_dict['tarball_url'] + # extract and clean up latest release version + latest_release = latest_release_dict['tag_name'] + return latest_release, latest_release_tarball + + +def git_lfs_install(): + """""" + 'git-lfs install' must be run after installing git-lfs and before cloning a repo + that uses Git LFS. + """""" + try: + subprocess.run(['git-lfs', 'install'], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + except subprocess.CalledProcessError as e: + stderr = e.stderr.decode('utf-8') + sys.stderr.write(cyan(f""Error: {e}:\n{stderr}\n"")) + sys.exit(-1) + +def pip_install_dep(dependency, release, datadir=None): + """""" + Use pip install to install a cov-lineages repository with the specificed release + """""" + url = f""git+https://github.com/cov-lineages/{dependency}.git@{release}"" + pip_command = [sys.executable, '-m', 'pip', 'install', '--upgrade'] + if datadir is not None: + pip_command.extend(['--target', datadir]) + pip_command.append(url) + subprocess.run(pip_command, + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + + +def install_pangolin_assignment(pangolin_assignment_version, datadir=None): + """""" + If the pangolin-assignment repo has not been installed already then install the latest release. + """""" + if pangolin_assignment_version is not None: + print(f""pangolin-assignment already installed with version {pangolin_assignment_version}; use --update or --update-data if you wish to update it."", file=sys.stderr) + else: + git_lfs_install() + latest_release, tarball = get_latest_release('pangolin-assignment') + pip_install_dep('pangolin-assignment', latest_release, datadir) + print(f""pangolin-assignment installed with latest release ({latest_release})"") + +def update(version_dictionary, data_dir=None): + """""" + Using the github releases API check for the latest current release + of the set of dependencies provided e.g., pangolin, scorpio, pangolin-data and + constellations for complete --update and just pangolearn and constellations + for --update_data. If pangolin-assignment has been added to the installation + then it will be included in both --update and --update-data. + + Dictionary keys must be one of pangolin, scorpio, pangolin-data, constellations + or pangolin-assignment + + Compare these to the currently running versions and if newer releases + exist update to them accordingly (or do nothing if current). + Afterwards, exit program safely with a 0 exit code. + + version_dictionary: dictionary keyed with dependency names and version for + that dependency + e.g. + {pangolin: string containing the __version__ data for the currently + running pangolin module + pangolin-data: string containing the __version__ data for the imported + pangolin-data module + scorpio: string containing the __version__ data for the imported + scorpio module + constellations: string containing the __version__ data for the imported + constellations data module} + + """""" + package_names = {'pangolin-data': 'pangolin_data', + 'pangolin-assignment': 'pangolin_assignment' + } + + # flag if any element is update if everything is the latest release + # we want to just continue running + for dependency, version in version_dictionary.items(): + + latest_release, latest_release_tarball = get_latest_release(dependency) + latest_release_tidied = latest_release.strip('data release').lstrip('v').strip() + latest_release_tidied = LooseVersion(latest_release_tidied) + + # clean up version numbers to remove leading v's and ""data release"" + version = version.strip('data release').lstrip('v').strip() + if dependency not in version_dict_keys: + + raise ValueError(""Dependency name for auto-update must be one of: '"" + + ""', '"".join(version_dict_keys) + ""'"") + + # convert to LooseVersion to have proper ordering of versions + # this prevents someone using the latest commit/HEAD from being + # downgraded to the last stable release + version = LooseVersion(version) + + if version < latest_release_tidied: + pip_install_dep(dependency, latest_release, data_dir) + print(f""{dependency} updated to {latest_release}"", file=sys.stderr) + elif version > latest_release_tidied: + print(f""{dependency} ({version}) is newer than latest stable "" + f""release ({latest_release}), not updating."", file=sys.stderr) + else: + print(f""{dependency} already latest release ({latest_release})"", + file=sys.stderr) + sys.exit(0) + +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/__init__.py",".py","0","0","","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/initialising.py",".py","10297","255","import os +import sys +import itertools +import re +import subprocess +from distutils.version import LooseVersion +from Bio import SeqIO + +import pangolin.utils.custom_logger as custom_logger +from pangolin.utils.log_colours import green,cyan +from pangolin.utils.config import * +from pangolin.utils.data_checks import * +from pangolin import __version__ + +import pangolin_data +class PangolinAssignmentWrapper(): + __version__ = None + __path__ = [None] +try: + import pangolin_assignment +except ImportError: + # if we can't import the module, leave the variables we replace it with a mock with suitable attributes + pangolin_assignment = PangolinAssignmentWrapper() +import scorpio +import constellations + +def setup_config_dict(cwd): + default_dict = { + KEY_ANALYSIS_MODE:""usher"", #options: accurate, fast, usher, pangolearn + + KEY_DESIGNATION_CACHE: """", + + KEY_QUERY_FASTA:None, + + KEY_OUTDIR:cwd, + KEY_OUTFILE:""lineage_report.csv"", + + KEY_ALIGNDIR: cwd, + KEY_ALIGNMENT_FILE:""alignment.fasta"", + KEY_ALIGNMENT_OUT: False, + + KEY_TEMPDIR:None, + KEY_NO_TEMP:False, + + KEY_DATADIR:None, + + KEY_MAXAMBIG: 0.3, + KEY_TRIM_START:265, # where to pad to using datafunk + KEY_TRIM_END:29674, # where to pad after using datafunk + + KEY_ALIAS_FILE: None, + + KEY_SKIP_SCORPIO: False, + + KEY_EXPANDED_LINEAGE: False, + + KEY_CONSTELLATION_FILES: [], + + KEY_INPUT_COMPRESSION_TYPE: ""plaintext"", + + KEY_PANGOLIN_VERSION: __version__, + KEY_PANGOLIN_DATA_VERSION: pangolin_data.__version__, + KEY_SCORPIO_VERSION: scorpio.__version__, + KEY_CONSTELLATIONS_VERSION: constellations.__version__, + KEY_PANGOLIN_ASSIGNMENT_VERSION: pangolin_assignment.__version__, + KEY_PANGOLIN_ASSIGNMENT_PATH: pangolin_assignment.__path__[0], + + KEY_VERBOSE: False, + KEY_LOG_API: """", + KEY_THREADS: 1 + } + return default_dict + +def set_up_analysis_mode(analysis_arg, default_mode): + """""" + the logic here + - takes the default mode set in the config dict (accurate) + - it equates the usher arg to accurate arg and pangolearn to fast + - checks if incompatible flags were used (only one of accurate, fast or cache) + - overwrites default if any other analysis mode flagged + - returns new analysis mode + """""" + + analysis_mode = default_mode + if analysis_arg: + if not analysis_arg in [""usher"",""pangolearn"",""fast"",""accurate"",""scorpio""]: + sys.stderr.write(cyan(f""Invalid `--analysis-mode` option specified: please select one of `fast`,`accurate`,`pangolearn`, `usher` or `scorpio`\n"")) + sys.exit(-1) + + if analysis_arg in ['pangolearn','fast']: + analysis_mode = ""pangolearn"" + elif analysis_arg in ['usher','accurate']: + analysis_mode = ""usher"" + elif analysis_arg == ""scorpio"": + analysis_mode = ""scorpio"" + + return analysis_mode + +def get_snakefile(thisdir,analysis_mode): + snakefile = """" + if analysis_mode != ""scorpio"": + # in this case now, the snakefile used should be the name of the analysis mode (i.e. pangolearn, usher or preprocessing) + snakefile = os.path.join(thisdir, 'scripts',f'{analysis_mode}.smk') + if not os.path.exists(snakefile): + sys.stderr.write(cyan(f'Error: cannot find Snakefile at {snakefile}. Check installation\n')) + sys.exit(-1) + return snakefile + +def check_datadir(datadir_arg): + datadir = None + # find the data + if datadir_arg: + # this needs to be an absolute path when we pass it to scorpio + datadir = os.path.abspath(datadir_arg) + if not os.path.exists(datadir): + sys.stderr.write(cyan(f""Cannot find data directory specified: {datadir}\n"")) + sys.exit(-1) + return datadir + +def version_from_init(init_file): + version=None + with open(init_file, ""r"") as fr: + for l in fr: + if l.startswith(""__version__""): + l = l.rstrip(""\n"") + version = l.split('=')[1] + version = version.replace('""',"""").replace("" "","""") + break + return version + +def setup_data(datadir_arg, analysis_mode, config, use_old_data): + datadir = check_datadir(datadir_arg) + + config[KEY_PANGOLIN_DATA_VERSION] = pangolin_data.__version__ + config[KEY_DATADIR] = pangolin_data.__path__[0] + config[KEY_CONSTELLATIONS_VERSION] = constellations.__version__ + config[KEY_CONSTELLATION_FILES] = get_constellation_files(constellations.__path__[0]) + config[KEY_PANGOLIN_ASSIGNMENT_VERSION] = pangolin_assignment.__version__ + config[KEY_PANGOLIN_ASSIGNMENT_PATH] = pangolin_assignment.__path__[0] + + if datadir: + for module_name in ('constellations', 'pangolin_data', 'pangolin_assignment'): + for r, _, f in os.walk(datadir): + for fn in f: + if r.endswith('/' + module_name) and fn == '__init__.py': + version = version_from_init(os.path.join(r, fn)) + # module_name has been imported so exists in global namespace + current_version = getattr(globals()[module_name], '__version__', '0') + if use_old_data or current_version is None or LooseVersion(version) >= LooseVersion(current_version): + if module_name == ""pangolin_data"": + config[KEY_PANGOLIN_DATA_VERSION] = version + config[KEY_DATADIR] = os.path.join(datadir, r) + elif module_name == ""pangolin_assignment"": + config[KEY_PANGOLIN_ASSIGNMENT_VERSION] = version + config[KEY_PANGOLIN_ASSIGNMENT_PATH] = os.path.join(datadir, r) + elif module_name == ""constellations"": + config[KEY_CONSTELLATIONS_VERSION] = version + config[KEY_CONSTELLATION_FILES] = get_constellation_files(r) + else: + sys.stderr.write(cyan(f""Warning: Ignoring {module_name} in specified datadir {datadir} - it contains {module_name} with older ({version}) than those installed ({current_version})\n"")) + +def parse_qc_thresholds(maxambig, minlen, reference_fasta, config): + + if maxambig: + maxambig = float(maxambig) + if maxambig <=1 and maxambig >= 0: + config[KEY_MAXAMBIG] = maxambig + else: + sys.stderr.write(cyan(f'Error: `--max-ambiguity` should be a float between 0 and 1.\n')) + sys.exit(-1) + + if minlen: + minlen = float(minlen) + reflen = 0 + for record in SeqIO.parse(reference_fasta,""fasta""): + reflen = len(record) + + if minlen>reflen: + sys.stderr.write(cyan(f'Error: `--min-length` should be less than the length of the reference: {reflen}.\n')) + sys.exit(-1) + else: + new_maxambig = round(1-(minlen/reflen), 3) + print(f""Converting minimum length of {minlen} to maximum ambiguity of {new_maxambig}."") + if new_maxambig < config[KEY_MAXAMBIG]: + config[KEY_MAXAMBIG] = new_maxambig + + print(green(f""Maximum ambiguity allowed is {config[KEY_MAXAMBIG]}.\n****"")) + +def print_ram_warning(analysis_mode): + if analysis_mode == ""pangolearn"": + print(cyan(""Warning: pangoLEARN mode may use a significant amount of RAM, be aware that it will not suit every system."")) + +def print_alias_file_exit(alias_file): + with open(alias_file, 'r') as handle: + for line in handle: + print(line.rstrip()) + + sys.exit(0) + +def get_version(programs): + for program in programs: + cmd = [f""{program} --version""] + output = subprocess.run(cmd, shell=True, check=True, + stdout=subprocess.PIPE, encoding='utf-8') + version = output.stdout.strip().split()[-1].strip('()v') + print(f""{program.split()[0]} {version}"") + +def print_faToVf_version(): + output = subprocess.run(""faToVcf -verbose=2 -h 2>&1 | grep '#'"", shell=True, check=True, + stdout=subprocess.PIPE, encoding='utf-8') + version = output.stdout.split(' ')[-2] + print(f""faToVcf: {version}"") + +def print_conda_version(pkg_list): + for pkg in pkg_list: + try: + result = subprocess.run(['conda', 'list', pkg], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True) + + except subprocess.CalledProcessError as e: + stderr = e.stderr.decode('utf-8') + sys.stderr.write(cyan(f""Error: {e}:\n{stderr}\n"")) + sys.exit(-1) + output = result.stdout.decode('utf-8') + m = re.search(f'\n{pkg} +([0-9.]+) .*\sbioconda$', output) + if m: + version = m.group(1) + print(f""{pkg}: {version}"") + else: + sys.stderr.write(cyan(f""version not found in output of 'conda list {pkg}':\n{output}\n"")) + +def print_versions_exit(config): + print(f""pangolin: {config[KEY_PANGOLIN_VERSION]}\n"" + f""pangolin-data: {config[KEY_PANGOLIN_DATA_VERSION]}\n"" + f""constellations: {config[KEY_CONSTELLATIONS_VERSION]}\n"" + f""scorpio: {config[KEY_SCORPIO_VERSION]}"") + # Report pangolin_assignment version if it is installed, otherwise ignore + if config[KEY_PANGOLIN_ASSIGNMENT_VERSION] is not None: + print(f""pangolin-assignment: {config[KEY_PANGOLIN_ASSIGNMENT_VERSION]}"") + # Print versions of other important tools used by pangolin + get_version(['usher', 'gofasta', 'minimap2']) + print_faToVf_version() + # print_conda_version(['usher', 'ucsc-fatovcf', 'gofasta', 'minimap2']) + sys.exit(0) + +def set_up_verbosity(config): + if config[KEY_VERBOSE]: + config[""quiet""] = False + config[KEY_LOG_API] = """" + config[""log_string""] = """" + else: + config[""quiet""] = True + logger = custom_logger.Logger() + config[KEY_LOG_API] = logger.log_handler +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/dependency_checks.py",".py","1626","61","#!/usr/bin/env python3 +import subprocess +import os +import sys +from pangolin.utils.log_colours import green,cyan,red +import importlib + +import pangolin.utils.custom_logger as custom_logger +import pangolin.utils.log_handler_handle as lh + +def which(dependency): + try: + subprocess.check_output([""which"", dependency]) + return True + except subprocess.CalledProcessError: + return False + +def check_module(module, missing): + try: + importlib.import_module(module) + except ImportError: + missing.append(module) + +def check_this_dependency(dependency,missing): + check = which(dependency) + + if not check: + missing.append(dependency) + +def check_dependencies(dependency_list, module_list, usher_arg, cache_arg): + + missing = [] + + if usher_arg: + dependency_list.append(""usher"") + + if cache_arg: + dependency_list.append(""pangolin-assignment"") + + for dependency in dependency_list: + check_this_dependency(dependency, missing) + + for module in module_list: + check_module(module, missing) + + if missing: + if len(missing)==1: + sys.stderr.write(cyan(f'Error: Missing dependency `{missing[0]}`.')+'\nPlease update your pangolin environment.\n') + sys.exit(-1) + else: + dependencies = """" + for i in missing: + dependencies+=f""\t- {i}\n"" + + sys.stderr.write(cyan(f'Error: Missing dependencies.')+f'\n{dependencies}Please update your pangolin environment.\n') + sys.exit(-1) + else: + print(green(""All dependencies satisfied."")) + +# check_dependencies() +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/config.py",".py","2156","83","KEY_ANALYSIS_MODE=""analysis_mode"" + +KEY_QUERY_FASTA=""query_fasta"" +KEY_REFERENCE_FASTA=""reference_fasta"" + +KEY_OUTDIR=""outdir"" +KEY_OUTFILE=""outfile"" + +KEY_ALIGNDIR=""aligndir"" +KEY_ALIGNMENT_FILE=""alignment_file"" +KEY_ALIGNMENT_OUT=""alignment_out"" + +KEY_TEMPDIR=""tempdir"" +KEY_NO_TEMP = ""no_temp"" + +KEY_DATADIR=""datadir"" + +KEY_MAXAMBIG=""maxambig"" +KEY_TRIM_START=""trim_start"" +KEY_TRIM_END=""trim_end"" + +KEY_ALIAS_FILE=""alias_file"" + +KEY_SKIP_SCORPIO = ""skip_scorpio"" + +KEY_EXPANDED_LINEAGE=""expanded_lineage"" + +KEY_CONSTELLATION_FILES=""constellation_files"" +KEY_USHER_PB = ""usher_pb"" +KEY_PLEARN_MODEL = ""plearn_model"" +KEY_PLEARN_HEADER = ""plearn_header"" +KEY_DESIGNATION_CACHE=""designation_cache"" +KEY_ASSIGNMENT_CACHE = ""assignment_cache"" +KEY_INPUT_COMPRESSION_TYPE = ""compression_type"" + + +# Version KEYS + +KEY_PANGOLIN_DATA_VERSION=""pangolin_data_version"" +KEY_PANGOLIN_VERSION=""pangolin_version"" +KEY_CONSTELLATIONS_VERSION=""constellation_version"" +KEY_SCORPIO_VERSION=""scorpio_version"" +KEY_PANGOLIN_ASSIGNMENT_VERSION=""pangolin_assignment_version"" +KEY_PANGOLIN_ASSIGNMENT_PATH=""pangolin_assignment_path"" + +KEY_VERBOSE=""verbose"" +KEY_LOG_API = ""log_api"" +KEY_THREADS=""threads"" + +UNASSIGNED_LINEAGE_REPORTED=""Unassigned"" + +# final report header +FINAL_HEADER= [""taxon"", ""lineage"", ""conflict"", ""ambiguity_score"", +""scorpio_call"", ""scorpio_support"", ""scorpio_conflict"", ""scorpio_notes"", + ""version"", KEY_PANGOLIN_VERSION, KEY_SCORPIO_VERSION, KEY_CONSTELLATIONS_VERSION, +""is_designated"", ""qc_status"", ""qc_notes"", ""note""] + +HEADER_FIELD_MAP = { + ""name"":""taxon"", + ""scorpio_constellations"":""scorpio_call"", + ""designated"":""is_designated"", + ""usher_note"":""note"", + ""pangolearn_note"":""note"" + +} + +# File names +DESIGNATION_CACHE_FILE = ""lineages.hash.csv"" +ALIAS_FILE = ""alias_key.json"" +USHER_ASSIGNMENT_CACHE_FILE = ""usher_assignments.cache.csv.gz"" + +pangolearn_files = { + ""randomForest_v1.joblib"":KEY_PLEARN_MODEL, + ""randomForestHeaders_v1.joblib"":KEY_PLEARN_HEADER + } +usher_files = { + ""lineageTree.pb"":KEY_USHER_PB + } + +# Dependencies +dependency_list = [""gofasta"",""minimap2"",""snakemake""] +module_list = [""Bio"",""sklearn"",""pandas"",""joblib"",""pangoLEARN"",""constellations""] +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/custom_logger.py",".py","12117","393","#!/usr/bin/env python3 +"""""" +Adapted from snakemake source code +__author__ = ""Johannes Köster"" +__copyright__ = ""Copyright 2015-2019, Johannes Köster"" +__email__ = ""koester@jimmy.harvard.edu"" +__license__ = ""MIT"" +"""""" + +import logging as _logging +import platform +import time +import datetime +import sys +import os +import json +import threading +import tempfile +from functools import partial +import inspect +import textwrap + +from snakemake.common import DYNAMIC_FILL +from snakemake.common import Mode + + +class ColorizingStreamHandler(_logging.StreamHandler): + + BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8) + RESET_SEQ = ""\033[0m"" + COLOR_SEQ = ""\033[%dm"" + BOLD_SEQ = ""\033[1m"" + + colors = { + ""WARNING"": YELLOW, + ""INFO"": GREEN, + ""DEBUG"": BLUE, + ""CRITICAL"": RED, + ""ERROR"": RED, + } + + def __init__( + self, nocolor=False, stream=sys.stderr, use_threads=False, mode=Mode.default + ): + super().__init__(stream=stream) + + self._output_lock = threading.Lock() + + self.nocolor = nocolor or not self.can_color_tty(mode) + + def can_color_tty(self, mode): + if ""TERM"" in os.environ and os.environ[""TERM""] == ""dumb"": + return False + if mode == Mode.subprocess: + return True + return self.is_tty and not platform.system() == ""Windows"" + + @property + def is_tty(self): + isatty = getattr(self.stream, ""isatty"", None) + return isatty and isatty() + + def emit(self, record): + with self._output_lock: + try: + self.format(record) # add the message to the record + self.stream.write(self.decorate(record)) + self.stream.write(getattr(self, ""terminator"", ""\n"")) + self.flush() + except BrokenPipeError as e: + pass + except (KeyboardInterrupt, SystemExit): + # ignore any exceptions in these cases as any relevant messages have been printed before + pass + except Exception as e: + pass + + def decorate(self, record): + message = record.message + message = [message] + if not self.nocolor and record.levelname in self.colors: + message.insert(0, self.COLOR_SEQ % (30 + self.colors[record.levelname])) + message.append(self.RESET_SEQ) + return """".join(message) + + +class SlackLogger: + def __init__(self): + from slacker import Slacker + + self.token = os.getenv(""SLACK_TOKEN"") + if not self.token: + print( + ""The use of slack logging requires the user to set a user specific slack legacy token to the SLACK_TOKEN environment variable. Set this variable by 'export SLACK_TOKEN=your_token'. To generate your token please visit https://api.slack.com/custom-integrations/legacy-tokens."" + ) + exit(-1) + self.slack = Slacker(self.token) + # Check for success + try: + auth = self.slack.auth.test().body + except Exception: + print( + ""Slack connection failed. Please compare your provided slack token exported in the SLACK_TOKEN environment variable with your online token at https://api.slack.com/custom-integrations/legacy-tokens. A different token can be set up by 'export SLACK_TOKEN=your_token'."" + ) + exit(-1) + self.own_id = auth[""user_id""] + self.error_occured = False + + def log_handler(self, msg): + if msg[""level""] == ""error"" and not self.error_occured: + self.slack.chat.post_message( + self.own_id, text=""At least one error occured."", username=""snakemake"" + ) + self.error_occured = True + + if msg[""level""] == ""progress"" and msg[""done""] == msg[""total""]: + # workflow finished + self.slack.chat.post_message( + self.own_id, text=""Workflow complete."", username=""snakemake"" + ) + + +class Logger: + def __init__(self): + self.logger = _logging.getLogger(__name__) + self.log_handler = [self.text_handler] + self.stream_handler = None + self.printshellcmds = False + self.printreason = False + self.debug_dag = False + self.quiet = False + self.logfile = None + self.last_msg_was_job_info = False + self.mode = Mode.default + self.show_failed_logs = False + self.logfile_handler = None + + def setup_logfile(self): + if self.mode == Mode.default: + os.makedirs(os.path.join("".snakemake"", ""log""), exist_ok=True) + self.logfile = os.path.abspath( + os.path.join( + "".snakemake"", + ""log"", + datetime.datetime.now().isoformat().replace("":"", """") + + "".snakemake.log"", + ) + ) + + self.logfile_handler = _logging.FileHandler(self.logfile) + self.logger.addHandler(self.logfile_handler) + + def cleanup(self): + if self.mode == Mode.default and self.logfile_handler is not None: + self.logger.removeHandler(self.logfile_handler) + self.logfile_handler.close() + self.log_handler = [self.text_handler] + + def get_logfile(self): + if self.logfile is not None: + self.logfile_handler.flush() + return self.logfile + + def remove_logfile(self): + if self.mode == Mode.default: + self.logfile_handler.close() + os.remove(self.logfile) + + def handler(self, msg): + for handler in self.log_handler: + handler(msg) + + def set_stream_handler(self, stream_handler): + if self.stream_handler is not None: + self.logger.removeHandler(self.stream_handler) + self.stream_handler = stream_handler + self.logger.addHandler(stream_handler) + + def set_level(self, level): + self.logger.setLevel(level) + + def logfile_hint(self): + if self.mode == Mode.default: + logfile = self.get_logfile() + self.info(""Complete log: {}"".format(logfile)) + + def location(self, msg): + callerframerecord = inspect.stack()[1] + frame = callerframerecord[0] + info = inspect.getframeinfo(frame) + self.debug( + ""{}: {info.filename}, {info.function}, {info.lineno}"".format(msg, info=info) + ) + + def info(self, msg, indent=False): + self.handler(dict(level=""info"", msg=msg, indent=indent)) + + def warning(self, msg): + self.handler(dict(level=""warning"", msg=msg)) + + def debug(self, msg): + self.handler(dict(level=""debug"", msg=msg)) + + def error(self, msg): + self.handler(dict(level=""error"", msg=msg)) + + def progress(self, done=None, total=None): + self.handler(dict(level=""progress"", done=done, total=total)) + + def resources_info(self, msg): + self.handler(dict(level=""resources_info"", msg=msg)) + + def run_info(self, msg): + self.handler(dict(level=""run_info"", msg=msg)) + + def group_info(self, **msg): + msg[""level""] = ""group_info"" + self.handler(msg) + + def job_info(self, **msg): + msg[""level""] = ""job_info"" + self.handler(msg) + + def job_error(self, **msg): + msg[""level""] = ""job_error"" + self.handler(msg) + + def group_error(self, **msg): + msg[""level""] = ""group_error"" + self.handler(msg) + + def dag_debug(self, msg): + self.handler(dict(level=""dag_debug"", **msg)) + + def shellcmd(self, msg, indent=False): + if msg is not None: + msg = dict(level=""shellcmd"", msg=msg) + msg[""indent""] = indent + self.handler(msg) + + def job_finished(self, **msg): + msg[""level""] = ""job_finished"" + self.handler(msg) + + def rule_info(self, **msg): + msg[""level""] = ""rule_info"" + self.handler(msg) + + def d3dag(self, **msg): + msg[""level""] = ""d3dag"" + self.handler(msg) + + def text_handler(self, msg): + """"""The default snakemake log handler. + Prints the output to the console. + Args: + msg (dict): the log message dictionary + """""" + + def job_info(msg): + def format_item(item, omit=None, valueformat=str): + value = msg[item] + if value != omit: + return """".format(item, valueformat(value)) + + yield """" + + for item in [""input"", ""output"", ""log""]: + fmt = format_item(item, omit=[], valueformat="", "".join) + if fmt != None: + yield fmt + + singleitems = [""jobid"", ""benchmark""] + if self.printreason: + singleitems.append(""reason"") + for item in singleitems: + fmt = format_item(item, omit=None) + if fmt != None: + yield fmt + + wildcards = format_wildcards(msg[""wildcards""]) + + for item, omit in zip(""priority threads"".split(), [0, 1]): + fmt = format_item(item, omit=omit) + if fmt != None: + yield fmt + + resources = format_resources(msg[""resources""]) + + def indent(item): + if msg.get(""indent""): + return """" + else: + return """" + + def timestamp(): + self.logger.info(indent(""[{}]"".format(time.asctime()))) + + level = msg[""level""] + if level == ""job_error"": + pass + # timestamp() + + # for item in msg[""aux""].items(): + # self.logger.error(indent("" {}: {}"".format(*item))) + + # if self.show_failed_logs and msg[""log""]: + # for f in msg[""log""]: + # try: + # self.logger.error(""Logfile {}:\n{}"".format(f, open(f).read())) + # except FileNotFoundError: + # self.logger.error(""Logfile {} not found."".format(f)) + + self.logger.error("""") + elif level == ""group_error"": + pass + else: + if level == ""error"": + pass + elif level == ""debug"": + pass + elif level == ""job_finished"" and not self.quiet: + pass + elif level == ""d3dag"": + pass + elif level == ""dag_debug"": + if self.debug_dag: + if ""file"" in msg: + pass + else: + # job = msg[""job""] + pass + self.last_msg_was_job_info = True + + +def format_dict(dict_like, omit_keys=[], omit_values=[]): + from snakemake.io import Namedlist + + if isinstance(dict_like, Namedlist): + items = dict_like.items() + elif isinstance(dict_like, dict): + items = dict_like.items() + else: + raise ValueError( + ""bug: format_dict applied to something neither a dict nor a Namedlist"" + ) + return """" + + + +format_resources = partial(format_dict, omit_keys={""_cores"", ""_nodes""}) +format_wildcards = partial(format_dict, omit_values={DYNAMIC_FILL}) + + +def format_resource_names(resources, omit_resources=""_cores _nodes"".split()): + return """" + + +logger = Logger() + + +def setup_logger( + handler=[], + quiet=True, + printshellcmds=False, + printreason=False, + debug_dag=False, + nocolor=False, + stdout=False, + debug=False, + use_threads=False, + mode=Mode.default, + show_failed_logs=False, +): + logger.log_handler.extend(handler) + + # console output only if no custom logger was specified + stream_handler = ColorizingStreamHandler( + nocolor=nocolor, + stream=sys.stdout if stdout else sys.stderr, + use_threads=use_threads, + mode=mode, + ) + logger.set_stream_handler(stream_handler) + + logger.set_level(_logging.DEBUG if debug else _logging.INFO) + logger.quiet = True + logger.printshellcmds = False + logger.printreason = printreason + logger.debug_dag = debug_dag + logger.mode = mode + logger.show_failed_logs = show_failed_logs +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/preprocessing.py",".py","7168","197","import os +import sys +from pangolin.utils.log_colours import green,cyan +import hashlib +from Bio import SeqIO +import csv +import gzip +import lzma + + +def create_seq_hash(seq_file,hash_map,hashed_seqs): + """""" + iterates through seq file, keeps track of seq hash + writes record id -> hash map as it goes along + writes out records as it goes along + + returns record count and collapsed record count + """""" + hash_dict = {} + record_count = 0 + + fw2 = open(hashed_seqs, ""w"") + + with open(hash_map,""w"") as fw: + fw.write(""name\thash\n"") + for record in SeqIO.parse(seq_file, ""fasta""): + record_count +=1 + + seq = str(record.seq).encode() + hash_object = hashlib.md5(seq) + hash_str = hash_object.hexdigest() + fw.write(f""{record.description}\t{hash_str}\n"") + + if hash_str not in hash_dict: + + fw2.write(f"">{hash_str}\n{record.seq}\n"") + hash_dict[hash_str] = 1 + + fw2.close() + + return record_count,len(hash_dict) + +def designation_assign(designation_cache,hash_map,outfile): + """""" + loads the designation hash file as a dictionary + runs through query file- checks if in designation dict + writes to csv the status + """""" + pango_hash = {} + with open(designation_cache,""r"") as f: + reader = csv.DictReader(f) + for row in reader: + pango_hash[row[""seq_hash""]] = row[""lineage""] + + designated = 0 + with open(outfile,""w"") as fw: + fw.write(""hash,designated,lineage\n"") + with open(hash_map, ""r"") as f: + reader = csv.DictReader(f, delimiter=""\t"") + for row in reader: + seq_hash = row[""hash""] + if seq_hash in pango_hash: + designated +=1 + + lineage = pango_hash[seq_hash] + fw.write(f""{seq_hash},True,{lineage}\n"") + else: + fw.write(f""{seq_hash},False,\n"") + + return designated + +def seq_qc(in_fasta,pass_qc,qc_status,max_ambiguity): + """""" + loads the aligned, hashed fasta file + calculates n percentage + if it's greater than max ambiguity, qc is failed + writes failed and passed to a file + """""" + fw_pass = open(pass_qc,""w"") + with open(qc_status,""w"") as fw: + fw.write(""hash,qc_status,qc_notes\n"") + + total_input = 0 + total_pass = 0 + + for record in SeqIO.parse(in_fasta, ""fasta""): + total_input +=1 + + num_N = str(record.seq).upper().count(""N"") + prop_N = round((num_N)/len(record.seq), 2) + if prop_N > max_ambiguity: + fw.write(f""{record.id},fail,Ambiguous_content:{prop_N}\n"") + else: + total_pass +=1 + + fw.write(f""{record.id},pass,Ambiguous_content:{prop_N}\n"") + fw_pass.write(f"">{record.id}\n{record.seq}\n"") + fw_pass.close() + + return total_pass + + +def merge_files(fasta, qc_status, scorpio_report, designated, hash_map, out_merged): + """""" + gets the status of scorpio assignments, designation assignments, seq qc + as well as the hashing map + goes through the original fasta file and for every record collates the + available info into a csv file with header fields as below: + """""" + header = [""name"",""hash"",""lineage"",""scorpio_constellations"",""scorpio_mrca_lineage"",""scorpio_incompatible_lineages"",""scorpio_support"",""scorpio_conflict"",""scorpio_notes"",""designated"",""qc_status"",""qc_notes""] + with open(out_merged,""w"") as fw: + writer = csv.DictWriter(fw, fieldnames=header,lineterminator=""\n"") + writer.writeheader() + info_dict = {} + name_dict = {} + + with open(hash_map, ""r"") as f: + reader = csv.DictReader(f,delimiter=""\t"") + for row in reader: + info_dict[row[""hash""]] = { + ""hash"":row[""hash""] + } + name_dict[row[""name""]] = row[""hash""] + + with open(designated, ""r"") as f: + reader = csv.DictReader(f) + for row in reader: + info_dict[row[""hash""]][""designated""] = row[""designated""] + info_dict[row[""hash""]][""lineage""] = row[""lineage""] + + with open(qc_status, ""r"") as f: + reader = csv.DictReader(f) + for row in reader: + info_dict[row[""hash""]][""qc_status""] = row[""qc_status""] + info_dict[row[""hash""]][""qc_notes""] = row[""qc_notes""] + + if os.stat(scorpio_report).st_size > 0: + with open(scorpio_report,""r"") as f: + reader = csv.DictReader(f) + for row in reader: + info_dict[row[""query""]][""scorpio_constellations""] = row[""constellations""] + info_dict[row[""query""]][""scorpio_mrca_lineage""] = row[""mrca_lineage""] + info_dict[row[""query""]][""scorpio_incompatible_lineages""] = row[""incompatible_lineages""] + if row[""support""]: + info_dict[row[""query""]][""scorpio_support""] = round(float(row[""support""]),2) + info_dict[row[""query""]][""scorpio_conflict""] = round(float(row[""conflict""]),2) + else: + info_dict[row[""query""]][""scorpio_support""] = row[""support""] + info_dict[row[""query""]][""scorpio_conflict""] = row[""conflict""] + if row[""mrca_lineage""]: + info_dict[row[""query""]][""scorpio_notes""] = f'scorpio call: Alt alleles {row[""alt_count""]}; Ref alleles {row[""ref_count""]}; Amb alleles {row[""ambig_count""]}; Oth alleles {row[""other_count""]}' + else: + info_dict[row[""query""]][""scorpio_notes""] = """" + + file_ending = fasta.split(""."")[-1] + if file_ending in [""gz"",""gzip"",""tgz""]: + query = gzip.open(fasta, 'rt') + elif file_ending in [""xz"",""lzma""]: + query = lzma.open(fasta, 'rt') + else: + query = open(fasta,""r"") + + for l in query: + if l[0]=='>': + + query_record = {} + name = l.rstrip(""\n"").lstrip("">"") + modified_name=name.replace("" "",""_"").replace("","",""_"") + if modified_name in name_dict: + query_record = info_dict[name_dict[modified_name]] + query_record[""name""] = name + else: + query_record = { + ""name"":name, + ""hash"":"""", + ""designated"":""False"", + ""lineage"":""Unassigned"", + ""qc_status"":""fail"", + ""qc_notes"":""failed to map"", + ""scorpio_mrca_lineage"":"""", + ""scorpio_constellations"":"""", + ""scorpio_incompatible_lineages"":"""", + ""scorpio_support"":"""", + ""scorpio_conflict"":"""", + ""scorpio_notes"":"""" + } + + writer.writerow(query_record) + + + + + + + + +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/log_handler_handle.py",".py","164","6","#!/usr/bin/env python3 +import pangolin.utils.custom_logger as custom_logger + +def log_handler(msg): + logger = custom_logger.Logger() + return logger.log_handler","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/report_collation.py",".py","13111","295","#!/usr/bin/env python + +import os +import re +import csv +import json + +from pangolin.utils.config import * + +def usher_parsing(usher_result,output_report): + """""" + Parsing the output of usher inference into a lineage report with columns + hash, lineage, conflict, usher_note + """""" + + with open(output_report, ""w"") as fw: + fw.write(""hash,lineage,conflict,usher_note\n"") + + with open(usher_result, ""r"") as f: + for l in f: + name,lineage_histogram = l.rstrip(""\n"").split(""\t"") + if ""*|"" in lineage_histogram: + # example: A.28*|A.28(1/10),B.1(6/10),B.1.511(1/10),B.1.518(2/10) + lineage,histogram = lineage_histogram.split(""*|"") + histo_list = [ i for i in histogram.split("","") if i ] + conflict = 0.0 + if len(histo_list) > 1: + selected_count = 0 + total = 0 + for lin_counts in histo_list: + m = re.match('([A-Z0-9.]+)\(([0-9]+)/([0-9]+)\)', lin_counts) + if m: + lin, place_count, total = [m.group(1), int(m.group(2)), int(m.group(3))] + if lin == lineage: + selected_count = place_count + break + conflict = (total - selected_count) / total + histogram_note = ""Usher placements: "" + "" "".join(histo_list) + else: + lineage = lineage_histogram + conflict = """" + histogram_note = """" + + fw.write(f""{name},{lineage},{conflict},{histogram_note}\n"") + +def pangolearn_parsing(pangolearn_result,output_report): + """""" + Parsing the output of pangolearn inference into a lineage report with columns + hash, lineage, conflict, ambiguity_score, pangolearn_note + """""" + with open(output_report,""w"") as fw: + fw.write(""hash,lineage,conflict,ambiguity_score,pangolearn_note\n"") + + with open(pangolearn_result, ""r"") as f: + reader = csv.DictReader(f) + + for row in reader: + note = '' + support = round((1 - float(row[""score""])), 2) + ambiguity_score = round(float(row['imputation_score']), 2) + + non_zero_ids = row[""non_zero_ids""].split("";"") + if len(non_zero_ids) > 1: + note = f""Alt assignments: {row['non_zero_ids']},{row['non_zero_scores']}"" + + fw.write(f""{row['taxon']},{row['prediction']},{support},{ambiguity_score},{note}\n"") + + +def expand_alias(pango_lineage, alias_dict): + if not pango_lineage or pango_lineage in [""None"", None, """", UNASSIGNED_LINEAGE_REPORTED] or ""/"" in pango_lineage: + return None + + lineage_parts = pango_lineage.split(""."") + while lineage_parts[0] in alias_dict.keys() and not lineage_parts[0].startswith('X'): + if len(lineage_parts) > 1: + pango_lineage = alias_dict[lineage_parts[0]] + ""."" + ""."".join(lineage_parts[1:]) + else: + pango_lineage = alias_dict[lineage_parts[0]] + lineage_parts = pango_lineage.split(""."") + if lineage_parts[0] not in [""A"",""B""] and not lineage_parts[0].startswith('X'): + return None + return pango_lineage + +def get_recombinant_parents(pango_lineage, alias_dict): + # return the direct parents and the expanded lineage + list_expanded = [] + if pango_lineage in [""None"", None, """", UNASSIGNED_LINEAGE_REPORTED]: + return list_expanded + + lineage_parts = pango_lineage.split(""."") + if not lineage_parts[0].startswith('X'): + return list_expanded + + for parent in alias_dict[lineage_parts[0]]: + list_expanded.append(expand_alias(parent, alias_dict)) + + return list_expanded + +def get_alias_dict(alias_file): + alias_dict = {} + with open(alias_file, ""r"") as read_file: + alias_dict = json.load(read_file) + if ""A"" in alias_dict: + del alias_dict[""A""] + if ""B"" in alias_dict: + del alias_dict[""B""] + return alias_dict + +def get_inference_dict(inference_csv): + inference_dict = {} + with open(inference_csv,""r"") as f: + reader = csv.DictReader(f) + for row in reader: + inference_dict[row[""hash""]] = row + return inference_dict + +def get_cached_dict(cached_csv): + cached_dict = {} + if os.path.exists(cached_csv): + with open(cached_csv, ""r"") as f: + reader = csv.DictReader(f) + for row in reader: + cached_dict[row[""hash""]] = row + return cached_dict + +def get_voc_list(voc_file, alias_file): + voc_list = [] + alias_dict = get_alias_dict(alias_file) + + with open(voc_file,""r"") as f: + for line in f: + expanded_voc = expand_alias(line.rstrip(), alias_dict) + if expanded_voc: + voc_list.append(expanded_voc) + return voc_list + +def add_relevant_fields_to_new_row(data_dict,new_row): + for field in data_dict: + if field in FINAL_HEADER: + new_row[field] = data_dict[field] + elif field in HEADER_FIELD_MAP: + final_field = HEADER_FIELD_MAP[field] + new_row[final_field] = data_dict[field] + +def append_note(new_row, new_note): + if new_row[""note""]: + new_row[""note""] += ""; "" + new_note + else: + new_row[""note""] = new_note + +def generate_final_report(preprocessing_csv, inference_csv, cached_csv, alias_file, voc_list, pango_version, analysis_mode, skip_cache, output_report, config): + """""" + preprocessing_csv header is: + [""name"",""hash"",""lineage"",""scorpio_constellations"", + ""scorpio_mrca_lineage"",""scorpio_incompatible_lineages"", + ""scorpio_support"",""scorpio_conflict"",""scorpio_notes"", + ""designated"",""qc_status"",""qc_notes""] + + inference_csv header is: + usher: hash,lineage,conflict,usher_note + pangolearn: hash,lineage,conflict,ambiguity_score,pangolearn_note + + cached_csv header is: + hash,lineage,conflict,version,note + """""" + # the lineage aliases + alias_dict = get_alias_dict(alias_file) + + if analysis_mode == ""scorpio"": + inference_dict = {} + else: + # the output(s) of pangolearn/usher inference pipelines + # only pass qc records present in this file + inference_dict = get_inference_dict(inference_csv) + cached_dict = get_cached_dict(cached_csv) + + if analysis_mode == ""pangolearn"": + version = f""PLEARN-v{pango_version}"" + elif analysis_mode == ""usher"": + version = f""PUSHER-v{pango_version}"" + else: + version = f"""" + + with open(output_report, ""w"") as fw: + # the output of preprocessing csv, all records present in this file + with open(preprocessing_csv, ""r"") as f: + reader = csv.DictReader(f) + + out_header = FINAL_HEADER + if config['expanded_lineage']: + out_header.append('expanded_lineage') + + writer = csv.DictWriter(fw, fieldnames=out_header, lineterminator=""\n"") + writer.writeheader() + + for row in reader: + new_row = {} + add_relevant_fields_to_new_row(row,new_row) + has_assignment = False + + inference_lineage = UNASSIGNED_LINEAGE_REPORTED + if row[""hash""] in cached_dict: + has_assignment = True + cached_out = cached_dict[row[""hash""]] + add_relevant_fields_to_new_row(cached_out, new_row) + inference_lineage = cached_out[""lineage""] + else: + new_row[""version""] = version + if row[""hash""] in inference_dict: + has_assignment = True + inference_out = inference_dict[row[""hash""]] + add_relevant_fields_to_new_row(inference_out,new_row) + inference_lineage = inference_out[""lineage""] + + new_row[KEY_PANGOLIN_VERSION] = config[KEY_PANGOLIN_VERSION] + new_row[KEY_SCORPIO_VERSION] = config[KEY_SCORPIO_VERSION] + new_row[KEY_CONSTELLATIONS_VERSION] = config[KEY_CONSTELLATIONS_VERSION] + + # if it passed qc and mapped + if has_assignment: + expanded_pango_lineage = expand_alias(inference_lineage, alias_dict) + + #1. check if hash assigned + if row[""designated""] == ""True"" and not skip_cache: + new_row[""note""] = ""Assigned from designation hash."" + new_row[""version""] = f""PANGO-v{pango_version}"" + new_row[""lineage""] = row[""lineage""] # revert back to designation hash lineage + + #2. check if scorpio assigned + elif row[""scorpio_constellations""]: + scorpio_lineage = row[""scorpio_mrca_lineage""] + expanded_scorpio_lineage = expand_alias(scorpio_lineage, alias_dict) + + recombinant_parents = get_recombinant_parents(expanded_pango_lineage, alias_dict) + + if '/' not in scorpio_lineage: + if expanded_scorpio_lineage and \ + not expanded_pango_lineage.startswith(expanded_scorpio_lineage) and \ + not (expanded_pango_lineage.startswith(""X"") and expanded_scorpio_lineage in recombinant_parents): + if analysis_mode == ""usher"": + append_note(new_row, f'scorpio lineage {scorpio_lineage} conflicts with inference lineage {inference_lineage}') + else: + append_note(new_row, f'scorpio replaced lineage inference {inference_lineage}') + new_row[""lineage""] = scorpio_lineage + + elif row[""scorpio_incompatible_lineages""] and inference_lineage in row[""scorpio_incompatible_lineages""].split(""|""): + if analysis_mode == ""usher"": + append_note(new_row, f'scorpio lineage {scorpio_lineage} conflicts with inference lineage {inference_lineage} (incompatible)') + else: + append_note(new_row, f'scorpio replaced lineage inference {inference_lineage}') + new_row[""lineage""] = scorpio_lineage + + elif not expanded_scorpio_lineage: + if analysis_mode == ""usher"": + append_note(new_row, f'scorpio found insufficient support to assign a specific lineage') + else: + append_note(new_row, f'scorpio replaced lineage inference {inference_lineage}') + new_row['lineage'] = UNASSIGNED_LINEAGE_REPORTED + + #3. check if lineage is a voc + elif row[""lineage""] in voc_list: + while expanded_pango_lineage and len(expanded_pango_lineage) > 3: + for voc in voc_list: + if expanded_pango_lineage.startswith(voc + ""."") or expanded_pango_lineage == voc: + # have no scorpio call but an inference voc/vui call + append_note(new_row, f'Lineage inference {inference_lineage} was not supported by scorpio') + if analysis_mode != ""usher"": + new_row['lineage'] = UNASSIGNED_LINEAGE_REPORTED + new_row['conflict'] = """" + new_row['ambiguity_score'] = """" + break + + if new_row['lineage'] == UNASSIGNED_LINEAGE_REPORTED: + break + + expanded_pango_lineage = ""."".join(expanded_pango_lineage.split(""."")[:-1]) + + else: + new_row[""lineage""] = UNASSIGNED_LINEAGE_REPORTED + if row[""scorpio_constellations""]: + scorpio_lineage = row[""scorpio_mrca_lineage""] + + if '/' not in scorpio_lineage and scorpio_lineage!=""None"": + new_row[""note""] = f'scorpio called lineage {scorpio_lineage}' + new_row[""lineage""] = scorpio_lineage + new_row[""version""] = f""SCORPIO_{config[KEY_CONSTELLATIONS_VERSION]}"" + + + if config['expanded_lineage']: + if new_row[""lineage""] == UNASSIGNED_LINEAGE_REPORTED: + new_row[""expanded_lineage""] = UNASSIGNED_LINEAGE_REPORTED + else: + new_row[""expanded_lineage""] = expand_alias(new_row[""lineage""], alias_dict) + writer.writerow(new_row) +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/io_parsing.py",".py","5678","155","import sys +import os +from pangolin.utils.log_colours import green,cyan +import select +from Bio import SeqIO +import gzip +import lzma + +import tempfile +import shutil + +from pangolin.utils.config import * + + +def find_query_file(cwd, tempdir, query_arg): + if len(query_arg) > 1: + print(cyan(f""Error: Too many query (input) fasta files supplied: {query_arg}\nPlease supply one only."")) + sys.exit(-1) + + # find the query fasta + try: + if not os.path.exists(os.path.join(cwd, query_arg[0])): + if select.select([sys.stdin,],[],[],0.0)[0]: + query = os.path.join(tempdir, ""stdin_query.fasta"") + with open(query,""w"") as fw: + for l in sys.stdin: + l= l.rstrip(""\n"") + fw.write(l + '\n') + + print(green(""Query:\t"") + ""reading from stdin."") + elif not select.select([sys.stdin,],[],[],0.0)[0]: + tried_path = os.path.join(cwd, query_arg[0]) + if tried_path.endswith(""-""): + sys.stderr.write(cyan( + f'Error: cannot find query (input) fasta file using stdin.\n' + + 'Please enter your fasta sequence file and refer to pangolin usage at: https://cov-lineages.org/pangolin.html' + + ' for detailed instructions.\n')) + sys.exit(-1) + else: + sys.stderr.write(cyan(f'Error: cannot find query (input) fasta file at:') + f'{tried_path}\n' + + 'Please enter your fasta sequence file and refer to pangolin usage at: https://cov-lineages.org/pangolin.html' + + ' for detailed instructions.\n') + sys.exit(-1) + else: + query = os.path.join(cwd, query_arg[0]) + print(green(f""Query file:\t"") + f""{query}"") + except IndexError: + sys.stderr.write(cyan( + f'Error: input query fasta could not be detected from a filepath or through stdin.\n' + + 'Please enter your fasta sequence file and refer to pangolin usage at: https://cov-lineages.org/pangolin.html' + + ' for detailed instructions.\n')) + sys.exit(-1) + + return query + + +def quick_check_query_file(cwd, query_arg, query): + input_compression_type = ""plaintext"" + if os.path.exists(os.path.join(cwd, query_arg[0])): + file_ending = query.split(""."")[-1] + if file_ending in [""gz"",""gzip"",""tgz""]: + input_compression_type = ""gz"" + query = gzip.open(query, 'rt') + elif file_ending in [""xz"",""lzma""]: + input_compression_type = ""xz"" + query = lzma.open(query, 'rt') + try: + parse= True + c = 0 + + for record in SeqIO.parse(query, ""fasta""): + if parse == False: + break + parse = False + + return input_compression_type + except UnicodeDecodeError: + sys.stderr.write(cyan( + f'Error: the input query fasta could not be parsed.\n' + + 'Double check your query fasta and that compressed stdin was not passed.\n' + + 'Please enter your fasta sequence file and refer to pangolin usage at: https://cov-lineages.org/pangolin.html' + + ' for detailed instructions.\n')) + sys.exit(-1) + +def set_up_outdir(outdir_arg,cwd,outdir): + if outdir_arg: + outdir = os.path.join(cwd, outdir_arg) + if not os.path.exists(outdir): + try: + os.mkdir(outdir) + except: + sys.stderr.write(cyan(f'Error: cannot create directory:') + f""{outdir}"") + sys.exit(-1) + return outdir + +def set_up_outfile(outfile_arg, outfile, outdir): + if outfile_arg: + outfile = os.path.join(outdir, outfile_arg) + else: + outfile = os.path.join(outdir, outfile) + return outfile + + +def set_up_tempdir(tempdir_arg,no_temp_arg,cwd,outdir,config): + + if no_temp_arg: + tempdir = outdir + config[KEY_TEMPDIR] = tempdir + print(green(f""\n--no-temp: "") + f""all intermediate files will be written to {outdir}\n"") + elif tempdir_arg: + to_be_dir = os.path.join(cwd, tempdir_arg) + try: + if not os.path.exists(to_be_dir): + os.mkdir(to_be_dir) + except: + sys.stderr.write(cyan(f'Error: cannot create temp directory {to_be_dir}.\n')) + sys.exit(-1) + tempdir = tempfile.mkdtemp(dir=to_be_dir) + config[KEY_TEMPDIR] = tempdir + else: + tempdir = tempfile.mkdtemp() + config[KEY_TEMPDIR] = tempdir + try: + if not os.path.exists(tempdir): + os.mkdir(tempdir) + except: + sys.stderr.write(cyan(f'Error: cannot create temp directory {tempdir}.\n')) + sys.exit(-1) + + try: + with open(os.path.join(tempdir, ""test.txt""),""w"") as fw: + fw.write(""Test"") + except: + sys.stderr.write(cyan(f'Error: cannot write to temp directory {tempdir}.\n')) + sys.exit(-1) + +def cleanup(no_temp,tempdir): + if not no_temp: + shutil.rmtree(tempdir) + +def parse_alignment_options(alignment_arg, outdir, tempdir,alignment_file_arg, alignment_file): + if alignment_arg: + aligndir = outdir + alignment_out = True + else: + aligndir = tempdir + alignment_out = False + + if alignment_file_arg: + alignment_file = os.path.join(aligndir, alignment_file_arg) + else: + alignment_file = os.path.join(aligndir, alignment_file) + + return alignment_file,alignment_out +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/utils/log_colours.py",".py","374","20","#!/usr/bin/env python3 +END_FORMATTING = '\033[0m' +RED = '\033[31m' +GREEN = '\033[32m' +YELLOW = '\033[93m' +CYAN = '\u001b[36m' +DIM = '\033[2m' + +def red(text): + return RED + text + END_FORMATTING + +def cyan(text): + return CYAN + text + END_FORMATTING + +def green(text): + return GREEN + text + END_FORMATTING + +def yellow(text): + return YELLOW + text + END_FORMATTING +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/pangolearn/pangolearn.py",".py","5803","208","#!/usr/bin/env python3 + +import pandas as pd +import numpy as np +from sklearn.model_selection import train_test_split +from sklearn.linear_model import LogisticRegression +from sklearn import metrics +from sklearn.datasets import make_classification +from sklearn.model_selection import StratifiedShuffleSplit +from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix +from datetime import datetime +import joblib +from Bio import SeqIO +import sys +import os + +import warnings + +warnings.filterwarnings(""ignore"") + +def findReferenceSeq(referenceFile): + currentSeq = """" + + with open(referenceFile) as f: + for line in f: + if "">"" not in line: + currentSeq = currentSeq + line.strip() + + f.close() + return currentSeq + +# function for handling weird sequence characters +def clean(referenceSeq,x, loc): + x = x.upper() + + if x in {'T', 'A', 'G', 'C', '-'}: + return x, False + + if x == 'U': + return 'T', False + + # replace ambiguity with the reference seq value + + if referenceSeq[loc] == x: + return referenceSeq[loc], False + + return referenceSeq[loc], True + +# generates data line +def encodeSeq(referenceSeq,seq, indiciesToKeep): + dataLine = [] + imputed = 0 + nonimputed = 0 + + for i in indiciesToKeep: + if i < len(seq): + cleaned, isImputed = clean(referenceSeq,seq[i], i) + + dataLine.extend(cleaned) + + if(isImputed): + imputed = imputed + 1 + else: + nonimputed = nonimputed + 1 + + score = 0 + + if nonimputed != 0 and imputed < nonimputed: + score = 1 - (imputed/nonimputed) + + return dataLine, score + +# reads in the two data files +def readInAndFormatData(referenceSeq, imputationScores,sequencesFile, indiciesToKeep, blockSize=1000): + idList = [] + seqList = [] + + # open sequencesFile, which is the first snakemake input file + with open(sequencesFile) as f: + currentSeq = """" + + # go line by line through the file, collecting a list of the sequences + for line in f: + # if the line isn't the header line + if ""taxon,lineage"" not in line: + line = line.strip() + + if "">"" in line: + # starting new entry, gotta save the old one + if currentSeq: + # yield sequence as one-hot encoded vector + idList.append(seqid) + + finalSeq, imputationScore = encodeSeq(referenceSeq,currentSeq, indiciesToKeep) + seqList.append(finalSeq) + currentSeq = """" + + imputationScores[seqid] = imputationScore + + # this is a fasta line designating an id, but we don't want to keep the > + seqid = line.strip('>') + + else: + currentSeq = currentSeq + line + + if len(seqList) == blockSize: + yield idList, seqList + idList = [] + seqList = [] + + # gotta get the last one + idList.append(seqid) + finalSeq, imputationScore = encodeSeq(referenceSeq,currentSeq, indiciesToKeep) + seqList.append(finalSeq) + imputationScores[seqid] = imputationScore + + yield idList, seqList + +def assign_lineage(header_file,model_file,reference_file,sequences_file,outfile): + + print(""Running pangoLEARN assignment"") + dirname = os.path.dirname(__file__) + + referenceSeq = """" + referenceId = ""reference"" + + imputationScores = dict() + records = 0 + for record in SeqIO.parse(sequences_file,""fasta""): + records +=1 + if records ==0: + f = open(outfile, ""w"") + f.write(""taxon,prediction,score,imputation_score,non_zero_ids,non_zero_scores,designated\n"") + f.close() + print(""No sequences to assign with pangoLEARN."") + else: + + # loading the list of headers the model needs. + model_headers = joblib.load(header_file) + indiciesToKeep = model_headers[1:] + + referenceSeq = findReferenceSeq(reference_file) + # possible nucleotide symbols + categories = ['-','A', 'C', 'G', 'T'] + columns = [f""{i}_{c}"" for i in indiciesToKeep for c in categories] + + + + rs, score = encodeSeq(referenceSeq, referenceSeq, indiciesToKeep) + + refRow = [r==c for r in rs for c in categories] + + print(""Loading model "" + datetime.now().strftime(""%m/%d/%Y, %H:%M:%S"")) + loaded_model = joblib.load(model_file) + print(""Finished loading model "" + datetime.now().strftime(""%m/%d/%Y, %H:%M:%S"")) + + # write predictions to a file + f = open(outfile, ""w"") + f.write(""taxon,prediction,score,imputation_score,non_zero_ids,non_zero_scores,designated\n"") + for idList, seqList in readInAndFormatData(referenceSeq,imputationScores,sequences_file, indiciesToKeep): + print(""Processing block of {} sequences {}"".format( + len(seqList), datetime.now().strftime(""%m/%d/%Y, %H:%M:%S"") + )) + + rows = [[r==c for r in row for c in categories] for row in seqList] + # the reference seq must be added to everry block to make sure that the + # spots in the reference have Ns are in the dataframe to guarentee that + # the correct number of columns is created when get_dummies is called + rows.append(refRow) + idList.append(referenceId) + + # create a data from from the seqList + d = np.array(rows, np.uint8) + df = pd.DataFrame(d, columns=columns) + + predictions = loaded_model.predict_proba(df) + + for index in range(len(predictions)): + + maxScore = 0 + maxIndex = -1 + + nonZeroIds = [] + nonZeroScores = [] + + # get the max probability score and its assosciated index + for i in range(len(predictions[index])): + if predictions[index][i] > maxScore: + maxScore = predictions[index][i] + maxIndex = i + + nonZeroScores.append(predictions[index][i]) + nonZeroIds.append(loaded_model.classes_[i]) + + score = maxScore + prediction = loaded_model.classes_[maxIndex] + seqId = idList[index] + + nonZeroIds = "";"".join(nonZeroIds) + nonZeroScores = ';'.join(str(x) for x in nonZeroScores) + + if seqId != referenceId: + f.write(seqId + "","" + prediction + "","" + str(score) + "","" + str(imputationScores[seqId]) + "","" + nonZeroIds + "","" + nonZeroScores + "","" + ""\n"") + + f.close() + + print(""Complete "" + datetime.now().strftime(""%m/%d/%Y, %H:%M:%S"")) +","Python" +"Pathogens","cov-lineages/pangolin","pangolin/pangolearn/__init__.py",".py","0","0","","Python" +"Pathogens","cov-lineages/pangolin","pangolin/scripts/__init__.py",".py","0","0","","Python" +"Pathogens","cov-lineages/pangolin","docs/update_guide_tree.md",".md","701","27","# Updating the guide tree and alignment with new data + +### Requirements + +1. A csv with taxon names and lineage + +2. A fasta file (doesn't need to be an alignment but can be) with the corresponding sequences. + +3. A metadata csv from ``grapevine`` + +### Usage + +1. Activate the environment ``conda activate pangolin`` +2. Run the following: + +``` +snakemake + --snakefile prepare_package_data.smk \ + --config \ + metadata=your_new_metadata.csv \ + fasta=your_new_fasta.fasta \ + global_tree=global_tree.nexus \ + outdir=where/to/put/your/data \ + lineages=lineages.csv \ + --cores 2 +``` +","Markdown" +"Pathogens","cov-lineages/pangolin","tests/test_command.py",".py","1036","34","from pathlib import Path +from pangolin import command + +TEST_DIR = Path(__file__).parent + + +def test_cmd_line(tmp_path): + query_file = TEST_DIR / 'test-data' / 'sequence1.fasta' + output_file = TEST_DIR / 'out.csv' + args = ['--outfile', str(output_file), + '--analysis-mode', 'fast', + str(query_file) + ] + command.main(sysargs=args) + results = open(output_file).read() + assert 'Delta (B.1.617.2-like)' in results + + +def test_cmd_line_partial_datadir(tmp_path): + # test with a datadir with just the `constellations` data + test_data_dir = TEST_DIR / 'test-data' + query_file = test_data_dir / 'sequence1.fasta' + datadir = test_data_dir / 'datadir1' + + output_file = TEST_DIR / 'out.csv' + args = ['--outfile', str(output_file), + '--datadir', str(datadir), + '--analysis-mode', 'fast', + str(query_file) + ] + command.main(sysargs=args) + results = open(output_file).read() + assert 'Delta (B.1.617.2-like-with-bells)' in results +","Python" +"Pathogens","cov-lineages/pangolin","tests/test-data/datadir1/constellations/__init__.py",".py","55","4","_program = ""constellations"" +__version__ = ""v999.9.99"" + +","Python" +"Pathogens","jodyphelan/pathogen-profiler","setup.py",".py","333","15","import setuptools +import glob + +version = [l.strip() for l in open(""pathogenprofiler/__init__.py"") if ""version"" in l][0].split('""')[1] + +setuptools.setup( + + name=""pathogen-profiler"", + version=version, + packages=[""pathogenprofiler"",], + license=""GPL3"", + long_description=""Pathogen profiling tool"", + scripts= glob.glob(""scripts/*.py"") +) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/fastq.py",".py","12968","255","from __future__ import division +from .bam import Bam +from .utils import filecheck, add_arguments_to_self, run_cmd,bwa_index,bwa_meme_index,bwa2_index,bowtie_index,cmd_out, shared_dict +import os +from collections import defaultdict +from .kmer import KmerDump +import platform +import logging +from .taxonomy import Sketch, SourmashSig, SylphSketch +from .models import FastqQC +import tempfile + + + +class Fastq: + """""" + Class to represent a fastq file(s). + Methods include sketching, trimming and mapping to a reference genome. + """""" + def __init__(self,r1: str,r2: str = None,r3: str = None): + """""" + Initialize Fastq object + + Parameters + ---------- + r1 : str + Read 1 fastq file + r2 : str + Read 2 fastq file (optional) + r3 : str + Unpaired reads fastq file (optional) + """""" + self.r1 = r1 + self.r2 = r2 + self.r3 = r3 + # Work out if it is paired end sequencing + self.paired = True if (r1 and r2) else False + filecheck(r1) + self.files = [r1] + if self.paired: + filecheck(r2) + self.files.append(r2) + if r3: + filecheck(r3) + self.files.append(r3) + + def trim(self, prefix, threads=1): + """"""Perform trimming"""""" + logging.info(""Trimming reads"") + shared_dict['software']['trimming'] = 'trimmomatic' + add_arguments_to_self(self, locals()) + if self.paired: + run_cmd(""trimmomatic PE -threads %(threads)s -phred33 %(r1)s %(r2)s -baseout %(prefix)s LEADING:3 TRAILING:3 SLIDINGWINDOW:4:20 MINLEN:36"" % vars(self)) + run_cmd(""cat %(prefix)s_1U %(prefix)s_2U > %(prefix)s_TU"" % vars(self)) + run_cmd(""rm %(prefix)s_1U %(prefix)s_2U"" % vars(self)) + return Fastq(""%(prefix)s_1P"" % vars(self), ""%(prefix)s_2P"" % vars(self), ""%(prefix)s_TU"" % vars(self)) + else: + run_cmd(""trimmomatic SE -threads %(threads)s -phred33 %(r1)s %(prefix)s_TU LEADING:3 TRAILING:3 SLIDINGWINDOW:4:20 MINLEN:36"" % vars(self)) + return Fastq(""%(prefix)s_TU"" % vars(self)) + + def map_to_ref(self, ref_file: str, prefix: str, sample_name: str, aligner: str, platform: str, threads: int = 1, markdup: bool = True, max_mem: str = ""768M"") -> Bam: + """"""Mapping to a reference genome"""""" + logging.info(""Mapping to reference genome"") + add_arguments_to_self(self, locals()) + self.prefix = prefix + self.sample_name = sample_name + self.aligner = aligner.lower() + accepted_aligners = [""bwa"",""bwa-meme"",""bwa-mem2"",""bowtie2"",""minimap2""] + if self.aligner not in accepted_aligners: + quit(""ERROR: %s not in accepted aligners\n"" % aligner) + + self.platform = platform.lower() + accepted_platforms = [""illumina"",""nanopore"",""pacbio""] + if self.platform not in accepted_platforms: + quit(""ERROR: %s not in accepted platforms\n"" % platform) + + if self.aligner==""minimap2"": + pass + else: + {""bwa"":bwa_index,""bwa-meme"":bwa_meme_index,""bwa-mem2"":bwa2_index,""bowtie2"":bowtie_index}[self.aligner](ref_file) + + self.bwa_prefix = ""bwa mem -t %(threads)s -K 10000000 -c 100 -R '@RG\\tID:%(sample_name)s\\tSM:%(sample_name)s\\tPL:%(platform)s' -M -T 50"" % vars(self) + self.bwa_meme_prefix = ""bwa-meme mem -t %(threads)s -K 10000000 -c 100 -R '@RG\\tID:%(sample_name)s\\tSM:%(sample_name)s\\tPL:%(platform)s' -M -T 50"" % vars(self) + self.bwa2_prefix = ""bwa-mem2 mem -t %(threads)s -c 100 -R '@RG\\tID:%(sample_name)s\\tSM:%(sample_name)s\\tPL:%(platform)s' -M -T 50"" % vars(self) + self.bowtie2_prefix = ""bowtie2 -p %(threads)s --rg-id '%(sample_name)s' --rg 'SM:%(sample_name)s' --rg 'PL:%(platform)s'"" % vars(self) + self.minimap2_prefix = ""minimap2 --MD -t %(threads)s -R '@RG\\tID:%(sample_name)s\\tSM:%(sample_name)s\\tPL:%(platform)s' -a"" % vars(self) + self.bam_file = ""%s.bam"" % self.prefix + self.bam_single_file = ""%s.single.bam"" % self.prefix + self.bam_pair_file = ""%s.pair.bam"" % self.prefix + self.bam_unsort_file = ""%s.unsort.bam"" % self.prefix + if self.platform == ""nanopore"": + run_cmd(""%(minimap2_prefix)s -x map-ont %(ref_file)s %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + elif self.platform == ""pacbio"": + run_cmd(""%(minimap2_prefix)s -x map-pb %(ref_file)s %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + else: + if aligner==""bwa"" and self.paired: + run_cmd(""%(bwa_prefix)s %(ref_file)s %(r1)s %(r2)s | samtools sort -@ %(threads)s -o %(bam_pair_file)s -"" % vars(self)) + if self.r3: + run_cmd(""%(bwa_prefix)s %(ref_file)s %(r3)s | samtools sort -@ %(threads)s -o %(bam_single_file)s -"" % vars(self)) + elif aligner==""bwa"" and not self.paired: + run_cmd(""%(bwa_prefix)s %(ref_file)s %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + elif aligner==""bwa-meme"" and self.paired: + run_cmd(""%(bwa_meme_prefix)s %(ref_file)s %(r1)s %(r2)s | samtools sort -@ %(threads)s -o %(bam_pair_file)s -"" % vars(self)) + if self.r3: + run_cmd(""%(bwa_meme_prefix)s %(ref_file)s %(r3)s | samtools sort -@ %(threads)s -o %(bam_single_file)s -"" % vars(self)) + elif aligner==""bwa-meme"" and not self.paired: + run_cmd(""%(bwa_meme_prefix)s %(ref_file)s %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + elif aligner==""bwa-mem2"" and self.paired: + run_cmd(""%(bwa2_prefix)s %(ref_file)s %(r1)s %(r2)s | samtools sort -@ %(threads)s -o %(bam_pair_file)s -"" % vars(self)) + if self.r3: + run_cmd(""%(bwa2_prefix)s %(ref_file)s %(r3)s | samtools sort -@ %(threads)s -o %(bam_single_file)s -"" % vars(self)) + elif aligner==""bwa-mem2"" and not self.paired: + run_cmd(""%(bwa2_prefix)s %(ref_file)s %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + elif aligner==""bowtie2"" and self.paired: + run_cmd(""%(bowtie2_prefix)s -x %(ref_file)s -1 %(r1)s -2 %(r2)s | samtools sort -@ %(threads)s -o %(bam_pair_file)s -"" % vars(self)) + if self.r3: + run_cmd(""%(bowtie2_prefix)s -x %(ref_file)s -U %(r3)s | samtools sort -@ %(threads)s -o %(bam_single_file)s"" % vars(self)) + elif aligner==""bowtie2"" and not self.paired: + run_cmd(""%(bowtie2_prefix)s -x %(ref_file)s -1 %(r1)s | samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + elif aligner==""minimap2"" and self.paired: + run_cmd(""%(minimap2_prefix)s -ax sr %(ref_file)s %(r1)s %(r2)s | samtools sort -@ %(threads)s -o %(bam_pair_file)s -"" % vars(self)) + if self.r3: + run_cmd(""%(minimap2_prefix)s -ax sr %(ref_file)s %(r3)s| samtools sort -@ %(threads)s -o %(bam_single_file)s -"" % vars(self)) + elif aligner==""minimap2"" and not self.paired: + run_cmd(""%(minimap2_prefix)s -ax sr %(ref_file)s %(r1)s| samtools sort -@ %(threads)s -o %(bam_file)s -"" % vars(self)) + + if self.paired: + if self.r3: + run_cmd(""samtools merge -@ %(threads)s -f %(bam_unsort_file)s %(bam_pair_file)s %(bam_single_file)s"" % vars(self)) + else: + self.bam_unsort_file = self.bam_pair_file + # run_cmd(""samtools sort -@ %(threads)s -o %(bam_file)s %(bam_unsort_file)s"" % vars(self)) + if markdup: + run_cmd(""samtools sort -m %(max_mem)s -n -@ %(threads)s %(bam_unsort_file)s | samtools fixmate -@ %(threads)s -m - - | samtools sort -m %(max_mem)s -@ %(threads)s - | samtools markdup -@ %(threads)s - %(bam_file)s"" % vars(self)) + else: + run_cmd(""samtools sort -m %(max_mem)s -@ %(threads)s -o %(bam_file)s %(bam_unsort_file)s"" % vars(self)) + if self.r3: + run_cmd(""rm %(bam_single_file)s %(bam_pair_file)s %(bam_unsort_file)s"" % vars(self)) + else: + run_cmd(""rm %(bam_pair_file)s"" % vars(self)) + shared_dict['software']['mapping'] = aligner + return Bam(self.bam_file,self.prefix,self.platform,threads=threads) + + def get_kmer_counts(self,prefix,klen = 31,threads=1,max_mem=8,counter = ""kmc""): + logging.info(""Counting kmers"") + shared_dict['software']['kmer_counting'] = counter + if counter==""kmc"": + if threads>32: + threads = 32 + tmp_prefix = f""{prefix}_kmers"" + tmp_file_list = f""{prefix}.kmc.list"" + os.mkdir(tmp_prefix) + with open(tmp_file_list,""w"") as O: + O.write(""\n"".join(self.files)) + bins = ""-n128"" if platform.system()==""Darwin"" else """" + run_cmd(f""kmc {bins} -m{max_mem} -t{threads} -k{klen} @{tmp_file_list} {tmp_prefix} {tmp_prefix}"") + run_cmd(f""kmc_dump {tmp_prefix} {prefix}.kmers.txt"") + run_cmd(f""rm -r {tmp_prefix}*"") + + return KmerDump(f""{prefix}.kmers.txt"",counter) + elif counter==""dsk"": + max_mem = max_mem * 1000 + tmp_prefix = f""{prefix}_kmers"" + os.mkdir(tmp_prefix) + r2 = f""-file {self.r2}"" if self.r2 else """" + run_cmd(f""dsk -file {self.r1} {r2} -abundance-min 2 -nb-cores {threads} -kmer-size {klen} -max-memory {max_mem} -out {tmp_prefix} -out-tmp {tmp_prefix}"") + run_cmd(f""dsk2ascii -file {tmp_prefix}.h5 -out {prefix}.kmers.txt"") + run_cmd(f""rm -r {tmp_prefix}*"") + + return KmerDump(f""{prefix}.kmers.txt"",counter) + elif counter==""FastK"": + tmpdir = f""{prefix}_kmers"" + os.mkdir(tmpdir) + # with tempfile.TemporaryDirectory() as tmpdir: + run_cmd(f""FastK -k{klen} -t -T{threads} -N{tmpdir}/out -P{tmpdir} {' '.join(self.files)}"") + run_cmd(f""Tabex -t2 {tmpdir}/out.ktab LIST > {tmpdir}/kmers.txt"") + with open(f""{prefix}.kmers.txt"", ""w"") as f: + infile = open(f""{tmpdir}/kmers.txt"") + infile.readline() + for line in infile: + row = line.strip().split() + f.write(f""{row[1].upper()}\t{row[-1]}\n"") + + + return KmerDump(f""{prefix}.kmers.txt"",counter) + def sourmash_sketch(self,prefix,scaled=200): + logging.info(""Sketching reads"") + read1 = self.r1 + read2 = self.r2 if self.r2 else """" + run_cmd(f""sourmash sketch dna -p abund,scaled={scaled} --merge {prefix} -o {prefix}.sig {read1} {read2}"") + return SourmashSig(f""{prefix}.sig"",tmp_prefix=prefix) + + def sylph_sketch(self,prefix, threads=1): + logging.info(""Sketching reads with sylph"") + + if self.r1 and self.r2: + reads_arg = f""-1 {self.r1} -2 {self.r2}"" + tmp_outfile = f""{prefix}_sylph/{self.r1.split('/')[-1]}.paired.sylsp"" + else: + reads_arg = f""-r {self.r1}"" + tmp_outfile = f""{prefix}_sylph/{self.r1.split('/')[-1]}.sylsp"" + + outfile = f""{prefix}.sylsp"" + + run_cmd(f""sylph sketch -d {prefix}_sylph {reads_arg} -t {threads}"") + run_cmd(f""mv {tmp_outfile} {outfile}"") + run_cmd(f""rm -r {prefix}_sylph"") + return SylphSketch(outfile,tmp_prefix=prefix) + + def sketch(self,prefix: str, software: str, threads: int = 1) -> Sketch: + """""" + Sketch reads using specified software + + Parameters + ---------- + prefix : str + Prefix for output files + software : str + Sketching software to use (""sourmash"" or ""sylph"") + threads : int + Number of threads to use + + Returns + ------- + Sketch + Sketch object + """""" + shared_dict['software']['taxonomic_software'] = software + + if software==""sourmash"": + return self.sourmash_sketch(prefix) + elif software==""sylph"": + return self.sylph_sketch(prefix, threads=threads) + else: + raise NotImplementedError(f""{software} not implemented as a sketch method"") + + def get_qc(self): + """"""Get quality control metrics"""""" + header = None + result = defaultdict(int) + for l in cmd_out('seqkit stats -T %s' % ""\t"".join(self.files)): + row = l.strip().split() + if row[0]=='file': + header = row + continue + r = dict(zip(header,row)) + for column in ('num_seqs','sum_len'): + result[column] += int(r[column]) + return FastqQC( + num_bases=result['sum_len'], + num_sequences=result['num_seqs'] + ) + + def __repr__(self): + return ""Fastq(%s)"" % "","".join(self.files)","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/mutation_db.py",".py","6949","178","from typing import List, Union, Set +import json +from .models import Variant, Gene, GenomePositionDepth, Consequence +from copy import deepcopy +from collections import defaultdict +import re +from .hgvs import extract_numbers +import logging + +class DictSet: + """""" + A class to create a set that works with dictionaries + """""" + def __init__(self,data: List[dict] = None): + self.container = set() + if data: + for d in data: + self.container.add(json.dumps(d)) + def add(self,data: Union[dict,list]) -> None: + if isinstance(data,list): + for d in data: + self.container.add(json.dumps(d)) + elif isinstance(data,dict): + self.container.add(json.dumps(data)) + + def to_dict_list(self) -> List[dict]: + return [json.loads(d) for d in sorted(list(self.container))] + + + +def db_compare(variants: List[Variant],db: dict) -> List[Union[Variant,Gene]]: + annotated_results = deepcopy(variants) + mutation_db = MutationDB(db) + + for var in annotated_results: + mutation_db.annotate_variant(var) + mutation_db.apply_lof_annotation(var) + + genes = mutation_db.get_functionally_normal_genes(annotated_results) + annotated_results += genes + + return annotated_results + +class MutationDB: + """""" + A class to store mutations in a data structure that can be queried + Can be used to annotate mutations with data from a database + """""" + def __init__(self,db: dict): + self.db = {} + self.genes = set() + self.genome_pos2annotation = defaultdict(list) + for gene in db: + self.genes.add(gene) + for var in db[gene]: + self.db[(gene,var)] = db[gene][var] + if self.db[(gene,var)]['genome_positions']: + for pos in self.db[(gene,var)]['genome_positions']: + for ann in self.db[(gene,var)]['annotations']: + # deep copy the annotation to avoid changing the original + ann = deepcopy(ann) + ann['gene'] = gene + ann['variant'] = var + self.genome_pos2annotation[(db[gene][var]['chromosome'],pos)].append(ann) + + + def annotate_variant(self,var: dict) -> List[dict]: + """"""Annotate a variant with data from the database"""""" + for csq in var.consequences: + annotations = self.get_annotation(csq) + csq.annotation = annotations + + def apply_lof_annotation(self, var: Variant) -> None: + """"""Apply loss of function annotation to a variant"""""" + for csq in var.consequences: + for annotation in csq.annotation: + if annotation['type']=='loss_of_function': + csq.type = annotation['so_term'] + + + def get_annotation(self,csq: Consequence) -> List[dict]: + """"""Get the annotation for a consequence from the database"""""" + db_var_match = DictSet() + + if csq.gene_id not in self.genes: + return [] + + key = (csq.gene_id,csq.nucleotide_change) + if key in self.db: + db_var_match.add(self.db[key]['annotations']) + key = (csq.gene_id,csq.protein_change) + if key in self.db: + db_var_match.add(self.db[key]['annotations']) + key = (csq.gene_id,csq.sequence_hgvs) + if key in self.db: + db_var_match.add(self.db[key]['annotations']) + + for t in csq.type.split(""&""): + key = (csq.gene_id,t) + if key in self.db: + db_var_match.add(self.db[(csq.gene_id,t)]['annotations']) + if d:=self.check_for_so_wildcard(csq): + db_var_match.add(d['annotations']) + return db_var_match.to_dict_list() + + def get_functionally_normal_genes(self, variants: List[dict]) -> List[str]: + """"""Get all variants for a gene that are functionally normal"""""" + genes_to_check = [gene for gene,variant in self.db.keys() if variant=='functionally_normal'] + logging.debug(f""Checking for functionally normal genes among: {genes_to_check}"") + genes_to_return = [] + for gene in genes_to_check: + intact = True + for var in variants: + for csq in var.consequences: + if csq.gene_id==gene: + if csq.type in ('loss_of_function_variant','stop_gained','frameshift_variant','feature_ablation','transcript_ablation'): + intact = False + if intact: + genes_to_return.append(gene) + + gene_objects = [] + for gene in genes_to_return: + gene_objects.append(Gene( + gene_id=gene, + annotation=self.db[(gene,'functionally_normal')]['annotations'], + type=""functionally_normal"" + )) + + return gene_objects + + + def get_gene_variants(self,gene: str) -> List[str]: + """"""Get all variants for a gene"""""" + return [v for g,v in self.db if g==gene] + + def check_for_so_wildcard(self,csq: dict): + """"""Check if the variant is in the database with a wildcard SO term"""""" + for var in self.get_gene_variants(csq.gene_id): + for t in csq.type.split('&'): + r = re.search(f""{t}_([pcn]).(\d+)_(\d+)"",var) + if r: + context = r.group(1) + positions = set(range(int(r.group(2)),int(r.group(3))+1)) + if context==""p"": + change = csq.protein_change + elif context==""c"": + change = csq.nucleotide_change + elif context==""n"": + change = csq.nucleotide_change + affected_positions = extract_affected_positions(change) + if len(positions.intersection(affected_positions))>0: + return self.db[(csq.gene_id,var)] + + def annotate_missing_positions(self, positions: List[GenomePositionDepth]) -> None: + """""" + Annotate missing positions with data from the database + + Arguments + --------- + positions: List[PositionDepth] + A list of positions to annotate + + Returns + ------- + List[MissingPos] + A list of annotated positions + """""" + annotated_positions = [] + for pos in positions: + if (pos.chrom,pos.pos) in self.genome_pos2annotation: + pos.annotation = self.genome_pos2annotation[(pos.chrom,pos.pos)] + return annotated_positions + +def extract_affected_positions(change: str) -> Set[int]: + """"""Extract the affected positions from a variant annotation with a range of positions"""""" + numbers = extract_numbers(change) + return set(range(numbers[0],numbers[-1]+1)) + ","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/kmer.py",".py","3449","92","from tqdm import tqdm +import statistics as stats +from .utils import revcom +from itertools import combinations, product +import os +import logging +from .models import Species + + + +class KmerDump: + def __init__(self,kmer_file,counter): + self.kmer_file = kmer_file + if counter==""kmc"": + nuc_order = ""ACGT"" + elif counter==""dsk"": + nuc_order = ""ACTG"" + elif counter==""FastK"": + nuc_order = ""ACGT"" + self.nuc_order = {n:i for i,n in enumerate(nuc_order)} + + def load_kmer_counts(self,kmer_db_file,remove_after_processing=True,max_mismatch=1): + self.kmer_counts = [] + kmers = {} + for l in open(kmer_db_file): + row = l.strip().split(""\t"") + for k in self.mutate_kmer(row[0],d=max_mismatch): + kmers[k] = row[1] + tmp_counts = {} + logging.info(f""Looking for {len(kmers)} kmers"") + for l in tqdm(open(self.kmer_file)): + row = l.strip().split() + if row[0] not in kmers: continue + tmp_counts[row[0]] = int(row[1]) + + for l in open(kmer_db_file): + row = l.strip().split(""\t"") + count = sum([tmp_counts.get(k,0) for k in self.mutate_kmer(row[0],d=max_mismatch)]) + self.kmer_counts.append({""name"":kmers[self.get_canonical_kmer(row[0])],""seq"":row[0],""count"":count}) + if remove_after_processing: + os.remove(self.kmer_file) + return self.kmer_counts + + def get_taxonomic_support(self,kmer_db_file,output_kmer_counts=None) -> Species: + if not hasattr(self, 'kmer_counts'): + self.load_kmer_counts(kmer_db_file,max_mismatch=0) + + if output_kmer_counts: + with open(output_kmer_counts,""w"") as O: + for k in self.kmer_counts: + O.write(""%(name)s\t%(seq)s\t%(count)s\n"" % k) + + + taxon_set = set(l.strip().split(""\t"")[1] for l in open(kmer_db_file)) + taxon_support = [] + for s in taxon_set: + support = [x[""count""] for x in self.kmer_counts if x[""name""]==s] + if len([x for x in support if x!=0]) str: + return f""Gene: {vars(self)}"" + def __contains__(self,position: tuple[str,int]) -> bool: + chrom,pos = position + pos = GenomePosition(chrom=chrom,pos=pos) + range = GenomeRange(chrom=self.chrom,start=self.feature_start,end=self.feature_end) + return pos in range + +class Exon: + def __init__(self, chrom, start, end, strand, phase): + self.chrom = chrom + self.start = start + self.end = end + self.strand = strand + self.phase = phase + def __repr__(self): + return ""Exon: %s-%s (%s)"" % (self.start, self.end, self.strand) + +class Transcript: + def __init__(self,name): + self.name = name + self.exons = [] + +def load_gff(gff) -> List[Gene]: + GFF = open(gff) + genes = {} + relationships = {} + items = {} + while True: + l = GFF.readline().strip() + if not l: break + if l[0]==""#"": continue + if l.strip()=='': continue + fields = l.rstrip().split(""\t"") + strand = fields[6] + chrom = fields[0] + p1 = int(fields[3]) + p2 = int(fields[4]) + feature_id = re.search(""ID=([^;]*)"",l) + feature_id = feature_id.group(1) if feature_id else None + parent_id = re.search(""Parent=([^;]*)"",l) + parent_id = parent_id.group(1) if parent_id else None + + if fields[2] in [""gene"",""pseudogene"",""rRNA_gene"",""ncRNA_gene"",""protein_coding_gene"",""tRNA_gene""]: + gene_length = p2-p1+1 + + gene_id = None + search_strings = [ + r""ID=gene:([a-zA-Z0-9\.\-\_]+)"", + r""ID=gene-([a-zA-Z0-9\.\-\_]+)"", + r""gene_id=([a-zA-Z0-9\.\-\_]+)"", + r""ID=([a-zA-Z0-9\.\-\_]+)"", + r""locus_tag=([a-zA-Z0-9\.\-\_]+)"", + + ] + for s in search_strings: + re_obj = re.search(s,l) + if re_obj: + gene_id = re_obj.group(1) + break + if not gene_id: + continue + re_obj = re.search(r""Name=([a-zA-Z0-9\.\-\_\(\)]+)"",l) + gene_name = re_obj.group(1) if re_obj else gene_id + start = p1 + end = p2 + + items[feature_id] = Gene(gene_name,gene_id,strand,chrom,start,end,gene_length) + relationships[feature_id] = None + + if fields[2] in [""mRNA"",""transcript""]: + items[feature_id] = Transcript(feature_id) + relationships[feature_id] = parent_id + + if fields[2] in [""CDS""]: + if fields[7]=="""": + continue + phase = int(fields[7]) + _id = str(uuid4()) + items[_id] = Exon(chrom,p1,p2,strand,phase) + relationships[_id] = parent_id + + transcript_exons = defaultdict(list) + for item in items: + if isinstance(items[item],Exon): + transcript_exons[relationships[item]].append(items[item]) + + for item in items: + if isinstance(items[item],Transcript): + exons = transcript_exons[item] + items[item].exons = sorted(exons,key=lambda x: x.start) + gene = items[relationships[item]] + gene.transcripts.append(items[item]) + + for item in items: + if isinstance(items[item],Gene): + genes[items[item].gene_id] = items[item] + + + return list(genes.values())","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/models.py",".py","28469","893","from typing import List, Union, Optional, Generator +from pydantic import BaseModel, Field +from statistics import median + +def generate_example_consequence(): + """"""Generate an example consequence"""""" + return Consequence( + gene_id='Rv0667', + gene_name='rpoB', + feature_id='CCP43410', + type='missense_variant', + nucleotide_change='c.1349C>T', + protein_change='p.Ser450Leu', + annotation=[{'type':'drug_resistance','drug':'rifampicin'}] + ) + +def generate_example_variant(forward_reads=50,reverse_reads=50): + """"""Generate an example variant"""""" + return Variant( + chrom='Chromosome', + pos=761155, + ref='C', + alt='T', + depth=forward_reads+reverse_reads, + freq=0.5, + forward_reads=forward_reads, + reverse_reads=reverse_reads, + sv=False, + sv_len=False, + consequences=[ + Consequence( + gene_id='Rv0667', + gene_name='rpoB', + feature_id='CCP43410', + type='missense_variant', + nucleotide_change='c.1349C>T', + protein_change='p.Ser450Leu', + annotation=[{'type':'drug_resistance','drug':'rifampicin'}] + ) + ] + ) + +def generate_example_dr_variant(): + """"""Generate an example drug resistant variant"""""" + return DrVariant( + chrom='Chromosome', + pos=761155, + ref='C', + alt='T', + depth=100, + freq=0.5, + forward_reads=50, + reverse_reads=50, + sv=False, + sv_len=0, + consequences=[ + Consequence( + gene_id='Rv0667', + gene_name='rpoB', + feature_id='CCP43410', + type='missense_variant', + nucleotide_change='c.1349C>T', + protein_change='p.Ser450Leu', + annotation=[{'type':'drug_resistance','drug':'rifampicin'}] + ) + ], + drugs=[{'drug':'rifampicin'}] + ) + +def generate_example_gene(): + """"""Generate an example gene"""""" + return Gene( + gene_id='Rv0667', + type='functionally_normal', + gene_name='rpoB', + annotation=[{'type':'drug_resistance','drug':'rifampicin'}] + ) + +def generate_example_dr_gene(): + """"""Generate an example drug resistant gene"""""" + return DrGene( + gene_name='rpoB', + gene_id='Rv0667', + annotation=[], + drugs=[{'drug':'rifampicin'}] + ) + +class Consequence(BaseModel): + """""" + A consequence of a variant + + Attributes + ---------- + gene_id : str + The gene id + gene_name : str + The gene name + feature_id : str + The feature id + type : str + The type of variant + nucleotide_change : str + The nucleotide change + protein_change : str + The protein change + annotation : List[dict] + A list of annotations + + Examples + -------- + >>> from pathogenprofiler import Consequence, generate_example_consequence + >>> csq = generate_example_consequence() + >>> csq + Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + gene_id: str + gene_name: Union[str,None] + feature_id: Union[str,None] + type: str + nucleotide_change: str + protein_change: Union[str,None] + sequence_hgvs: Union[str,None] = None + annotation: List[dict] = Field(default_factory=list) + + def causes_drug_resistance(self, drug: str = None) -> bool: + """""" + Check if variant causes drug resistance + + Parameters + ---------- + drug : str + The drug to check for + + Returns + ------- + bool + True if variant causes drug resistance, False otherwise + + Examples + -------- + >>> from pathogenprofiler import Consequence, generate_example_consequence + >>> csq = generate_example_consequence() + >>> csq.causes_drug_resistance() + True + >>> csq.causes_drug_resistance('rifampicin') + True + >>> csq.causes_drug_resistance('isoniazid') + False + """""" + for ann in self.annotation: + if ann['type']=='drug_resistance': + if drug is None: + return True + if ann['drug']==drug: + return True + return False + + +class Variant(BaseModel): + """""" + A variant + + Attributes + ---------- + chrom : str + The chromosome + pos : int + The position + ref : str + The reference allele + alt : str + The alternate allele + depth : int + The depth + freq : float + The frequency + sv : bool + True if variant is a structural variant, False otherwise + filter : str + The filter string (pass, soft_fail or hard_fail) + forward_reads : int + The number of forward reads + reverse_reads : int + The number of reverse reads + sv_len : int + The length of the structural variant + consequences : List[Consequence] + A list of consequences + gene_id : str + The gene id + gene_name : str + The gene name + feature_id : str + The feature id + type : str + The type of variant + change : str + The change + nucleotide_change : str + The nucleotide change + protein_change : str + The protein change + annotation : List[dict] + A list of annotations + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> var = generate_example_variant() + >>> var + Variant(chrom='Chromosome', pos=761155, ref='C', alt='T', depth=100, freq=0.5, forward_reads=50, reverse_reads=50, sv=False, sv_len=0, consequences=[Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}])], gene_id=None, gene_name=None, feature_id=None, type=None, change=None, nucleotide_change=None, protein_change=None, annotation=[]) + """""" + chrom: str + pos: int + ref: str + alt: str + depth: int + freq: float + sv: bool + filter: Optional[str] = None + forward_reads: Optional[int] = None + reverse_reads: Optional[int] = None + sv_len: Optional[int] = None + gene_id: Optional[str] = None + gene_name: Optional[str] = None + feature_id: Optional[str] = None + type: Optional[str] = None + change: Optional[str] = None + nucleotide_change: Optional[str] = None + protein_change: Optional[str] = None + annotation: List[dict] = Field(default_factory=list) + consequences: List[Consequence] = Field(default_factory=list) + + def select_most_relevant_csq(self): + """""" + Select the most relevant consequence for a variant + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> var = generate_example_variant() + >>> var.select_most_relevant_csq() + Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + + rank = [""transcript_ablation"",""exon_loss_variant"",""frameshift_variant"",""large_deletion"",""start_lost"",""disruptive_inframe_deletion"",""disruptive_inframe_insertion"",""stop_gained"",""stop_lost"",""conservative_inframe_deletion"",""conservative_inframe_insertion"",""initiator_codon_variant"",""missense_variant"",""non_coding_transcript_exon_variant"",""upstream_gene_variant"",""5_prime_UTR_premature_start_codon_gain_variant"",""5_prime_UTR_variant"",""3_prime_UTR_variant"",""non_coding_transcript_variant"",""stop_retained_variant"",""splice_region_variant"",""synonymous_variant""] + + ranked_csq = sorted(self.consequences,key=lambda x: min([rank.index(y) if y in rank else 999 for y in x.type.split(""&"")])) + return ranked_csq[0] + + def set_default_csq(self): + """""" + Set the default consequence for a variant + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> var = generate_example_variant() + >>> var.set_default_csq() + >>> var + Variant(chrom='Chromosome', pos=761155, ref='C', alt='T', depth=100, freq=0.5, forward_reads=50, reverse_reads=50, sv=False, sv_len=0, consequences=[Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}])], gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', change='p.Ser450Leu', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + annotated_csq = [] + for csq in self.consequences: + if len(csq.annotation)>0: + annotated_csq.append(csq) + if len(annotated_csq)==0: + rank = [""transcript_ablation"",""exon_loss_variant"",""frameshift_variant"",""large_deletion"",""start_lost"",""disruptive_inframe_deletion"",""disruptive_inframe_insertion"",""stop_gained"",""stop_lost"",""conservative_inframe_deletion"",""conservative_inframe_insertion"",""initiator_codon_variant"",""missense_variant"",""non_coding_transcript_exon_variant"",""upstream_gene_variant"",""5_prime_UTR_premature_start_codon_gain_variant"",""5_prime_UTR_variant"",""3_prime_UTR_variant"",""non_coding_transcript_variant"",""stop_retained_variant"",""splice_region_variant"",""synonymous_variant""] + ranked_csq = sorted(self.consequences,key=lambda x: min([rank.index(y) if y in rank else 999 for y in x.type.split(""&"")])) + csq = ranked_csq[0] + elif len(annotated_csq)==1: + csq = annotated_csq[0] + else: + chosen_annotation = None + for csq in annotated_csq: + if csq.causes_drug_resistance()==True: + chosen_annotation = csq + break + if chosen_annotation: + csq = chosen_annotation + else: + csq = annotated_csq[0] + + vars(self).update(vars(csq)) + protein_csqs = [""loss_of_function_variant"",""missense_variant"",""stop_gained"",""start_lost""] + self.change = self.protein_change if self.type in protein_csqs else self.nucleotide_change + + def set_gene_name(self, gene_names: dict) -> None: + """""" + Reset gene names for a variant + + Parameters + ---------- + gene_names : dict + A dictionary of gene names + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> var = generate_example_variant() + >>> var.set_default_csq() + >>> var.set_gene_name({'Rv0667':'rpoB'}) + >>> var + Variant(chrom='Chromosome', pos=761155, ref='C', alt='T', depth=100, freq=0.5, forward_reads=50, reverse_reads=50, sv=False, sv_len=0, consequences=[Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}])], gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', change='p.Ser450Leu', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + self.gene_name = gene_names[self.gene_id] + for csq in self.consequences: + csq.gene_name = gene_names.get(csq.gene_id,csq.gene_name) + + def convert_to_dr_element(self) -> None: + """""" + Convert a variant to a drug resistant variant + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> var = generate_example_variant() + >>> var.set_default_csq() + >>> var.convert_to_dr_element() + >>> var + DrVariant(chrom='Chromosome', pos=761155, ref='C', alt='T', depth=100, freq=0.5, forward_reads=50, reverse_reads=50, sv=False, sv_len=0, consequences=[Consequence(gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}])], gene_id='Rv0667', gene_name='rpoB', feature_id='CCP43410', type='missense_variant', change='p.Ser450Leu', nucleotide_change='c.1349C>T', protein_change='p.Ser450Leu', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}], drugs=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + if any([csq.causes_drug_resistance() for csq in self.consequences]): + self.__class__ = DrVariant + self.drugs = [] + for ann in self.annotation: + if ann['type']=='drug_resistance': + self.drugs.append(ann) + + def get_str(self): + """""" + Return string representation of variant + + Examples + -------- + >>> from pathogenprofiler import DrVariant, generate_example_dr_variant + >>> var = generate_example_dr_variant() + >>> var.get_str() + 'Chromosome 761155 C>T (0.50)' + """""" + return ""%s %s (%.2f)"" % (self.gene_name,self.change,self.freq) + + def get_annotation_value(self, annotation_type: str, key: str) -> List[str]: + """""" + Get annotation value + + Parameters + ---------- + annotation_type : str + The annotation type + key : str + The key to return + + Returns + ------- + str + The annotation value + + Examples + -------- + >>> from pathogenprofiler import DrVariant, generate_example_dr_variant + >>> var = generate_example_dr_variant() + >>> var.get_annotation_value('drug_resistance','drug') + 'rifampicin' + """""" + return [ann[key] for ann in self.annotation if ann['type']==annotation_type] + + def __lt__(self, other) -> bool: + return self.get_str() < other.get_str() + + def __hash__(self) -> int: + return self.model_dump_json().__hash__() + +class DrVariant(Variant): + drugs: List[dict] = Field(default_factory=list) + + def get_drugs(self): + """""" + Return list of drugs associated with variant or gene + + Examples + -------- + >>> from pathogenprofiler import DrVariant, generate_example_dr_variant + >>> var = generate_example_dr_variant() + >>> var.get_drugs() + ['rifampicin'] + """""" + return [x['drug'] for x in self.drugs] + + +class Gene(BaseModel): + """""" + A gene + + Attributes + ---------- + gene_id : str + The gene id + type: str + The sequence ontology term for the variant (usually functionally_normal) + gene_name : str + The gene name + annotation : List[dict] + A list of annotations + + Examples + -------- + >>> from pathogenprofiler import Gene, generate_example_gene + >>> gene = generate_example_gene() + >>> gene + Gene(gene_id='Rv0667', type='functionally_normal', gene_name='rpoB', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + gene_id: str + type: str = 'functionally_normal' + filter: str = 'pass' + gene_name: Optional[str] = None + annotation: List[dict] = Field(default_factory=list) + + def set_gene_name(self, gene_names: dict) -> None: + """""" + Reset gene names for a gene + + Parameters + ---------- + gene_names : dict + A dictionary of gene names + + Examples + -------- + >>> from pathogenprofiler import Gene, generate_example_gene + >>> gene = generate_example_gene() + >>> gene.set_gene_name({'Rv0667':'rpoB'}) + >>> gene + Gene(gene_id='Rv0667', type='functionally_normal', gene_name='rpoB', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + self.gene_name = gene_names[self.gene_id] + + def convert_to_dr_element(self) -> None: + """""" + Convert a gene to a drug resistant gene + + Examples + -------- + >>> from pathogenprofiler import Gene, generate_example_gene + >>> gene = generate_example_gene() + >>> gene.convert_to_dr_element() + >>> gene + DrGene(gene_id='Rv0667', type='functionally_normal', gene_name='rpoB', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}], drugs=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + if any([ann['type']=='drug_resistance' for ann in self.annotation]): + self.__class__ = DrGene + self.drugs = [] + for ann in self.annotation: + if ann['type']=='drug_resistance': + self.drugs.append(ann) + def get_str(self): + """""" + Return string representation of variant + + Examples + -------- + >>> from pathogenprofiler import Gene, generate_example_gene + >>> gene = generate_example_gene() + >>> gene.get_str() + 'rpoB (functionally_normal)' + """""" + return ""%s (%s)"" % (self.gene_name,self.type) + + def __lt__(self, other) -> bool: + return True + +class DrGene(Gene): + """""" + A gene that causes drug resistance + + Attributes + ---------- + gene_id : str + The gene id + type: str + The sequence ontology term for the variant (usually functionally_normal) + gene_name : str + The gene name + annotation : List[dict] + A list of annotations + drugs : List[dict] + A list of drugs associated with the gene + + Examples + -------- + >>> from pathogenprofiler import DrGene + >>> gene = DrGene( + ... gene_name='rpoB', + ... gene_id='Rv0667', + ... type='functionally_normal', + ... annotation=[{'type':'drug_resistance','drug':'rifampicin'}], + ... drugs=[{'drug':'rifampicin'}] + ... ) + >>> gene + DrGene(gene_id='Rv0667', type='functionally_normal', gene_name='rpoB', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}], drugs=[{'drug': 'rifampicin'}]) + """""" + drugs: List[dict] = Field(default_factory=list) + coverage: Optional[float] + + def get_drugs(self): + """""" + Return list of drugs associated with variant or gene + + Examples + -------- + >>> from pathogenprofiler import DrGene + >>> gene = DrGene( + ... gene_name='rpoB', + ... gene_id='Rv0667', + ... annotation=[], + ... type='functionally_normal', + ... drugs=[{'drug':'rifampicin'}] + ... ) + >>> gene.get_drugs() + ['rifampicin'] + """""" + return [x['drug'] for x in self.drugs] + def get_str(self): + """""" + Return string representation of variant + + Examples + -------- + >>> from pathogenprofiler import DrGene + >>> gene = DrGene( + ... gene_name='rpoB', + ... gene_id='Rv0667', + ... annotation=[], + ... type='functionally_normal', + ... drugs=[{'drug':'rifampicin'}] + ... ) + >>> gene.get_str() + 'rpoB (functionally_normal)' + """""" + return ""%s (resistance_gene:%s)"" % (self.gene_name,self.type) + + +class GenomePosition(BaseModel): + chrom: str + pos: int + + def __hash__(self) -> int: + return (self.chrom, self.pos).__hash__() + + def __lt__(self, other) -> bool: + if self.chrom != other.chrom: + raise ValueError(f""Cannot compare positions on different chromosomes: {self.chrom} and {other.chrom}"") + return self.pos < other.pos + +class BarcodePosition(BaseModel): + id: str + chrom: str + pos: int + target_allele_count: int + other_allele_count: int + all_allele_count: int + target_allele_percent: float + + +class GenomePositionDepth(BaseModel): + """""" + Class storing information about a missing position + + Attributes + ---------- + chromosome : str + The chromosome + position : int + The position + depth : int + The depth + annotation : List[dict] + A list of annotations + + Examples + -------- + >>> from pathogenprofiler import GenomePosition + >>> missing_pos = GenomePosition( + ... chromosome='Chromosome', + ... position=761155, + ... depth=1, + ... annotation=[{'type':'drug_resistance','drug':'rifampicin'}] + ... ) + >>> missing_pos + GenomePosition(chromosome='Chromosome', position=761155, depth=1, annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + """""" + chrom: str + pos: int + depth: int = None + annotation: List[dict] = [] + +class GenomeRange(BaseModel): + chrom: str + start: int + end: int + + def iter_positions(self) -> Generator[GenomePosition,None,None]: + for p in range(self.start,self.end): + yield GenomePosition(chrom=self.chrom,pos=p) + + def __contains__(self,pos: GenomePosition): + if pos.chrom==self.chrom and pos.pos >= self.start and pos.pos <= self.end: + return True + else: + return False + + def __hash__(self) -> int: + return (self.chrom, self.start, self.end).__hash__() + +class TargetQC(BaseModel): + """""" + Class storing information about the coverage of a target + + Attributes + ---------- + target : str + The target region + percent_depth_pass : float + The percent depth pass + median_depth : float + The median depth + + Examples + -------- + >>> from pathogenprofiler import TargetQC + >>> target_qc = TargetQC( + ... target='rpoB', + ... percent_depth_pass=100, + ... median_depth=100 + ... ) + >>> target_qc + TargetQC(target='rpoB', percent_depth_pass=100.0, median_depth=100) + """""" + + target: str + percent_depth_pass: float + median_depth: float + +class SequenceQC(BaseModel): + def get_target_median_depth(self) -> Optional[float]: + if hasattr(self,'target_qc'): + return median([x.median_depth for x in self.target_qc]) + else: + return None + + def get_reads_mapped(self) -> Optional[int]: + if hasattr(self,'num_reads_mapped'): + return self.num_reads_mapped + else: + return None + + def get_percent_reads_mapped(self) -> Optional[float]: + if hasattr(self,'percent_reads_mapped'): + return self.percent_reads_mapped + else: + return None + +class FastqQC(SequenceQC): + num_sequences: int + num_bases: int + + +class FastaQC(SequenceQC): + """""" + Class storing information about the quality of a fasta file + + Attributes + ---------- + num_sequences : int + The number of sequences + num_bases : int + The number of bases + n50 : int + The n50 + target_qc : List[TargetQC] + A list of target qc objects + + Examples + -------- + >>> from pathogenprofiler import FastaQC, TargetQC + >>> fasta_qc = FastaQC( + ... num_sequences=20, + ... num_bases=4000000, + ... n50=200000, + ... target_qc=[ + ... TargetQC( + ... target='rpoB', + ... percent_depth_pass=100, + ... median_depth=1 + ... ) + ... ] + ... ) + >>> fasta_qc + FastaQC(num_sequences=20, num_bases=4000000, n50=200000, target_qc=[TargetQC(target='rpoB', percent_depth_pass=100.0, median_depth=1)]) + """""" + num_sequences: int + num_bases: int + n50: int + target_qc: List[TargetQC] + + +class BamQC(SequenceQC): + """""" + Class storing information about quality of the data in a bam file + + Attributes + ---------- + percent_reads_mapped : float + The percent reads mapped + num_reads_mapped : int + The number of reads mapped + target_median_depth : float + The median depth of targets + genome_median_depth : int + The median depth of the genome + target_qc : List[TargetQC] + A list of target qc objects + + Examples + -------- + >>> from pathogenprofiler import BamQC, TargetQC, GenomePosition + >>> bam_qc = BamQC( + ... percent_reads_mapped=100, + ... num_reads_mapped=100, + ... target_median_depth=100, + ... genome_median_depth=100, + ... target_qc=[ + ... TargetQC( + ... target='rpoB', + ... percent_depth_pass=100, + ... median_depth=100 + ... ) + ... ] + ... ) + >>> bam_qc + BamQC(percent_reads_mapped=100.0, num_reads_mapped=100, target_median_depth=100, genome_median_depth=100, target_qc=[TargetQC(target='rpoB', percent_depth_pass=100.0, median_depth=100)]) + """""" + + percent_reads_mapped: float + num_reads_mapped: int + target_median_depth: float + genome_median_depth: Optional[float] + target_qc: List[TargetQC] + missing_positions: List[GenomePositionDepth] = [] + + +class VcfQC(SequenceQC): + """""" + Class storing information about quality of the data in a vcf file + + Attributes + ---------- + num_variants : int + The number of variants + """""" + total_variants: int + + + +class SourmashSpeciesInfo(BaseModel): + species: str + accession: str + ani: float + + + + +class BarcodeResult(BaseModel): + """""" + Class storing information about a prediction using a mutation barcode + + Attributes + ---------- + id : str + The id + frequency: float + The frequency + info : list + A list of info + + """""" + + id: str + frequency: float + info: list = [] + support: List[BarcodePosition] + + + + + + + +class Species(BaseModel): + """""" + Class storing information about a species + + Attributes + ---------- + species : str + The species + prediction_info : dict + The prediction info + + Examples + -------- + >>> from pathogenprofiler import Species + >>> species = Species( + ... species='Mycobacterium abscessus', + ... prediction_info=None + ... ) + >>> species + Species(species='Mycobacterium abscessus', prediction_info=None) + """""" + species: str + ani: Optional[float] = None + abundance: Optional[float] = None + relative_abundance: Optional[float] = None + coverage: Optional[float] = None + accession: Optional[str] = None + ncbi_organism_name: Optional[str] = None + prediction_method: Optional[str] = None + notes: Optional[List[str]] = [] + + +class TaxonomicHit(BaseModel): + prediction_method: str = None + accession: str + abundance: Optional[float] = None + ani: Optional[float] = None + num_reads: Optional[int] = None + +class SpeciesPrediction(BaseModel): + """""" + Class storing information about a species + + Attributes + ---------- + prediction_method : str + The prediction method + species : List[Species] + A list of species objects + species_db : dict + The species database + + """""" + prediction_method: str + taxa: List[Species] = [] + qc_fail_taxa: List[Species] = [] + species_db: dict = {} + + def get_species_str(self): + """""" + Return the species + + Examples + -------- + >>> from pathogenprofiler import SpeciesPrediction, Species + >>> species_prediction = SpeciesPrediction( + ... prediction_method='user_specified', + ... species=[ + ... Species( + ... species='Mycobacterium abscessus', + ... prediction_info=None + ... ) + ... ] + ... ) + >>> species_prediction.get_species() + Mycobacterium abscessus + """""" + return ';'.join([x.species for x in self.species]) + + + + +class ProfileResult(BaseModel): + id: str + software_version: str + input_data_source: str + database: dict + pipeline_software: list = Field(default_factory=list) + variants: List[Union[Variant,Gene]] + +class BamProfileResult(ProfileResult): + qc: BamQC + +class VcfProfileResult(ProfileResult): + input_data_source: str = 'vcf'","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/fasta.py",".py","5909","167","from collections import OrderedDict +from .utils import run_cmd, cmd_out +from .kmer import KmerDump +import os +import platform +import logging +from .taxonomy import SourmashSig, SylphSketch +from .models import TargetQC, FastaQC +from typing import List +from .utils import shared_dict + + +class Fasta: + """""" + Class to represent fasta seuqnces in a python dict. + + Args: + filename(str): Location of the fasta file + + Returns: + fasta: A fasta class object + """""" + def __init__(self,filename): + fa_dict = OrderedDict() + seq_name = """" + self.fa_file = filename + for l in open(filename): + line = l.rstrip() + if line=="""": continue + if line.startswith("">""): + seq_name = line[1:].split()[0] + fa_dict[seq_name] = [] + else: + fa_dict[seq_name].append(line) + result = {} + counter = 0 + sum_length = {} + for seq in fa_dict: + result[seq] = """".join(fa_dict[seq]) + result[seq] = result[seq].upper() + sum_length[(counter+1,counter+len(result[seq]))] = seq + counter = counter+len(result[seq]) + self.sum_length = sum_length + self.fa_dict = result + + def align_to_ref(self,refseq,file_prefix): + shared_dict['software']['alignment'] = 'minimap2' + self.ref_aln = f""{file_prefix}.paf"" + run_cmd(f""minimap2 {refseq} {self.fa_file} --cs | sort -k6,6 -k8,8n > {self.ref_aln}"") + return self.ref_aln + + def get_amplicons(self,primer_file): + bed = [] + for l in cmd_out(f""seqkit amplicon {self.fa_file} -p {primer_file} --bed""): + row = l.strip().split() + bed.append(tuple(row[:4])) + + return bed + def get_kmer_counts(self,prefix,klen = 31,threads=1,max_mem=2, counter = ""kmc""): + shared_dict['software']['kmer_counting'] = counter + if counter==""kmc"": + if threads>32: + threads = 32 + tmp_prefix = f""{prefix}_kmers"" + os.mkdir(tmp_prefix) + bins = ""-n128"" if platform.system()==""Darwin"" else """" + run_cmd(f""kmc {bins} -m{max_mem} -t{threads} -k{klen} -ci1 -fm {self.fa_file} {tmp_prefix} {tmp_prefix}"") + run_cmd(f""kmc_dump -ci1 {tmp_prefix} {prefix}.kmers.txt"") + run_cmd(f""rm -r {tmp_prefix}*"") + + return KmerDump(f""{prefix}.kmers.txt"",counter) + elif counter==""dsk"": + max_mem = max_mem * 1000 + tmp_prefix = f""{prefix}_kmers"" + os.mkdir(tmp_prefix) + run_cmd(f""dsk -file {self.fa_file} -abundance-min 1 -nb-cores {threads} -kmer-size {klen} -max-memory {max_mem} -out {tmp_prefix} -out-tmp {tmp_prefix}"") + run_cmd(f""dsk2ascii -file {tmp_prefix}.h5 -out {prefix}.kmers.txt"") + run_cmd(f""rm -r {tmp_prefix}*"") + + return KmerDump(f""{prefix}.kmers.txt"",counter) + + def sourmash_sketch(self,prefix,scaled=1000): + logging.info(""Sketching fasta"") + shared_dict['software']['taxonomic_classifier'] = 'sourmash' + run_cmd(f""sourmash sketch dna -p abund,scaled={scaled} --merge {prefix} -o {prefix}.sig {self.fa_file}"") + return SourmashSig(f""{prefix}.sig"",tmp_prefix=prefix) + + def get_n50(self): + lengths = sorted([len(self.fa_dict[x]) for x in self.fa_dict]) + total = sum(lengths) + half = total/2 + count = 0 + for l in lengths: + count += l + if count>=half: + return l + + def get_fasta_qc(self) -> FastaQC: + return FastaQC( + num_sequences = len(self.fa_dict), + num_bases = sum([len(self.fa_dict[x]) for x in self.fa_dict]), + n50 = self.get_n50(), + target_qc=[] + ) + + def sylph_sketch(self,prefix, threads=1): + logging.info(""Sketching reads with sylph"") + + + + outfile = f""{prefix}.syldb"" + + run_cmd(f""sylph sketch -d {prefix}_sylph {self.fa_file} -t {threads}"") + return SylphSketch(outfile,tmp_prefix=prefix) + + def sketch(self,prefix,software, threads=1): + shared_dict['software']['taxonomic_software'] = software + + if software==""sourmash"": + return self.sourmash_sketch(prefix) + elif software==""sylph"": + return self.sylph_sketch(prefix, threads=threads) + else: + quit(f""ERROR: {software} not in accepted sketching methods\n"") + +class Paf: + def __init__(self,filename: str): + self.filename = filename + + def get_target_qc(self,bed_file: str) -> List[TargetQC]: + results = [] + for l in cmd_out(f""cut -f6,8,9 {self.filename} | bedtools coverage -a {bed_file} -b -""): + row = l.strip().split() + results.append( + TargetQC( + target = row[4], + percent_depth_pass=float(row[9])*100, + median_depth=int(float(row[9])), + ) + ) + return results + + def get_ref_variants(self,refseq: str,sample_name: str,file_prefix: str) -> str: + """""" + Generate a vcf file of variants against a reference sequence from a paf file + + Arguments + --------- + refseq : str + Reference sequence + sample_name : str + Sample name + file_prefix : str + Prefix for output file + + Returns + ------- + str + Filename of vcf file + """""" + self.refseq = refseq + self.sample_name = sample_name + self.file_prefix = file_prefix + shared_dict['software']['variant_calling'] = 'paftools.js' + run_cmd(""cat %(filename)s | paftools.js call -l 100 -L 100 -f %(refseq)s -s %(sample_name)s - | add_dummy_AD.py | bcftools view -Oz -o %(file_prefix)s.vcf.gz"" % vars(self)) + return ""%s.vcf.gz"" % self.file_prefix +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/snp_dist.py",".py","7426","209","from typing import Tuple +import sqlite3 +from pydantic import BaseModel +from typing import List +import logging +import pickle +from .utils import cmd_out +from tqdm import tqdm +import filelock +import numpy as np +import json + +class Link(BaseModel): + source: str + target: str + distance: float + positions: List[int] + missing: int + +def extract_variant_set(vcf_file: str) -> Tuple[set,set]: + ref_diffs = set() + missing = set() + for l in cmd_out(f""bcftools view {vcf_file} | bcftools query -f '%POS[\t%GT]\n'""): + if l[0]==""#"": continue + row = l.strip().split() + pos = int(row[0]) + gt = row[1] + if gt==""."": + missing.add(pos) + continue + elif gt==""1"": + ref_diffs.add(int(pos)) + else: + raise Exception(""Unknown GT: %s"" % gt) + + return ref_diffs, missing + + + +class SnpDistDB: + """""" + Class for storing and searching for SNP differences between samples + + Arguments + --------- + filename : str + Filename of the sqlite database to use + + Attributes + ---------- + filename : str + Filename of the sqlite database to use + conn : sqlite3.Connection + Connection to the sqlite database + c : sqlite3.Cursor + Cursor to the sqlite database + + Methods + ------- + store(result,vcf_file) + Store the SNP differences from a sample in the database + search(result,vcf_file,cutoff=20) + Search for samples with similar SNP differences in the database + """""" + def __init__(self, filename: str) -> None: + with filelock.SoftFileLock(f""{filename}.lock""): + self.filename = filename + self.conn = sqlite3.connect(filename) + self.c = self.conn.cursor() + self.c.execute('''CREATE TABLE IF NOT EXISTS samples (sample text, taxa text, diffs binary, missing binary)''') + self.c.execute('''CREATE TABLE IF NOT EXISTS links (source text, target text, snps binary, dist integer, missing integer)''') + + def store(self, sample_name:str, vcf_file: str, taxa: str, cutoff: int = 10) -> List[Link]: + """""" + Store the SNP differences from a sample in the database. + + Parameters + ---------- + sample_name : str + Name of the sample + vcf_file : str + VCF file containing the SNP differences + taxa : str + Taxonomic classification of the sample + cutoff : int, optional + Maximum SNP distance to consider a sample as similar, by default 10 + + Returns + ------- + List[Link] + List of Link objects representing similar samples + """""" + new_diffs, new_missing = extract_variant_set(vcf_file) + res = self.c.execute(""SELECT sample FROM samples WHERE sample=?"",(sample_name,)).fetchone() + if not res: + self.c.execute(""INSERT INTO samples VALUES (?,?,?,?)"",(sample_name, taxa, pickle.dumps(new_diffs), pickle.dumps(new_missing))) + + + logging.info(""Searching for close samples in %s"" % self.filename) + + self.c.execute(""SELECT sample, diffs, missing FROM samples WHERE taxa=?"", (taxa,)) + + sample_dists = [] + for s,d,m in tqdm(self.c.fetchall(),desc=""Searching for close samples""): + dist = new_diffs.symmetric_difference(pickle.loads(d)) + dist -= new_missing + dist -= pickle.loads(m) + logging.debug(f""Sample {sample_name} vs {s}: {len(dist)} SNPs different"") + if (ld:=len(dist)) Tuple[List[str], List[List[int]]]: + """""" + Extract a distance matrix from the database. + + Returns + ------- + Tuple[List[str], List[List[int]]] + A tuple containing a list of sample names and a 2D list representing the distance matrix. + """""" + samples = [] + sample_idx = {} + self.c.execute(""SELECT sample FROM samples"") + for i, (s,) in enumerate(self.c.fetchall()): + samples.append(s) + sample_idx[s] = i + n = len(samples) + matrix = [[np.nan for _ in range(n)] for _ in range(n)] + self.c.execute(""SELECT source, target, dist FROM links"") + for s,t,d in self.c.fetchall(): + i = sample_idx[s] + j = sample_idx[t] + matrix[i][j] = d + matrix[j][i] = d + for i in range(n): + matrix[i][i] = 0 + return samples, matrix + def write_graph(self,outfile:str, distance_cutoff: int, sample_data: dict) -> None: + samples, matrix = self.extract_matrix() + num_samples = len(samples) + edges = [] + for i in range(num_samples): + for j in range(num_samples): + if i >= j: + continue + if matrix[i][j] <= distance_cutoff: + edges.append({'source':samples[i], 'target': samples[j], 'properties': {'distance': matrix[i][j]} }) + tmpnodes = set() + for e in edges: + tmpnodes.add(e['source']) + tmpnodes.add(e['target']) + nodes = [] + for n in tmpnodes: + nodes.append({'id':n,'properties':sample_data.get(n, {})}) + + graph = {'nodes':nodes,'edges':edges} + json.dump(graph,open(outfile,'w')) + + def _sample_present(self, sample_name: str) -> bool: + res = self.c.execute(""SELECT sample FROM samples WHERE sample=?"",(sample_name,)).fetchone() + return res is not None + + def inspect_link(self, source: str, target: str) -> Link: + """""" + Inspect a specific link between two samples. + + Parameters + ---------- + source : str + Name of the source sample + target : str + Name of the target sample + + Returns + ------- + Link + A Link object representing the SNP differences between the two samples. + """""" + if not self._sample_present(source): + raise Exception(f""Sample {source} not found in database"") + if not self._sample_present(target): + raise Exception(f""Sample {target} not found in database"") + res1 = self.c.execute(""SELECT snps, dist, missing FROM links WHERE source=? AND target=?"", (source, target)).fetchone() + res2 = self.c.execute(""SELECT snps, dist, missing FROM links WHERE source=? AND target=?"", (target, source)).fetchone() + if not res1 and not res2: + raise Exception(f""No link found between {source} and {target}"") + snps, dist, missing = res1 if res1 else res2 + return Link( + source=source, + target=target, + distance=dist, + positions=sorted(list(pickle.loads(snps))), + missing=missing + )","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/vcf.py",".py","17395","435","from .utils import TempFilePrefix, run_cmd, cmd_out,add_arguments_to_self, index_bcf,tabix, load_bed +import logging +from .fasta import Fasta +from collections import defaultdict +import re +import sys +import os.path +import json +import pysam +from .models import Variant,Consequence, VcfQC, GenomePosition +from typing import Optional, List, Tuple, Dict + +def get_default_snpeff_config(): + share_dir = os.path.join(sys.base_prefix, 'share') + # check folder exists + if os.path.isdir(share_dir): + snp_eff_dirs = [d for d in os.listdir(share_dir) if d.startswith('snpeff-')] + if len(snp_eff_dirs) == 1: + snp_eff_dir = snp_eff_dirs[0] + return os.path.join(share_dir, snp_eff_dir, 'snpEff.config') + +def get_custom_snpeff_config(software_name: str): + # check folder exists + share_dir = os.path.join(sys.base_prefix, 'share') + software_dir = os.path.join(share_dir, software_name) + if os.path.isdir(software_dir): + config = os.path.join(software_dir, 'snpEff.config') + if os.path.isfile(config): + return config + +def get_stand_support(var: pysam.VariantRecord,alt: str) -> Tuple[int,int]: + alt_index = list(var.alts).index(alt) + forward_support = None + reverse_support = None + if 'SAF' in var.info: + forward_support = var.info['SAF'][alt_index] + reverse_support = var.info['SAR'][alt_index] + elif 'ADF' in var.samples[0]: + forward_support = var.samples[0]['ADF'][alt_index+1] + reverse_support = var.samples[0]['ADR'][alt_index+1] + elif 'SB' in var.samples[0]: + logging.debug(var.samples[0]['SB']) + forward_support = var.samples[0]['SB'][1*2] + reverse_support = var.samples[0]['SB'][1*2+1] + elif 'DP4' in var.info: + forward_support = var.info['DP4'][1*2] + reverse_support = var.info['DP4'][1*2+1] + else: + forward_support = None + reverse_support = None + + logging.debug(f""Forward support: {forward_support}, Reverse support: {reverse_support}"") + return forward_support, reverse_support + +def get_sv_ad(var): + return [ + var.samples[0]['DR']+var.samples[0]['RR'], + var.samples[0]['DV']+var.samples[0]['RV'] + ] +class Vcf: + def __init__(self,filename,prefix=None,threads=1): + self.samples = [] + add_arguments_to_self(self,locals()) + if prefix==None: + if filename[-4:] == "".bcf"": + self.prefix = filename[:-4] + elif filename[-7:] == "".vcf.gz"": + self.prefix = filename[:-7] + elif filename[-8:] == "".gvcf.gz"": + self.prefix = filename[:-8] + elif filename[-4:] == "".vcf"": + self.prefix = filename[:-4] + else: + self.prefix = filename + else: + self.prefix = prefix + if filename[-4:] == "".bcf"": + index_bcf(filename,threads) + else: + tabix(filename,threads) + self.vcf_dir = ""/"".join(os.path.abspath(filename).split(""/"")[:-1]) + for l in cmd_out(""bcftools query -l %(filename)s"" % vars(self)): + self.samples.append(l.rstrip()) + self.nsamples = len(self.samples) + header = ""\n"".join([l.strip() for l in cmd_out(""bcftools view -h %(filename)s"" % vars(self))]) + if ""bcftools_callCommand"" in header: + self.caller = ""bcftools"" + elif ""source=lofreq call"" in header: + self.caller = ""lofreq"" + elif ""GATKCommandLine= List[Variant]: + logging.info(""Loading snpEff annotations"") + filter_out = [] + filter_types = { + ""intergenic"":[""intergenic_region""], + ""intragenic"":[""intragenic_variant""], + ""noncoding"":[""non_coding_transcript_variant"",""non_coding_transcript_exon_variant""], + ""downstream"":[""downstream_gene_variant""], + ""upstream"":[""upstream_gene_variant""], + ""intron"":[""intron_variant""], + ""synonymous"":[""synonymous_variant""], + ""splice"":[""splice_region_variant&intron_variant"",""splice_region_variant&synonymous_variant""], + ""ablation"":[""transcript_ablation""], + ""utr"":[""5_prime_UTR_variant"",""3_prime_UTR_variant""], + ""other"":[""feature_ablation""] + } + if exclude_variant_types: + for t in exclude_variant_types: + filter_out += filter_types[t] + if keep_variant_types: + for t in filter_types: + if t in keep_variant_types: continue + filter_out += filter_types[t] + + if bed_file: + genes_to_keep = set() + for l in open(bed_file): + row = l.strip().split() + genes_to_keep.add(row[3]) + genes_to_keep.add(row[4]) + + variants = [] + vcf = pysam.VariantFile(self.filename) + for var in vcf: + logging.debug(str(var)[:5000]) + chrom = var.chrom + pos = var.pos + ref = var.ref + alleles = var.alleles + if ""SVTYPE"" in var.info: + if var.info['SVTYPE']!=""DEL"": + continue + ad = get_sv_ad(var) + varlen = var.stop - var.pos + sv = True + else: + ad = [int(x) for x in var.samples[0]['AD']] + varlen = None + sv = False + if sum(ad)==0: + continue + af_dict = {alleles[i]:ad[i]/sum(ad) for i in range(len(alleles))} + if ""ANN"" not in var.info: + ## TODO - add a way to get the annotations from the VCF + continue + ann_strs = var.info['ANN'] + ann_list = [x.split(""|"") for x in ann_strs] + for alt in alleles[1:]: + strand_support = get_stand_support(var,alt) + if strand_support[0] != None: + freq = sum(strand_support)/sum(ad) + else: + if 'QNAME' in var.info: + freq = 1.0 + else: + freq = af_dict[alt] + + + tmp_var = Variant( + chrom = chrom, + pos = int(pos), + ref = ref, + alt = alt, + depth = sum(ad), + freq = freq, + forward_reads = strand_support[0], + reverse_reads = strand_support[1], + sv = sv, + sv_len = varlen, + ) + + tmp_var.filter = filter_variant(tmp_var,filter_params) + if tmp_var.filter==""hard_fail"": + continue + + + for ann in ann_list: + ann[3] = ann[3].replace(""gene:"","""").replace(""gene-"","""") + ann[4] = ann[4].replace(""gene:"","""").replace(""gene-"","""") + if ann[0]!=alt: + continue + if ann[1] in filter_out: + continue + if bed_file: + if ann[3] in genes_to_keep or ann[4] in genes_to_keep: + pass + else: + continue + if ann[1]==""upstream_gene_variant"": + r = re.search(""[cn].-([0-9]+)"",ann[9]) + if int(r.group(1))>max_promoter_length: + continue + + tmp_var.consequences.append( + Consequence( + gene_name = ann[3], + gene_id = ann[4], + feature_id = ann[6], + type = ann[1], + nucleotide_change = ann[9], + protein_change = ann[10], + sequence_hgvs= f'{chrom}:g.{pos}{ref}>{alt}' + ) + ) + + # genes_in_csq = set([x.gene_id for x in tmp_var.consequences]) + # for gene in genes_in_csq: + # tmp_var.consequences.append( + # Consequence( + # gene_name = None, + # gene_id = gene, + # feature_id = None, + # type = ""genomic_change"", + # nucleotide_change = f'{chrom}:g.{pos}{ref}>{alt}', + # protein_change = None + # ) + # ) + + + if len(tmp_var.consequences)==0: + continue + variants.append(tmp_var) + # variants = uniqify_dict_list(variants) + return variants + + + + def add_annotations(self,ref_file,bam_file): + add_arguments_to_self(self,locals()) + self.new_file = self.prefix + "".ann.vcf.gz"" + + run_cmd(""gatk VariantAnnotator -R %(ref_file)s -I %(bam_file)s -V %(filename)s -O %(new_file)s -A MappingQualityRankSumTest -A ReadPosRankSumTest -A QualByDepth -A BaseQualityRankSumTest -A TandemRepeat -A StrandOddsRatio -OVI false"" % vars(self)) + return Vcf(self.new_file,self.prefix) + + + def get_positions(self) -> List[GenomePosition]: + results = [] + for l in cmd_out(""bcftools query -f '%%CHROM\\t%%POS\\n' %s"" % self.filename): + row = l.split() + results.append(GenomePosition(chrom=row[0],posposition=int(row[1]))) + return results + + def get_bed_gt(self,bed_file: str,ref_file: str) -> Dict[GenomePosition,Dict[str,int]]: + self.bed_file = bed_file + self.ref_file = ref_file + cmd = f""bcftools view -T {bed_file} {self.filename}"" + r"" | bcftools query -u -f '%CHROM\t%POS\t%REF\t%ALT[\t%GT\t%AD]\n'"" + results = defaultdict(dict) + ref_seq = Fasta(ref_file).fa_dict + for l in cmd_out(cmd): + #Chromosome 4348079 0/0 51 + chrom,pos,ref,alt,gt,ad = l.rstrip().split() + p = GenomePosition(chrom=chrom,pos=int(pos)) + d = {} + alts = alt.split("","") + ad = [int(x) for x in ad.split("","")] if ad!=""."" else [0,100] + if gt==""0/0"": + d[ref] = ad[0] + elif gt==""./."": + d[ref] = 0 + else: + for i,a in enumerate([ref]+alts): + d[a] = ad[i] + results[p] = d + bed = load_bed(bed_file) + for r in bed: + p = GenomePosition(chrom=r.chrom,pos=r.end) + if p not in results: + results[p] = {ref_seq[p.chrom][p.pos-1]:50} + return results + + def get_gatk_annotations(self): + possible_annotations = [""ReadPosRankSum"",""QD"",""MQRankSum"",""ClippingRankSum"",""BaseQRankSum"",""SOR"",""TandemRepeat""] + lines = [] + for l in cmd_out(""bcftools view -h %s | grep INFO"" % self.filename): + lines.append(l) + lines = """".join(lines) + found_annotations = [] + for x in possible_annotations: + if x in lines: + found_annotations.append(x) + return found_annotations + + def get_vcf_qc(self): + for l in cmd_out(f'bcftools stats {self.filename}'): + row = l.strip().split(""\t"") + if row[0]=='SN' and 'number of records' in l: + num_variants = int(l.split(""\t"")[3].strip()) + return VcfQC(total_variants=num_variants) + +# class DellyVcf(Vcf): +# def __init__(self,filename): +# Vcf.__init__(self,filename) +# def get_robust_calls(self,prefix,bed_file = None): +# self.tmpfile = f""{prefix}.tmp.delly.vcf.gz"" +# self.outfile = f""{prefix}.delly.vcf.gz"" +# run_cmd(""bcftools view -c 2 %(filename)s | bcftools view -e '(INFO/END-POS)>=100000' -Oz -o %(tmpfile)s"" % vars(self)) +# if bed_file: +# run_cmd(f""bcftools index {self.tmpfile}"") +# run_cmd(f""bcftools view -R {bed_file} {self.tmpfile} -Oz -o {self.outfile}"") +# else: +# self.outfile = self.tmpfile +# return DellyVcf(self.outfile) + +def uniqify_dict_list(data): + s = [] + for obj in data: + t = json.dumps(obj) + if t not in s: + s.append(t) + + return [json.loads(d) for d in s] + + +def var_qc_test(var: Variant,min_depth: int,min_af: float,strand_support: int) -> bool: + """"""Test if a variant passes QC"""""" + fail = False + if min_depth!=None and var.depth bool: + + fail = False + if min_depth!=None and var.depthsv_len: + fail = True + return fail + +def filter_variant(var,filter_params): + """""" + Filter a variant based on the filter parameters + + Parameters + ---------- + var : Variant + The variant to filter + filter_params : dict + The filter parameters + + Returns + ------- + str + The QC status of the variant + + Examples + -------- + >>> from pathogenprofiler import Variant, generate_example_variant + >>> filter_params = { + ... ""depth_hard"":5, + ... ""depth_soft"":10, + ... ""af_hard"":0, + ... ""af_soft"":0.1, + ... ""strand_hard"":0, + ... ""strand_soft"":3 + ... } + >>> var = generate_example_variant(forward_reads=1,reverse_reads=1) + >>> filter_variant(var,filter_params) + 'hard_fail' + >>> var = generate_example_variant(forward_reads=3,reverse_reads=3) + >>> filter_variant(var,filter_params) + 'soft_fail' + >>> var = generate_example_variant(forward_reads=10,reverse_reads=10) + >>> filter_variant(var,filter_params) + 'pass' + """""" + qc = ""pass"" + if var.sv==True: + if sv_var_qc_test(var,filter_params[""sv_depth_hard""],filter_params[""sv_af_hard""],filter_params[""sv_len_hard""]): + qc = ""hard_fail"" + elif sv_var_qc_test(var,filter_params[""sv_depth_soft""],filter_params[""sv_af_soft""],filter_params[""sv_len_soft""]): + qc = ""soft_fail"" + else: + if var_qc_test(var,filter_params[""depth_hard""],filter_params[""af_hard""],filter_params[""strand_hard""]): + qc = ""hard_fail"" + elif var_qc_test(var,filter_params[""depth_soft""],filter_params[""af_soft""],filter_params[""strand_soft""]): + qc = ""soft_fail"" + logging.debug(qc) + return qc +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/profiler.py",".py","4207","117","from .utils import run_cmd, bed2gene_lookup +from .bam import Bam +from .barcode import barcode +from .mutation_db import db_compare +from .models import BarcodeResult, DrVariant, Variant, Gene, DrGene +from .vcf import Vcf +import os +from .models import Variant +from typing import List, Union +import argparse + +def bam_barcoder(args: argparse.Namespace) -> List[BarcodeResult]: + conf = args.conf + if 'barcode' not in conf: + return [] + bam = Bam(args.bam, args.files_prefix, platform=args.platform, threads=args.threads) + if not hasattr(args,'barcode_snps'): + args.barcode_snps = None + barcode_mutations = bam.get_bed_gt(conf[""barcode""],conf[""ref""], caller=args.caller,platform=args.platform) + opts = { + 'mutations': barcode_mutations, + 'barcode_bed': conf[""barcode""], + 'snps_file': args.barcode_snps, + } + if hasattr(args,'barcode_iqr_cutoff'): + opts['iqr_cutoff'] = args.barcode_iqr_cutoff + if hasattr(args,'barcode_freq_cutoff'): + opts['freq_cutoff'] = args.barcode_freq_cutoff + barcode_assignment = barcode(**opts) + return barcode_assignment + +def vcf_barcoder(args: argparse.Namespace) -> List[BarcodeResult]: + conf = args.conf + if 'barcode' not in conf: + return [] + vcf = Vcf(args.vcf) + barcode_mutations = vcf.get_bed_gt(conf[""barcode""],conf[""ref""]) + if not hasattr(args,'barcode_snps'): + args.barcode_snps = None + opts = { + 'mutations': barcode_mutations, + 'barcode_bed': conf[""barcode""], + 'snps_file': args.barcode_snps, + } + if hasattr(args,'barcode_iqr_cutoff'): + opts['iqr_cutoff'] = args.barcode_iqr_cutoff + if hasattr(args,'barcode_freq_cutoff'): + opts['freq_cutoff'] = args.barcode_freq_cutoff + barcode_assignment = barcode(**opts) + return barcode_assignment + + + + +def vcf_is_indexed(vcf_file: str) -> bool: + if os.path.exists(vcf_file+"".tbi""): + return True + elif os.path.exists(vcf_file+"".csi""): + return True + else: + return False + +def vcf_profiler(args: argparse.Namespace) -> List[Union[Variant,DrVariant,Gene,DrGene]]: + conf = args.conf + vcf_targets_file = ""%s.targets.vcf.gz"" % args.files_prefix + if not vcf_is_indexed(args.vcf): + run_cmd(""bcftools index %s"" % args.vcf) + if args.caller == 'freebayes-haplotype': + args.supplementary_bam = None + annotated_variants = vcf_variant_profiler( + conf=conf, + prefix=args.files_prefix, + vcf_file=args.vcf, + bam_for_phasing=args.supplementary_bam, + db_dir=args.db_dir if hasattr(args,'db_dir') else None + ) + return annotated_variants + + + + + + +def vcf_variant_profiler(conf: dict, prefix: str, vcf_file: str, bam_for_phasing: str = None, db_dir: str = None) -> List[Union[Variant,Gene]]: + vcf_targets_file = ""%s.targets_for_profile.vcf.gz"" % prefix + if not vcf_is_indexed(vcf_file): + run_cmd(""bcftools index %s"" % vcf_file) + run_cmd(""bcftools view -R %s %s -Oz -o %s"" % (conf[""bed""],vcf_file,vcf_targets_file)) + vcf_obj = Vcf(vcf_targets_file) + vcf_obj = vcf_obj.run_snpeff(conf[""snpEff_db""],conf[""ref""],conf[""gff""],conf['snpEff_config'],rename_chroms=conf.get(""chromosome_conversion"",None),bam_for_phasing=bam_for_phasing, db_dir=db_dir) + variants = vcf_obj.load_ann(conf['variant_filters'],bed_file=conf[""bed""],keep_variant_types = [""ablation"",""upstream"",""synonymous"",""noncoding""]) + + # compare against database of variants + annotated_variants = db_compare(db=conf[""json_db""], variants=variants) + + + + # set the default consequence + for obj in annotated_variants: + # check if it is a variant or a gene class + if isinstance(obj, Variant): + obj.set_default_csq() + + # Add gene names based on the bed file + gene_id2name = bed2gene_lookup(conf[""bed""]) + for obj in annotated_variants: + obj.set_gene_name(gene_id2name) + + # if 'rules' in conf: + # rules_applied = apply_rules(conf['rules'], annotated_variants) + + # # Convert variant objects to DrVariant if they cause resistance + # for var in annotated_variants: + # var.convert_to_dr_element() + + return annotated_variants +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/drug_resistance.py",".py","3684","111","from collections import defaultdict +from typing import List, Union +from .models import DrVariant, DrGene + +def get_lt2drugs(bed_file): + lt2drugs = {} + for l in open(bed_file): + row = l.strip().split() + lt2drugs[row[3]] = row[5].split("","") + return lt2drugs + +def get_gene2drugs(bed_file): + lt2drugs = {} + for l in open(bed_file): + row = l.strip().split() + lt2drugs[row[4]] = row[5].split("","") + return lt2drugs + +def get_drugs2lt(bed_file): + tmp = get_lt2drugs(bed_file) + results = defaultdict(list) + for gene in tmp: + for drug in tmp[gene]: + results[drug].append(gene) + return dict(results) + +def get_drugs2gene(bed_file): + tmp = get_gene2drugs(bed_file) + results = defaultdict(list) + for gene in tmp: + for drug in tmp[gene]: + results[drug].append(gene) + return dict(results) + +def get_drug_list(bed_file): + tmp = get_drugs2lt(bed_file) + return set(tmp.keys()) + +def get_dr_summary( + elements: List[Union[DrVariant,DrGene]], + conf: dict +) -> List[dict]: + drug_elements = {d:[] for d in conf['drugs']} + for d in elements: + for drug in d.get_drugs(): + drug_elements[drug].append(d) + + drug_table = [] + for d in conf['drugs']: + drug_elements[d] = sorted(drug_elements[d]) + drug_table.append({ + ""Drug"":d.capitalize(), + ""Genotypic Resistance"":""R"" if len(drug_elements[d])>0 else """", + ""Mechanisms"":"", "".join([x.get_str() for x in drug_elements[d]]) if len(drug_elements[d])>0 else """" + }) + return drug_table + + +def get_summary(json_results,conf,columns = None): + if not columns: + columns=[] + drugs = conf['drugs'] + + drug_table = [] + results = {} + annotation = {} + + pool = json_results[""dr_variants""].copy() + if 'resistance_genes' in json_results: + pool += json_results['resistance_genes'] + for x in pool: + for d in x[""drugs""]: + drug = d[""drug""] + if drug not in results: results[drug] = [] + if ""freq"" in x: + results[d[""drug""]].append(""%s %s (%.2f)"" % (x[""gene""],x[""change""],float(x[""freq""]))) + else: + results[d[""drug""]].append(""%s (resistance_gene)"" % (x[""gene""],)) + if drug not in annotation: + annotation[drug] = {key:[] for key in columns} + for key in columns: + annotation[drug][key].append(d.get(key,"""")) + for d in drugs: + if d in results: + results[d] = "", "".join(results[d]) if len(results[d])>0 else """" + r = ""R"" if len(results[d])>0 else """" + for key in columns: + annotation[d][key] = "", "".join(annotation[d][key]) if len(annotation[d][key])>0 else """" + else: + results[d] = """" + r = """" + dictline = {""Drug"":d.capitalize(),""Genotypic Resistance"":r,""Mutations"":results[d]} + for key in columns: + dictline[key] = annotation[d][key] if d in annotation else """" + drug_table.append(dictline) + new_json = json_results.copy() + new_json[""drug_table""] = drug_table + return new_json + +def add_drugs_to_variants(variants: List[dict]) -> List[dict]: + for var in variants: + if 'annotation' not in var: + continue + drug_annotations = [a for a in var['annotation'] if a['type']=='drug_resistance'] + if len(drug_annotations)>0: + var['drugs'] = drug_annotations + # for a in var['annotation']: + # if a['type']=='drug_resistance': + # d = a.copy() + # var['drugs'].append(d) + return variants","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/consensus.py",".py","4329","130","import logging +from .utils import run_cmd, cmd_out, TempFilePrefix +import pysam +import argparse +from uuid import uuid4 +import numpy as np +import tempfile + +def robust_bounds(data, k=5): + median = np.median(data) + mad = np.median(np.abs(data - median)) + mad_scaled = 1.4826 * mad + lower = median - k * mad_scaled + upper = median + k * mad_scaled + logging.debug(f""Robust bounds for depth: {median} [{lower}, {upper}]"") + return lower, upper + +def generate_low_dp_mask(bam: str,ref: str,outfile: str,min_dp: int = 10) -> None: + refseq = pysam.FastaFile(ref) + seqname = refseq.references[0] + dp = np.zeros(refseq.get_reference_length(seqname)) + for l in cmd_out(f""samtools depth {bam}""): + row = l.strip().split(""\t"") + dp[int(row[1])-1] = int(row[2]) + + lower, upper = robust_bounds(dp) + if min_dp>lower: + lower = min_dp + + + masked_positions = [] + for i, d in enumerate(dp): + if d < lower or d > upper: + masked_positions.append(i) + + with open(outfile,""w"") as O: + for i in masked_positions: + O.write(f""{seqname}\t{i}\t{i+1}\n"") + + + +def generate_low_dp_mask_vcf(vcf: str,outfile: str,min_dp: int = 10) -> None: + missing_positions = [] + vcf_obj = pysam.VariantFile(vcf) + for rec in vcf_obj: + # use AD field if available + if 'AD' in rec.samples[0]: + dp = sum(rec.samples[0]['AD']) + else: + dp = rec.samples[0]['DP'] + if dp str: + with TempFilePrefix() as tmp: + tmp_vcf = f""{tmp}.{sample_name}.vcf.gz"" + run_cmd(f"""""" + bcftools view {input_vcf} \ + | annotate_maaf.py \ + | bcftools filter -S . -e 'GT=""alt"" && MAAF<0.7' \ + | snp-gap.py \ + | rename_vcf_sample.py --sample-name {sample_name} \ + | vcf-process-for-consensus.py \ + | bcftools view -v snps -Oz -o {tmp_vcf} + """""") + run_cmd(f""bcftools index {tmp_vcf}"") + + run_cmd(f""vcf-extract-mixed-pos-bed.py --vcf {tmp_vcf} --lb 0.2 --ub 0.8 > {tmp_vcf}.mixed_positions.bed "") + if low_dp_regions: + mask_cmd = f""-m {low_dp_regions} -m {tmp_vcf}.mixed_positions.bed -m {excluded_regions}"" + else: + mask_cmd = f""-m {excluded_regions}"" + + + + run_cmd(f""bcftools consensus --sample {sample_name} {mask_cmd} -f {ref} {tmp_vcf} | sed 's/>/>{sample_name} /' > {output_file}"") + return output_file + +def cli_prepare_sample_consensus(sample: str,input_vcf: str,args: argparse.Namespace) -> str: + + mask_bed = f""{args.files_prefix}.{sample}.mask.bed"" + if hasattr(args,'supplementary_bam') and args.supplementary_bam: + args.bam = args.supplementary_bam + if args.bam: + generate_low_dp_mask(f""{args.bam}"",args.conf['ref'],mask_bed) + elif args.low_dp_mask: + mask_bed = args.low_dp_mask + elif args.vcf: + generate_low_dp_mask_vcf(args.vcf,mask_bed) + else: + mask_bed = None + + output_file = f'{args.files_prefix}.consensus.fa' + + prepare_sample_consensus( + sample_name=sample, + ref=args.conf['ref'], + input_vcf=input_vcf, + output_file=output_file, + excluded_regions=args.conf['bedmask'], + low_dp_regions=mask_bed, + ) + return output_file + +def consensus_fasta_to_vcf(consensus_fasta: str, ref: str, outfile: str) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + tmp_aln = f""{tmpdir}/temp_aln.fa"" + run_cmd(f""cat {ref} {consensus_fasta}> {tmp_aln}"") + run_cmd(f""fa2vcf.py {tmp_aln} {outfile}"") + +def cli_get_consensus_vcf(sample: str,input_vcf: str,args: argparse.Namespace) -> str: + consensus_file = cli_prepare_sample_consensus(sample,input_vcf,args) + outfile = f""{args.files_prefix}.masked.vcf"" + consensus_fasta_to_vcf(consensus_file, args.conf['ref'], outfile) + return outfile + +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/rules.py",".py","8044","233","from typing import List, Union +from .models import Variant, Gene +import re +import logging + +# Define all the necessary functions for the complete example + +def parse_string(s: str) -> Union[bool, int, float, str]: + """"""Parse string to most appropriate type"""""" + if s.lower() == 'true': + return True + elif s.lower() == 'false': + return False + # if string consists of digits, convert to int + elif s.isdigit(): + return int(s) + # if string consists of digits and a decimal point, convert to float + elif re.match(r'^\d+\.\d+$', s): + return float(s) + return s + +def dsl_parse_genetic_object(query: str) -> dict: + """""" + Improved parsing of the DSL query to handle attribute keys and values correctly. + + Arguments + --------- + query : str + The DSL query to parse. + + Returns + ------- + dict + The parsed query in a dictionary format. + + Examples + -------- + >>> dsl_parse_genetic_object('Gene(name=""gyrA"",position=""1234"")') + {'class': 'Gene', 'attributes': {'name': 'gyrA', 'position': 1234}} + """""" + pattern = r'(\w+)\((.*)\)' + match = re.match(pattern, query) + + if not match: + return None + + class_type, attributes = match.groups() + attr_dict = {} + + for attr in attributes.split(','): + key, value = attr.split('=') + attr_dict[key.strip().strip('""').strip(""'"")] = parse_string(value.strip().strip('""').strip(""'"")) + + return { + 'class': class_type, + 'attributes': attr_dict + } + + +def search_for_object(data_structure: List[Union[Variant,Gene]], query: str) -> List[dict]: + """""" + Search the data structure for a match based on the DSL query and return the matching object or None. + + Arguments + --------- + data_structure : List[Variant] + The data structure to search. + query : str + The DSL query to search for. + + Returns + ------- + dict|None + The matching object or None if no match was found. + + Examples + -------- + >>> from pathogenprofiler.data import Variant, Gene, generate_example_gene + >>> genes = [generate_example_gene()] + >>> search_for_object(genes, 'Gene(gene_id=""Rv0667"")') + Gene(gene_id='Rv0667', type='functionally_normal', filter='pass', gene_name='rpoB', annotation=[{'type': 'drug_resistance', 'drug': 'rifampicin'}]) + >>> search_for_object(genes, 'Gene(gene_id=""Rv0668"")') == None + True + """""" + parsed_query = dsl_parse_genetic_object(query) + + if not parsed_query: + return None + + class_type = parsed_query['class'] + attributes = parsed_query['attributes'] + + attribute_expansions = [] + if 'type' in attributes and attributes['type'] == 'lof': + for t in ('frameshift_variant', 'stop_gained', 'transcript_ablation','feature_ablation'): + tmp = attributes.copy() + tmp['type'] = t + attribute_expansions.append(tmp) + else: + attribute_expansions.append(attributes) + + matched_entries = [] + for attrib in attribute_expansions: + for entry in data_structure: + if isinstance(entry,Variant) and class_type=='Gene': + continue + if isinstance(entry,Gene) and class_type=='Variant': + continue + + + if all(vars(entry).get(key, None) == value for key, value in attrib.items()): + matched_entries.append(entry) + + return matched_entries + + +def parse_flexible_dsl(rule: str) -> dict: + """""" + Parse the DSL query to handle actions between any two entities (genes or mutations) in an agnostic manner. + + Arguments + --------- + rule : str + The DSL query to parse. + + Returns + ------- + dict + The parsed query in a dictionary format. + + Examples + -------- + >>> parse_flexible_dsl('Variant(gene_name=""gyrA"") inactivates_resistance Variant(gene_name=""gyrB"")') + {'source_query': 'Variant(gene_name=""gyrA"")', 'target_query': 'Variant(gene_name=""gyrB"")', 'action': 'inactivates_resistance'} + """""" + parts = rule.split() + parts = parts[:3] + [' '.join(parts[3:])] + if len(parts) < 3: + return None + if len(parts)==3: + parts.append(None) + source_query, action, target_query, note = parts + + return { + 'source_query': source_query, + 'target_query': target_query, + 'action': action, + 'note': note + } + + +def execute_inactivates_resistance_flexible(data_structure: List[Variant], source_query: dict, target_query: dict, note: str, just_make_note=False) -> bool: + """""" + Execute the 'inactivates_resistance' action in a flexible manner where either genes or mutations + can inactivate resistance on genes or mutations. + """""" + source_objects = search_for_object(data_structure, source_query) + target_objects = search_for_object(data_structure, target_query) + + if source_objects and target_objects: + for target_object in target_objects: + for annotation in vars(target_object).get('annotation', []): + if annotation.get('type') == 'drug_resistance': + if note: + annotation['note'] = note + if not just_make_note: + annotation['type'] = 'inactivated_drug_resistance' + + return True + return False + +def execute_make_interaction_note(data_structure: List[Variant], source_query: dict, target_query: dict) -> bool: + """""" + Execute the 'make_note' action in a flexible manner where either genes or mutations + can inactivate resistance on genes or mutations. + """""" + source_objects = search_for_object(data_structure, source_query) + target_objects = search_for_object(data_structure, target_query) + if source_objects and target_objects: + for target_object in target_objects: + for annotation in vars(target_object).get('annotation', []): + if annotation.get('type') == 'drug_resistance': + annotation['note'] = 'There is an interaction between %s and %s. Please check mutations for further details.' % (source_query, target_query) + return True + return False + +def apply_rules(rules: List[str], genetic_objects: List[dict], just_make_note: bool=False) -> List[str]: + """""" + Apply the rules to the genetic objects. + + Arguments + --------- + rules : List[str] + The rules to apply. + genetic_objects : List[dict] + The genetic objects to apply the rules to. + + Examples + -------- + >>> from pathogenprofiler.data import Variant, Gene, Consequence, generate_example_gene + >>> data = [ + ... Variant(chrom='CU458896',pos=2345982,ref='T',alt='C',depth=100,freq=1,sv=False,filter='pass',gene_id='MAB_2297',gene_name='erm(41)',change='c.28T>C',nucleotide_change='c.28T>C',protein_change='p.Trp10Arg'), + ... Gene(gene_id=""MAB_2297"",type=""functionally_normal"",filter=""pass"",gene_name=""erm(41)"",annotation=[{""type"":""drug_resistance"",""drug"":""macrolides"",""literature"":""10.1038/s41467-021-25484-9""}]) + ... ] + >>> rules = ['Variant(gene_name=""erm(41)"", protein_change=""p.Trp10Arg"") inactivates_resistance Gene(gene_name=""erm(41)"")'] + >>> apply_rules(rules, data) + >>> data[1].annotation[0]['type']=='inactivated_drug_resistance' + True + """""" + actions = { + 'inactivates_resistance': execute_inactivates_resistance_flexible, + 'make_interaction_note': execute_make_interaction_note + } + rules_applied = [] + for rule in rules: + logging.debug(""Applying rule: %s"" % rule) + parsed_query = parse_flexible_dsl(rule) + if parsed_query: + action_executed = actions[parsed_query['action']]( + genetic_objects, + parsed_query['source_query'], + parsed_query['target_query'], + parsed_query['note'], + just_make_note=just_make_note + ) + if not action_executed: + pass + else: + rules_applied.append(rule) + + + return rules_applied + ","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/taxonomy.py",".py","5624","175"," +import logging +from typing import List +from .utils import run_cmd +import csv +from uuid import uuid4 +import os +from .models import TaxonomicHit, Species + + +def combine_species_abundance(matches: List[dict]) -> List[dict]: + """""" + Combine species abundance from multiple hits + Parameters + ---------- + matches : List[dict] + List of taxonomic hits + + Returns + ------- + List[dict] + List of combined species hits with relative abundance + """""" + species_detected = set(t.species for t in matches) + species_objects = [] + if len(matches) == 0: + return [] + + for species in species_detected: + hits = [t for t in matches if t.species == species] + hits = sorted(hits,key=lambda x: x.abundance,reverse=True) + species_objects.append(hits[0]) + + total_abundance = sum([s.abundance for s in species_objects]) + for s in species_objects: + s.relative_abundance = s.abundance/total_abundance*100 + + species_objects = sorted(species_objects,key=lambda x: x.relative_abundance,reverse=True) + return species_objects + +class Sketch: + """"""Base class for sketching and taxonomic classification"""""" + def __init__(self,filename, tmp_prefix=None): + self.filename = filename + self.tmp_prefix = tmp_prefix if tmp_prefix else str(uuid4()) + + def get_species_hits(self, ref_db: str, db_annotation: str, *args, **kwargs) -> List[Species]: + """""" + Get species hits with annotations + Parameters + ---------- + ref_db : str + Path to the reference database + db_annotation : str + Path to the database annotation CSV file + *args, **kwargs + Additional arguments for the classify method + See subclass implementations for details + Returns + ------- + List[Species] + List of species hits with annotations + """""" + sequence_hits = self.classify(ref_db, *args, **kwargs) + + accession_data = {} + for row in csv.DictReader(open(db_annotation)): + accession_data[row[""accession""]] = row + + species_hits = [] + for hit in sequence_hits: + data = hit.model_dump() + data.update(accession_data.get(hit.accession,{})) + species_hits.append(Species(**data)) + + combined_species_hits = combine_species_abundance(species_hits) + return combined_species_hits + + def classify(self, ref_db: str, *args, **kwargs) -> List[TaxonomicHit]: + raise NotImplementedError(""Subclasses must implement classify method"") + + + +class SourmashSig(Sketch): + + def __init__(self,filename: str,tmp_prefix: str = None): + super().__init__(filename, tmp_prefix=tmp_prefix) + + def classify(self, ref_db: str, intersect_bp: int=500000,f_match_threshold: float=0.1) -> List[TaxonomicHit]: + """""" + Classify using sourmash + + Parameters + ---------- + ref_db : str + Path to the sourmash reference database + intersect_bp : int + Minimum intersect base pairs to consider a hit + f_match_threshold : float + Minimum f_match to consider a hit + + Returns + ------- + List[TaxonomicHit] + List of taxonomic hits + """""" + outfile = ""%s"" % self.tmp_prefix+"".sourmash.csv"" + run_cmd(f""sourmash gather {self.filename} {ref_db} -o {outfile}"") + + + filtered_rows = [] + taxonomic_hits = [] + if not os.path.exists(outfile): + return [] + for row in csv.DictReader(open(outfile)): + logging.debug(row) + if intersect_bp and float(row['intersect_bp']) List[TaxonomicHit]: + """""" + Classify using sylph + + Parameters + ---------- + ref_db : str + Path to the sylph reference database directory + threads : int + Number of threads to use + + Returns + ------- + List[TaxonomicHit] + List of taxonomic hits + """""" + outfile = ""%s"" % self.tmp_prefix+"".sylph.tsv"" + run_cmd(f""sylph profile -t {threads} {ref_db}/* {self.filename} > {outfile}"") + + hits = [] + for row in csv.DictReader(open(outfile), delimiter=""\t""): + hit = TaxonomicHit( + prediction_method=""sylph"", + accession=row[""Genome_file""].split(""/"")[-1].replace("".fasta"","""").replace("".fna"","""").replace("".fa"",""""), + ani=round(float(row[""Adjusted_ANI""]),2), + abundance=float(row[""Taxonomic_abundance""]) + ) + hits.append(hit) + return hits + + def __repr__(self): + return ""SylphSketch(%s)"" % self.filename","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/variant.py",".py","2145","51","from .models import Variant + +def set_change(var: Variant) -> None: + """""" + Set the change field for a variant + + Parameters + ---------- + var : Variant + The variant to set the change field for + """""" + protein_csqs = [""missense_variant"",""stop_gained""] + var.change = var.protein_change if var.type in protein_csqs else var.nucleotide_change + return var + +def select_most_relevant_csq(csqs): + rank = [""transcript_ablation"",""exon_loss_variant"",""frameshift_variant"",""large_deletion"",""start_lost"",""disruptive_inframe_deletion"",""disruptive_inframe_insertion"",""stop_gained"",""stop_lost"",""conservative_inframe_deletion"",""conservative_inframe_insertion"",""initiator_codon_variant"",""missense_variant"",""non_coding_transcript_exon_variant"",""upstream_gene_variant"",""5_prime_UTR_premature_start_codon_gain_variant"",""5_prime_UTR_variant"",""3_prime_UTR_variant"",""non_coding_transcript_variant"",""stop_retained_variant"",""splice_region_variant"",""synonymous_variant""] + + ranked_csq = sorted(csqs,key=lambda x: min([rank.index(y) if y in rank else 999 for y in x['type'].split(""&"")])) + return ranked_csq[0] + + +def select_csq(var: Variant) -> None: + """"""Select the most relevant consequence for a variant"""""" + annotated_csq = [] + for csq in var.consequences: + if len(csq.annotation)>0: + annotated_csq.append(csq) + if len(annotated_csq)==0: + csq = select_most_relevant_csq(var.consequences) + elif len(annotated_csq)==1: + csq = annotated_csq[0] + else: + chosen_annotation = None + for csq in annotated_csq: + if csq.causes_drug_resistance()==True: + chosen_annotation = csq + break + if chosen_annotation: + csq = chosen_annotation + else: + csq = annotated_csq[0] + alternate_consequences = [json.dumps(x) for x in d[""consequences""]] + alternate_consequences.remove(json.dumps(csq)) + alternate_consequences = [json.loads(x) for x in alternate_consequences] + del d[""consequences""] + d.update(csq) + d[""alternate_consequences""] = alternate_consequences + d = set_change(d) + + ","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/__init__.py",".py","333","15","from .profiler import * +from .bam import * +from .fasta import * +from .fastq import * +from .utils import * +from .kmer import * +from .db import * +from .drug_resistance import * +from .barcode import * +from .cli import * +from .rules import * +from .models import * +from .consensus import * +from .snp_dist import * +__version__ = ""5.1.0""","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/db.py",".py","33295","880","import csv +from glob import glob +import json +import re +from collections import defaultdict +import sys +from .gff import load_gff, Gene +from .fasta import Fasta +import os +import shutil +import pathogenprofiler as pp +import math +import logging +from .hgvs import verify_mutation_list +from pysam import FastaFile +from typing import List +import argparse +import subprocess as sp + + +def get_git_repo_info(): + git_info = { + 'repo': None, + 'branch': None, + 'commit': None, + 'status': None, + 'author': None, + 'date': None + } + status = sp.run('git status', shell=True, capture_output=True).stderr.decode(""utf-8"") + + if status.startswith('fatal'): + log = None + logging.warning(""Not a git repository"") + else: + log = sp.run('git log -1', shell=True, capture_output=True).stdout.decode(""utf-8"") + # git config --get remote.origin.url + git_info['repo'] = sp.run('git config --get remote.origin.url', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + # git rev-parse --abbrev-ref HEAD + git_info['branch'] = sp.run('git rev-parse --abbrev-ref HEAD', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + # git rev-parse --short=8 HEAD + git_info['commit'] = sp.run('git rev-parse --short=8 HEAD', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + # git status + tmp = sp.run('git status', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + if 'modified' in tmp: + git_info['status'] = 'modified' + else: + git_info['status'] = 'clean' + # git log -1 --pretty=format:""%an"" + git_info['author'] = sp.run('git log -1 --pretty=format:""%an""', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + # git log -1 --pretty=format:""%ad"" + git_info['date'] = sp.run('git log -1 --pretty=format:""%ad""', shell=True, capture_output=True).stdout.decode(""utf-8"").strip() + + return git_info + + +supported_so_terms = [ + 'coding_sequence_variant', 'chromosome', 'duplication', 'inversion', 'coding_sequence_variant', + 'inframe_insertion', 'disruptive_inframe_insertion', 'inframe_deletion', 'disruptive_inframe_deletion', + 'downstream_gene_variant', 'exon_variant', 'exon_loss_variant', 'exon_loss_variant', 'duplication', + 'duplication', 'inversion', 'inversion', 'frameshift_variant', 'gene_variant', 'feature_ablation', + 'duplication', 'gene_fusion', 'gene_fusion', 'bidirectional_gene_fusion', 'rearranged_at_DNA_level', + 'intergenic_region', 'conserved_intergenic_variant', 'intragenic_variant', 'intron_variant', + 'conserved_intron_variant', 'miRNA', 'missense_variant', 'initiator_codon_variant', 'stop_retained_variant', + 'protein_protein_contact', 'structural_interaction_variant', 'rare_amino_acid_variant', + 'splice_acceptor_variant', 'splice_donor_variant', 'splice_region_variant', 'splice_region_variant', + 'splice_region_variant', 'stop_lost', '5_prime_UTR_premature_', 'start_codon_gain_variant', + 'start_lost', 'stop_gained', 'synonymous_variant', 'start_retained', 'stop_retained_variant', + 'transcript_variant', 'transcript_ablation', 'regulatory_region_variant', 'upstream_gene_variant', + '3_prime_UTR_variant', '3_prime_UTR_truncation + exon_loss', '5_prime_UTR_variant', + '5_prime_UTR_truncation + exon_loss_variant', 'sequence_feature + exon_loss_variant', 'functionally_normal', + 'conservative_inframe_deletion', 'conservative_inframe_insertion' +] + +def generate_kmer_database(kmer_file: str,outfile: str) -> None: + from itertools import combinations, product + + def generate(s, d=1): + N = len(s) + letters = 'ACGT' + pool = list(s) + + for indices in combinations(range(N), d): + for replacements in product(letters, repeat=d): + skip = False + for i, a in zip(indices, replacements): + if pool[i] == a: skip = True + if skip: continue + + keys = dict(zip(indices, replacements)) + yield ''.join([pool[i] if i not in indices else keys[i] + for i in range(N)]) + + with open(outfile,""w"") as O: + for l in open(kmer_file): + row = l.strip().split() + kmers = [row[0]] + list(generate(row[0])) + O.write(""%s\t%s\t%s\n"" % (row[1],len(kmers),""\t"".join(kmers))) + + + +def revcom(s: str) -> str: + """"""Return reverse complement of a sequence"""""" + def complement(s): + basecomplement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A', 'N': 'N'} + letters = list(s) + letters = [basecomplement[base] for base in letters] + return ''.join(letters) + return complement(s[::-1]) + + +def extract_genome_positions(db,gene): + pos = [] + for mut in db[gene]: + if mut[:2] not in [""p."",""c."",""n.""]: continue + pos.extend(db[gene][mut][""genome_positions""]) + return list(set(pos)) + +def write_bed( + db: dict, + gene_dict: dict, + gene_info: List[Gene], + ref_file: str, + outfile:str, + padding: int = 200, + gene_coordinates: List[dict] = None + ) -> None: + if os.path.exists(ref_file+"".fai""): + os.remove(ref_file+"".fai"") + ref = FastaFile(ref_file) + lines = [] + for gene in gene_dict: + if gene not in gene_info: + logging.error(""%s not found in the 'gene_info' dictionary... Exiting!"" % gene) + quit() + if gene_coordinates and gene in gene_coordinates: + genome_start = gene_coordinates[gene]['start'] + genome_end = gene_coordinates[gene]['end'] + elif gene_info[gene].gene_id in db: + genome_positions = extract_genome_positions(db,gene_info[gene].gene_id) + if gene_info[gene].strand==""+"": + if len(genome_positions)>0 and (gene_info[gene].feature_start > min(genome_positions)): + genome_start = min(genome_positions) - padding + else: + genome_start = gene_info[gene].start - padding + + if len(genome_positions)>0 and (gene_info[gene].feature_end < max(genome_positions)): + genome_end = max(genome_positions) #+ padding + else: + genome_end = gene_info[gene].end #+ padding + else: + if len(genome_positions)>0 and (gene_info[gene].feature_start > min(genome_positions)): + genome_start = min(genome_positions) #- padding + else: + genome_start = gene_info[gene].end #- padding + + if len(genome_positions)>0 and (gene_info[gene].feature_end < max(genome_positions)): + genome_end = max(genome_positions) + padding + else: + genome_end = gene_info[gene].start + padding + else: + genome_start = gene_info[gene].feature_start - padding + genome_end = gene_info[gene].feature_end + padding + + if genome_start<1: + genome_start = 1 + + chrom_lengths = dict(zip(ref.references, ref.lengths)) + if genome_end > chrom_lengths[gene_info[gene].chrom]: + genome_end = chrom_lengths[gene_info[gene].chrom] + + drugs = [d for d in gene_dict[gene] if d!=""""] + if len(drugs)==0: + drugs = ""None"" + else: + drugs = "","".join(sorted(list(drugs))) + lines.append([ + gene_info[gene].chrom, + str(genome_start), + str(genome_end), + gene_info[gene].gene_id, + gene_info[gene].name, + drugs + ]) + with open(outfile,""w"") as O: + for line in sorted(lines,key=lambda x: (x[0],int(x[1]))): + O.write(""%s\n"" %""\t"".join(line)) + +def assign_gene_to_amplicon(genes,chrom,start,end): + l = [] + for g in genes.values(): + if g.chrom!=chrom: continue + overlap = set(range(g.feature_start,g.feature_end)).intersection(set(range(int(start),int(end)))) + if overlap: + l.append((g.gene_id,g.name,len(overlap))) + return tuple(sorted(l,key=lambda x:x[2],reverse=True)[0][:2]) + + + +def assign_amplicon_drugs(db,chrom,start,end): + d = set() + for gene in db: + for change in db[gene]: + if db[gene][change]['chromosome']!=chrom: continue + if db[gene][change]['genome_positions']==None: continue + if set(db[gene][change]['genome_positions']).intersection(set(range(int(start),int(end)))): + for ann in db[gene][change]['annotations']: + if ""drug"" in ann: + d.add(ann['drug']) + return d + +def write_amplicon_bed(ref_seq,genes,db,primer_file,outfile): + ref = Fasta(ref_seq) + with open(outfile,""w"") as O: + for chrom,start,end,amplicon_name in ref.get_amplicons(primer_file): + locus_tag,gene_name = assign_gene_to_amplicon(genes,chrom,start,end) + drugs = "","".join(assign_amplicon_drugs(db,chrom,start,end)) + if drugs=="""": + drugs = ""None"" + O.write(f""{chrom}\t{start}\t{end}\t{locus_tag}\t{gene_name}\t{drugs}\t{amplicon_name}\n"") + +def so_term_in_mutation(mutation: str) -> bool: + for term in supported_so_terms: + if term in mutation: + return True + return False + +def get_snpeff_formated_mutation_list(hgvs_variants,ref,gff,snpEffDB,snpeff_config): + # initialise_snpeff_dir(snpeff_config) + logging.debug(""Converting HGVS to snpEff format"") + genes = load_gff(gff) + refseq = FastaFile(ref) + converted_mutations = {} + so_term_rows = [r for r in hgvs_variants if so_term_in_mutation(r['Mutation'])] + hgvs_variants = [r for r in hgvs_variants if not so_term_in_mutation(r['Mutation'])] + + converted_mutations = verify_mutation_list(hgvs_variants,genes,refseq, snpEffDB,snpeff_config) + for row in so_term_rows: + converted_mutations[(row[""Gene""],row['Mutation'])] = (row['Gene'],row['Mutation']) + + return converted_mutations + +def get_exon_to_aa_coords(exons): + converter = [] + offset = 0 + if exons[0].strand == ""+"": + for e in exons: + aa = [math.floor((x - e.phase)/3) + 1 + offset for x in range(e.start - e.start , e.end - e.start +1)] + genome = range(e.start,e.end+1) + converter.extend(list(zip(genome,aa))) + offset = aa[-1] + else: + for e in exons[::-1]: + aa = [math.floor((x - e.phase)/3) + 1 + offset for x in range(e.start - e.start , e.end - e.start +1)] + genome = range(e.end,e.start-1,-1) + converter.extend(list(zip(genome,aa))) + offset = aa[-1] + return converter + +def get_aa2genome_coords(exons): + converter = get_exon_to_aa_coords(exons) + aa2genome = defaultdict(list) + for g,a in converter: + aa2genome[a].append(g) + return aa2genome + +def get_genome_position(gene_object,change): + g = gene_object + for term in supported_so_terms: + if term in change: + return None + if ""any_missense_codon"" in change: + codon = int(change.replace(""any_missense_codon_"","""")) + change = f""p.Xyz{codon}Xyz"" + + if change[0]==""p"": + aa2genome = get_aa2genome_coords(g.transcripts[0].exons) + + + r = re.search(""p.[A-Za-z]+([0-9]+)"",change) + if r: + codon = int(r.group(1)) + return aa2genome[codon] + + # p.1? + r = re.search(r'p.1\?',change) + if r: + codon = 1 + return aa2genome[codon] + + r = re.search(""c.(-[0-9]+)[ACGT]+>[ACGT]+"",change) + if r: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos + return [p] + else: + p = g.start - pos + return [p] + r = re.search(""n.(-?[0-9]+)[ACGT]+>[ACGT]+"",change) + if r: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos -1 + return [p] + + # c.-30_-29insGCG + r = re.search(r'[nc].([\-\*0-9]+)_([\-\*0-9]+)ins[A-Z]+',change) + if r: + if ""*"" in r.group(1): + if g.strand==""+"": + pos = g.feature_end - g.feature_start + int(r.group(1).replace(""*"","""")) + 1 + else: + pos = g.feature_end - g.feature_start - int(r.group(1).replace(""*"","""")) - 1 + else: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos -1 + return [p, p+1] + else: + p = g.start - pos + return [p, p+1] + + # n.211_212delGC + r = re.search(r'[nc].([\-\*0-9]+)_([\-\*0-9]+)del[A-Z]*',change) + if r: + if ""*"" in r.group(1): + if g.strand==""+"": + pos1 = g.feature_end - g.feature_start + int(r.group(1).replace(""*"","""")) + else: + pos1 = g.feature_end - g.feature_start - int(r.group(1).replace(""*"","""")) + else: + pos1 = int(r.group(1)) + if ""*"" in r.group(2): + if g.strand==""+"": + pos2 = g.feature_end - g.feature_start + int(r.group(2).replace(""*"","""")) + else: + pos2 = g.feature_end - g.feature_start - int(r.group(2).replace(""*"","""")) + else: + pos2 = int(r.group(2)) + if g.strand==""+"": + p1 = g.start + pos1 -1 + p2 = g.start + pos2 -1 + if pos1<0: + p1+=1 + p2+=1 + return list(range(p1,p2+1)) + else: + p1 = g.start - pos1 + 1 + p2 = g.start - pos2 + 1 + if pos1<0: + p1-=1 + if pos2<0: + p2-=1 + return list(range(p2,p1+1)) + + # c.-37delT + r = re.search(r'[nc].([\-\*0-9]+)del[A-Z]+',change) + if r: + if ""*"" in r.group(1): + if g.strand==""+"": + pos = g.feature_end - g.feature_start + int(r.group(1).replace(""*"","""")) + 1 + else: + pos = g.feature_end - g.feature_start - int(r.group(1).replace(""*"","""")) - 1 + else: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos - 1 + return [p] + else: + p = g.start - pos + 1 + return [p] + + # n.1089dupC + r = re.search(r'[nc].([\-0-9]+)dup[A-Z]+',change) + if r: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos - 1 + return [p] + else: + p = g.start - pos + 1 + return [p] + + # c.134_135dupTC + r = re.search(r'[nc].([\-0-9]+)_([\-0-9]+)dup[A-Z]+',change) + if r: + pos1 = int(r.group(1)) + pos2 = int(r.group(2)) + if g.strand==""+"": + p1 = g.start + pos1 - 1 + p2 = g.start + pos2 - 1 + return list(range(p1,p2+1)) + else: + p1 = g.start - pos1 + 1 + p2 = g.start - pos2 + 1 + return list(range(p2,p1+1)) + + + + r = re.search(""[c].([0-9]+)([ACGT])>([ACGT])"",change) + if r: + pos = int(r.group(1)) + if g.strand==""+"": + p = g.start + pos - 1 + return [p] + else: + p = g.start - pos + 1 + return [p] + + r = re.search(""g.([0-9]+)"",change) + if r: + pos = int(r.group(1)) + # todo - check if this is correct add in chromosome + return [pos] + + quit(f""Don't know how to handle {str(vars(g))} {change}"") + +def get_chrom_sizes(ref: FastaFile) -> dict: + return dict(zip(ref.references, ref.lengths)) + +def match_ref_chrom_names(source: str,target: str) -> dict: + logging.debug(""Matching chromosome names"") + source_fa = FastaFile(source) + source_fa_size = get_chrom_sizes(source_fa) + target_fa = FastaFile(target) + target_fa_size = get_chrom_sizes(target_fa) + conversion = {} + for s in target_fa.references: + tlen = target_fa_size[s] + tmp = [x[0] for x in source_fa_size.items() if x[1]==tlen] + if len(tmp)==1: + conversion[s] = tmp[0] + return conversion + +def replace_file_column(oldfilename,newfilename,column,conversion,sep=""\t""): + + with open(newfilename,""w"") as f: + for line in open(oldfilename): + row = line.strip().split(sep) + if len(row)0 else None, + ) + variables['amplicon'] = False + + + if list(chrom_conversion.keys())!=list(chrom_conversion.values()): + variables[""chromosome_conversion""] = {""target"":list(chrom_conversion.keys()),""source"":list(chrom_conversion.values())} + variables_file = f""{new_db_dir}/variables.json"" + + + + variables[""files""] = { + ""snpEff_config"": ""snpeff/snpEff.config"", + ""ref"": just_file_name(genome_file), + ""gff"": just_file_name(gff_file), + ""bed"": just_file_name(bed_file), + ""json_db"": just_file_name(json_file), + ""variables"": just_file_name(variables_file) + } + + + + if extra_files: + for key,val in extra_files.items(): + if isinstance(val,str): + variables[""files""][key] = f""{val}"" + else: + variables[""files""][key] = f""{val['name']}"" + + json.dump(variables,open(variables_file,""w""), indent=4) + + if hasattr(args,'create_index') and args.create_index: + index_ref(genome_file) + + if args.load: + load_db(new_db_dir,args.db_dir,args.force) + +def just_file_name(path: str) -> str: + return path.split(""/"")[-1] + +def index_ref(target): + # pp.run_cmd(f""bwa index {target}"") + pp.run_cmd(f""samtools faidx {target}"") + tmp = target.replace("".fasta"","""") + pp.run_cmd(f""samtools dict {target} -o {tmp}.dict"") + pp.run_cmd(f""bwa index {target}"") + +def init_db_dir(db_dir): + if not os.path.isdir(db_dir): + os.mkdir(db_dir) + return db_dir + +def load_db(local_db_dir,global_db_dir,force=False): + + # copy local db to global db dir + if not os.path.isdir(global_db_dir): + os.mkdir(global_db_dir) + + db_name = local_db_dir.split(""/"")[-1] + + new_db_dir = f""{global_db_dir}/{db_name}"" + if os.path.isdir(new_db_dir) and not force: + logging.error(f""Database {db_name} already exists in {global_db_dir}. Use --force to overwrite. Exiting now!"") + quit(1) + + if os.path.isdir(new_db_dir) and force: + shutil.rmtree(new_db_dir) + + shutil.copytree(local_db_dir,f""{global_db_dir}/{db_name}"") + + logging.info(""[green]Sucessfully imported library[/]"",extra={""markup"":True}) + +def get_variable_file_name(db_dir:str,library_name:str): + library_prefix = f""{db_dir}/{library_name}"" + return f""{library_prefix}.variables.json"" + +def check_db_files(variables): + for key,val in variables.items(): + if key==""ref"": + if not os.path.isfile(val+"".fai""): + index_ref(val) + +def is_db_path(string): + if ""/"" in string: + return True + elif os.path.isfile(string+"".variables.json""): + return True + return False + +def check_db_exists(db_dir:str,db_name:str): + if is_db_path(db_name): + if ""/"" in db_name: + db_dir = ""/"".join(db_name.split(""/"")[:-1]) + db_name = db_name.split(""/"")[-1] + else: + db_dir = '.' + + if not os.path.isfile(f""{db_dir}/{db_name}/variables.json""): + logging.error(f""DB {db_name} does not exist in the current directory or in {db_dir}"") + raise FileExistsError + +def initialise_snpeff_genome(db_dir: str, db_name: str, genome_name: str) -> None: + """""" + Initialise the snpEff genome directory for a specific genome. + This function creates the necessary directories and files for snpEff to work with the specified genome. + """""" + initialise_snpeff_dir(db_dir) + genome_dir = get_snpeff_genome_dir(db_dir, genome_name) + if not os.path.isfile(f""{genome_dir}/snpEffectPredictor.bin""): + logging.debug(f""The snpEffPredictor.bin file for {genome_name} does not exist. Creating it."") + custom_bin_file = f""{db_dir}/{db_name}.snpEffectPredictor.bin"" + logging.debug(f""Custom snpEffPredictor.bin file: {custom_bin_file}"") + if not os.path.isfile(f""{genome_dir}/snpEffectPredictor.bin"") and os.path.isfile(custom_bin_file): + logging.debug(f""Copying custom snpEffectPredictor.bin file from {custom_bin_file} to {genome_dir}/snpEffectPredictor.bin"") + variables = json.load(open(f""{db_dir}/{db_name}.variables.json"")) + codon_table = variables.get('codon_table','Bacterial_and_Plant_Plastid') + load_snpEff_db(custom_bin_file, genome_name, db_dir, codon_table) + +def get_db(db_dir:str,db_name:str,verbose:bool=True): + logging.debug(f""Loading database {db_name} from {db_dir}"") + if is_db_path(db_name): + if ""/"" in db_name: + db_dir = ""/"".join(db_name.split(""/"")[:-1]) + db_name = db_name.split(""/"")[-1] + variable_file_name = f""{db_dir}/{db_name}/variables.json"" + else: + db_dir = '.' + variable_file_name = f""{db_dir}/{db_name}/variables.json"" + else: + variable_file_name = os.path.join(db_dir,f""{db_name}/variables.json"") + + if not os.path.isfile(variable_file_name): + return None + + variables = json.load(open(variable_file_name)) + + + init_db_dir(db_dir) + + # if not ('type' in variables and variables['type'] != 'reference'): + # initialise_snpeff_genome(db_dir, db_name, variables['snpEff_db']) + + for key,val in variables['files'].items(): + if verbose: + logging.info(f""Using {key} file: {db_dir}/{db_name}/{val}"") + + if "".json"" in val: + variables[key] = json.load(open(f""{db_dir}/{db_name}/{val}"")) + elif key==""snpEff_db"": + continue # snpEff_db is handled separately + else: + variables[key] = f""{db_dir}/{db_name}/{val}"" + + check_db_files(variables) + return variables + +def list_db(db_dir): + if not os.path.isdir(db_dir): + return [] + dbs = [] + for name in os.listdir(db_dir): + #check if it is a directory + if os.path.isdir(f""{db_dir}/{name}""): + if os.path.isfile(f""{db_dir}/{name}/variables.json""): + dbs.append(json.load(open(f""{db_dir}/{name}/variables.json""))) + return dbs + + + +def create_species_db(args: argparse.Namespace ,extra_files:dict = None, db_dir:str = None): + variables = json.load(open(""variables.json"")) + if not extra_files: + extra_files = {} + version = { + ""db-schema-version"":variables['db-schema-version'], + ""name"":args.prefix + } + for key,val in variables.items(): + if 'version' in key: + version[key] = val + + new_db_dir = os.path.join(os.getcwd(),args.prefix) #if not db_dir else os.path.join(db_dir,args.prefix) + if os.path.isdir(new_db_dir) and not args.force: + logging.error(f""Directory {new_db_dir} already exists. Add --force to overwrite. Exiting now!"") + quit(1) + + if os.path.isdir(new_db_dir) and args.force: + shutil.rmtree(new_db_dir) + os.mkdir(new_db_dir) + + version.update(get_git_repo_info()) + + for key, filename in extra_files.items(): + if filename is None: + continue + if key=='sylph_db': + shutil.copytree(filename,f""{new_db_dir}/sylph_db"") + else: + target = f""{new_db_dir}/{filename}"" + shutil.copyfile(filename,target) + + variables_file = f""{new_db_dir}/variables.json"" + variables.update({ + ""version"": version, + ""files"":{ + ""variables"": just_file_name(variables_file) + } + }) + + if extra_files: + for key,val in extra_files.items(): + if key=='sylph_db': + variables[""files""][key] = ""sylph_db"" + else: + variables[""files""][key] = just_file_name(val) + json.dump(variables,open(variables_file,""w"")) + + + init_db_dir(db_dir) + + if args.load: + load_db(new_db_dir,db_dir,args.force) + + + +def get_default_snpeff_dir(): + tmp = glob(f""{sys.base_prefix}/share/*snpeff*"") + if len(tmp)>0: + return tmp[0] + else: + return None + +def get_default_snpeff_config_filename(): + default_snpeff_dir = get_default_snpeff_dir() + return f""{default_snpeff_dir}/snpEff.config"" + +def get_custom_snpeff_dir(db_dir): + dirpath = f""{db_dir}/snpeff/"" + if not os.path.isdir(dirpath): + os.mkdir(dirpath) + if not os.path.isdir(f""{dirpath}/data""): + os.mkdir(f""{dirpath}/data"") + return dirpath + + +def get_custom_snpeff_config(db_dir): + default_snpeff_config = get_default_snpeff_config_filename() + logging.debug(f""Default snpEff config file: {default_snpeff_config}"") + custom_snpeff_config = f""{get_custom_snpeff_dir(db_dir)}/snpEff.config"" + if not os.path.isfile(custom_snpeff_config): + logging.debug(f""Custom snpEff config file {custom_snpeff_config} does not exist. Copying from default snpEff config."") + shutil.copyfile(default_snpeff_config,custom_snpeff_config) + + return custom_snpeff_config + + +def initialise_snpeff_dir(db_dir: str) -> None: + custom_snpeff_dir = get_custom_snpeff_dir(db_dir) + logging.debug(f""Custom snpEff directory: {custom_snpeff_dir}"") + custom_snpeff_config = get_custom_snpeff_config(db_dir) + logging.debug(f""Custom snpEff config file: {custom_snpeff_config}"") + if not os.path.isfile(custom_snpeff_config): + logging.debug(f""Custom snpEff config file {custom_snpeff_config} does not exist. Copying from default snpEff config."") + default_snpeff_config = get_default_snpeff_config_filename() + shutil.copyfile(default_snpeff_config,custom_snpeff_config) + +def get_snpeff_genome_dir(db_dir: str, genome_name: str) -> str: + custom_snpeff_dir = get_custom_snpeff_dir(db_dir) + genome_dir = f""{custom_snpeff_dir}/data/{genome_name}"" + if not os.path.isdir(genome_dir): + logging.debug(f""Creating snpEff genome directory: {genome_dir}"") + os.mkdir(genome_dir) + return genome_dir + +def load_snpEff_db(bin_file: str,genome_name: str,db_dir:str, codon_table='Bacterial_and_Plant_Plastid'): + logging.debug(f""Loading snpEff database {genome_name} from {bin_file} into {db_dir}"") + initialise_snpeff_dir(db_dir) + custom_snpeff_config = get_custom_snpeff_config(db_dir) + + with open(custom_snpeff_config,""a"") as F: + F.write(f""{genome_name}.genome : {genome_name}\n"") + F.write(f""{genome_name}.codonTable : {codon_table}\n"") + + genome_dir = get_snpeff_genome_dir(db_dir,genome_name) + logging.debug(f""Copying {bin_file} to {genome_dir}/snpEffectPredictor.bin"") + shutil.copyfile(bin_file,f""{genome_dir}/snpEffectPredictor.bin"") +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/utils.py",".py","24373","754","import sys +import os.path +from collections import defaultdict +import re +import subprocess as sp +from uuid import uuid4 +import logging +import pysam +from typing import List, Dict, Generator +from joblib import Parallel, delayed +from tqdm import tqdm +from glob import glob +from .models import GenomeRange +import shutil +import math +import json +import csv + + +tmp_prefix = str(uuid4()) + +shared_dict = { + 'software': {} +} + +def get_version(tool): + cmds = { + 'bcftools': 'bcftools --version', + 'samtools': 'samtools --version', + 'delly': 'delly --version', + 'bwa': 'bwa', + 'trimmomatic': 'trimmomatic -version', + 'gatk': 'gatk -version', + 'lofreq': 'lofreq version', + 'bedtools': 'bedtools --version', + 'minimap2': 'minimap2 --version', + 'freebayes': 'freebayes --version', + 'pilon': 'pilon --version', + 'snpEff': 'snpEff -version', + 'kmc': 'kmc', + 'sourmash': 'sourmash --version', + 'paftools.js': 'paftools.js version', + 'sylph': 'sylph --version', + } + regex = { + 'bcftools': r'bcftools (\d+\.\d+\.?\d?)', + 'samtools': r'samtools (\d+\.\d+\.?\d?)', + 'delly': r'Delly version: v(\d+\.\d+\.?\d?)', + 'bwa': r'Version: (\d+\.\d+\.?\d?)', + 'trimmomatic': r'(\d+\.\d+)', + 'gatk': r'The Genome Analysis Toolkit \(GATK\) v(\d+\.\d+\.?\d?)', + 'lofreq': r'version: (\d+\.\d+\.?\d?)', + 'bedtools': r'bedtools v(\d+\.\d+\.?\d?)', + 'minimap2': r'(\d+\.\d+)', + 'freebayes': r'version: v(\d+\.\d+\.?\d?)', + 'pilon': r'Pilon version (\d+\.\d+\.?\d?)', + 'snpEff': r'SnpEff\t(\d+\.\d+.?)', + 'kmc': r'K-Mer Counter \(KMC\) ver. (\d+\.\d+\.\d+)', + 'sourmash': r'sourmash (\d+\.\d+\.\d?)', + 'paftools.js': r'([\w.-]+)', + 'sylph': r'sylph (\d+\.\d+\.\d?)', + } + x = sp.run([cmds[tool]], shell=True, stdout=sp.PIPE, stderr=sp.PIPE) + text = x.stdout.decode('utf-8', errors='ignore') + x.stderr.decode('utf-8', errors='ignore') + version = re.search(regex[tool], text).group(1) + return version + +def get_software_used(): + data = [] + for process,software in shared_dict['software'].items(): + + data.append({ + 'process': process, + 'software': software, + 'version': get_version(software) + }) + return data + +class TempFilePrefix(object): + """"""Create a temporary file prefix"""""" + def __init__(self): + self.prefix = str(uuid4()) + def __enter__(self): + return self.prefix + def __exit__(self, exc_type, exc_value, traceback): + """"""Remove temporary files"""""" + logging.debug(""Removing temporary files: %s"" % self.prefix) + for f in glob(self.prefix+""*""): + os.remove(f) + +class TempFolder(object): + """"""Create a temporary file prefix"""""" + def __init__(self): + self.prefix = str(uuid4()) + def __enter__(self): + os.mkdir(self.prefix) + return self.prefix + def __exit__(self, exc_type, exc_value, traceback): + """"""Remove temporary files"""""" + logging.debug(""Removing temporary folder: %s"" % self.prefix) + shutil.rmtree(self.prefix) + +def get_tmp_file(prefix=None): + """"""Get a temporary file"""""" + if prefix: + return ""%s.%s"" % (prefix,uuid4()) + else: + return ""%s"" % uuid4() + + +def sanitize_region(region: str) -> str: + """"""Replace : and - with _"""""" + return region.replace("":"",""_"").replace(""-"",""_"") + +class Region: + """"""A class to represent a region"""""" + def __init__(self,region: str): + self.region = region + self.chrom = region.split("":"")[0] + self.start = int(region.split("":"")[1].split(""-"")[0]) + self.end = int(region.split("":"")[1].split(""-"")[1]) + self.length = self.end - self.start + self.safe = sanitize_region(region) + + def __str__(self): + return self.region + + def __repr__(self): + return self.region + + def __len__(self): + return self.length + + + +def genome_job(cmd: str,region: Region) -> sp.CompletedProcess: + """"""Run a command on a region of the genome"""""" + region_safe = region.safe + cmd = cmd.format(region=region,region_safe=region_safe) + out = run_cmd(cmd) + return out + + +def get_genome_chunks(fasta: str,nchunks: int) -> List[Region]: + """""" + Split genome into n chunks + + Parameters + ---------- + fasta : str + Path to fasta file + nchunks : int + Number of chunks to split the genome into + safe : bool + Replace : and - with _ in the region string + + Returns + ------- + List[Region] + A list of regions + """""" + genome = pysam.FastaFile(fasta) + total_length = sum(genome.lengths) + chunk_length = int(total_length/nchunks) + 10 + chunks = [] + chunk_start = 0 + chunk_end = 0 + for chrom in genome.references: + while chunk_end < genome.get_reference_length(chrom): + chunk_end += chunk_length + if chunk_end > genome.get_reference_length(chrom): + chunk_end = genome.get_reference_length(chrom) + chunks.append([chrom,chunk_start,chunk_end]) + chunk_start = chunk_end + regions = [Region(f""{r[0]}:{r[1]+1}-{r[2]}"") for r in chunks] + return regions + +def load_bed_regions(bed_file: str) -> List[Region]: + """"""Load regions from a bed file"""""" + regions = [] + with open(bed_file) as fh: + for line in fh: + if line.startswith(""#""): + continue + chrom,start,end = line.strip().split(""\t"")[:3] + regions.append(Region(f""{chrom}:{start}-{end}"")) + return regions + +def run_cmd_parallel_on_genome(cmd: str,genome: str,threads: int = 2,desc: str=None,bed_file: str=None) -> List[sp.CompletedProcess]: + """"""Run a command in parallel in chunks of the genome"""""" + logging.debug(""Running command in parallel: %s"" % cmd) + if bed_file: + regions = load_bed_regions(bed_file) + else: + regions = get_genome_chunks(genome,nchunks=threads) + + parallel = Parallel(n_jobs=threads, return_as=""generator"") + desc = desc if desc else ""Running command in parallel..."" + results = [r for r in tqdm(parallel(delayed(genome_job)(cmd,r) for r in regions),total=len(regions),desc=desc)] + return results + + + + +def stringify(l): + return [str(x) for x in list(l)] + +def parse_csv(filename): + """"""Parses a CSV file into a dictionary using the first column as the key."""""" + with open(filename, 'r') as f: + reader = csv.DictReader(f) + key = reader.fieldnames[0] + return {row[key]: row for row in reader} + +def return_fields(obj,args,i=0): + """"""Return a field from a nested dictionary"""""" + largs = args.split(""."") + if i+1>len(largs): + return obj + if largs[i] not in obj: + return None + sub_obj = obj[largs[i]] + if isinstance(sub_obj,dict): + return return_fields(sub_obj,args,i+1) + elif isinstance(sub_obj,list): + return list(set([return_fields(x,args,i+1) for x in sub_obj])) + else: + return sub_obj + +def variable2string(var,quote=False): + q = '""' if quote else """" + if isinstance(var,float): + return ""%.3f"" % var + elif isinstance(var,dict): + return ""%s%s%s"" % (q,"","".join(list(var)),q) + elif isinstance(var,list): + if set(var)=={''}: + return """" + elif len(set(var))==1: + return ""%s%s%s"" % (q,str(var[0]),q) + return ""%s%s%s"" % (q,"","".join(var),q) + else: + return ""%s%s%s"" % (q,str(var),q) + +def dict_list2text(l,columns = None, mappings = None,sep=""\t""): + if len(l)==0: + return """" + if mappings: + headings = list(mappings) + elif columns: + headings = columns + else: + headings = list(l[0].keys()) + rows = [] + header = sep.join([mappings[x].title() if (mappings!=None and x in mappings) else x.title() for x in headings]) + for row in l: + r = sep.join([variable2string(return_fields(row,x)) for x in headings]) + rows.append(r) + str_rows = ""\n"".join(rows) + out =""%s\n%s"" % (header,str_rows) + return out.strip() + +def object_list2text(l: list,columns: list = None, mappings: dict = None,sep: str=""\t""): + if len(l)==0: + return """" + l = [l.dict() for l in l] + if mappings: + headings = list(mappings) + elif columns: + headings = columns + else: + headings = list(l[0].keys()) + + rows = [] + header = sep.join([mappings[x].title() if (mappings!=None and x in mappings) else x.title() for x in headings]) + for row in l: + r = sep.join([variable2string(return_fields(row,x)) for x in headings]) + rows.append(r) + str_rows = ""\n"".join(rows) + out =""%s\n%s"" % (header,str_rows) + return out.strip() + +def get_lt2drugs(bed_file): + lt2drugs = {} + for l in open(bed_file): + row = l.strip().split() + lt2drugs[row[3]] = None if row[5]==""None"" else row[5].split("","") + return lt2drugs + + +# def process_variants(results: dict,conf: dict,annotations: List[str]): +# variant_containers = {d:[] for d in annotations} +# variant_containers['other'] = [] +# variant_containers['qc_fail'] = [] +# for var in results['variants']: +# annotation_containers = {d:[a for a in var.get('annotation',[]) if a['type']==d] for d in annotations} +# qc = filter_variant(var,conf[""variant_filters""]) +# if qc==""hard_fail"": +# continue +# elif qc==""soft_fail"": +# variant_containers['qc_fail'].append(var) +# else: +# assigned = False +# for a in annotations: +# if annotation_containers[a]: +# assigned = True +# variant_containers[a].append(var) +# if not assigned: +# variant_containers['other'].append(var) + +# for a in annotations: +# results[a+""_variants""] = variant_containers[a] +# results['other_variants'] = variant_containers['other'] +# results['qc_fail_variants'] = variant_containers['qc_fail'] +# del results['variants'] + +# return results + + + +def reformat_annotations(results,conf): + #Chromosome 4998 Rv0005 -242 + lt2drugs = get_lt2drugs(conf[""bed""]) + results[""dr_variants""] = [] + results[""other_variants""] = [] + results[""qc_fail_variants""] = [] + for var in results[""variants""]: + drugs = tuple([x[""drug""] for x in var.get(""annotation"",[]) if x[""type""]==""drug_resistance""]) + if len(drugs)>0: + tmp = var.copy() + dr_ann = [] + other_ann = [] + while len(tmp[""annotation""])>0: + x = tmp[""annotation""].pop() + if x[""type""]==""drug_resistance"": + dr_ann.append(x) + else: + other_ann.append(x) + tmp[""drugs""] = dr_ann + tmp[""annotation""] = other_ann + tmp[""gene_associated_drugs""] = lt2drugs[var[""locus_tag""]] + qc = filter_variant(var,conf[""variant_filters""]) + if qc==""hard_fail"": + continue + elif qc==""soft_fail"": + results[""qc_fail_variants""].append(tmp) + else: + results[""dr_variants""].append(tmp) + else: + var[""gene_associated_drugs""] = lt2drugs[var[""locus_tag""]] + qc = filter_variant(var,conf[""variant_filters""]) + if qc==""hard_fail"": + continue + elif qc==""soft_fail"": + results[""qc_fail_variants""].append(var) + else: + results[""other_variants""].append(var) + del results[""variants""] + return results + +def get_genome_positions_from_db(db): + genome_positions = defaultdict(set) + for gene in db: + for var in db[gene]: + drugs = tuple([x[""drug""] for x in db[gene][var][""annotations""] if x[""type""]==""drug""]) + if len(drugs)==0: + continue + if db[gene][var][""genome_positions""]: + for pos in db[gene][var][""genome_positions""]: + genome_positions[pos].add((gene,var,drugs)) + + return genome_positions + +def bed2gene_lookup(bed_file: str) -> dict: + """""" + Create a lookup table for gene id to gene name + + Parameters + ---------- + bed_file : str + Path to bed file + + Returns + ------- + dict + A dictionary with gene id as key and gene name as value + + Examples + -------- + >>> from tempfile import NamedTemporaryFile + >>> from pathogenprofiler.utils import bed2gene_lookup + >>> with NamedTemporaryFile() as tmp: + ... tmp.write(b""Chromosome\t759310\t763325\tRv0667\trpoB\trifampicin"") + ... tmp.flush() + ... bed2gene_lookup(tmp.name) + 58 + {'Rv0667': 'rpoB'} + """""" + id2name = {} + for l in open(bed_file): + row = l.strip().split() + id2name[row[3]] = row[4] + return id2name + + +def reformat_missing_genome_pos(positions,conf): + lt2gene = lt2genes(conf[""bed""]) + dr_associated_genome_pos = get_genome_positions_from_db(conf[""json_db""]) + new_results = [] + for pos in positions: + if pos in dr_associated_genome_pos: + tmp = dr_associated_genome_pos[pos] + gene = list(tmp)[0][0] + variants = "","".join([x[1] for x in tmp]) + drugs = "","".join(set(unlist([x[2] for x in tmp]))) + new_results.append({""position"":pos,""locus_tag"":gene, ""gene"": lt2gene[gene], ""variants"": variants, ""drugs"":drugs}) + return new_results + +def select_most_relevant_csq(csqs): + rank = [""transcript_ablation"",""exon_loss_variant"",""frameshift_variant"",""large_deletion"",""start_lost"",""disruptive_inframe_deletion"",""disruptive_inframe_insertion"",""stop_gained"",""stop_lost"",""conservative_inframe_deletion"",""conservative_inframe_insertion"",""initiator_codon_variant"",""missense_variant"",""non_coding_transcript_exon_variant"",""upstream_gene_variant"",""5_prime_UTR_premature_start_codon_gain_variant"",""5_prime_UTR_variant"",""3_prime_UTR_variant"",""non_coding_transcript_variant"",""stop_retained_variant"",""splice_region_variant"",""synonymous_variant""] + + ranked_csq = sorted(csqs,key=lambda x: min([rank.index(y) if y in rank else 999 for y in x['type'].split(""&"")])) + return ranked_csq[0] + +def set_change(var): + protein_csqs = [""missense_variant"",""stop_gained""] + var[""change""] = var[""protein_change""] if var[""type""] in protein_csqs else var[""nucleotide_change""] + return var + +def annotation_has_drug_type(ann): + return any([x[""type""]==""drug"" for x in ann]) + +def select_csq(dict_list): + for d in dict_list: + annotated_csq = [] + for csq in d[""consequences""]: + if ""annotation"" in csq: + annotated_csq.append(csq) + if len(annotated_csq)==0: + csq = select_most_relevant_csq(d[""consequences""]) + alternate_consequences = [json.dumps(x) for x in d[""consequences""]] + alternate_consequences.remove(json.dumps(csq)) + alternate_consequences = [json.loads(x) for x in alternate_consequences] + elif len(annotated_csq)==1: + csq = annotated_csq[0] + alternate_consequences = [] + else: + chosen_annotation = None + for csq in annotated_csq: + if annotation_has_drug_type(csq[""annotation""]): + chosen_annotation = csq + break + if chosen_annotation: + csq = chosen_annotation + else: + csq = annotated_csq[0] + alternate_consequences = [json.dumps(x) for x in d[""consequences""]] + alternate_consequences.remove(json.dumps(csq)) + alternate_consequences = [json.loads(x) for x in alternate_consequences] + del d[""consequences""] + d.update(csq) + d[""alternate_consequences""] = alternate_consequences + d = set_change(d) + return dict_list + +def dict_list_add_genes(dict_list,conf,key=""gene_id""): + lt2gene = {} + for l in open(conf[""bed""]): + row = l.rstrip().split() + lt2gene[row[3]] = row[4] + for d in dict_list: + d[""locus_tag""] = d[key] + d[""gene""] = lt2gene[d[key]] + del d[key] + if ""gene_name"" in d: + del d[""gene_name""] + return dict_list + + + +def iupac(n): + tmp = { + ""A"":[""A""], + ""C"":[""C""], + ""G"":[""G""], + ""T"":[""T""], + ""R"":[""A"",""G""], + ""Y"":[""C"",""T""], + ""S"":[""G"",""C""], + ""W"":[""A"",""T""], + ""K"":[""G"",""T""], + ""M"":[""A"",""C""], + ""B"":[""C"",""G"",""T""], + ""D"":[""A"",""G"",""T""], + ""H"":[""A"",""C"",""T""], + ""V"":[""A"",""C"",""G""], + ""N"":[""A"",""C"",""G"",""T""] + } + return tmp[n] + +def unlist(t): + return [item for sublist in t for item in sublist] + + +def get_seqs_from_bam(bamfile): + seqs = [] + for l in cmd_out(""samtools view %s -H | grep ^@SQ"" % bamfile): + row = l.rstrip().split() + seqs.append(row[1].replace(""SN:"","""")) + return seqs + + +def revcom(s): + """"""Return reverse complement of a sequence"""""" + def complement(s): + basecomplement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A', 'N': 'N'} + letters = list(s) + letters = [basecomplement[base] for base in letters] + return ''.join(letters) + return complement(s[::-1]) + + +def stdev(arr): + mean = sum(arr)/len(arr) + return math.sqrt(sum([(x-mean)**2 for x in arr])/len(arr)) + + +def add_arguments_to_self(self,args: dict) -> None: + # Function to add arguments to class instance + for x in args: + if x == ""self"": + continue + vars(self)[x] = args[x] + if ""kwargs"" in args: + for x in args[""kwargs""]: + vars(self)[x] = args[""kwargs""][x] + + + +def run_cmd(cmd: str, desc=None, log: str=None, exit_on_error: bool=True) -> sp.CompletedProcess: + if desc: + logging.info(desc) + processed_cmd = cmd.replace(""&&"",""XX"") + programs = set([x.strip().split()[0] for x in re.split(""[|&;]"",processed_cmd.strip()) if x!=""""]) + missing = [p for p in programs if which(p)==False] + if len(missing)>0: + raise ValueError(""Cant find programs: %s\n"" % ("", "".join(missing))) + logging.debug(f""Running command: {cmd}"") + cmd = ""/bin/bash -c set -o pipefail; "" + cmd + output = open(log,""w"") if log else sp.PIPE + result = sp.run(cmd,shell=True,stderr=output,stdout=output) + if result.returncode != 0: + logging.error(result.stderr.decode(""utf-8"")) + if exit_on_error: + raise ValueError(""Command Failed:\n%s\nstderr:\n%s"" % (cmd,result.stderr.decode())) + return result + +def cmd_out(cmd: str) -> Generator[str, None, None]: + filename = str(uuid4()) + cmd = f""{cmd} > {filename}"" + run_cmd(cmd) + for line in open(filename): + yield line.strip() + os.remove(filename) + + + +def log(msg,ext=False): + sys.stderr.write(""\n""+str(msg)+""\n"") + if ext: + exit(1) + +def load_bed(filename: str) -> Dict[GenomeRange, List[str]]: + data = {} + for l in open(filename): + row = l.rstrip().split('\t') + r = GenomeRange(chrom=row[0],start=int(row[1]),end=int(row[2])) + data[r] = row + return data + + +def _load_bed(filename: str,columns,key1,key2=None,intasint=False): + results = defaultdict(lambda: defaultdict(tuple)) + for l in open(filename): + row = l.rstrip().split(""\t"") + if l[0]==""#"": + header = row + continue + if key2: + if max(columns+[key1,key2])>len(row): + logging.error(""Can't access a column in BED file. The largest column specified is too big"",True) + if key2==2 or key2==3: + results[row[key1-1]][int(row[key2-1])] = tuple([row[int(x)-1] for x in columns]) + else: + results[row[key1-1]][row[key2-1]] = tuple([row[int(x)-1] for x in columns]) + else: + if max(columns+[key1])>len(row): + logging.error(""Can't access a column in BED file. The largest column specified is too big"",True) + results[row[key1-1]]= tuple([row[int(x)-1] for x in columns]) + return results + + +def filecheck(filename): + """""" + Check if file is there and quit if it isn't + """""" + if filename==""/dev/null"": + return filename + elif not os.path.isfile(filename): + logging.error(""Can't find %s\n"" % filename) + exit(1) + else: + return filename + + +def nofile(filename): + """""" + Return True if file does not exist + """""" + if not os.path.isfile(filename): + return True + else: + return False + +def nofolder(filename): + """""" + Return True if file does not exist + """""" + if not os.path.isdir(filename): + return True + else: + return False + +def create_seq_dict(ref): + ref_prefix = ref.replace("".fasta"","""").replace("".fa"","""") + if nofile(f""{ref_prefix}.dict""): + run_cmd(""samtools dict %s -o {ref_prefix}.dict"" % ref) + +def bowtie_index(ref): + if nofile(""%s.1.bt2""%ref): + cmd = ""bowtie2-build %s %s"" % (ref,ref) + run_cmd(cmd) + +def bwa2_index(ref): + """""" + Create BWA index for a reference + """""" + if nofile(""%s.bwt.2bit.64""%ref): + cmd = ""bwa-mem2 index %s"" % ref + run_cmd(cmd) + +def bwa_index(ref): + """""" + Create BWA index for a reference + """""" + if nofile(""%s.bwt""%ref): + cmd = ""bwa index %s"" % ref + run_cmd(cmd) + +def bwa_meme_index(ref): + """""" + Create BWA index for a reference + """""" + if nofile(""%s.0123""%ref): + cmd = ""bwa index %s"" % ref + run_cmd(cmd) + +def which(program): + def is_exe(fpath): + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + + fpath, fname = os.path.split(program) + if fpath: + if is_exe(program): + return True + else: + for path in os.environ[""PATH""].split(os.pathsep): + exe_file = os.path.join(path, program) + if is_exe(exe_file): + return True + return False + + +# def run_cmd(cmd,verbose=1,target=None,terminate_on_error=True): +# """""" +# Wrapper to run a command using subprocess with 3 levels of verbosity and automatic exiting if command failed +# """""" +# programs = set([x.strip().split()[0] for x in re.split(""[|&;]"",cmd) if x!=""""]) +# missing = [p for p in programs if which(p)==False] +# if len(missing)>0: +# raise ValueError(""Cant find programs: %s\n"" % ("", "".join(missing))) +# if target and filecheck(target): return True +# cmd = ""set -u pipefail; "" + cmd +# if verbose>0: +# sys.stderr.write(""\nRunning command:\n%s\n"" % cmd) + +# p = subprocess.Popen(cmd,shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) +# stdout,stderr = p.communicate() + +# if terminate_on_error is True and p.returncode!=0: +# raise ValueError(""Command Failed:\n%s\nstderr:\n%s"" % (cmd,stderr.decode())) + +# if verbose>1: +# sys.stdout.write(stdout) +# sys.stderr.write(stderr) + +# return (stdout.decode(),stderr.decode()) + +def index_bam(bamfile,threads=1,overwrite=False): + """""" + Indexing a bam file + """""" + cmd = ""samtools index -@ %s %s"" % (threads,bamfile) + bam_or_cram = ""cram"" if bamfile[-4:]==""cram"" else ""bam"" + suffix = "".bai"" if bam_or_cram==""bam"" else "".crai"" + if filecheck(bamfile): + if nofile(bamfile+suffix): + run_cmd(cmd) + elif os.path.getmtime(bamfile+suffix) None: + """""" + Process the input arguments and return a Namespace object + + Arguments + --------- + args : argparse.Namespace + The input arguments + + Returns + ------- + argparse.Namespace + The processed arguments + + Examples + -------- + >>> from pathogenprofiler import cli + >>> import argparse + >>> args = argparse.Namespace() + >>> args.software_name = ""ntm-profiler"" + >>> args.resistance_db = ""Mycobacterium_abscessus"" + >>> args.platform = ""illumina"" + >>> args.no_samclip = False + >>> args.no_coverage_qc = False + >>> args.read1 = ""test.fastq.gz"" + >>> args = cli.process_args(args) + >>> args.software_name + 'ntm-profiler' + """""" + args = set_platform_params(args) + args.samclip = True if not args.no_samclip else False + args.coverage_qc = True if not args.no_coverage_qc else False + args.data_source = get_input_data_source(args) + if 'conf' in vars(args) and args.conf: + args.conf['variant_filters'] = get_variant_filters(args) + if hasattr(args,'snp_dist') and args.snp_dist: + args.call_whole_genome = True + args.consensus = True + if hasattr(args,'consensus') and args.consensus==True: + args.call_whole_genome = True + if args.fasta: + args.taxonomic_software = ""sourmash"" + + +def get_vcf_from_bam(args: argparse.Namespace): + conf = args.conf + ### Create bam object and call variants ### + bam = Bam(args.bam, args.files_prefix, platform=args.platform, threads=args.threads) + if args.call_whole_genome: + wg_vcf_obj = bam.call_variants(conf[""ref""], caller=args.caller, filters = conf['variant_filters'], threads=args.threads, calling_params=args.calling_params, samclip = args.samclip, cli_args=vars(args)) + vcf_obj = wg_vcf_obj + # TODO optional? + # vcf_obj = wg_vcf_obj.view_regions(conf[""bed""]) + else: + vcf_obj = bam.call_variants(conf[""ref""], caller=args.caller, filters = conf['variant_filters'], bed_file=conf[""bed""], threads=args.threads, calling_params=args.calling_params, samclip = args.samclip, cli_args=vars(args)) + + ### Run delly if specified ### + final_target_vcf_file = args.files_prefix+"".targets.vcf.gz"" + if 'amplicon' in args.conf and args.conf['amplicon']==True: + args.no_delly = True + if not args.no_delly: + delly_vcf_obj = bam.run_delly(conf['ref'],conf['bed']) + if delly_vcf_obj is not None: + run_cmd(""bcftools index %s"" % delly_vcf_obj.filename) + run_cmd(""bcftools concat %s %s | bcftools sort -Oz -o %s"" % (vcf_obj.filename,delly_vcf_obj.filename,final_target_vcf_file)) + run_cmd(""bcftools index %s"" % (final_target_vcf_file)) + else: + return vcf_obj.filename + #run_cmd(""mv %s %s"" % (vcf_obj.filename, final_target_vcf_file)) + else: + return vcf_obj.filename + #run_cmd(""mv %s %s"" % (vcf_obj.filename, final_target_vcf_file)) + + return final_target_vcf_file + +def get_vcf_file(args: argparse.Namespace): + if args.vcf: + args.vcf = args.vcf + elif args.fasta: + args.paf = Fasta(args.fasta).align_to_ref(args.conf[""ref""],args.files_prefix) + args.vcf = Paf(args.paf).get_ref_variants(args.conf[""ref""], args.prefix, args.files_prefix) + elif args.bam: + args.vcf = get_vcf_from_bam(args) + +def run_barcoder(args: argparse.Namespace) -> List[BarcodeResult]: + if args.data_source in ('fastq', 'bam'): + if not args.bam: + quit() + else: + barcode_result = bam_barcoder(args) + elif args.data_source == 'fasta': + barcode_result = vcf_barcoder(args) + elif args.data_source == 'vcf': + barcode_result = vcf_barcoder(args) + + return barcode_result + +def run_profiler(args) -> List[Union[Variant,DrVariant,Gene,DrGene]]: + if args.read1 or args.bam: + args.bam = get_bam_file(args) + get_vcf_file(args) + args.supplementary_bam = args.bam + + elif args.fasta: + get_vcf_file(args) + + elif args.vcf: + if test_vcf_for_lofreq(args.vcf): + tmp_vcf_file = f""{args.files_prefix}.tmp.vcf.gz"" + run_cmd(f""bcftools view {args.vcf} | modify_lofreq_vcf.py --sample {args.prefix} | bcftools view -Oz -o {tmp_vcf_file}"") + args.vcf = tmp_vcf_file + check_vcf_chrom_match(args.vcf,args.conf[""ref""]) + annotated_variants = vcf_profiler(args) + + return annotated_variants + +def kmer_speciate(args,bam_region=None): + conf = get_db(args.software_name,args.species_db) + if conf==None: + logging.error( + f""\nDatabase '{args.species_db}' not found. You may need to load this database first... Exiting!\n"" + ) + + if ""read1"" in vars(args) and args.read1: + fastq = Fastq(args.read1,args.read2) + kmer_dump = fastq.get_kmer_counts(args.files_prefix,threads=args.threads,max_mem=args.ram,counter = args.kmer_counter) + elif ""bam"" in vars(args) and args.bam: + if bam_region: + region_arg = bam_region if bam_region else """" + run_cmd(f""samtools view -b {args.bam} {region_arg} | samtools fastq > {args.files_prefix}.tmp.fq"") + kmer_dump = Fastq(f""{args.files_prefix}.tmp.fq"").get_kmer_counts(args.files_prefix,threads=args.threads,max_mem=args.ram,counter = args.kmer_counter) + else: + bam = Bam(args.bam,args.files_prefix,""illumina"") + run_cmd(f""samtools fastq {bam.bam_file} > {args.files_prefix}.tmp.fq"") + kmer_dump = Fastq(f""{args.files_prefix}.tmp.fq"").get_kmer_counts(args.files_prefix,threads=args.threads,max_mem=args.ram,counter = args.kmer_counter) + elif ""fasta"" in vars(args) and args.fasta: + kmer_dump = Fasta(args.fasta).get_kmer_counts(args.files_prefix,threads=args.threads,max_mem=args.ram,counter = args.kmer_counter) + if ""output_kmer_counts"" not in vars(args): + args.output_kmer_counts = None + else: + args.output_kmer_counts = f""{args.prefix}.kmers.txt"" if args.output_kmer_counts else False + species = kmer_dump.get_taxonomic_support(conf['kmers'],args.output_kmer_counts) + return species + +def get_bam_file(args): + ### Create bam file if fastq has been supplied ### + if args.bam is None: + if args.read1 and args.read2 and args.no_trim: + # Paired + no trimming + fastq_obj = Fastq(args.read1,args.read2) + elif args.read1 and args.read2 and not args.no_trim: + # Paired + trimming + untrimmed_fastq_obj = Fastq(args.read1,args.read2) + fastq_obj = untrimmed_fastq_obj.trim(args.files_prefix,threads=args.threads) + elif args.read1 and not args.read2 and args.no_trim: + # Unpaired + no trimming + fastq_obj = Fastq(args.read1,args.read2) + elif args.read1 and not args.read2 and not args.no_trim: + # Unpaired + trimming + untrimmed_fastq_obj = Fastq(args.read1) + fastq_obj = untrimmed_fastq_obj.trim(args.files_prefix,threads=args.threads) + else: + exit(""\nPlease provide a bam file or a fastq file(s)...Exiting!\n"") + bam_obj = fastq_obj.map_to_ref( + ref_file=args.conf[""ref""], prefix=args.files_prefix,sample_name=args.prefix, + aligner=args.mapper, platform=args.platform, threads=args.threads + ) + bam_file = bam_obj.bam_file + else: + check_bam_for_rg(args.bam) + check_bam_chrom_match(args.bam,args.conf[""ref""]) + bam_file = args.bam + + return bam_file + + +def set_platform_params(args): + if args.platform in (""nanopore"",""pacbio""): + args.mapper = ""minimap2"" + available_callers = [cls.__software__ for cls in VariantCaller.__subclasses__()] + + if args.caller in ('gatk','freebayes'): + if 'clair3' in available_callers: + logging.debug(""Using clair3 for variant calling"") + args.caller = ""clair3"" + else: + logging.debug(""Using bcftools for variant calling"") + args.caller = ""bcftools"" + args.no_trim=True + args.run_delly = True + else: + if ""no_delly"" in vars(args): + args.run_delly = False if args.no_delly else True + + if args.fasta: + args.depth = ""0,0"" + args.strand = ""0,0"" + return args + +def get_sourmash_hit(args): + args.species_conf = get_db(args.db_dir,args.species_db) + if args.read1: + if args.read2: + fastq = Fastq(args.read1,args.read2) + else: + fastq = Fastq(args.read1) + sourmash_sig = fastq.sourmash_sketch(args.files_prefix) + elif args.fasta: + fasta = Fasta(args.fasta) + sourmash_sig = fasta.sourmash_sketch(args.files_prefix) + elif args.bam: + run_cmd(f""samtools fastq {args.bam} > {args.files_prefix}.tmp.fastq"") + fq_file = f""{args.files_prefix}.tmp.fastq"" + args.temp_fastq_file = fq_file + fastq = Fastq(fq_file) + sourmash_sig = fastq.sourmash_sketch(args.files_prefix) + + sourmash_sig = sourmash_sig.gather(args.species_conf[""sourmash_db""],args.species_conf[""sourmash_db_info""],intersect_bp=500000,f_match_threshold=0.1) + result = [] + + if len(sourmash_sig)>0: + result = sourmash_sig + + return result + +def get_taxonomic_hits(args): + args.species_conf = get_db(args.db_dir,args.species_db) + if args.read1: + if args.read2: + fastq = Fastq(args.read1,args.read2) + else: + fastq = Fastq(args.read1) + sketch = fastq.sketch(args.files_prefix, software=args.taxonomic_software) + elif args.fasta: + fasta = Fasta(args.fasta) + sketch = fasta.sketch(args.files_prefix, software=args.taxonomic_software) + elif args.bam: + run_cmd(f""samtools fastq {args.bam} > {args.files_prefix}.tmp.fastq"") + fq_file = f""{args.files_prefix}.tmp.fastq"" + args.temp_fastq_file = fq_file + fastq = Fastq(fq_file) + sketch = fastq.sketch(args.files_prefix, software=args.taxonomic_software) + + hits = sketch.get_species_hits(args.species_conf[f""{args.taxonomic_software}_db""],args.species_conf[""accessions""]) + + result = [] + + if len(hits)>0: + result = hits + + return result + +def set_species(args: argparse.Namespace) -> SpeciesPrediction: + """""" + Get a SpeciesPrediction object based on the input arguments + + Arguments + --------- + args : argparse.Namespace + The input arguments + + Returns + ------- + SpeciesPrediction + A SpeciesPrediction object + + Examples + -------- + >>> from pathogenprofiler import cli + >>> import argparse + >>> args = argparse.Namespace() + >>> args.software_name = ""ntm-profiler"" + >>> args.resistance_db = ""Mycobacterium_abscessus"" + >>> species_prediction = cli.set_species(args) + >>> species_prediction.species + [Species(species='Mycobacterium abscessus', prediction_info=None)] + """""" + check_db_exists(args.db_dir,args.resistance_db) + conf = get_db(args.db_dir,args.resistance_db) + species = Species( + species=conf[""species""] + ) + data = { + ""taxa"":[species], + ""prediction_method"":""user_defined"", + } + return SpeciesPrediction(**data) + + + + +# def get_sourmash_species_prediction(args: argparse.Namespace) -> SpeciesPrediction: +# """""" +# Get a SpeciesPrediction object based on prediction using sourmash + +# Arguments +# --------- +# args : argparse.Namespace +# The input arguments + +# Returns +# ------- +# SpeciesPrediction +# A SpeciesPrediction object + +# """""" +# conf = get_db(args.db_dir,args.species_db) +# sourmash_species_prediction = get_sourmash_hit(args) +# sourmash_species_prediction_combined = combine_species_abundance(sourmash_species_prediction) +# species = [] +# qc_failed_species = [] +# for obj in sourmash_species_prediction_combined: +# if obj['relative_abundance'] SpeciesPrediction: + """""" + Get a SpeciesPrediction object based on prediction using sourmash + + Arguments + --------- + args : argparse.Namespace + The input arguments + + Returns + ------- + SpeciesPrediction + A SpeciesPrediction object + + """""" + conf = get_db(args.db_dir,args.species_db) + species_hits = get_taxonomic_hits(args) + # sourmash_species_prediction_combined = combine_species_abundance(sourmash_species_prediction) + species = [] + qc_failed_species = [] + for species_hit in species_hits: + if species_hit.relative_abundance<1: + continue + if species_hit.relative_abundance int: + """""" + Convert a position in a gene to a position in the genome. + + Parameters: + pos (int): The position in the gene. + gene (Gene): The gene in which the position occurs. + + Returns: + int: The position in the genome. + """""" + if gene.strand==""+"": + genome_pos = gene.start + pos - 1 + if pos<0: + genome_pos+=1 + if gene.strand==""-"": + genome_pos = gene.start - pos + 1 + if pos<0: + genome_pos-=1 + if genome_pos<0: + genome_pos = ref.get_reference_length(gene.chrom) + genome_pos + return genome_pos + +def extract_insertion(hgvs: str, gene: Gene) -> str: + """""" + Extract the insertion sequence from an HGVS insertion mutation. + + Parameters: + hgvs (str): The HGVS insertion mutation. + gene (Gene): The gene in which the mutation occurs. + + Returns: + str: The insertion sequence. + """""" + r = re.search(r""ins([ACTG]+)"", hgvs) + insertion = r.group(1) + if gene.strand==""-"": + insertion = revcom(insertion) + return insertion + +def extract_duplication(hgvs: str, gene: Gene) -> str: + """""" + Extract the duplication sequence from an HGVS duplication mutation. + + Parameters: + hgvs (str): The HGVS duplication mutation. + gene (Gene): The gene in which the mutation occurs. + + Returns: + str: The duplication sequence. + """""" + r = re.search(r""dup([ACTG]+)"", hgvs) + duplication = r.group(1) + if gene.strand==""-"": + duplication = revcom(duplication) + return duplication + +def extract_numbers(s: str) -> List[int]: + """""" + Extract all the numbers from a string. + + Parameters: + s (str): The input string from which to extract numbers. + + Returns: + List[int]: A list of integers extracted from the input string. + """""" + # Find all numeric substrings using a regex + numbers_str = re.findall(r'-?\d+', s) + + # Convert the numeric substrings to integers and return them + return [int(num_str) for num_str in numbers_str] + +def parse_coding_indel(mutation: str, gene: Gene, ref_object: FastaFile) -> dict: + """""" + Parse an indel mutation in HGVS format and return a dictionary of VCF components. + + Parameters: + mutation (str): The indel mutation in HGVS format. + gene (Gene): The gene in which the mutation occurs. + + Returns: + dict: A dictionary of VCF components. + """""" + numbers = extract_numbers(mutation) + if len(numbers)==2: + start,end = numbers + else: + start = numbers[0] + end = start + start = get_genome_coords(start,gene,ref_object) + end = get_genome_coords(end,gene,ref_object) + if start>end: + start,end = end,start + if ""del"" in mutation: + vcf_pos = start - 1 + ref = ref_object.fetch(gene.chrom,vcf_pos-1,end) + alt = ref[0] + if ""ins"" in mutation: + if ""del"" not in mutation: + vcf_pos = start + ref = ref_object.fetch(gene.chrom,vcf_pos-1,end-1) + alt = ref[0] + extract_insertion(mutation,gene) + return {""chrom"":gene.chrom,""pos"":vcf_pos, ""ref"":ref, ""alt"":alt,""gene"":gene.gene_id,""type"":""nucleotide""} + +def parse_snv(mutation: str, gene: Gene, ref_object: FastaFile) -> dict: + """""" + Parse a SNV mutation in HGVS format and return a dictionary of VCF components. + + Parameters: + mutation (str): The SNV mutation in HGVS format. + gene (Gene): The gene in which the mutation occurs. + + Returns: + dict: A dictionary of VCF components. + """""" + numbers = extract_numbers(mutation) + vcf_pos = get_genome_coords(numbers[0],gene,ref_object) + ref = ref_object.fetch(gene.chrom,vcf_pos-1,vcf_pos) + alt = mutation[-1] + if gene.strand==""-"": + alt = revcom(alt) + return {""chrom"":gene.chrom,""pos"":vcf_pos, ""ref"":ref, ""alt"":alt,""gene"":gene.gene_id,""type"":""nucleotide""} + +def parse_genomic_snv(mutation: str,gene: Gene) -> dict: + """""" + Parse a SNV mutation in HGVS format and return a dictionary of VCF components. + + Parameters: + mutation (str): The SNV mutation in HGVS format. + gene (Gene): The gene in which the mutation occurs. + ref_object (FastaFile): The reference genome. + + Returns: + dict: A dictionary of VCF components. + """""" + r = re.search(""g.([0-9]+)([ACGT])>([ACGT])"",mutation) + vcf_pos = int(r.group(1)) + ref = r.group(2) + alt = r.group(3) + return {""chrom"":gene.chrom,""pos"":vcf_pos, ""ref"":ref, ""alt"":alt,""gene"":gene.gene_id,""type"":""nucleotide""} + + +def parse_duplication(mutation: str, gene: Gene, ref_object: FastaFile) -> dict: + """""" + Parse a duplication mutation in HGVS format and return a dictionary of VCF components. + + Parameters: + mutation (str): The duplication mutation in HGVS format. + gene (Gene): The gene in which the mutation occurs. + + Returns: + dict: A dictionary of VCF components. + """""" + numbers = extract_numbers(mutation) + genome_positions = [get_genome_coords(p,gene,ref_object) for p in numbers] + vcf_pos = min(genome_positions) - 1 + + ref = ref_object.fetch(gene.chrom,vcf_pos-1,vcf_pos) + alt = ref + extract_duplication(mutation,gene) + return {""chrom"":gene.chrom,""pos"":vcf_pos, ""ref"":ref, ""alt"":alt,""gene"":gene.gene_id,""type"":""nucleotide""} + + +def get_ann(variants: List[dict], snpEffDB: str, snpeff_config:str): + uuid = str(uuid4()) #""463545ef-71fc-449b-8f4e-9c907ee6fbf5"" + with open(uuid,""w"") as O: + O.write('##fileformat=VCFv4.2\n') + O.write('##FORMAT=\n') + O.write('#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\ttest\n') + for var in variants.values(): + O.write(""%(chrom)s\t%(pos)s\t.\t%(ref)s\t%(alt)s\t255\t.\t.\tGT\t1\n"" % var) + results = {} + keys = list(variants.keys()) + vals = list(variants.values()) + i = 0 + for l in cmd_out(f""snpEff ann -noLog -noStats -c {snpeff_config} {snpEffDB} {uuid}""): + if l[0]==""#"": continue + if l.startswith(""ann ""): continue + row = l.strip().split() + for ann in row[7].split(';')[0].split("",""): + a = ann.split(""|"") + if a[9]=='' and a[10]=='': + continue + if len(a)!=16:continue + if ""target_gene"" in vals[i]: + condition = vals[i][""target_gene""] in [a[3],a[4]] + else: + condition = vals[i][""gene""] in [a[3],a[4]] + if condition: + results[keys[i]] = (a[4],a[9]) if vals[i][""type""]==""nucleotide"" else (a[4],a[10]) + i+=1 + os.remove(uuid) + return results + +codon2amino_acid = { + ""TTT"": ""Phe"", ""TTC"": ""Phe"", ""TTA"": ""Leu"", ""TTG"": ""Leu"", ""CTT"": ""Leu"", + ""CTC"": ""Leu"", ""CTA"": ""Leu"", ""CTG"": ""Leu"", ""ATT"": ""Ile"", ""ATC"": ""Ile"", + ""ATA"": ""Ile"", ""ATG"": ""Met"", ""GTT"": ""Val"", ""GTC"": ""Val"", ""GTA"": ""Val"", + ""GTG"": ""Val"", ""TCT"": ""Ser"", ""TCC"": ""Ser"", ""TCA"": ""Ser"", ""TCG"": ""Ser"", + ""CCT"": ""Pro"", ""CCC"": ""Pro"", ""CCA"": ""Pro"", ""CCG"": ""Pro"", ""ACT"": ""Thr"", + ""ACC"": ""Thr"", ""ACA"": ""Thr"", ""ACG"": ""Thr"", ""GCT"": ""Ala"", ""GCC"": ""Ala"", + ""GCA"": ""Ala"", ""GCG"": ""Ala"", ""TAT"": ""Tyr"", ""TAC"": ""Tyr"", ""TAA"": ""Stop"", + ""TAG"": ""Stop"", ""TGT"": ""Cys"", ""TGC"": ""Cys"", ""TGA"": ""Stop"", ""TGG"": ""Trp"", + ""CGT"": ""Arg"", ""CGC"": ""Arg"", ""CGA"": ""Arg"", ""CGG"": ""Arg"", ""AGT"": ""Ser"", + ""AGC"": ""Ser"", ""AGA"": ""Arg"", ""AGG"": ""Arg"", ""GGT"": ""Gly"", ""GGC"": ""Gly"", + ""GGA"": ""Gly"", ""GGG"": ""Gly"" +} + + +def get_possible_alternate_codons(ref_codon: str, alternate_amino_acid: str) -> List[str]: + """""" + Get a list of possible alternate codons for a given reference codon and alternate amino acid. + + Parameters: + ref_codon (str): The reference codon. + alternate_amino_acid (str): The alternate amino acid. + + Returns: + List[str]: A list of possible alternate codons. + """""" + possible_codons = [] + for codon in codon2amino_acid: + if codon2amino_acid[codon]==alternate_amino_acid: + possible_codons.append(codon) + return possible_codons + +def get_reference_codon(codon_number: int, gene: Gene, refseq: FastaFile) -> str: + """""" + Get the reference codon for a given codon number in a gene. + + Parameters: + codon_number (int): The codon number in the gene. + gene (Gene): The gene in which the codon occurs. + + Returns: + str: The reference codon. + """""" + if gene.strand==""+"": + genome_start = gene.start + (codon_number * 3) - 3 + genome_end = gene.start + (codon_number * 3) - 1 + return refseq.fetch(gene.chrom,genome_start-1,genome_end) + if gene.strand==""-"": + genome_start = gene.start - (codon_number * 3) + 1 + genome_end = gene.start - (codon_number * 3) + 3 + logging.debug((genome_start,genome_end)) + return revcom(refseq.fetch(gene.chrom,genome_start-1,genome_end)) + + logging.debug((genome_start,genome_end)) + +def verify_mutation_list(hgvs_mutations: List[dict], genes: List[Gene], refseq: FastaFile, snpEffDB: str, snpeff_config:str) -> dict: + """""" + Break down a list of mutations info a list of VCF components and use SNPeff to reconvert to hgvs. + + Parameters: + mutations (List[dict]): A list of mutations. + genes (List[Gene]): A list of genes. + refseq (FastaFile): The reference genome. + + Returns: + dict: A dictionary of the original mutation and the recoded hgvs. + """""" + + converted_mutations = {} + mutations_genome = {} + for row in tqdm(hgvs_mutations,desc=""Parsing mutations""): + gene = [g for g in genes if g.name==row[""Gene""] or g.gene_id==row[""Gene""]][0] + key = (row[""Gene""],row[""Mutation""]) + + # Genomic Variants + if re.search(""g.([0-9]+)"",row[""Mutation""]): + converted_mutations[key] = (row['Gene'],row[""Mutation""]) + + + # Protein variants - not validated yet + elif r := re.search(r""p\..+"",row[""Mutation""]): + converted_mutations[key] = (row['Gene'],row[""Mutation""]) + + # Coding indels + elif ""del"" in row[""Mutation""] or ""ins"" in row[""Mutation""]: + mutations_genome[key] = parse_coding_indel(row[""Mutation""],gene,refseq) + + # Duplication + elif ""dup"" in row[""Mutation""]: + mutations_genome[key] = parse_duplication(row[""Mutation""],gene,refseq) + + # Coding SNPs + elif re.search(""c.(-?[0-9]+)([ACGT])>([ACGT])"",row[""Mutation""]): + mutations_genome[key] = parse_snv(row[""Mutation""],gene,refseq) + + + # Non-coding SNPs + elif re.search(""n.(-?[0-9]+)([ACGT]+)>([ACGT]+)"",row[""Mutation""]): + mutations_genome[key] = parse_snv(row[""Mutation""],gene,refseq) + + elif row['Mutation'] in supported_so_terms: + converted_mutations[key] = (row['Gene'],row['Mutation']) + + if ""target_gene"" in row and key in mutations_genome: + mutations_genome[key][""target_gene""] = row['target_gene'] + + + if len(mutations_genome)>0: + mutation_conversion = get_ann(mutations_genome,snpEffDB,snpeff_config) + for key in mutation_conversion: + converted_mutations[key] = mutation_conversion[key] + + + return converted_mutations + + +def split_protein_hgvs(hgvs) -> List[str]: + """""" + Split a protein HGVS into its components. + + Parameters: + hgvs (str): The protein HGVS. + + Returns: + List[str]: A list of protein HGVS components. + + Example: + >>> split_protein_hgvs(""p.MetAsnLys74IleGluThr"") + ['p.Met74Ile', 'p.Asn74Glu', 'p.Lys74Thr'] + """""" + # Remove the 'p.' prefix + hgvs = hgvs[2:] + components = [] + aa = re.findall(r'[A-Z][a-z][a-z]', hgvs) + refs = aa[:len(aa)//2] + alts = aa[len(aa)//2:] + start_pos = int(re.search(r'\d+', hgvs).group()) + for i,(ref,alt) in enumerate(zip(refs, alts)): + components.append(f'p.{ref}{start_pos+i}{alt}') + return components","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/variant_calling.py",".py","9788","157","import logging +from abc import abstractmethod +from .utils import cmd_out, run_cmd, run_cmd_parallel_on_genome, load_bed_regions, get_genome_chunks, TempFilePrefix, shared_dict +from uuid import uuid4 +from glob import glob +import os +from .vcf import Vcf +from typing import Optional + + +class VariantCaller: + """""" + A class to define a variant caller. + Methods are used to call variant from a bam. + """""" + def __init__( + self, + ref_file: str, + bam_file: str, + prefix: str, + bed_file: str = None, + threads: int = 1, + samclip: bool = False, + platform: str = ""illumina"", + calling_params: Optional[str] = None, + filters: dict = {}, + cli_args: dict = {} + ): + self.temp_file_prefix = str(uuid4()) + self.ref_file = ref_file + self.bam_file = bam_file + self.prefix = prefix + self.bed_file = bed_file + self.threads = threads + self.samclip = samclip + self.platform = platform + self.calling_params = calling_params if calling_params else """" + self.af_hard = filters['af_hard'] if 'af_hard' in filters else 0 + + # set the samclip command based on the platform + if self.platform in (""illumina""): + self.samclip_cmd = ""| samclip --ref %(ref_file)s"" % vars(self) if self.samclip else """" + else: + self.samclip_cmd = """" + + # get the sample name from the bam file + for l in cmd_out(""samtools view -H %s"" % (bam_file)): + if l[:3]==""@RG"": + row = l.strip().split(""\t"") + for r in row: + if r.startswith(""SM:""): + self.bam_sample_name = r.replace(""SM:"","""") + + # for each key in cli_args, set the value of the key as an attribute of the class + for k,v in cli_args.items(): + if not hasattr(self,k): + setattr(self,k,v) + + # log the software used for variant calling + logging.info(f""Variant calling software: {self.__software__}"") + + @abstractmethod + def call_variants(self): + pass + + def run_calling(self, cmd): + if self.bed_file: + self.vcf_file = ""%s.short_variants.targets.vcf.gz"" % (self.prefix) + genome_chunks = [r.safe for r in load_bed_regions(self.bed_file)] + else: + self.vcf_file = ""%s.vcf.gz"" % (self.prefix) + genome_chunks = [r.safe for r in get_genome_chunks(self.ref_file,self.threads)] + + + run_cmd_parallel_on_genome(self.calling_cmd,self.ref_file,bed_file = self.bed_file,threads=self.threads,desc=""Calling variants"") + cmd = ""bcftools index %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + run_cmd_parallel_on_genome(cmd,self.ref_file,bed_file = self.bed_file,threads=self.threads,desc=""Indexing variants"") + temp_vcf_files = ' '.join([f""{self.temp_file_prefix}.{r}.vcf.gz"" for r in genome_chunks]) + run_cmd(f""bcftools concat -aD {temp_vcf_files} | bcftools view -Oz -o {self.vcf_file}"") + for f in glob(self.temp_file_prefix+""*""): + os.remove(f) + + shared_dict['software']['variant_calling'] = self.__software__ + return Vcf(self.vcf_file) + +class BcftoolsCaller(VariantCaller): + __software__ = ""bcftools"" + def call_variants(self) -> Vcf: + if self.platform==""illumina"": + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && bcftools mpileup -f %(ref_file)s %(calling_params)s -a DP,AD,ADF,ADR -r {region} %(temp_file_prefix)s.{region_safe}.tmp.bam | bcftools call -mv | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""nanopore"": + self.calling_cmd = ""bcftools mpileup -f %(ref_file)s %(calling_params)s -a DP,AD,ADF,ADR -r {region} %(bam_file)s | bcftools call -mv | annotate_maaf.py | bcftools +fill-tags | bcftools norm -f %(ref_file)s | bcftools filter -e 'IMF < 0.7' -S 0 -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + else: + raise NotImplementedError(""%s not implemented for %s platform"" % (self.__software__,self.platform)) + return self.run_calling(self.calling_cmd) + +class FreebayesCaller(VariantCaller): + __software__ = ""freebayes"" + def call_variants(self) -> Vcf: + # Call variants using Freebayes + if self.platform==""illumina"": + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && freebayes -f %(ref_file)s -r {region} --haplotype-length -1 %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""nanopore"": + self.calling_cmd = ""freebayes -f %(ref_file)s -F %(af_hard)s -r {region} --haplotype-length -1 %(calling_params)s %(bam_file)s | annotate_maaf.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + else: + raise NotImplementedError(""%s not implemented for %s platform"" % (self.__software__,self.platform)) + return self.run_calling(self.calling_cmd) + +class GatkCaller(VariantCaller): + __software__ = ""gatk"" + def call_variants(self) -> Vcf: + # Call variants using GATK + if self.platform==""illumina"": + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && gatk HaplotypeCaller -A StrandBiasBySample -R %(ref_file)s -I %(temp_file_prefix)s.{region_safe}.tmp.bam -O /dev/stdout -L {region} %(calling_params)s -OVI false | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + else: + raise NotImplementedError(""%s not implemented for %s platform"" % (self.__software__,self.platform)) + return self.run_calling(self.calling_cmd) + +class PilonCaller(VariantCaller): + __software__ = ""pilon"" + def call_variants(self) -> Vcf: + # Call variants using Pilon + if self.platform==""illumina"": + self.calling_cmd = ""samtools view -T %(ref_file)s -f 0x1 -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && pilon --genome %(ref_file)s --targets {region} --diploid %(calling_params)s --frags %(temp_file_prefix)s.{region_safe}.tmp.bam --variant --output %(temp_file_prefix)s.{region_safe} && bcftools view -e "" % vars(self) + r""""""'ALT="".""'"""""" + "" %(temp_file_prefix)s.{region_safe}.vcf | fix_pilon_headers.py --sample %(bam_sample_name)s| add_dummy_AD.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""nanopore"": + self.calling_cmd = """"""pilon --genome %(ref_file)s --targets {region} %(calling_params)s --nanopore %(bam_file)s --variant --output %(temp_file_prefix)s.{region_safe} && bcftools view -i 'AF>0' %(temp_file_prefix)s.{region_safe}.vcf | fix_pilon_headers.py --sample %(bam_sample_name)s| add_dummy_AD.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"""""" % vars(self) + else: + raise NotImplementedError(""%s not implemented for %s platform"" % (self.__software__,self.platform)) + return self.run_calling(self.calling_cmd) + +class LofreqCaller(VariantCaller): + __software__ = ""lofreq"" + def call_variants(self) -> Vcf: + # Call variants using Lofreq + if self.platform==""illumina"": + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && lofreq call --call-indels -f %(ref_file)s -r {region} %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam | modify_lofreq_vcf.py --sample %(bam_sample_name)s | add_dummy_AD.py --ref %(ref_file)s --add-dp | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + else: + raise NotImplementedError(""%s not implemented for %s platform"" % (self.__software__,self.platform)) + return self.run_calling(self.calling_cmd) + +class FreebayesHaplotypeCaller(VariantCaller): + __software__ = ""freebayes-haplotype"" + def call_variants(self) -> Vcf: + # Call variants using Lofreq + + self.calling_cmd = """""" + samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | \ + samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && \ + samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && \ + freebayes -f %(ref_file)s -r {region} %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam | \ + bcftools view -Oz -o %(temp_file_prefix)s.{region_safe}.tmp.vcf.gz && \ + tabix %(temp_file_prefix)s.{region_safe}.tmp.vcf.gz && \ + freebayes -f %(ref_file)s -r {region} %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam --haplotype-length 100 --haplotype-basis-alleles %(temp_file_prefix)s.{region_safe}.tmp.vcf.gz | bcftools norm -a -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz + """""" % vars(self) + + return self.run_calling(self.calling_cmd) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/bam.py",".py","23288","466","from glob import glob +from .kmer import KmerDump +from .utils import TempFilePrefix, load_bed_regions, get_genome_chunks, add_arguments_to_self, run_cmd, cmd_out, filecheck, index_bam, run_cmd_parallel_on_genome, load_bed +from .vcf import Vcf +from collections import defaultdict +from uuid import uuid4 +import os +import platform +import statistics as stats +import logging +from pysam import FastaFile +from .models import BamQC, TargetQC, GenomePositionDepth, GenomePosition +from typing import List, Optional +from .utils import shared_dict + + + + +class Bam: + """""" + A class to perform operations on BAM files such as SNP calling and QC + """""" + def __init__( + self, + bam_file: str, + prefix: str, + platform: str, + threads: int = 1 + ): + self.bam_file = bam_file + self.prefix = prefix + self.platform = platform + self.threads = threads + + + logging.debug(""Creating Bam object with %s"" % (bam_file)) + filecheck(self.bam_file) + index_bam(bam_file,threads=threads) + self.filetype = ""cram"" if bam_file[-5:]=="".cram"" else ""bam"" + + def calculate_bed_depth(self,bed_file: str) -> List[GenomePositionDepth]: + """""" + Calculate depth of BAM file in regions specified by a BED file + + Arguments + --------- + bed_file : str + BED file containing regions to calculate depth for + + Returns + ------- + List of GenomePositionDepth objects + """""" + logging.info(""Calculating depth in regions"") + self.bed_file = bed_file + position_depth = defaultdict(list) + for r, _ in load_bed(self.bed_file).items(): + for p in r.iter_positions(): + position_depth[p] = 0 + + + for l in cmd_out(""samtools view -Mb -L %(bed_file)s %(bam_file)s | samtools depth - "" % vars(self)): + row = l.strip().split() + p = GenomePosition(chrom=row[0],pos=int(row[1])) + if p in position_depth: + position_depth[p] = int(row[2]) + + self.position_depth = [GenomePositionDepth(chrom=p.chrom,pos=p.pos,depth=v) for p,v in position_depth.items()] + return self.position_depth + + def run_delly(self,ref_file: str,bed_file: str) -> Vcf: + """""" + Method to run delly and extract variants overlapping with a BED file + + Arguments + --------- + bed_file : str + BED file to extract variants from + + Returns + ------- + Vcf object + """""" + logging.info(""Running delly"") + self.bed_file = bed_file + self.ref_file = ref_file + if self.platform==""illumina"": + cmd = ""delly call -t DEL -g %(ref_file)s %(bam_file)s -o %(prefix)s.delly.bcf"" % vars(self) + result = run_cmd(cmd, exit_on_error=False) + else: + cmd = ""delly lr -t DEL -g %(ref_file)s %(bam_file)s -o %(prefix)s.delly.bcf"" % vars(self) + result = run_cmd(cmd, exit_on_error=False) + + exitcode = result.returncode + if exitcode!=0: + logging.error(""Delly failed, skipping"") + return None + else: + shared_dict['software']['long_variant_calling'] = 'delly' + + run_cmd(""bcftools view -c 2 %(prefix)s.delly.bcf | bcftools view -e '(INFO/END-POS)>=100000' -Oz -o %(prefix)s.delly.vcf.gz"" % vars(self)) + run_cmd(""bcftools index %(prefix)s.delly.vcf.gz"" % vars(self)) + run_cmd(""bcftools view -R %(bed_file)s %(prefix)s.delly.vcf.gz -Oz -o %(prefix)s.delly.targets.vcf.gz"" % vars(self)) + return Vcf(""%(prefix)s.delly.targets.vcf.gz"" % vars(self)) + + def call_variants( + self, + ref_file: str, + caller: str, + filters: dict, + bed_file: Optional[str] = None, + threads: int = 1, + calling_params: Optional[str] = None, + samclip: bool = False, + cli_args: dict = {} + ) -> Vcf: + from .variant_calling import VariantCaller + subclasses = {cls.__software__:cls for cls in VariantCaller.__subclasses__()} + chosen_class = subclasses[caller] + caller = chosen_class( + ref_file=ref_file, + bam_file=self.bam_file, + prefix=self.prefix, + bed_file=bed_file, + threads=threads, + samclip=samclip, + platform=self.platform, + calling_params=calling_params, + filters=filters, + cli_args=cli_args + ) + return caller.call_variants() + + + + def __call_variants__deprecated( + self, + ref_file: str, + caller: str, + filters: str, + bed_file: Optional[str] = None, + threads: int = 1, + calling_params: Optional[str] = None, + samclip: bool = False + ) -> Vcf: + """"""Method to run variant calling"""""" + add_arguments_to_self(self, locals()) + filecheck(ref_file) + self.caller = caller.lower() + self.af_hard = filters['af_hard'] if 'af_hard' in filters else 0 + # Set up final vcf file name + # Make the windows for parallel calling based on chunking the whole + # genome or by providing a bed file + with TempFilePrefix() as tmp: + self.temp_file_prefix = tmp + if bed_file: + self.vcf_file = ""%s.short_variants.targets.vcf.gz"" % (self.prefix) if bed_file else ""%s.vcf.gz"" % (self.prefix) + genome_chunks = [r.safe for r in load_bed_regions(bed_file)] + else: + self.vcf_file = ""%s.short_variants.vcf.gz"" % (self.prefix) if bed_file else ""%s.vcf.gz"" % (self.prefix) + genome_chunks = [r.safe for r in get_genome_chunks(self.ref_file,self.threads)] + + if self.platform in (""illumina""): + self.samclip_cmd = ""| samclip --ref %(ref_file)s"" % vars(self) if samclip else """" + else: + self.samclip_cmd = """" + + # Run through different options. + + # Nanopore + if self.platform == ""nanopore"" and self.caller==""bcftools"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""bcftools mpileup -f %(ref_file)s %(calling_params)s -a DP,AD,ADF,ADR -r {region} %(bam_file)s | bcftools call -mv | annotate_maaf.py | bcftools +fill-tags | bcftools norm -f %(ref_file)s | bcftools filter -e 'IMF < 0.7' -S 0 -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform == ""nanopore"" and self.caller==""freebayes"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""freebayes -f %(ref_file)s -F %(af_hard)s -r {region} --haplotype-length -1 %(calling_params)s %(bam_file)s | annotate_maaf.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""nanopore"" and self.caller == ""pilon"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = """"""pilon --genome %(ref_file)s --targets {region} %(calling_params)s --nanopore %(bam_file)s --variant --output %(temp_file_prefix)s.{region_safe} && bcftools view -i 'AF>0' %(temp_file_prefix)s.{region_safe}.vcf | fix_pilon_headers.py --sample %(bam_sample_name)s| add_dummy_AD.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"""""" % vars(self) + + # Pacbio + elif self.platform == ""pacbio"" and self.caller==""freebayes"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""freebayes -f %(ref_file)s -r {region} --haplotype-length -1 %(calling_params)s %(bam_file)s | annotate_maaf.py | bcftools +fill-tags | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""pacbio"" and self.caller == ""pilon"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = """"""pilon --genome %(ref_file)s --targets {region} %(calling_params)s --pacbio %(bam_file)s --variant --output %(temp_file_prefix)s.{region_safe} && bcftools view -i 'AF>0' %(temp_file_prefix)s.{region_safe}.vcf | fix_pilon_headers.py --sample %(bam_sample_name)s| add_dummy_AD.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"""""" % vars(self) + + # Illumina + elif self.platform==""illumina"" and self.caller == ""bcftools"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && bcftools mpileup -f %(ref_file)s %(calling_params)s -a DP,AD,ADF,ADR -r {region} %(temp_file_prefix)s.{region_safe}.tmp.bam | bcftools call -mv | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""illumina"" and self.caller == ""gatk"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && gatk HaplotypeCaller -R %(ref_file)s -I %(temp_file_prefix)s.{region_safe}.tmp.bam -O /dev/stdout -L {region} %(calling_params)s -OVI false | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""illumina"" and self.caller == ""freebayes"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && freebayes -f %(ref_file)s -r {region} --haplotype-length -1 %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""illumina"" and self.caller == ""pilon"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""samtools view -T %(ref_file)s -f 0x1 -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && pilon --genome %(ref_file)s --targets {region} --diploid %(calling_params)s --frags %(temp_file_prefix)s.{region_safe}.tmp.bam --variant --output %(temp_file_prefix)s.{region_safe} && bcftools view -e "" % vars(self) + r""""""'ALT="".""'"""""" + "" %(temp_file_prefix)s.{region_safe}.vcf | fix_pilon_headers.py --sample %(bam_sample_name)s| add_dummy_AD.py | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + elif self.platform==""illumina"" and self.caller == ""lofreq"": + self.calling_params = calling_params if calling_params else """" + self.calling_cmd = ""samtools view -T %(ref_file)s -h %(bam_file)s {region} %(samclip_cmd)s | samtools view -b > %(temp_file_prefix)s.{region_safe}.tmp.bam && samtools index %(temp_file_prefix)s.{region_safe}.tmp.bam && lofreq call --call-indels -f %(ref_file)s -r {region} %(calling_params)s %(temp_file_prefix)s.{region_safe}.tmp.bam | modify_lofreq_vcf.py --sample %(bam_sample_name)s | add_dummy_AD.py --ref %(ref_file)s --add-dp | bcftools norm -f %(ref_file)s -Oz -o %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + else: + logging.debug(""Unknown combination %(platform)s + %(caller)s"" % vars(self)) + logging.info(""Running variant calling"") + shared_dict['software']['variant_calling'] = self.caller + run_cmd_parallel_on_genome(self.calling_cmd,ref_file,bed_file = bed_file,threads=threads,desc=""Calling variants"") + cmd = ""bcftools index %(temp_file_prefix)s.{region_safe}.vcf.gz"" % vars(self) + run_cmd_parallel_on_genome(cmd,ref_file,bed_file = bed_file,threads=threads,desc=""Indexing variants"") + temp_vcf_files = ' '.join([f""{tmp}.{r}.vcf.gz"" for r in genome_chunks]) + run_cmd(f""bcftools concat -aD {temp_vcf_files} | bcftools view -Oz -o {self.vcf_file}"") + + + return Vcf(self.vcf_file) + + def get_median_depth( + self, + ref_file: str, + software: str = ""samtools"" + ): + logging.info(""Calculating median depth using %s"" % software) + shared_dict['software']['depth_calculation'] = software + if software==""bedtools"": + lines = [] + for l in cmd_out(""bedtools genomecov -ibam %s"" % (self.bam_file)): + arr = l.split() + if arr[0]==""genome"": + lines.append(arr) + midpoint = int(lines[0][3])/2 + x = 0 + for row in lines: + x = x + int(row[2]) + if x>midpoint: + break + self.median_coverage = int(row[1]) + return int(row[1]) + elif software==""mosdepth"": + self.median_coverage = None + tmp = str(uuid4()) + run_cmd(f""mosdepth {tmp} {self.bam_file} -f {ref_file}"") + for l in open(f""{tmp}.mosdepth.summary.txt""): + row = l.strip().split() + if row[0]==""total"": + self.median_coverage = int(row[1]) + for f in glob(f""{tmp}*""): + os.remove(f) + return int(float(row[3])) + elif software==""samtools"": + dp = [] + for l in cmd_out(f""samtools depth {self.bam_file}""): + row = l.strip().split() + dp.append(int(row[2])) + ref = FastaFile(ref_file) + total_len = 0 + for name in ref.references: + total_len+=ref.get_reference_length(name) + dp += list([0 for _ in range(total_len - len(dp))]) + return stats.median(dp) + + def calculate_median_coverage(self,ref_file,software=""bedtools""): + logging.info(""Calculating median depth"") + if software==""bedtools"": + lines = [] + for l in cmd_out(""bedtools genomecov -ibam %s"" % (self.bam_file)): + arr = l.split() + + if arr[0]==""genome"": + lines.append(arr) + midpoint = int(lines[0][3])/2 + x = 0 + for row in lines: + x = x + int(row[2]) + if x>midpoint: + break + self.median_coverage = int(row[1]) + return int(row[1]) + elif software==""mosdepth"": + self.median_coverage = None + tmp = str(uuid4()) + run_cmd(f""mosdepth {tmp} {self.bam_file} -f {ref_file}"") + for l in open(f""{tmp}.mosdepth.summary.txt""): + row = l.strip().split() + if row[0]==""total"": + self.median_coverage = int(row[1]) + for f in glob(f""{tmp}*""): + os.remove(f) + return int(float(row[3])) + + + def get_bed_gt(self,bed_file: str,ref_file: str,caller: str,platform: str): + logging.info(""Getting genotypes for positions in bed file"") + add_arguments_to_self(self, locals()) + results = defaultdict(lambda : defaultdict(dict)) + run_cmd(""samtools view -Mb -L %(bed_file)s %(bam_file)s -T %(ref_file)s > %(prefix)s.tmp.bam"" % vars(self)) + run_cmd(""samtools index %(prefix)s.tmp.bam"" % vars(self)) + if platform in (""nanopore"",""pacbio""): + caller=""bcftools"" + if caller == ""gatk"": + cmd = ""gatk HaplotypeCaller -I %(prefix)s.tmp.bam -R %(ref_file)s -L %(bed_file)s -OVI false -O /dev/stdout | bcftools query -f '%%CHROM\\t%%POS\\t%%REF\\t%%ALT[\\t%%GT\\t%%AD]\\n'"" % vars(self) + elif caller == ""freebayes"": + cmd = ""freebayes -f %(ref_file)s -t %(bed_file)s %(prefix)s.tmp.bam --haplotype-length -1 | bcftools query -f '%%CHROM\\t%%POS\\t%%REF\\t%%ALT[\\t%%GT\\t%%AD]\\n'"" % vars(self) + elif caller == ""bcftools"": + cmd = ""bcftools mpileup -f %(ref_file)s -T %(bed_file)s %(prefix)s.tmp.bam -BI -a AD | bcftools call -mv | bcftools query -f '%%CHROM\\t%%POS\\t%%REF\\t%%ALT[\\t%%GT\\t%%AD]\\n'"" % vars(self) + elif caller == ""mpileup"": + cmd = ""bcftools mpileup -f %(ref_file)s -T %(bed_file)s %(prefix)s.tmp.bam -BI -a AD | bcftools query -f '%%CHROM\\t%%POS\\t%%REF\\t%%ALT[\\t%%AD]\\n'"" % vars(self) + else: + cmd = ""freebayes -f %(ref_file)s -t %(bed_file)s %(prefix)s.tmp.bam --haplotype-length -1 | bcftools query -f '%%CHROM\\t%%POS\\t%%REF\\t%%ALT[\\t%%GT\\t%%AD]\\n'"" % vars(self) + + for l in cmd_out(cmd): + # Chromosome 4348079 0/0 51 + row = l.strip().split() + if len(row)==6: + chrom, pos, ref, alt, gt, ad = l.rstrip().split() + elif len(row)==5: + chrom, pos, ref, alt, ad = l.rstrip().split() + gt = None + + p = GenomePosition(chrom=chrom,pos=int(pos)) + d = {} + alts = alt.split("","") + ad = [int(x) for x in ad.split("","")] + + if gt and gt == ""./."": + d[ref] = 0 + else: + genotypes = list([ref]+alts) + if platform in (""nanopore"",""pacbio""): + idx = ad.index(max(ad)) + d[genotypes[idx]] = ad[idx] + else: + for i, a in enumerate(genotypes): + d[a] = ad[i] + results[p] = d + + ref_nt = {} + for l in cmd_out(""bedtools getfasta -fi %s -bed %s"" % (ref_file,bed_file)): + if l[0]=="">"": + tmp = l.strip().replace("">"","""").split("":"") + tmp_chrom = tmp[0] + tmp_pos = int(tmp[1].split(""-"")[1]) + else: + ref_nt[GenomePosition(chrom=tmp_chrom,pos=tmp_pos)] = l.strip().upper() + + for l in cmd_out(f""samtools view -b -L {bed_file} {self.prefix}.tmp.bam | bedtools coverage -a {bed_file} -b - -d -sorted""): + row = l.strip().split() + p = GenomePosition(chrom=row[0],pos=int(row[2])) + cov = int(row[-1]) + if p not in results: + results[p] = {ref_nt[p]:cov} + + os.remove(f""{self.prefix}.tmp.bam"") + os.remove(f""{self.prefix}.tmp.bam.bai"") + + return results + + def calculate_bamstats(self): + logging.info(""Calculating bamstats"") + temp_file = str(uuid4()) + run_cmd(f""samtools stats {self.bam_file} > {temp_file}"") + for l in open(temp_file): + row = l.strip().split(""\t"") + if row[0]!=""SN"": continue + if row[1]=='raw total sequences:': self.total_reads = int(row[2]) + if row[1]=='reads mapped:': self.mapped_reads = int(row[2]) + if self.total_reads==0: + self.pct_reads_mapped = 0 + else: + self.pct_reads_mapped = round(self.mapped_reads/self.total_reads*100,2) + os.remove(temp_file) + + def get_missing_genomic_positions(self, bed_file:str, cutoff: int=10) -> List[GenomePositionDepth]: + """""" + Get all positions overlapping bed file that have a depth below a cutoff + + Arguments + --------- + bed_file : str + BED file containing regions to calculate QC metrics for + cutoff : int + Depth cutoff to use for calculating QC metrics + + Returns + ------- + List of GenomePositionDepth objects + """""" + + logging.info(""Getting missing genomic positions"") + if not hasattr(self,""position_depth""): + self.calculate_bed_depth(bed_file) + return [p for p in self.position_depth if p.depth=cutoff]) + target_qc.append(TargetQC( + target=target, + percent_depth_pass=round(pos_pass_thresh/region_len*100,2), + median_depth=stats.median([p.depth for p in target_depth]), + )) + return target_qc + + def get_kmer_counts(self,prefix,klen = 31,threads=1,max_mem=2,counter = ""kmc""): + logging.info(""Getting kmer counts"") + if counter==""kmc"": + if threads>32: + threads = 32 + tmp_prefix = str(uuid4()) + os.mkdir(tmp_prefix) + bins = ""-n128"" if platform.system()==""Darwin"" else """" + run_cmd(f""kmc {bins} -fbam -m{max_mem} -t{threads} -k{klen} {self.bam_file} {tmp_prefix} {tmp_prefix}"") + run_cmd(f""kmc_dump {tmp_prefix} {prefix}.kmers.txt"") + run_cmd(f""rm -r {tmp_prefix}*"") + return KmerDump(f""{prefix}.kmers.txt"",counter) + else: + logging.error(""Can't use dsk for bam files, please use kmc instead"") + + def get_bam_qc(self, bed_file: str, ref_file:str, depth_cutoff: int, coverage_tool: str = ""samtools"", only_targets=False) -> BamQC: + """""" + Get QC metrics for a bam file + + Arguments + --------- + bed_file : str + BED file containing regions to calculate QC metrics for + ref_file : str + Reference file to use for calculating median depth + depth_cutoff : int + Depth cutoff to use for calculating QC metrics + coverage_tool : str + Software to use for calculating median depth. Options are ""samtools"" or ""bedtools"" + + Returns + ------- + BamQC object + """""" + self.calculate_bamstats() + target_qc = self.get_region_qc(bed_file=bed_file,cutoff=depth_cutoff) + region_median_depth = stats.median([x.median_depth for x in target_qc]) + if not only_targets: + genome_median_depth = self.get_median_depth(ref_file=ref_file,software=coverage_tool) + else: + genome_median_depth = None + missing_positions = self.get_missing_genomic_positions(bed_file=bed_file,cutoff=depth_cutoff) + return BamQC( + percent_reads_mapped = self.pct_reads_mapped, + num_reads_mapped = self.mapped_reads, + target_median_depth = region_median_depth, + genome_median_depth = genome_median_depth, + target_qc = target_qc, + missing_positions = missing_positions, + ) + +","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/barcode.py",".py","6692","207","from .utils import iupac +import re +from collections import defaultdict +import logging +from typing import List +from .models import GenomePosition, BarcodeResult, BarcodePosition + +def get_missense_codon(x): + re_obj = re.search(""([0-9]+)"",x) + if re_obj: + return int(re_obj.group(1)) + else: + logging.error(""Error can't find codon number in %s"" % x,True) + +def get_indel_nucleotide(x): + re_obj = re.search(""([0-9]+)"",x) + if re_obj: + return int(re_obj.group(1)) + else: + logging.error(""Error can't find nucleotide number in %s"" % x,True) + + + +def get_barcoding_mutations(mutations: dict, barcode_bed: str) -> List[BarcodePosition]: + bed = [] + for l in open(barcode_bed): + if l[0]==""#"": + continue + row = l.strip().split(""\t"") + bed.append(row) + + snps_report = [] + for marker in bed: + tmp = [0,0] + p = GenomePosition(chrom=marker[0],pos=int(marker[2])) + if p in mutations: + for n in iupac(marker[4]): + if n in mutations[p]: + tmp[1]+= mutations[p][n] + tmp[0] = sum(list(mutations[p].values())) - tmp[1] + + if tmp==[0,0]: continue + snps_report.append( + BarcodePosition( + id=marker[3], + chrom=marker[0], + pos = marker[2], + target_allele_count=tmp[1], + other_allele_count=tmp[0], + all_allele_count=tmp[0]+tmp[1], + target_allele_percent=(tmp[1]/sum(tmp))*100 + ) + ) + + + return snps_report + +def barcode_rows_get_unique_taxa(rows: List[BarcodePosition]) -> List[str]: + """""" + Get unique taxa from a list of BarcodePosition rows. + + Arguments + --------- + rows: List[BarcodePosition] + A list of BarcodePosition objects. + + Returns + ------- + List[str] + A list of unique taxa IDs. + """""" + return sorted(set(row.id for row in rows)) + +def barcode_rows_calculate_all_allele_count(rows: List[BarcodePosition]) -> None: + """""" + Calculate the total allele count for each BarcodePosition row. + + Arguments + --------- + rows: List[BarcodePosition] + A list of BarcodePosition objects. + + Returns + ------- + None + The function modifies the rows in place. + """""" + for row in rows: + row.all_allele_count = row.target_allele_count + row.other_allele_count + +def barcode_rows_calculate_num_good_sites(rows: List[BarcodePosition],min_percent=2,min_allele_count=5) -> int: + """""" + Calculate the number of good sites based on target allele percent and all allele count. + A site is considered good if target allele percent >= min_percent and all allele count >= min_allele_count. + Arguments + --------- + rows: List[BarcodePosition] + A list of BarcodePosition objects. + Returns + ------- + int + The number of good sites. + """""" + num_good_sites = 0 + for row in rows: + if row.target_allele_percent >= 2 and row.all_allele_count >= 5: + num_good_sites += 1 + return num_good_sites + + +def barcode_rows_quantile(rows: List[BarcodePosition], quantile: float) -> float: + """""" + Calculate the quantile of target allele percent for a list of BarcodePosition rows. + + Arguments + --------- + rows: List[BarcodePosition] + A list of BarcodePosition objects. + quantile: float + The quantile to calculate (between 0 and 1). + + Returns + ------- + float + The calculated quantile value. + """""" + if not rows: + return 0.0 + target_allele_percents = [row.target_allele_percent for row in rows] + return sorted(target_allele_percents)[int(len(target_allele_percents) * quantile)] + +def barcode_rows_get_median_frequency(rows: List[BarcodePosition]) -> float: + """""" + Calculate the median frequency of target allele percent for a list of BarcodePosition rows. + + Arguments + --------- + rows: List[BarcodePosition] + A list of BarcodePosition objects. + + Returns + ------- + float + The median frequency of target allele percent. + """""" + if not rows: + return 0.0 + target_allele_percents = [row.target_allele_percent for row in rows] + sorted_percents = sorted(target_allele_percents) + if len(sorted_percents) % 2 == 1: + return sorted_percents[len(sorted_percents) // 2] + else: + mid_index = len(sorted_percents) // 2 + return (sorted_percents[mid_index - 1] + sorted_percents[mid_index]) / 2.0 + +def barcode(mutations,barcode_bed: str,snps_file=None,iqr_cutoff=15, freq_cutoff=2) -> List[BarcodeResult]: + bed_num_col = len(open(barcode_bed).readline().rstrip().split(""\t"")) + lineage_info = {} + for l in open(barcode_bed): + row = l.strip().split(""\t"") + lineage_info[row[3]] = row + + snps_report = get_barcoding_mutations(mutations,barcode_bed) + + + with open(snps_file,""w"") if snps_file else open(""/dev/null"",""w"") as O: + for tmp in sorted(snps_report,key=lambda x: x.id): + O.write(""%s\n"" % ""\t"".join([str(x) for x in vars(tmp).values()])) + + barcode_frac = defaultdict(float) + + + barcode_rows_calculate_all_allele_count(snps_report) + uniq_taxa = barcode_rows_get_unique_taxa(snps_report) + for taxon in uniq_taxa: + taxon_rows = [row for row in snps_report if row.id == taxon] + + # calculate number of 'good' sites + num_good_sites = barcode_rows_calculate_num_good_sites(taxon_rows) + + if num_good_sites==0: + logging.debug(f'Skipping {taxon} as no sites pass basic filters') + continue + + # skip if IQR > cutoff (default=15) + iqr = barcode_rows_quantile(taxon_rows, 0.75) - barcode_rows_quantile(taxon_rows, 0.25) + if iqr > iqr_cutoff: + logging.debug(f'Skipping {taxon} due to high IQR ({iqr})') + continue + + # skip if median frequency < cutoff (default=2%) + median_frac = barcode_rows_get_median_frequency(taxon_rows) + if median_frac < freq_cutoff: + logging.debug(f'Skipping {taxon} due to low median frequency ({median_frac})') + continue + + barcode_frac[taxon] = median_frac + logging.debug(f'Keeping {taxon} with median frequency {median_frac}') + + final_results = [] + for l in barcode_frac: + tmp = {""id"":l,""frequency"":barcode_frac[l],""info"":[]} + if bed_num_col>6: + tmp[""info""] = [lineage_info[l][i] for i in range(5,bed_num_col)] + tmp['support'] = [p for p in snps_report if p.id==tmp['id']] + final_results.append(BarcodeResult(**tmp)) + return final_results","Python" +"Pathogens","jodyphelan/pathogen-profiler","pathogenprofiler/sanity.py",".py","1163","29","import pysam + +def check_bam_for_rg(bam_file) -> None: + """""" + Check if the BAM file has a read group. + """""" + bam = pysam.AlignmentFile(bam_file, ""rb"") + if 'RG' not in bam.header: + raise Exception(f""No read group found in {bam_file}. Please create create your bam with a read group or add using `samtools addreplacerg`."") + +def check_vcf_chrom_match(vcf_file, ref_file) -> None: + """""" + Check if the chromosomes in the VCF file match the reference file. + """""" + vcf = pysam.VariantFile(vcf_file) + ref = pysam.FastaFile(ref_file) + for chrom in vcf.header.contigs: + if chrom not in ref.references: + raise Exception(f""Chromosome {chrom} in VCF file {vcf_file} not found in reference file {ref_file}."") + +def check_bam_chrom_match(bam_file, ref_file) -> None: + """""" + Check if the chromosomes in the BAM file match the reference file. + """""" + bam = pysam.AlignmentFile(bam_file, ""rb"") + ref = pysam.FastaFile(ref_file) + for chrom in bam.references: + if chrom not in ref.references: + raise Exception(f""Chromosome {chrom} in BAM file {bam_file} not found in reference file {ref_file}."")","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/combine_vcf_variants.py",".py","7801","225","#! /usr/bin/env python3 +import pysam +from typing import List +from collections import Counter, defaultdict +import argparse +from pathogenprofiler.models import GenomePosition +from pathogenprofiler.gff import load_gff, Exon +from itertools import product +import logging + +parser = argparse.ArgumentParser(description='tbprofiler script',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--vcf',type=str,help='') +parser.add_argument('--gff',type=str,help='',required = True) +parser.add_argument('--ref',type=str,help='',required = True) +parser.add_argument('--out',type=str,help='') +parser.add_argument('--bam',type=str,help='') +parser.add_argument('--debug',action='store_true',help='Print debug information') +args = parser.parse_args() + +if args.debug: + logging.basicConfig(level=logging.DEBUG) +else: + logging.basicConfig(level=logging.INFO) + + +def get_alleles( + read:pysam.libcalignedsegment.AlignedSegment, + positions=List[GenomePosition], + bystrand=False +): + + alleles = {} + for read_pos, ref_pos, read_nt in read.get_aligned_pairs(with_seq=True): + if read_nt is None: + continue + if read_pos is None: + continue + p = GenomePosition(chrom=read.reference_name,pos=ref_pos+1) + if p not in positions: + continue + if read.query_qualities[read_pos] < 12: + continue + + if read_nt.islower(): + read_nt = read.query_sequence[read_pos].upper() + + if bystrand: + alleles[p] = read_nt.lower() if read.is_reverse else read_nt.upper() + else: + alleles[p] = read_nt + + return [alleles.get(p) for p in positions] + + +def get_haplotype_counts( + bam:pysam.AlignmentFile, + positions:List[GenomePosition], + bystrand=False +): + allele_combinations = [] + chrom = positions[0].chrom + start = min(positions).pos + end = max(positions).pos + for read in bam.fetch(contig=chrom,start=start,end=end): + logging.debug((read.qname, read.mapping_quality<10, read.is_secondary, read.is_supplementary, read.is_unmapped)) + if read.mapping_quality < 10: + continue + if read.is_secondary: + continue + if read.is_supplementary: + continue + if read.is_unmapped: + continue + alleles = get_alleles(read,positions=positions,bystrand=bystrand) + logging.debug(alleles) + if all(alleles): + allele_combinations.append(''.join(alleles)) + counts = Counter(allele_combinations) + logging.debug(counts) + return counts + + + +def get_overlapping_exons(chrom: str,pos: int,exons: List[Exon]): + exons = [e for e in exons if e.start<=pos and e.end>=pos and chrom==e.chrom] + if len(exons)==0: + return None + else: + return exons[0] + +def get_codon_pos(chrom: str,pos: int,exons: List[Exon]): + e = get_overlapping_exons(chrom,pos,exons) + if e==None: + return (None,None) + logging.debug(f""{chrom}:{pos} {vars(e)}"") + if e.strand==""+"": + codon_pos = (pos-e.start-e.phase)//3 + 1 + else: + codon_pos = (e.end + e.phase - pos )//3 + 1 + return (e.id,codon_pos) + + +gff = load_gff(args.gff) +exons = [] +for gene in gff: + for transcript in gene.transcripts: + for i,exon in enumerate(transcript.exons): + exon.id = f""{gene.gene_id}_exon{i+1}"" + exons.append(exon) + +def has_md_tag(bam): + for read in bam.fetch(): + break + if read.has_tag('MD'): + return True + else: + return False + +ref = pysam.FastaFile(args.ref) +coding_variants = defaultdict(list) +other_variants = [] +vcf = pysam.VariantFile(args.vcf) if args.vcf else pysam.VariantFile('-') + +if ""AF"" not in vcf.header.info.keys(): + ##INFO= + vcf.header.add_line('##INFO=') + +for var in vcf: + logging.debug(var) + gene,cpos = get_codon_pos(var.chrom,var.pos,exons) + if var.rlen!=1 or len(var.alts[0])!=1: + other_variants.append(var) + elif gene==None: + other_variants.append(var) + else: + coding_variants[(gene,cpos)].append(var) + + + + +for key,variants in coding_variants.items(): + logging.debug((key, variants)) + if len(variants)==1: + other_variants.append(variants[0]) + continue + all_positions = [GenomePosition(chrom=v.chrom,pos=v.pos) for v in variants] + positions = sorted(list(set(all_positions))) + if len(positions)==2 and positions[0].pos == positions[1].pos-2: + positions.insert(1,GenomePosition(chrom=positions[0].chrom,pos=positions[0].pos+1)) + + ref_hap = ''.join([ref.fetch(p.chrom,p.pos-1,p.pos) for p in positions]) + if args.bam and has_md_tag(pysam.AlignmentFile(args.bam)): + haplotypes_by_strand = get_haplotype_counts(pysam.AlignmentFile(args.bam),positions,bystrand=True) + logging.debug(haplotypes_by_strand) + else: + # alt is just a combination of all the alt alleles + alt_hap = ''.join([v.alts[0] for v in variants]) + ds = defaultdict(list) + for v in variants: + ds[v.pos].append(v.alts[0]) + v = variants[0] + if 'DP4' in v.info: + haplotypes_by_strand = { + ref_hap: int(v.info['DP4'][0])+int(v.info['DP4'][1]) + } + elif 'AD' in v.samples[0]: + haplotypes_by_strand = { + ref_hap: int(v.samples[0]['AD'][0]) + } + if len(ds)==2 and list(ds)[0]+2 == list(ds)[1]: + midpos = list(ds)[0]+1 + # insert the ref allele in between + ds[midpos] = ref.fetch(v.chrom,midpos-1,midpos) + # sort + ds = dict(sorted(ds.items())) + + for alts in product(*ds.values()): + hap = ''.join(alts) + if 'DP4' in v.info: + haplotypes_by_strand[hap] = int(v.info['DP4'][2])+int(v.info['DP4'][3]) + elif 'SAF' in v.info: + haplotypes_by_strand[hap] = int(v.info['SAF'][0]) + haplotypes_by_strand[hap.lower()] = int(v.info['SAR'][0]) + elif 'AD' in v.samples[0]: + haplotypes_by_strand[hap] = int(v.samples[0]['AD'][1]) + + + haplotypes = Counter() + for h,count in haplotypes_by_strand.items(): + haplotypes[h.upper()] += count + dp = sum(haplotypes.values()) + + if dp==0: + # can happen if malformed VCF (e.g. https://github.com/jodyphelan/pathogen-profiler/issues/63) + continue + + ref_fwd = haplotypes_by_strand.get(ref_hap.upper(),0) + ref_rev = haplotypes_by_strand.get(ref_hap.lower(),0) + for i,(hap,count) in enumerate(haplotypes.items()): + hap_fwd = haplotypes_by_strand.get(hap.upper(),0) + hap_rev = haplotypes_by_strand.get(hap.lower(),0) + if hap.upper()==ref_hap.upper(): + continue + variant = variants[0].copy() + variant.alts = (hap,) + variant.ref = ref_hap + variant.info.update({'AF':count/dp}) + if 'DP4' in variant.info: + variant.info['DP4'] = [ref_fwd,ref_rev,hap_fwd,hap_rev] + if 'SAF' in variant.info: + variant.info['SAF'] = hap_fwd + variant.info['SAR'] = hap_rev + if 'ADF' in var.samples[0]: + variant.samples[0]['ADF'] = (ref_fwd,hap_fwd) + variant.samples[0]['ADR'] = (ref_rev,hap_rev) + if 'AD' in variant.samples[0]: + variant.samples[0]['AD'] = [dp - count, hap_fwd + hap_rev] + + other_variants.append(variant) + + +new_vcf = pysam.VariantFile(args.out,'w',header = vcf.header) if args.out else pysam.VariantFile('-','w',header = vcf.header) +for var in other_variants: + new_vcf.write(var) +new_vcf.close()","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/filter_short_sam_reads.py",".py","670","23","#! /usr/bin/env python3 +import sys +import re +import argparse + +def main(args): + for l in sys.stdin: + row = l.strip().split() + if l[0]==""@"": + sys.stdout.write(l) + continue + num_matches = sum([int(x) for x in re.findall(""(\d+)M"",row[5])]) + if num_matches' in l: + l = re.sub(r'##INFO=', r'##INFO=',l) + if '##INFO=' in l: + l = re.sub(r'##INFO=', r'##INFO=',l) + if l.startswith('#CHROM'): + l = re.sub(r'SAMPLE', args.sample,l) + sys.stdout.write(l) + +parser = argparse.ArgumentParser(description='Fix pilon headers',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.set_defaults(func=main) +parser.add_argument('--sample',help='Sample name',required=True) +args = parser.parse_args() +args.func(args)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/rename_vcf_sample.py",".py","435","14","#! /usr/bin/env python3 +import argparse +import sys + +parser = argparse.ArgumentParser(description='add required annotations',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--sample-name',type=str,help='Sample name') +args = parser.parse_args() + +for l in sys.stdin: + row = l.strip().split() + if row[0]==""#CHROM"": + row[9] = args.sample_name + l = ""\t"".join(row)+""\n"" + sys.stdout.write(l)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/snp-gap.py",".py","2201","64","#! /usr/bin/env python3 +import argparse +import pysam + +parser = argparse.ArgumentParser(description=""Set GT to ./ for SNPs in indel areas."") +parser.add_argument(""--vcf"", help=""Path to the input VCF file."") +parser.add_argument(""--output"", help=""Path to the output BED file."") +parser.add_argument(""--padding"", type=int, default=50, help=""Padding around indels."") +parser.add_argument(""--remove"", action=""store_true"", help=""Remove SNPs in indel areas."") + +args = parser.parse_args() + +def is_indel(var): + ref = var.ref + alts = var.alts + for alt in alts: + if len(ref) != len(alt): + return True + return False + +def load_vcf_lines(vcf_file): + vcf = pysam.VariantFile(vcf_file, 'r') + lines = [] + for rec in vcf.fetch(): + lines.append(rec) + return lines + +def extract_af(var: pysam.VariantRecord): + sample = list(var.header.samples)[0] # Assuming we are interested in the first sample + AD = var.samples[sample][""AD""] + alt_ad = sum(AD[1:]) if len(AD) > 1 else 0 + alt_af = alt_ad / sum(AD) if sum(AD) > 0 else 0 + return alt_af + +def extract_indel_area(vcf_lines, padding): + indel_area = set() + for rec in vcf_lines: + if is_indel(rec): + alt_af = extract_af(rec) + if alt_af < 0.20: continue + for pos in range(rec.start - padding, rec.stop + padding): + indel_area.add((rec.chrom, pos)) + return indel_area + +def set_gt_to_missing(vcf_lines, indel_area, output_file): + with pysam.VariantFile(output_file, 'w', header=vcf_lines[0].header) as out_vcf: + sample = vcf_lines[0].header.samples[0] # Assuming single sample VCF + for rec in vcf_lines: + if not is_indel(rec): + if (rec.chrom, rec.start) in indel_area: + if args.remove: + continue + # Set GT to ./. + rec.samples[sample]['GT'] = (None, None) + out_vcf.write(rec) + +if not args.vcf: + args.vcf = '/dev/stdin' +if not args.output: + args.output = '/dev/stdout' + +vcf_lines = load_vcf_lines(args.vcf) +indel_area = extract_indel_area(vcf_lines, args.padding) +set_gt_to_missing(vcf_lines, indel_area, args.output)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/realign_tandem_deletions.py",".py","3584","95","#! /usr/bin/env python +import pysam +import argparse +import logging +from pathogenprofiler.gff import load_gff +from collections import defaultdict +from tqdm import tqdm +import bisect + +parser = argparse.ArgumentParser(description='Right-align deletions in a VCF file') +parser.add_argument('input', help='VCF file with deletions to right-align') +parser.add_argument('ref', help='Reference genome in fasta format') +parser.add_argument('gff', help='Gff annotation file') +parser.add_argument('output', help='Output VCF file with right-aligned deletions') +parser.add_argument('--debug',action='store_true',help='Print debug information') + +args = parser.parse_args() + +if args.debug: + logging.basicConfig(level=logging.DEBUG) + + +def check_coordinates(var: pysam.VariantRecord,refseq: pysam.FastaFile, direction: str) -> tuple[int,int,str,tuple]: + original_tuple = (var.start, var.stop, var.ref, var.alts) + if var.alts[0] != '' and len(var.ref)==len(var.alts[0]): + return original_tuple + start = var.start + 1 + if var.alts[0] == '': + end = var.stop + else: + end = var.start + len(var.ref) + 1 + svlen = end-start + if svlen<=1: + return original_tuple + deleted_seq = refseq.fetch(var.chrom, start, end-1) + if direction == ""right"": + nextseq = refseq.fetch(var.chrom, end-1, end+svlen-2) + else: + if start-svlen < 0: + return original_tuple + nextseq = refseq.fetch(var.chrom, start-svlen, start-1) + if deleted_seq == nextseq: + logging.debug((svlen,deleted_seq,nextseq)) + logging.debug(f""Deletion {var.chrom}:{start}-{end} is a tandem repeat"") + if direction == ""right"": + last_del_nuc = deleted_seq[-1] + ref = last_del_nuc + deleted_seq + if var.alts[0] == '': + alt = var.alts[0] + ref = ref[0] + else: + alt = last_del_nuc + return end-2, end+svlen-1, ref, (alt,) + else: + first_del_nuc = deleted_seq[0] + ref = deleted_seq + first_del_nuc + if var.alts[0] == '': + alt = var.alts[0] + ref = ref[-1] + else: + alt = first_del_nuc + return start-svlen+1, start, ref, (alt,) + else: + logging.debug(f""Deletion {var.chrom}:{start}-{end} is not a tandem repeat"") + return original_tuple + +vcf_in = pysam.VariantFile(args.input) +header = vcf_in.header +refseq = pysam.FastaFile(args.ref) +genes = load_gff(args.gff) + +gene_ends = defaultdict(list) +gene_names = defaultdict(list) + +for chrom in refseq.references: + for gene in genes: + gene_ends[gene.chrom].append(gene.end) + gene_names[gene.chrom].append(gene.name) + + +vcf_out = pysam.VariantFile(args.output, ""w"", header=header) +for var in vcf_in: + logging.debug(f""Processing variant {var.chrom}:{var.start}-{var.stop}"") + # find if the variant overlaps with a gene end using the bisect module + gene_ends_list = gene_ends[var.chrom] + gene_end_index = bisect.bisect_left(gene_ends_list, var.start) + if gene_end_index var.start and gene_ends_list[gene_end_index] < var.stop: + logging.debug(f""Variant overlaps with gene end {genes[gene_end_index].name}"") + direction = ""right"" if genes[gene_end_index].strand == ""+"" else ""left"" + start,end,ref,alts = check_coordinates(var,refseq,direction) + var.start = start + var.stop = end + var.ref = ref + var.alts = alts + vcf_out.write(var)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/rename_vcf_chrom.py",".py","810","25","#! /usr/bin/env python3 +import pathogenprofiler as pp +import sys +import argparse + + +def main(args): + generator = pp.cmd_out(f""bcftools view {args.vcf}"") if args.vcf else sys.stdin + convert = dict(zip(args.source,args.target)) + for l in generator: + if l[0]==""#"": + sys.stdout.write(l) + else: + row = l.strip().split() + row[0] = convert[row[0]] + sys.stdout.write(""\t"".join(row)+""\n"") + +parser = argparse.ArgumentParser(description='tbprofiler script',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--vcf',type=str,help='') +parser.add_argument('--source',nargs=""+"",type=str,help='') +parser.add_argument('--target',nargs=""+"",type=str,help='') +parser.set_defaults(func=main) +args = parser.parse_args() +args.func(args) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/fa2vcf.py",".py","1808","67","#! /usr/bin/env python +import argparse +import pysam + +parser = argparse.ArgumentParser(description='Convert fasta to vcf') +parser.add_argument('aln', help='Alignment file') +parser.add_argument('out', help='Output vcf file') + +args = parser.parse_args() + + + +aln = pysam.FastaFile(args.aln) +chrom = aln.references[0] +sample_name = aln.references[1] +chrom_len = aln.get_reference_length(chrom) + +variants = [] +for i,(ref,alt) in enumerate(zip(aln.fetch(chrom),aln.fetch(aln.references[1]))): + if ref!=alt: + variants.append( + { + ""chrom"": aln.references[0], + ""pos"": i, + ""ref"": ref, + ""alt"": alt if alt!=""N"" else ""*"" + } + ) + +# create vcf file + +header = pysam.VariantHeader() +header.add_sample(sample_name) +header.contigs.add(chrom, length=chrom_len) +header.add_line('##INFO=') +header.add_line('##INFO=') +header.add_line('##FORMAT=') + +vcf = pysam.VariantFile(args.out, ""w"", header=header) + +# add a variant +for variant in variants: + record = vcf.new_record( + contig=variant[""chrom""], + start=variant[""pos""], + alleles=[variant[""ref""], variant[""alt""]], + id=variant['ref'] + str(variant['pos']+1) + (variant['alt'] if variant[""alt""]!=""*"" else variant['ref'] ) + ) + if variant[""alt""]==""*"": + record.info[""AC""] = [0] + record.info[""AN""] = 0 + record.samples[sample_name][""GT""] = (None) + + else: + record.info[""AC""] = [1] + record.info[""AN""] = 1 + record.samples[sample_name][""GT""] = (1) + + # write GT field + vcf.write(record) + +vcf.close() + + + + +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/vcf_add_variant_annotations.py",".py","5327","203","import pysam +import argparse +import math +import logging + +parser = argparse.ArgumentParser(description=""Add variant annotations to a VCF file."") + + +parser.add_argument( + ""bam"", type=str, help=""Input BAM file."" +) + + + +args = parser.parse_args() + + + +import pysam +from scipy.stats import ranksums + + + +rc = {""A"": ""T"", ""T"": ""A"", ""C"": ""G"", ""G"": ""C""} + +def read_pos_rank_sum(bam: str, chrom: str, pos: int, ref: str, alt: str): + bam = pysam.AlignmentFile(bam, ""rb"") + + ref_positions = [] + alt_positions = [] + + for read in bam.fetch(chrom, pos, pos + 1): + if read.is_unmapped or read.is_duplicate or read.is_secondary: + continue + + # Get the read position that aligns to the genomic position + read_pos = read.get_reference_positions(full_length=True) + try: + read_idx = read_pos.index(pos-1) + except ValueError: + continue # This read doesn't actually cover the position (e.g., deletion) + + base = read.query_sequence[read_idx] + + # Store read-relative position (0 to read length) + rel_pos = read_idx + + + if base.upper() == ref.upper(): + ref_positions.append(rel_pos) + elif base.upper() == alt.upper(): + alt_positions.append(rel_pos) + else: + continue # Ignore mismatches that don't match ref or alt + + + if len(ref_positions) == 0 or len(alt_positions) == 0: + logging.info(""Insufficient data: need both ref and alt reads."") + return None + + # Perform Wilcoxon rank-sum test + stat, p_value = ranksums(alt_positions, ref_positions) + + return { + ""statistic"": stat, + ""p_value"": p_value, + ""alt_positions"": alt_positions, + ""ref_positions"": ref_positions + } + +def alt_near_read_ends_pct(bam: str, chrom: str, pos: int, alt: str, margin: int = 10): + bam = pysam.AlignmentFile(bam, ""rb"") + + alt_read_positions = [] + near_end_count = 0 + + for read in bam.fetch(chrom, pos, pos + 1): + if read.is_unmapped or read.is_duplicate or read.is_secondary: + continue + + # Get aligned reference-to-read positions + read_pos = read.get_reference_positions(full_length=True) + try: + read_idx = read_pos.index(pos-1) + except ValueError: + continue # skip reads that do not align to the position (e.g. deletions) + + # Skip if out of read bounds + if read_idx >= len(read.query_sequence): + continue + + base = read.query_sequence[read_idx] + + + if base.upper() == alt.upper(): + alt_read_positions.append(read_idx) + read_len = read.query_length + # Check if variant is within 'margin' bases from either end + if read_idx < margin or (read_len - read_idx - 1) < margin: + near_end_count += 1 + + total_alt_reads = len(alt_read_positions) + if total_alt_reads == 0: + return { + ""percent_near_ends"": None, + ""total_alt_reads"": 0, + ""near_end_reads"": 0 + } + + percent = 100.0 * near_end_count / total_alt_reads + return { + ""percent_near_ends"": percent, + ""total_alt_reads"": total_alt_reads, + ""near_end_reads"": near_end_count + } + + + +def calculate_epp(bam: str, chrom: str, pos: int, alt: str, margin: int = 10): + bam = pysam.AlignmentFile(bam, ""rb"") + EL = 0 + ER = 0 + + for read in bam.fetch(chrom, pos, pos + 1): + # check read name + if read.is_unmapped or read.is_duplicate or read.is_secondary: + continue + + ref_pos = read.get_reference_positions(full_length=True) + try: + read_idx = ref_pos.index(pos-1) + except ValueError: + continue # read doesn't align over this position + + if read_idx >= len(read.query_sequence): + continue + + + + + base = read.query_sequence[read_idx] + + if base.upper() != alt.upper(): + continue + + read_len = read.query_length + if read_idx < margin: + EL += 1 + elif (read_len - read_idx - 1) < margin: + ER += 1 + + + n = EL + ER + if n == 0: + return { + ""EPP"": None, + ""EL"": EL, + ""ER"": ER + } + + delta = abs((EL / n) - 0.5) + p = 2 * math.exp(-2 * n * delta ** 2) + p = min(max(p, 1e-300), 1.0) # Clamp for numerical safety + + epp = -10 * math.log10(p) + return { + ""EPP"": epp, + ""EL"": EL, + ""ER"": ER + } + + + +vcf_in = pysam.VariantFile(""-"") +header = vcf_in.header + +# add float INFO field +tags = [ + {'ID':'AEP','Number':'1','Type':'Float','Description':'Allele End Proximity'}, + {'ID':'AEPT','Number':'1','Type':'Integer','Description':'Total Alt Reads'}, + {'ID':'AEPE','Number':'1','Type':'Integer','Description':'Alt Reads Near Ends'}, +] +for tag in tags: + header.add_meta('INFO',items=tag.items()) + + +vcf_out = pysam.VariantFile(""-"", ""w"", header=header) + +for var in vcf_in: + x = alt_near_read_ends_pct( + bam=args.bam, + chrom=var.chrom, + pos=var.pos, + alt=var.alts[0], + margin=10 + ) + var.info[""AEP""] = x[""percent_near_ends""] + var.info[""AEPT""] = x[""total_alt_reads""] + var.info[""AEPE""] = x[""near_end_reads""] + vcf_out.write(var) + + +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/vcf-process-for-consensus.py",".py","1425","42","#! /usr/bin/env python3 +import argparse +import pysam + +parser = argparse.ArgumentParser(description=""Set GT to ./ for SNPs in indel areas."") +parser.add_argument(""--vcf"", help=""Path to the input VCF file."") +parser.add_argument(""--output"", help=""Path to the output BED file."") +parser.add_argument(""--af"", type=float, default=0.8, help=""Allele frequency threshold."") +parser.add_argument(""--min-dp"", type=int, default=10, help=""Minimum depth threshold."") + +args = parser.parse_args() + + + +if not args.vcf: + args.vcf = '/dev/stdin' +if not args.output: + args.output = '/dev/stdout' + +vcf = pysam.VariantFile(args.vcf) # Open the input VCF file +vcf_lines = [] +for var in vcf: + ad = var.samples[0]['AD'] # Get the Allelic Depth (AD) field + adf = [d/sum(ad) for d in ad] # Calculate allele depth fractions + + if sum(ad) args.af and var.samples[0]['GT'] == (0, 1): + var.samples[0]['GT'] = (1, 1) # Modify genotype to homozygous variant + major_allele_freq = max(adf) + if len(adf)>2: + # handle multi-allelic sites + var.samples[0]['GT'] = (None, None) + + vcf_lines.append(var) # Print the modified variant + + +with pysam.VariantFile(args.output, 'w', header=vcf_lines[0].header) as out_vcf: + sample = vcf_lines[0].header.samples[0] # Assuming single sample VCF + for rec in vcf_lines: + out_vcf.write(rec) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/right_align_deletions.py",".py","3683","86","#! /usr/bin/env python +import pysam +import argparse +import logging +from pathogenprofiler.gff import load_gff +from collections import defaultdict +from tqdm import tqdm +import bisect + +parser = argparse.ArgumentParser(description='Right-align deletions in a VCF file') +parser.add_argument('input', help='VCF file with deletions to right-align') +parser.add_argument('ref', help='Reference genome in fasta format') +parser.add_argument('gff', help='Gff annotation file') +parser.add_argument('output', help='Output VCF file with right-aligned deletions') +parser.add_argument('--debug',action='store_true',help='Print debug information') + +args = parser.parse_args() + +if args.debug: + logging.basicConfig(level=logging.DEBUG) + +def right_align_deletion(var: pysam.VariantRecord, refseq: pysam.FastaFile) -> tuple[int,int,str,tuple]: + """""" + Right-align a deletion variant in a VCF record. + """""" + + + stop_pos = var.stop + original_alt = var.alts[0] + deleted_seq = refseq.fetch(var.chrom, var.start, var.stop-1) + logging.debug('Found deleted seq') + next_base = refseq.fetch(var.chrom,var.stop, var.stop+1) # Fetch the base at the stop position + logging.debug(f""Variant before right alignment: {var.chrom}:{var.start}-{var.stop} {var.ref} {var.alts}"") + logging.debug(f""Deleted sequence: {deleted_seq}, Next base: {next_base}"") + i=0 + while next_base==deleted_seq[1]: + logging.debug(f""Next base {next_base} is equal to deleted seq {deleted_seq[1]}"") + deleted_seq = deleted_seq[1:] + next_base + var.start += 1 + stop_pos += 1 + next_base = refseq.fetch(var.chrom,stop_pos, stop_pos+1) # Fetch the base at the stop position + logging.debug(f""Updated variant start: {var.start}, stop: {var.stop}, ref: {var.ref}, alts: {var.alts}, next_base: {next_base}"") + i += 1 + + if original_alt=='': + var.ref = refseq.fetch(var.chrom, var.start, var.start+1) + else: + var.ref = refseq.fetch(var.chrom, var.start, var.stop) + var.alts = (next_base,) + logging.debug(f""Right-aligned deletion: {var.chrom}:{var.start}-{var.stop} {var.ref} {var.alts}"") + logging.debug(f""Number of bases shifted: {i}"") + +vcf_in = pysam.VariantFile(args.input) +header = vcf_in.header +refseq = pysam.FastaFile(args.ref) +genes = load_gff(args.gff) + +gene_ends = defaultdict(list) +gene_names = defaultdict(list) + +for chrom in refseq.references: + for gene in genes: + gene_ends[gene.chrom].append(gene.end) + gene_names[gene.chrom].append(gene.name) + +vcf_out = pysam.VariantFile(args.output, ""w"", header=header) +for var in vcf_in: + needs_processing = False + if var.alts[0]=='' or len(var.ref)>len(var.alts[0]): + needs_processing = True + if var.stop - var.start >= 50000: + logging.debug(f""Skipping large variant {var.chrom}:{var.start}-{var.stop} {var.ref} {var.alts}"") + needs_processing = False + if needs_processing: + logging.debug(f""Processing variant {var.chrom}:{var.start}-{var.stop} {var.ref} {var.alts}"") + + # find if the variant overlaps with a gene end using the bisect module + gene_ends_list = gene_ends[var.chrom] + gene_end_index = bisect.bisect_left(gene_ends_list, var.start) + if gene_end_index var.start and gene_ends_list[gene_end_index] < var.stop: + logging.debug(f""Variant overlaps with gene end {genes[gene_end_index].name}"") + direction = ""right"" if genes[gene_end_index].strand == ""+"" else ""left"" + if direction==""right"": + right_align_deletion(var, refseq) + + vcf_out.write(var)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/add_dummy_AD.py",".py","2417","72","#! /usr/bin/env python3 +import sys +import re +import argparse + +def main(args): + if args.ref: + chroms = [] + for l in open(args.ref+"".fai""): + chroms.append(l.strip().split()) + for l in sys.stdin: + row = l.rstrip().split() + if l[0]==""#"": + # temp fix for issue with pilon vcf header + if ""ID=DP,Number=1,Type=String"" in l: + l = re.sub(r'ID=DP,Number=1,Type=String', r'ID=DP,Number=1,Type=Integer',l) + if ""source=lofreq call"" in l: + # r = re.search(""(\S+).bam"",l) + # sample_name = args.sample_name if args.sample_name else r.group(1) + # sys.stdout.write('##FORMAT=\n') + # sys.stdout.write('##FORMAT=\n') + # for chrom in chroms: + # sys.stdout.write(f'##contig=\n') + pass + if ""#CHROM"" in l: + sys.stdout.write('##FORMAT=\n') + if len(row)==8: + l = l.strip() + f""\tFORMAT\t{sample_name}\n"" + sys.stdout.write(l) + else: + if len(row)<9: + row.append(""GT"") + row.append(""1/1"") + if ""AD"" not in row[8]: + row[8]+="":AD"" + if ""DP4="" in row[7]: + r = re.search(""DP4=([0-9,]+)"",row[7]) + if r: + dp4 = [int(x) for x in r.group(1).split("","")] + ref = dp4[0]+dp4[1] + alt = dp4[2]+dp4[3] + row[9]+=f"":{ref},{alt}"" + elif ""AF="" in row[7]: + raf = re.search(""AF=([0-9\.]+)"",row[7]) + rdp = re.search(""DP=([0-9]+)"",row[7]) + if raf and rdp: + dp = int(rdp.group(1)) + alt = int(dp*float(raf.group(1))) + ref = int(dp-alt) + row[9]+=f"":{ref},{alt}"" + else: + quit(f""AF and DP not found in {row[7]}"") + + else: + alt = 100 + ref = 0 + row[9]+=f"":{ref},{alt}"" + # quit(f""AD not found in {row[7]}"") + if args.add_dp: + if ""DP"" not in row[8]: + row[8]+="":DP"" + row[9]+=f"":{ref+alt}"" + + sys.stdout.write(""%s\n"" % ""\t"".join(row)) + +parser = argparse.ArgumentParser(description='add required annotations',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--ref',type=str,help='Reference file (lofreq required)') +parser.add_argument('--sample-name',type=str,help='Sample name (lofreq required)') +parser.add_argument('--add-dp',action=""store_true"",help='Add FORMAT/DP (lofreq required)') +parser.set_defaults(func=main) +args = parser.parse_args() +args.func(args)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/annotate_maaf.py",".py","1120","37","#! /usr/bin/env python +import pysam +import logging + +vcf_in = pysam.VariantFile(""-"") +header = vcf_in.header + +# add float INFO field +tag = {'ID':'MAAF','Number':'1','Type':'Float','Description':'Major Alternative Allele Frequency'} +header.add_meta('INFO',items=tag.items()) + +vcf_out = pysam.VariantFile(""-"", ""w"", header=header) +for var in vcf_in: + # short variant + if 'AD' in var.samples[0]: + if var.samples[0]['AD'] == (None,): + maaf = 0 + else: + # calculate MAF from FMT/AD + maaf = max(var.samples[0]['AD'][1:])/sum(var.samples[0]['AD']) + + elif 'SVTYPE' in var.info: + # long variant + # use DR:DV:RR:RV + total_reads = var.samples[0]['DR'] + var.samples[0]['DV'] + var.samples[0]['RR'] + var.samples[0]['RV'] + if var.samples[0]['RR'] == (None,): + maaf = 0 + elif total_reads==0: + maaf = 0 + else: + maaf = (var.samples[0]['DV'] + var.samples[0]['RV'])/total_reads + else: + # panic + raise ValueError(""No AD or SVTYPE in INFO field"") + var.info['MAAF'] = maaf + vcf_out.write(var) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/setGT.py",".py","1929","61","#! /usr/bin/env python3 +import sys +from tqdm import tqdm +import argparse +import re + +def main(args): + ad_cutoff = args.fraction + for l in tqdm(sys.stdin): + line = l.strip().replace(""|"",""/"") + something_changed = False + row = line.split() + if l[0]==""#"": + sys.stdout.write(l) + continue + alleles = [row[3]]+row[4].split("","") + if len(alleles)>9: continue + + if ""*"" in row[4]: + something_changed = True + for i in range(9,len(row)): + if row[i][0]==""."" or row[i][2]==""."": continue + if alleles[int(row[i][0])]==""*"" or alleles[int(row[i][2])]==""*"": + tmp = list(row[i]) + tmp[0] = ""."" + tmp[2] = ""."" + row[i]="""".join(tmp) + + + idx = row[8].split("":"").index(""AD"") + + for i in range(9,len(row)): + + fmt = row[i].split("":"") + ad = [int(x) for x in fmt[idx].split("","")] + total_ad = sum(ad) + if total_ad==0:continue + adf = [ad[j]/total_ad for j in range(len(ad))] + + if max(adf)>=ad_cutoff: + new_gt = adf.index(max(adf)) + if alleles[new_gt]==""*"": new_gt = ""."" + fmt[0] = f""{new_gt}/{new_gt}"" + something_changed = True + row[i] = "":"".join(fmt) + else: + something_changed = True + fmt[0] = ""./."" + row[i] = "":"".join(fmt) + if something_changed: + sys.stdout.write(""\t"".join(row)+""\n"") + else: + sys.stdout.write(l) + +parser = argparse.ArgumentParser(description='TBProfiler pipeline',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--fraction',default=0.7,type=float,help='Fraction of coverage to assign major') +parser.set_defaults(func=main) + +args = parser.parse_args() +args.func(args) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/modify_lofreq_vcf.py",".py","2296","64","#! /usr/bin/env python3 +import pysam +from collections import defaultdict +import argparse + +parser = argparse.ArgumentParser(description='Fix lofreq vcf',formatter_class=argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('--sample',help='Sample name',required=True) +args = parser.parse_args() + + +variants = defaultdict(list) +input_vcf = pysam.VariantFile(""-"") +for var in input_vcf: + variants[(var.chrom,var.pos)].append(var) + +new_header = input_vcf.header.copy() +##INFO= +##INFO= +info_tags = [ + {'ID':'SAF','Number':'A','Type':'Integer','Description':'Number of alternate observations on the forward strand'}, + {'ID':'SAR','Number':'A','Type':'Integer','Description':'Number of alternate observations on the reverse strand'}, +] + +format_tags = [ + {'ID':'GT','Number':'1','Type':'String','Description':'Genotype'}, + {'ID':'DP','Number':'1','Type':'Integer','Description':'Read Depth'}, + {'ID':'AD','Number':'R','Type':'Integer','Description':'Allelic depths (high-quality bases)'}, +] + + + +if len(new_header.samples)==0: + for tag in info_tags: + new_header.add_meta('INFO',items=tag.items()) + for tag in format_tags: + new_header.add_meta('FORMAT',items=tag.items()) + new_header.add_sample(args.sample) +output_vcf = pysam.VariantFile(""-"", 'w', header=new_header) +for vars in variants.values(): + if ""SAF"" in vars[0].info: + output_vcf.write(vars[0]) + else: + new_var = output_vcf.new_record() + new_var.chrom = vars[0].chrom + new_var.pos = vars[0].pos + new_var.ref = vars[0].ref + new_var.filter.add(""PASS"") + new_var.info['DP'] = vars[0].info['DP'] + if len(vars) == 1: + new_var.alts = vars[0].alts + else: + new_var.alts = vars[0].alts + vars[1].alts + # copy the first variant record's INFO and FORMAT fields + + new_var.info['SAF'] = [v.info['DP4'][2] for v in vars] + new_var.info['SAR'] = [v.info['DP4'][3] for v in vars] + + new_var.samples[0]['GT'] = [1,1] + new_var.samples[0]['DP'] = vars[0].info['DP'] + new_var.samples[0]['AD'] = [vars[0].info['DP4'][0] + vars[0].info['DP4'][1]] + [v.info['DP4'][2]+v.info['DP4'][3] for v in vars] + + output_vcf.write(new_var) +output_vcf.close() +","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/vcf-extract-mixed-pos-bed.py",".py","1741","46","#!/usr/bin/env python +import argparse +import pysam + +parser = argparse.ArgumentParser(description=""Extract mixed calls from a VCF file and output them in BED format."") +parser.add_argument(""--vcf"", help=""Path to the input VCF file."") +parser.add_argument(""--output"", help=""Path to the output BED file."") +parser.add_argument(""--lb"", type=float, default=0.1, help=""Lower bound for allele frequency."") +parser.add_argument(""--ub"", type=float, default=0.9, help=""Upper bound for allele frequency."") +args = parser.parse_args() + +def extract_mixed_calls(vcf_file): + afs = [] + vcf = pysam.VariantFile(vcf_file) + sample = list(vcf.header.samples)[0] # Assuming we are interested in the first sample + for var in vcf.fetch(): + AD = var.samples[sample][""AD""] + alt_ad = sum(AD[1:]) if len(AD) > 1 else 0 + alt_af = alt_ad / sum(AD) if sum(AD) > 0 else 0 + afs.append({ + 'chrom': var.chrom, + 'pos': var.pos, + 'ref': var.ref, + 'alt': var.alts[0] if var.alts else None, + 'alt_af': alt_af, + 'alt_ad': alt_ad, + 'total_ad': sum(AD), + 'GT': var.samples[sample][""GT""] + }) + return afs + +def write_bed_file(afs, output_bed, lb_cut, ub_cut): + with open(output_bed, ""w"") as bed_file: + for r in afs: + if lb_cut <= r['alt_af'] <= ub_cut: + bed_file.write(f""{r['chrom']}\t{r['pos']-1}\t{r['pos']}\n"") + if r['GT'] == (None, None): + bed_file.write(f""{r['chrom']}\t{r['pos']-1}\t{r['pos']}\n"") + +if not args.vcf: + args.vcf = '/dev/stdin' +if not args.output: + args.output = '/dev/stdout' + +afs = extract_mixed_calls(args.vcf) +write_bed_file(afs, args.output, args.lb, args.ub)","Python" +"Pathogens","jodyphelan/pathogen-profiler","scripts/vcf-get-high-density-snp-regions.py",".py","2512","73","#! /usr/bin/env python3 +import argparse +import pysam + +parser = argparse.ArgumentParser(description=""Set GT to ./ for SNPs in indel areas."") +parser.add_argument(""--vcf"", help=""Path to the input VCF file."") +parser.add_argument(""--ref"", help=""Path to the reference genome file."",required=True) +parser.add_argument(""--output"", help=""Path to the output BED file."") +parser.add_argument(""--window-size"", type=int, default=50, help=""Window size for high-density SNP regions."") +parser.add_argument(""--max-snps"", type=int, default=5, help=""Maximum number of SNPs in a window."") + +args = parser.parse_args() + + + +if not args.vcf: + args.vcf = '/dev/stdin' +if not args.output: + args.output = '/dev/stdout' + +ref = pysam.FastaFile(args.ref) # Open the reference genome file +ref_seqname = ref.references[0] # Assuming single contig/reference +chrom_len = ref.get_reference_length(ref_seqname) + +vcf = pysam.VariantFile(args.vcf) # Open the input VCF file + +snp_positions = [] +snp_vector = [0] * chrom_len +for record in vcf: + if record.alts[0] == ""*"": + continue # Skip deletions + if record.alts and len(record.alts[0]) == 1 and len(record.ref) == 1: # Check for SNP + snp_vector[record.pos - 1] = 1 # Mark SNP position + snp_positions.append(record.pos - 1) + +windows = [] +for i,pos in enumerate(snp_positions): + start = max(0, pos - args.window_size // 2) + end = min(chrom_len, pos + args.window_size // 2) + num_snps_in_window = sum(snp_vector[start:end]) + if num_snps_in_window > args.max_snps: + windows.append({ + 'chrom': ref_seqname, + 'start': start, + 'end': end, + 'num_snps': num_snps_in_window + }) + +def merge_intervals(intervals): + if not intervals: + return [] + # Sort intervals by start position + intervals.sort(key=lambda x: x['start']) + merged = [intervals[0]] + for current in intervals[1:]: + last = merged[-1] + if current['start'] <= last['end']: # Overlap + merged[-1] = { + 'chrom': last['chrom'], + 'start': last['start'], + 'end': max(last['end'], current['end']), + 'num_snps': max(last['num_snps'], current['num_snps']) + } # Merge + else: + merged.append(current) + return merged + +merged_windows = merge_intervals(windows) + +with open(args.output, ""w"") as bed_file: + for window in merged_windows: + bed_file.write(""{chrom}\t{start}\t{end}\t{num_snps}\n"".format(**window)) +","Python" +"Pathogens","jodyphelan/pathogen-profiler","tests/run_test.py",".py","3711","157","import pathogenprofiler as pp +import subprocess as sp +import json +import semver + +ref = ""MTB-h37rv_asm19595v2-eg18.fa"" +gff = ""MTB-h37rv_asm19595v2-eg18.gff"" + + +hgvs_mutations = [ + { + ""Gene"":""gid"", + ""Mutation"":""c.615_628delACGACGTGGAAAGCinsGCGACGTGGAAAG"", + ""target"":""c.615_628delACGACGTGGAAAGCinsGCGACGTGGAAAG"" + }, + { + ""Gene"":""gid"", + ""Mutation"":""c.615_628delACGACGTGGAAAGC"", + ""target"":""c.615_628delACGACGTGGAAAGC"" + }, + { + ""Gene"":""ethA"", + ""Mutation"":""c.1057_1059del"", + ""target"":""c.1057_1059delACG"" + }, + { + ""Gene"": ""rpoB"", + ""Mutation"": ""c.1282_1290del"", + ""target"": ""c.1287_1295delGCTGAGCCA"" + }, + { + ""Gene"":""ethA"", + ""Mutation"":""c.341del"", + ""target"":""c.341delA"" + }, + { + ""Gene"": ""embA"" , + ""Mutation"": ""c.-29_-28del"", + ""target"": ""c.-29_-28delCT"" + }, + { + ""Gene"": ""alr"", + ""Mutation"": ""c.-283_-280delCAAT"", + ""target"": ""c.-283_-280delCAAT"" + }, + { + ""Gene"": ""ethA"", + ""Mutation"": ""c.-1058_968del"", + ""target"": ""c.-1058_968del"" + }, + { + ""Gene"": ""rpoB"", + ""Mutation"":""c.1296_1297insTTC"", + ""target"": ""c.1297_1299dupTTC"" + }, + { + ""Gene"": ""pncA"", + ""Mutation"": ""c.521_522insT"", + ""target"": ""c.521_522insT"" + }, + { + ""Gene"": ""alr"", + ""Mutation"": ""c.-283_-280delCAAT"", + ""target"": ""c.-283_-280delCAAT"" + }, + { + ""Gene"": ""pncA"", + ""Mutation"": ""c.7G>C"", + ""target"": ""c.7G>C"" + }, + { + ""Gene"": ""rrs"", + ""Mutation"": ""n.5G>A"", + ""target"": ""n.5G>A"" + }, + # { + # ""Gene"": ""gid"", + # ""Mutation"": ""g.4408196C>G"", + # ""target"": ""c.7G>C"", + # }, + { + ""Gene"": ""rrs"", + ""Mutation"": ""n.-93C>T"", + ""target"": ""n.-93C>T"" + }, + { + ""Gene"": ""rrs"", + ""Mutation"": ""n.4_17dupTGTTTGGAGAGTTT"", + ""target"": ""n.4_17dupTGTTTGGAGAGTTT"" + }, + { + ""Gene"": ""mmpR5"", + ""Mutation"": ""c.-21_-20insTTC"", + ""target"": ""c.-21_-20insTTC"" + }, + { + ""Gene"": ""gid"", + ""Mutation"": ""c.114_115dupCC"", + ""target"": ""c.114_115dupCC"" + }, + { + ""Gene"": ""gid"", + ""Mutation"": ""c.248_250dupGGC"", + ""target"": ""c.248_250dupGGC"" + }, + + { + ""Gene"": ""pncA"", + ""Mutation"": ""p.Ter187Argext*?"", + ""target"": ""p.Ter187Argext*?"" + } + +] + +test = [ + { + ""Gene"": ""pncA"", + ""Mutation"": ""p.Ter187Argext*?"", + ""target"": ""p.Ter187Argext*?"" + } +] + +todo = [ + { + ""Gene"": ""rrs"", + ""Mutation"": ""n.-29_-28insATAC"", + ""target"": ""n.-29_-28insATAC"" + }, + { + ""Gene"": ""dnaA"", + ""Mutation"": ""c.-110_-109insTG"", + ""target"": ""c.-110_-109insTG"" + }, +] + + +# converted_mutations = pp.get_snpeff_formated_mutation_list(hgvs_mutations,ref,gff,""Mycobacterium_tuberculosis_h37rv"") + + + + +# logging.debug(converted_mutations) + +# @pytest.mark.parametrize(""mutation"",hgvs_mutations) +# def test_variant(mutation): +# gene = mutation[""Gene""] +# change = mutation[""Mutation""] +# target = mutation[""target""] +# assert(target == converted_mutations[(gene,change)][1]) + +def test_version(): + current_version = semver.VersionInfo.parse(pp.__version__) + stdout = sp.check_output(['gh', 'release', 'view', '--json', 'tagName'], text=True).splitlines() + release_version = semver.VersionInfo.parse(json.loads(stdout[0].strip())['tagName'][1:]) + # check the current version is greater than the release version + assert current_version > release_version, f""Current version {current_version} is not greater than the release version {release_version}."" +","Python" +"Pathogens","indexofire/ndafp","source/conf.py",".py","10193","345","# -*- coding: utf-8 -*- +import sphinx_rtd_theme +from recommonmark.parser import CommonMarkParser + +# +# NGS Data Analysis for Pathogens documentation build configuration file, created by +# sphinx-quickstart on Sat Jul 16 11:11:04 2016. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +# +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +source_parsers = {'.md': CommonMarkParser} +source_suffix = ['.rst', '.md'] +#source_suffix = '.rst' + +# The encoding of source files. +# +# source_encoding = 'utf-8-sig' + +# The master toctree document. +master_doc = 'index' + +# General information about the project. +project = u'NGS Data Analysis for Pathogens' +copyright = u'2016, Mark Renton' +author = u'Mark Renton' + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The short X.Y version. +version = u'0.0.1a' +# The full version, including alpha/beta/rc tags. +release = u'0.0.1a' + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set ""language"" from the command line for these cases. +language = 'zh_CN' + +# There are two options for replacing |today|: either, you set today to some +# non-false value, then it is used: +# +# today = '' +# +# Else, today_fmt is used as the format for a strftime call. +# +# today_fmt = '%B %d, %Y' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = [] + +# The reST default role (used for this markup: `text`) to use for all +# documents. +# +# default_role = None + +# If true, '()' will be appended to :func: etc. cross-reference text. +# +# add_function_parentheses = True + +# If true, the current module name will be prepended to all description +# unit titles (such as .. function::). +# +# add_module_names = True + +# If true, sectionauthor and moduleauthor directives will be shown in the +# output. They are ignored by default. +# +# show_authors = False + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = 'sphinx' + +# A list of ignored prefixes for module index sorting. +# modindex_common_prefix = [] + +# If true, keep warnings as ""system message"" paragraphs in the built documents. +# keep_warnings = False + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = False + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +#html_theme = 'alabaster' +html_theme = 'sphinx_rtd_theme' +html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# +# html_theme_options = {} + +# Add any paths that contain custom themes here, relative to this directory. +# html_theme_path = [] + +# The name for this set of Sphinx documents. +# "" v documentation"" by default. +# +# html_title = u'NGS Data Analysis for Pathogens v0.0.1a' + +# A shorter title for the navigation bar. Default is the same as html_title. +# +# html_short_title = None + +# The name of an image file (relative to this directory) to place at the top +# of the sidebar. +# +# html_logo = None + +# The name of an image file (relative to this directory) to use as a favicon of +# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 +# pixels large. +# +# html_favicon = None + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named ""default.css"" will overwrite the builtin ""default.css"". +html_static_path = ['_static'] + +# Add any extra paths that contain custom files (such as robots.txt or +# .htaccess) here, relative to this directory. These files are copied +# directly to the root of the documentation. +# +# html_extra_path = [] + +# If not None, a 'Last updated on:' timestamp is inserted at every page +# bottom, using the given strftime format. +# The empty string is equivalent to '%b %d, %Y'. +# +# html_last_updated_fmt = None + +# If true, SmartyPants will be used to convert quotes and dashes to +# typographically correct entities. +# +# html_use_smartypants = True + +# Custom sidebar templates, maps document names to template names. +# +# html_sidebars = {} + +# Additional templates that should be rendered to pages, maps page names to +# template names. +# +# html_additional_pages = {} + +# If false, no module index is generated. +# +# html_domain_indices = True + +# If false, no index is generated. +# +# html_use_index = True + +# If true, the index is split into individual pages for each letter. +# +# html_split_index = False + +# If true, links to the reST sources are added to the pages. +# +# html_show_sourcelink = True + +# If true, ""Created using Sphinx"" is shown in the HTML footer. Default is True. +# +# html_show_sphinx = True + +# If true, ""(C) Copyright ..."" is shown in the HTML footer. Default is True. +# +# html_show_copyright = True + +# If true, an OpenSearch description file will be output, and all pages will +# contain a tag referring to it. The value of this option must be the +# base URL from which the finished HTML is served. +# +# html_use_opensearch = '' + +# This is the file name suffix for HTML files (e.g. "".xhtml""). +# html_file_suffix = None + +# Language to be used for generating the HTML full-text search index. +# Sphinx supports the following languages: +# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja' +# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh' +# +# html_search_language = 'en' + +# A dictionary with options for the search language support, empty by default. +# 'ja' uses this config value. +# 'zh' user can custom change `jieba` dictionary path. +# +# html_search_options = {'type': 'default'} + +# The name of a javascript file (relative to the configuration directory) that +# implements a search results scorer. If empty, the default will be used. +# +# html_search_scorer = 'scorer.js' + +# Output file base name for HTML help builder. +htmlhelp_basename = 'NGSDataAnalysisforPathogensdoc' + +# -- Options for LaTeX output --------------------------------------------- + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + # + # 'papersize': 'letterpaper', + + # The font size ('10pt', '11pt' or '12pt'). + # + # 'pointsize': '10pt', + + # Additional stuff for the LaTeX preamble. + # + # 'preamble': '', + + # Latex figure (float) alignment + # + # 'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + (master_doc, 'NGSDataAnalysisforPathogens.tex', u'NGS Data Analysis for Pathogens Documentation', + u'Mark Renton', 'manual'), +] + +# The name of an image file (relative to this directory) to place at the top of +# the title page. +# +# latex_logo = None + +# For ""manual"" documents, if this is true, then toplevel headings are parts, +# not chapters. +# +# latex_use_parts = False + +# If true, show page references after internal links. +# +# latex_show_pagerefs = False + +# If true, show URL addresses after external links. +# +# latex_show_urls = False + +# Documents to append as an appendix to all manuals. +# +# latex_appendices = [] + +# It false, will not define \strong, \code, itleref, \crossref ... but only +# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added +# packages. +# +# latex_keep_old_macro_names = True + +# If false, no module index is generated. +# +# latex_domain_indices = True + + +# -- Options for manual page output --------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + (master_doc, 'ngsdataanalysisforpathogens', u'NGS Data Analysis for Pathogens Documentation', + [author], 1) +] + +# If true, show URL addresses after external links. +# +# man_show_urls = False + + +# -- Options for Texinfo output ------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + (master_doc, 'NGSDataAnalysisforPathogens', u'NGS Data Analysis for Pathogens Documentation', + author, 'NGSDataAnalysisforPathogens', 'One line description of project.', + 'Miscellaneous'), +] + +# Documents to append as an appendix to all manuals. +# +# texinfo_appendices = [] + +# If false, no module index is generated. +# +# texinfo_domain_indices = True + +# How to display URL addresses: 'footnote', 'no', or 'inline'. +# +# texinfo_show_urls = 'footnote' + +# If true, do not generate a @detailmenu in the ""Top"" node's menu. +# +# texinfo_no_detailmenu = False +","Python" +"Pathogens","indexofire/ndafp","source/chapter_03/aln2phy.py",".py","332","11","# -*- coding: utf-8 -*- +from Bio import AlignIO +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument(""-input"", action=store, dest=input, type=str) +parser.add_argument(""-output"", action=store, dest=output, type=str) +args = parser.parse_args() + +AlignIO.convert(args.input, ""clustal"", args.output, ""phylip-relaxed"") +","Python" +"Pathogens","indexofire/ndafp","markdown/docs/index.md",".md","484","18","# Welcome to MkDocs + +For full documentation visit [mkdocs.org](http://mkdocs.org). + +## Commands + +* `mkdocs new [dir-name]` - Create a new project. +* `mkdocs serve` - Start the live-reloading docs server. +* `mkdocs build` - Build the documentation site. +* `mkdocs help` - Print this help message. + +## Project layout + + mkdocs.yml # The configuration file. + docs/ + index.md # The documentation homepage. + ... # Other markdown pages, images and other files. +","Markdown" +"Pathogens","nextstrain/mpox","CHANGELOG.md",".md","6271","97","# CHANGELOG + +We use this CHANGELOG to document breaking changes, new features, bug fixes, +and config value changes that may affect both the usage of the workflows and +the outputs of the workflows. + +Changes for this project _do not_ currently follow the [Semantic Versioning rules](https://semver.org/spec/v2.0.0.html). +Instead, changes appear below grouped by the date they were added to the workflow. + + +## 2025 + +* 10 December 2025: BREAKING CHANGE - the `outbreak` column values have been updated with the latest release of the Nextclade dataset. + See [Nextclade release notes](https://github.com/nextstrain/nextclade_data/releases/tag/2025-12-10--14-52-38Z) for details. + * phylogenetic workflow's default filter params have been updated to replace outbreak `hMPXV-1` with `sh2017` +* 10 November 2025: Transition to Pathoplexus as data source + * Ingest workflow updated to pull data from Pathoplexus API instead of directly from INSDC databases. + * Phylogenetic workflow updated to take into account changes in metadata and sequence data from Pathoplexus. + +* 05 November 2025: Data files archived before transition to Pathoplexus data source. + * The data files published on 05 November 2025 (prior to the Pathoplexus transition) are available at: + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/metadata.tsv.zst + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/sequences.fasta.zst + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/alignment.fasta.zst + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/nextclade.tsv.zst + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/translations.zip + * https://data.nextstrain.org/files/workflows/mpox/archive/20251105/ncbi.ndjson.zst + * After this date, the main data files at https://data.nextstrain.org/files/workflows/mpox/ might contain data from Pathoplexus (which includes INSDC data). + +* 08 October 2025: phylogenetic - Major update to the definition of inputs. ([#339][]) + * Configs are now required to include the `inputs` param to define inputs for the workflow + + ```yaml + inputs: + - name: ncbi + metadata: ""https://data.nextstrain.org/files/workflows/mpox/metadata.tsv.zst"" + sequences: ""https://data.nextstrain.org/files/workflows/mpox/sequences.fasta.zst"" + ``` + +* 02 July 2025: phylogenetic - config schema updates for easier config overlays ([#321][]) + * new required config params + * `exclude` - path to exclude.txt for `augur filter` + * `filter[""query""]` - argument for the `--query` option for `augur filter` + * `color_ordering` - path to color_ordering.tsv for generating colors.tsv + * `color_schemes` - path to color_schemes.tsv for generating colors.tsv + * string params that were converted to lists. + These are automatically converted to lists in the workflow but you are still encouraged to update your config file + * `root` + * `traits[""columns""]` + * `colors[""ignore_categories""]` + * `[""subsampling""][]` values are now expected to be a single string of `augur filter` options. + These are automatically converted to a string if they are still a dict in the config file but you are still encouraged to update your config file. + See the [default config](./phylogenetic/defaults/hmpxv1/config.yaml) for an example. + * specific subsamples can now be disabled by setting the value to null. + This is useful for disabling default subsampling when running the workflow with config overlays. + For example, you can disable the `non_b1` subsampling in the [default config](./phylogenetic/defaults/hmpxv1/config.yaml) with the YAML null value (~): + ```yaml + subsample: + non_b1: ~ + ``` +* 01 July 2025: phylogenetic - Use `strain_id_field` for node name. ([#275][]) + The final Auspice JSONs now use the `strain_id_field` config param as the + node name and the `display_strain_field` config param is no longer supported. + If you want to use a different field as the default tip label, then add + `display_defaults['tip_label']` to your auspice_config.json. +* 25 June 2025: metadata.tsv column changes. ([#319][]) + * `date_submitted` has been corrected to `date_released`. + * added columns `date_updated`, `length`, and `url` + Note that our public metadata.tsv files still has the `date_submitted` column + for backwards compatibility, but it will be removed by 28 July 2025 so please + update your workflows to use the new `date_released` column. +* 25 June 2025: All workflows now use the zstd compressed outputs on S3. ([#318][]) + Note that the gzip and xz compressed files on S3 will be removed by 28 July 2025, + so please update your workflows to use the zstd compressed files. +* 23 June 2025: added the following zstd compressed outputs. ([#317][]) + * https://data.nextstrain.org/files/workflows/mpox/metadata.tsv.zst + * https://data.nextstrain.org/files/workflows/mpox/sequences.fasta.zst + * https://data.nextstrain.org/files/workflows/mpox/alignment.fasta.zst +* 23 June 2025: ingest - updated intermediate NDJSON file. ([#316][]) + * Removed the following intermediate NDJSON files + * https://data.nextstrain.org/files/workflows/mpox/all_sequences.ndjson.xz + * https://data.nextstrain.org/files/workflows/mpox/genbank.ndjson.xz + * Added a new NDJSON file that is zstd compressed and uses the [NCBI Datasets mnemonics][] as field names. + * https://data.nextstrain.org/files/workflows/mpox/ncbi.ndjson.zst +* 23 June 2025: ingest - removed path for separate data sources. ([#316][]) + * The config param `sources` is no longer supported + + +[#275]: https://github.com/nextstrain/mpox/pull/275 +[#316]: https://github.com/nextstrain/mpox/pull/316 +[#317]: https://github.com/nextstrain/mpox/pull/317 +[#318]: https://github.com/nextstrain/mpox/pull/318 +[#319]: https://github.com/nextstrain/mpox/pull/319 +[#321]: https://github.com/nextstrain/mpox/pull/321 +[#339]: https://github.com/nextstrain/mpox/pull/339 +[NCBI Datasets mnemonics]: https://www.ncbi.nlm.nih.gov/datasets/docs/v2/reference-docs/command-line/dataformat/tsv/dataformat_tsv_virus-genome/#fields +","Markdown" +"Pathogens","nextstrain/mpox","CONTRIBUTING.md",".md","1416","51","# Developer guide + +## CI + +Checks are automatically run on certain pushed commits for testing and linting +purposes. Some are defined by [.github/workflows/ci.yaml][] while others are +configured outside of this repository. + +[.github/workflows/ci.yaml]: ./.github/workflows/ci.yaml + +## Pre-commit + +[pre-commit][] is used for various checks (see [configuration][]). + +You can either [install it yourself][] to catch issues before pushing or look +for the [pre-commit.ci run][] after pushing. + +[pre-commit]: https://pre-commit.com/ +[configuration]: ./.pre-commit-config.yaml +[install it yourself]: https://pre-commit.com/#install +[pre-commit.ci run]: https://results.pre-commit.ci/repo/github/493877605 + +## Snakemake formatting + +We use [`snakefmt`](https://github.com/snakemake/snakefmt) to ensure consistency in style across Snakemake files in this project. + +### Installing + +- Using mamba/bioconda: + +```bash +mamba install -c bioconda snakefmt +``` + +- Using pip: + +```bash +pip install snakefmt +``` + +### IDE-independent + +1. Check for styling issues with `snakefmt --check .` +1. Automatically fix styling issues with `snakefmt .` + +### Using VSCode extension + +1. Install the [VSCode extension](https://marketplace.visualstudio.com/items?itemName=tfehlmann.snakefmt) +1. Check for styling issues with `Ctrl+Shift+P` and select `snakefmt: Check` +1. Automatically fix styling issues with `Ctrl+Shift+P` and select `Format document` +","Markdown" +"Pathogens","nextstrain/mpox","nextclade/resources/all-clades/CHANGELOG.md",".md","1498","26","## Unreleased + +## TKTK + +- Clade Ia and clade Ib are now distinguished +- Sequences shared via Genbank since 2024 have been added + +## 2024-04-19T07:50:39Z + +- New hMPXV-1 lineages B.1.21, B.1.22, and C.1.1 are now included in the dataset. For more information on these lineages, see the [hMPXV-1 lineage definitions PR](https://github.com/mpxv-lineages/lineage-designation/pull/37) +- The sequences used in the reference trees have been updated to include the latest sequences available in Genbank as of 2024-04-16 + +## 2024-01-16T20:31:02Z + +Initial release of this dataset. This dataset is similar to the v2 dataset [`MPXV/ancestral`](https://github.com/nextstrain/nextclade_data/tree/2023-08-17--15-51-24--UTC/data/datasets/MPXV/references/ancestral/versions/2023-08-01T12%3A00%3A00Z/files) with some differences. + +### New and changed gene names + +Some genes have been renamed and one has been added. The new annotation is based on NCBI refseq annotations that were released in November 2022. The v2 dataset predates this refseq: + +- The 4 genes in the inverted terminal repeat segment (ITR) on both ends of the genome (OPG001, OPG002, OPG003,OPG015) are now all included. The genes on the 3' end (~positions 190000-197000) now have an `_dup` appended to distinguish them. +- The gene previously named `NBT03_gp052` is now called `OPG073` +- The gene previously named `NBT03_gp174` is now called `OPG016` +- The gene previously named `NBT03_gp175` is now called `OPG015_dup` +- Gene `OPG166` has been added +","Markdown" +"Pathogens","nextstrain/mpox","nextclade/resources/clade-i/CHANGELOG.md",".md","48","4","## Unreleased + +Initial release of this dataset. +","Markdown" +"Pathogens","nextstrain/mpox","nextclade/resources/lineage-b.1/CHANGELOG.md",".md","998","14","## Unreleased + +Initial release of this dataset. This dataset is similar to the v2 dataset [`hMPXV_B.1/pseudo_ON563414`](https://github.com/nextstrain/nextclade_data/tree/2023-08-17--15-51-24--UTC/data/datasets/hMPXV_B.1/references/pseudo_ON563414/versions/2023-08-01T12%3A00%3A00Z/files) with some differences. + +### New and changed gene names + +Some genes have been renamed and one has been added. The new annotation is based on NCBI refseq annotations that were released in November 2022. The v2 dataset predates this refseq: + +- The 4 genes in the inverted terminal repeat segment (ITR) on both ends of the genome (OPG001, OPG002, OPG003,OPG015) are now all included. The genes on the 3' end (~positions 190000-197000) now have an `_dup` appended to distinguish them. +- The gene previously named `NBT03_gp052` is now called `OPG073` +- The gene previously named `NBT03_gp174` is now called `OPG016` +- The gene previously named `NBT03_gp175` is now called `OPG015_dup` +- Gene `OPG166` has been added +","Markdown" +"Pathogens","nextstrain/mpox","nextclade/resources/clade-iib/CHANGELOG.md",".md","982","14","## Unreleased + +Initial release of this dataset. This dataset is similar to the v2 dataset [`hMPXV/NC_063383.1`](https://github.com/nextstrain/nextclade_data/tree/2023-08-17--15-51-24--UTC/data/datasets/hMPXV/references/NC_063383.1/versions/2023-08-01T12%3A00%3A00Z/files) with some differences. + +### New and changed gene names + +Some genes have been renamed and one has been added. The new annotation is based on NCBI refseq annotations that were released in November 2022. The v2 dataset predates this refseq: + +- The 4 genes in the inverted terminal repeat segment (ITR) on both ends of the genome (OPG001, OPG002, OPG003,OPG015) are now all included. The genes on the 3' end (~positions 190000-197000) now have an `_dup` appended to distinguish them. +- The gene previously named `NBT03_gp052` is now called `OPG073` +- The gene previously named `NBT03_gp174` is now called `OPG016` +- The gene previously named `NBT03_gp175` is now called `OPG015_dup` +- Gene `OPG166` has been added +","Markdown" +"Pathogens","nextstrain/mpox","nextclade/scripts/gb-to-ppx.py",".py","4234","115","import argparse +import csv +import re +import sys + + +def load_accession_map(metadata_file): + """""" + Load mapping from GenBank accessions to PPX accessions from metadata.tsv + """""" + accession_map = {} + + with open(metadata_file, 'r', newline='') as tsv_file: + reader = csv.DictReader(tsv_file, delimiter='\t') + for row in reader: + ppx_accession = row.get('accession') + genbank_base = row.get('insdcAccessionBase') + genbank_full = row.get('insdcAccessionFull') + + # Map both forms of GenBank accessions to PPX + if genbank_base and ppx_accession: + accession_map[genbank_base] = ppx_accession + if genbank_full and ppx_accession: + accession_map[genbank_full] = ppx_accession + + return accession_map + +def replace_accessions_inplace(input_file, accession_map): + """""" + Process file line by line: + - Keep original lines + - Add new lines with replacements when GenBank accessions are found + """""" + # Sort accessions by length (longest first) to avoid partial replacements + sorted_accessions = sorted(accession_map.keys(), key=len, reverse=True) + + # Compile regex pattern for faster matching + # This creates a pattern like: (acc1|acc2|acc3) with proper escaping + pattern = '|'.join(re.escape(acc) for acc in sorted_accessions) + regex = re.compile(f'({pattern})') + + with open(input_file, 'r') as f: + lines = f.readlines() + + new_lines = [] + replacement_count = 0 + lines_modified = 0 + + for line in lines: + new_lines.append(line) + + # Check if line contains any accessions + matches = regex.findall(line) + if matches: + # Create a new line with replacements + modified_line = line + replacements_in_line = 0 + + for match in set(matches): # Use set to avoid counting duplicates multiple times + modified_line = modified_line.replace(match, accession_map[match]) + replacements_in_line += modified_line.count(accession_map[match]) + + # If we made replacements, add the modified line + if modified_line != line: + new_lines.append(modified_line) + replacement_count += replacements_in_line + lines_modified += 1 + + # Only write back if we made changes + if replacement_count > 0: + with open(input_file, 'w') as f: + f.writelines(new_lines) + + return replacement_count, lines_modified + +def main(): + parser = argparse.ArgumentParser(description='Process GenBank accessions to PPX accessions') + parser.add_argument('--metadata', required=True, help='Path to the metadata.tsv file') + parser.add_argument('--input', required=True, nargs='+', help='Input file(s) containing GenBank accessions') + + args = parser.parse_args() + + # Load the accession mapping + print(f""Loading accession mapping from {args.metadata}..."", file=sys.stderr) + accession_map = load_accession_map(args.metadata) + print(f""Loaded {len(accession_map)} accession mappings"", file=sys.stderr) + + # Process each input file + total_files = len(args.input) + changed_files = 0 + total_replacements = 0 + total_lines_modified = 0 + + for idx, input_file in enumerate(args.input, 1): + print(f""Processing file {idx}/{total_files}: {input_file}..."", file=sys.stderr) + replacements, lines_modified = replace_accessions_inplace(input_file, accession_map) + + if replacements > 0: + changed_files += 1 + total_replacements += replacements + total_lines_modified += lines_modified + print(f"" - Made {replacements} replacements across {lines_modified} lines"", file=sys.stderr) + else: + print(f"" - No replacements needed"", file=sys.stderr) + + # Print summary statistics + print(""\nSummary:"", file=sys.stderr) + print(f""- Files processed: {total_files}"", file=sys.stderr) + print(f""- Files modified: {changed_files}"", file=sys.stderr) + print(f""- Total replacements: {total_replacements}"", file=sys.stderr) + print(f""- Total lines with replacements: {total_lines_modified}"", file=sys.stderr) + +if __name__ == ""__main__"": + main() +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/mutation_context.py",".py","2164","60","from collections import defaultdict +import json +import argparse + + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""calculate mutation context json"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--tree"", type=str, required=True, help=""tree file"") + parser.add_argument(""--mutations"", type=str, required=True, help=""mutations"") + parser.add_argument(""--output"", type=str, metavar=""JSON"", required=True, help=""output Auspice JSON"") + args = parser.parse_args() + + with open(args.mutations) as fh: + data = json.load(fh)[""nodes""] + + terminal_muts = defaultdict(lambda: defaultdict(int)) + internal_muts = defaultdict(lambda: defaultdict(int)) + + node_data = {} + + for name, node in data.items(): + GA_count = 0 + CT_count = 0 + total_muts = 0 + for mut in node[""muts""]: + a, pos, d = mut[0], int(mut[1:-1]), mut[-1] + if a in ""ACGT"" and d in ""ACGT"": + total_muts += 1 + if a + d == ""GA"": + GA_count += 1 + elif a + d == ""CT"": + CT_count += 1 + GA_CT_count = GA_count + CT_count + if total_muts: + node_data[name] = {""GA_CT_fraction"": GA_CT_count / total_muts} + else: + node_data[name] = {""GA_CT_fraction"": None} + + dinuc_count = 0 + if GA_CT_count: + # node_data[name][""CT_fraction""] = CT_count/GA_CT_count + for mut in node[""muts""]: + a, pos, d = mut[0], int(mut[1:-1]), mut[-1] + if a in ""ACGT"" and d in ""ACGT"": + if a + d == ""GA"" and node[""sequence""][pos] == ""A"": + dinuc_count += 1 + elif a + d == ""CT"" and node[""sequence""][pos - 2] == ""T"": + dinuc_count += 1 + node_data[name][""dinuc_context_fraction""] = dinuc_count / GA_CT_count + else: + node_data[name][""dinuc_context_fraction""] = None + # node_data[name][""CT_fraction""] = None + + with open(args.output, ""w"") as fh: + json.dump({""nodes"": node_data}, fh) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/lift_annotations.py",".py","3001","114",""""""" +#%% +Use the output of nextclade to lift annotations from reference to query +"""""" + +import json +from pathlib import Path + +import pandas as pd + +df = pd.read_csv(""out3/nextclade.tsv"", sep=""\t"") + +# get the first row +df = df.iloc[0] + +alignment_start = df[""alignmentStart""] +alignment_end = df[""alignmentEnd""] +insertions = df[""insertions""].split("","") +deletions = df[""deletions""].split("","") + +# Turn insertions and deletions into a list of tuples: (pos, length) + +dels = [] +for i in deletions: + if ""-"" in i: + start, end = i.split(""-"") + dels.append((int(start), int(end) - int(start) + 1)) + continue + dels.append((int(i), 1)) + +# print(dels) + + +ins = [] +for i in insertions: + pos, seq = i.split("":"") + ins.append((int(pos), len(seq))) + +offset = -(alignment_start - 1) +next_del = dels.pop(0) if dels else None +next_ins = ins.pop(0) if ins else None + +offsets = {} + +for r in range(alignment_start, alignment_end + 1): + # if inside deletion, bump offset + # if end of deletion, pop next deletion + if next_del: + if r >= next_del[0]: + offset -= 1 + if r == next_del[0] + next_del[1] - 1: + next_del = dels.pop(0) if dels else None + + offsets[int(r)] = [int(offset), int(r + offset)] + + # if inside insertion, bump offset, pop next insertion + if next_ins: + if r == next_ins[0]: + offset += next_ins[1] + next_ins = ins.pop(0) if ins else None + + +print(offsets) + + +with open(""out/offsets.json"", ""w"") as f: + f.write(json.dumps(offsets, indent=2)) + + +# %% + +# We can check that these are correct by looking at ref and query sequences +ref = """".join(Path(""/Users/corneliusromer/Downloads/sequence (20).fasta"").read_text().split(""\n"")[1:]) +print(ref) +# %% +qry = """".join(Path(""resources/clade-i/reference.fasta"").read_text().split(""\n"")[1:]) +# %% + +for ref_pos, (offset, qry_pos) in offsets.items(): + # only print if ref and query are different + if ref[ref_pos - 1] != qry[qry_pos - 1]: + print(f""Ref: {ref_pos} {ref[ref_pos - 1]} Query: {qry_pos} {qry[qry_pos - 1]} Offset: {offset}"") + +# %% + +# Read in GFF file +# Treat as simple TSV + +gff = pd.read_csv(""resources/clade-i/sequence (20).gff3"", sep=""\t"", comment=""#"", header=None) +new_gff = gff.copy() + +# Map columns 2/3 to qry positions from ref positions +# Editing the gff DataFrame new_gff in place +qry_len = len(qry) +new_gff[3] = gff[3].apply(lambda x: offsets.get(x, [1, 1])[1]) +new_gff[4] = gff[4].apply(lambda x: offsets.get(x, [qry_len, qry_len])[1]) + + +# %% +new_gff + +Path(""resources/clade-i/genome_annotation2.gff3"").write_text( + new_gff.to_csv(sep=""\t"", header=False, index=False) +) + +# %% + +mask = pd.read_csv(""resources/clade-iib/mask.bed"", sep=""\t"") +new_mask = mask.copy() +new_mask[""ChromStart""] = mask[""ChromStart""].apply(lambda x: offsets.get(x, [1, 1])[1]) +new_mask[""ChromEnd""] = mask[""ChromEnd""].apply(lambda x: offsets.get(x, [qry_len, qry_len])[1]) +Path(""resources/clade-i/mask2.bed"").write_text(new_mask.to_csv(sep=""\t"", index=False)) +# %% +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/deduplicate.py",".py","4823","144",""""""" +Standard typer CLI with high-level parallelization +Called as follows: +python3 scripts/deduplicate.py \ +--sequences {input.sequences} \ +--output {output} +"""""" +import itertools +import multiprocessing +from functools import partial + +import typer +from Bio import SeqIO + + +def informative_sites(sequence: str) -> int: + """""" + Count number of ACGT characters in a sequence + """""" + return sum([1 for c in sequence if c in ""ACGT""]) + +def identical(seq1: str, seq2: str, info_sites: list) -> bool: + """""" + Check if two sequences are identical (up to Ns) + Short circuit at the first difference + """""" + for i in info_sites: + c1 = seq1[i] + c2 = seq2[i] + if c1 != c2 and c2 in ""ACGT"" and c1 in ""ACGT"": + return False + return True + +def composition_per_site(sequences) -> list: + """""" + Compute the composition of each site in a list of sequences + """""" + length = len(sequences[0][""seq""]) + composition = [{} for _ in range(length)] + for sequence in sequences: + for i, c in enumerate(sequence[""seq""]): + if c not in composition[i]: + composition[i][c] = 0 + # Increment the count for that character + composition[i][c] += 1 + return composition + +def mismatch_prob_per_site(composition: list) -> list: + """""" + Compute the mismatch probability of each site in a list of sequences + For each character, probability of selecting it * probability of selecting a mismatching character + """""" + result = [] + seqs = sum(composition[0].values()) + for site in composition: + values = [val / seqs for char, val in site.items() if char in ""ACGT""] + prob = 0 + for i, value in enumerate(values): + for j, other_value in enumerate(values): + if i < j: + prob += value * other_value + result.append(prob) + return result + +def informative_indexes_sorted_by_entropy(composition: list) -> list: + """""" + List of indexes of informative sites sorted by entropy + Uninformative sites are not included + """""" + site_information = {i: info for i, info in enumerate(mismatch_prob_per_site(composition)) if info > 0} + site_information = sorted(site_information.items(), key=lambda x: x[1], reverse=True) + return [x[0] for x in site_information] + +def process_batch(batch_indices, all_sequences, info_sites): + """""" + Process a batch of ying sequences against all potential duplicates + Returns a list of IDs to remove + """""" + duplicates = [] + + for ying_idx in batch_indices: + ying_seq = all_sequences[ying_idx] + + # Compare with all sequences that come after this one + for yang_idx in range(ying_idx + 1, len(all_sequences)): + yang_seq = all_sequences[yang_idx] + + if identical(ying_seq[""seq""], yang_seq[""seq""], info_sites): + print(f""Removing {yang_seq['id']} as identical to {ying_seq['id']}"") + duplicates.append(yang_seq[""id""]) + + return duplicates + +def deduplicate(input: str, output: str, num_processes: int = 10): + """""" + Deduplicate sequences in a file + Args: + sequences: path to sequences file + output: path to output file + num_processes: number of cores to use + """""" + with open(input, ""r"") as f: + sequences = [ + { + ""id"": record.id, + ""seq"": str(record.seq), + ""number_informative_sites"": informative_sites(str(record.seq)), + } + for record in itertools.islice(SeqIO.parse(f, ""fasta""), 0, None) + ] + sequences = sorted(sequences, key=lambda x: x[""number_informative_sites""], reverse=True) + composition = composition_per_site(sequences) + info_sites = informative_indexes_sorted_by_entropy(composition) + + # Divide work among processes - each process takes a batch of ying sequences + num_sequences = len(sequences) + batch_size = max(1, num_sequences // (num_processes * 5)) # Smaller batches for better load balancing + + # Create batches of indices + batches = [] + for i in range(0, num_sequences-1, batch_size): # -1 because the last sequence has nothing to compare against + end = min(i + batch_size, num_sequences-1) + batches.append(list(range(i, end))) + + # Process batches in parallel + pool = multiprocessing.Pool(processes=num_processes) + process_func = partial(process_batch, all_sequences=sequences, info_sites=info_sites) + results = pool.map(process_func, batches) + + # Clean up + pool.close() + pool.join() + + # Combine results + dup_list = {dup for batch_result in results for dup in batch_result} + + # Write output + with open(output, ""w"") as f: + for dup in dup_list: + f.write(f""{dup}\n"") + +if __name__ == ""__main__"": + typer.run(deduplicate) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/remove_timeinfo.py",".py","983","37","import json +import argparse + + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--input-node-data"", type=str, required=True, help=""input data"") + parser.add_argument( + ""--output-node-data"", + type=str, + metavar=""JSON"", + required=True, + help=""output Auspice JSON"", + ) + args = parser.parse_args() + + with open(args.input_node_data) as fh: + data = json.load(fh) + + new_node_data = {} + + for name, node in data[""nodes""].items(): + new_node_data[name] = { + ""mutation_length"": node[""mutation_length""], + ""branch_length"": node[""branch_length""], + } + if ""raw_date"" in node: + new_node_data[name][""date""] = node[""raw_date""] + + data[""nodes""] = new_node_data + with open(args.output_node_data, ""w"") as fh: + json.dump(data, fh) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/remove_identical_seqs.py",".py","936","32","# %% +import json + +# %% +tree = json.load(open(""auspice/nextclade_monkeypox_b1.json"")) +# %% +# For each internal node create a list of children with 0 divergence +id_children = {} + + +def get_identical_children(tree, parent_div=0, parent=""""): + if ""node_attrs"" in tree and ""div"" in tree[""node_attrs""] and tree[""node_attrs""][""div""] == parent_div: + if ""strain"" in tree[""node_attrs""]: + if parent not in id_children: + id_children[parent] = [] + id_children[parent].append(tree[""node_attrs""][""strain""][""value""]) + if ""children"" in tree: + for child in tree[""children""]: + get_identical_children(child, tree[""node_attrs""][""div""], tree[""name""]) + + +get_identical_children(tree[""tree""], 0, ""root"") + +# %% +# Print all but first of identical children +for parent in id_children: + if len(id_children[parent]) > 1: + for child in id_children[parent][1:]: + print(child) + +# %% +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/make_nice_strain_names.py",".py","1039","35",""""""" +Adds a new column `--output-column` that is a concatenation of +`--input-columns` with a separator `--separator`. +Usage: +python3 scripts/make_nice_strain_names.py \ + --metadata {input.metadata} \ + --input-columns accession country date \ + --separator '|' \ + --output-column strain_display \ + --output {output.metadata} +"""""" + +import argparse + +import pandas as pd + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument(""--metadata"", required=True) + parser.add_argument(""--input-columns"", nargs=""+"", required=True) + parser.add_argument(""--separator"", required=True) + parser.add_argument(""--output-column"", required=True) + parser.add_argument(""--output"", required=True) + args = parser.parse_args() + + df = pd.read_csv(args.metadata, sep=""\t"", dtype=str) + separator = str(args.separator) + df[args.output_column] = df[args.input_columns].astype(str).apply(lambda x: separator.join(x), axis=1) + df.to_csv(args.output, sep=""\t"", index=False) + + +if __name__ == ""__main__"": + main() +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/graft-recombinants.py",".py","5150","162","#!/usr/bin/env python3 +"""""" +Graft recombinant sequences onto a phylogenetic tree. + +This script takes a tree and a list of recombinant sequences, roots the tree +on specified root sequences, and attaches recombinants to the root with long branches. +"""""" + +import argparse +import sys + +from Bio import Phylo + + +def read_recombinants(recombinants_file): + """""" + Read recombinant sequence names from a file. + + Args: + recombinants_file (str): Path to file containing recombinant names (one per line) + + Returns: + list: List of recombinant sequence names + """""" + try: + with open(recombinants_file, 'r') as f: + recombinants = [line.strip() for line in f if line.strip()] + return recombinants + except FileNotFoundError: + print(f""Warning: Recombinants file not found: {recombinants_file}"", file=sys.stderr) + return [] + + +def graft_recombinants(tree, recombinants, root_sequences, branch_length=10.0, verbose=False): + """""" + Graft recombinant sequences onto the root of a tree. + + Args: + tree: Bio.Phylo tree object + recombinants (list): List of recombinant sequence names to graft + root_sequences (list): List of sequence names to use for rooting + branch_length (float): Branch length for grafted recombinants (default: 10.0) + verbose (bool): Print verbose output + """""" + if not recombinants: + if verbose: + print(""No recombinants to graft"", file=sys.stderr) + return tree + + # Root the tree on specified sequences + if root_sequences: + # If multiple root sequences provided, root on first available + root_found = False + for root_seq in root_sequences: + # Check if root sequence exists in tree + for clade in tree.find_clades(): + if clade.name == root_seq: + try: + tree.root_with_outgroup(root_seq) + root_found = True + if verbose: + print(f""Rooted tree on: {root_seq}"", file=sys.stderr) + break + except Exception as e: + if verbose: + print(f""Warning: Could not root on {root_seq}: {e}"", file=sys.stderr) + continue + if root_found: + break + + if not root_found and verbose: + print(""Warning: None of the specified root sequences found in tree"", file=sys.stderr) + + # Graft each recombinant to the root with a long branch + clade_cls = type(tree.root) + for recombinant in recombinants: + new_clade = clade_cls(name=recombinant, branch_length=branch_length) + tree.root.clades.append(new_clade) + if verbose: + print(f""Grafted recombinant: {recombinant} (branch length: {branch_length})"", file=sys.stderr) + + return tree + + +def main(args): + """"""Main function to orchestrate the grafting process."""""" + # Load the input tree + tree = Phylo.read(args.input_tree, ""newick"") + + if args.verbose: + print(f""Loaded tree from: {args.input_tree}"", file=sys.stderr) + terminal_count = len(list(tree.get_terminals())) + print(f""Tree has {terminal_count} terminal nodes"", file=sys.stderr) + + # Read recombinants file + recombinants = read_recombinants(args.recombinants) + + if args.verbose: + print(f""Found {len(recombinants)} recombinant(s): {', '.join(recombinants) if recombinants else 'none'}"", file=sys.stderr) + + # Parse root sequences (can be space-separated) + root_sequences = args.root.split() if args.root else [] + + # Graft recombinants onto the tree + tree = graft_recombinants( + tree, + recombinants, + root_sequences, + branch_length=args.branch_length, + verbose=args.verbose + ) + + # Write output tree + Phylo.write(tree, args.output_tree, ""newick"", format_branch_length=""%1.8f"") + + if args.verbose: + print(f""Output tree written to: {args.output_tree}"", file=sys.stderr) + + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""Graft recombinant sequences onto a phylogenetic tree"" + ) + parser.add_argument( + ""--input-tree"", + type=str, + required=True, + help=""Path to input Newick tree file"" + ) + parser.add_argument( + ""--recombinants"", + type=str, + required=True, + help=""Path to file containing recombinant sequence names (one per line)"" + ) + parser.add_argument( + ""--root"", + type=str, + default="""", + help=""Space-separated sequence name(s) to root the tree on"" + ) + parser.add_argument( + ""--output-tree"", + type=str, + required=True, + help=""Path to output Newick tree file"" + ) + parser.add_argument( + ""--branch-length"", + type=float, + default=10.0, + help=""Branch length for grafted recombinants (default: 10.0)"" + ) + parser.add_argument( + ""--verbose"", + action=""store_true"", + help=""Print verbose output"" + ) + + args = parser.parse_args() + main(args) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/set_final_strain_name.py",".py","1475","49","import pandas as pd +import json +import argparse + + +def replace_name_recursive(node, lookup): + if node[""name""] in lookup: + node[""name""] = lookup[node[""name""]] + + if ""children"" in node: + for child in node[""children""]: + replace_name_recursive(child, lookup) + + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--input-auspice-json"", type=str, required=True, help=""input auspice_json"") + parser.add_argument(""--metadata"", type=str, required=True, help=""input data"") + parser.add_argument( + ""--display-strain-name"", + type=str, + required=True, + help=""field to use as strain name in auspice"", + ) + parser.add_argument(""--output"", type=str, metavar=""JSON"", required=True, help=""output Auspice JSON"") + args = parser.parse_args() + + metadata = pd.read_csv(args.metadata, sep=""\t"") + name_lookup = {} + for ri, row in metadata.iterrows(): + strain_id = row[""strain""] + name_lookup[strain_id] = ( + args.display_strain_name + if pd.isna(row[args.display_strain_name]) + else row[args.display_strain_name] + ) + + with open(args.input_auspice_json, ""r"") as fh: + data = json.load(fh) + + replace_name_recursive(data[""tree""], name_lookup) + + with open(args.output, ""w"") as fh: + json.dump(data, fh) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/assign-colors.py",".py","3638","88","import argparse + +import pandas as pd + +# Forced colours MUST NOT appear in the ordering TSV +forced_colors = {} + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""Assign colors based on ordering"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--ordering"", type=str, required=True, help=""input ordering file"") + parser.add_argument(""--color-schemes"", type=str, required=True, help=""input color schemes file"") + parser.add_argument( + ""--metadata"", + type=str, + help=""if provided, restrict colors to only those found in metadata"", + ) + parser.add_argument(""--output"", type=str, required=True, help=""output colors tsv"") + args = parser.parse_args() + + assignment = {} + with open(args.ordering) as f: + for line in f.readlines(): + array = line.lstrip().rstrip().split(""\t"") + if len(array) == 2: + name = array[0] + trait = array[1] + if name not in assignment: + assignment[name] = [trait] + else: + assignment[name].append(trait) + + # if metadata supplied, go through and + # 1. remove assignments that don't exist in metadata + # 2. remove assignments that have 'focal' set to 'False' in metadata + if args.metadata: + metadata = pd.read_csv(args.metadata, delimiter=""\t"") + for name, trait in assignment.items(): + # Items not to exclude if not (yet) present in metadata to solve bootstrapping issue + if name in metadata and name not in [ + ""clade_membership"", + ""outbreak"", + ""lineage"", + ]: + subset_present = [x for x in assignment[name] if x in metadata[name].unique()] + assignment[name] = subset_present + if name in metadata and ""focal"" in metadata: + focal_list = metadata.loc[metadata[""focal""] == True, name].unique() + subset_focal = [x for x in assignment[name] if x in focal_list] + assignment[name] = subset_focal + + schemes = {} + counter = 0 + with open(args.color_schemes) as f: + for line in f.readlines(): + counter += 1 + array = line.lstrip().rstrip().split(""\t"") + schemes[counter] = array + + with open(args.output, ""w"") as f: + for trait_name, trait_array in assignment.items(): + if len(trait_array) == 0: + print(f""No traits found for {trait_name}"") + continue + if len(schemes) < len(trait_array): + print(f""WARNING: insufficient colours available for trait {trait_name} - reusing colours!"") + remain = len(trait_array) + color_array = [] + while remain > 0: + if remain > len(schemes): + color_array = [*color_array, *schemes[len(schemes)]] + remain -= len(schemes) + else: + color_array = [*color_array, *schemes[remain]] + remain = 0 + else: + color_array = schemes[len(trait_array)] + extra_trait_values = list(forced_colors.get(trait_name, {}).keys()) + extra_color_values = list(forced_colors.get(trait_name, {}).values()) + + zipped = list(zip(trait_array + extra_trait_values, color_array + extra_color_values)) + for trait_value, color in zipped: + f.write(trait_name + ""\t"" + trait_value + ""\t"" + color + ""\n"") + f.write(""\n"") +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/clades_renaming.py",".py","3344","91","import argparse +import json + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""Split clade membership into clade, outbreak and lineage"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument(""--input-node-data"", type=str, required=True, help=""input data"") + parser.add_argument( + ""--output-node-data"", + type=str, + metavar=""JSON"", + required=True, + help=""output Auspice JSON"", + ) + parser.add_argument(""--outgroup-clade-name"", type=str, default=""outgroup"", help=""name for outgroup clade"") + args = parser.parse_args() + with open(args.input_node_data) as fh: + data = json.load(fh) + new_node_data = {} + for name, node in data[""nodes""].items(): + old_clade_name = node[""clade_membership""] + outbreak_name = """" + lineage_name = """" + + # if it starts with clade -> it's a clade + # if it starts with outbreak -> it's outbreak, need to look up clade + # if it starts with lineage -> it's clade IIb, outbreak hMPXV-1 + if old_clade_name.startswith(""clade""): + clade_name = old_clade_name.split()[1] + match clade_name: + case ""Ib"": + outbreak_name = ""sh2023"" + case ""Ib/IIb"": + outbreak_name = ""recombinant"" + elif old_clade_name == ""sh2024"": + clade_name = ""Ia"" + outbreak_name = old_clade_name + elif old_clade_name == ""sh2017"": + clade_name = ""IIb"" + outbreak_name = old_clade_name + lineage_name = ""A"" + elif old_clade_name.startswith(args.outgroup_clade_name): + clade_name = args.outgroup_clade_name + elif old_clade_name.startswith(""outgroup""): + clade_name = ""outgroup"" + elif old_clade_name.startswith(""unassigned""): + clade_name = ""unassigned"" + else: + clade_name = ""IIb"" + outbreak_name = ""sh2017"" + lineage_name = old_clade_name + + node_data = { + ""clade_membership"": clade_name, + ""outbreak"": outbreak_name, + ""lineage"": lineage_name, + } + + # Add placement prior for Ib/IIb recombinants + # To discourage attachment of short sequences to this clade + if clade_name == ""Ib/IIb"": + node_data[""placement_prior""] = -11.0 + + new_node_data[name] = node_data + + new_branch_labels = {} + + for name, node in data[""branches""].items(): + # Rename sh2017 -> sh2017/A + # Rename clade Ib -> clade IIb/outbreak sh2023 + if ""labels"" in node and ""clade"" in node[""labels""]: + + def make_label(label: str) -> dict: + return {""labels"": {""clade"": label}} + + match node[""labels""][""clade""]: + case ""sh2017"": + new_branch_labels[name] = make_label(""sh2017/A"") + case ""clade Ib"": + new_branch_labels[name] = make_label(""clade Ib/sh2023"") + case ""A"": + new_branch_labels[name] = make_label(""sh2017/A"") + case _: + new_branch_labels[name] = node + data[""branches""] = new_branch_labels + data[""nodes""] = new_node_data + with open(args.output_node_data, ""w"") as fh: + json.dump(data, fh) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/wrangle_metadata.py",".py","805","23","import pandas as pd +import argparse + + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--metadata"", type=str, required=True, help=""input data"") + parser.add_argument(""--strain-id"", type=str, required=True, help=""field to use as strain id"") + parser.add_argument(""--output"", type=str, required=True, help=""output metadata"") + args = parser.parse_args() + + metadata = pd.read_csv(args.metadata, sep=""\t"") + if ""strain"" in metadata.columns: + metadata.rename(columns={""strain"": ""strain_original""}, inplace=True) + + metadata.rename(columns={args.strain_id: ""strain""}, inplace=True) + + metadata.to_csv(args.output, sep=""\t"", index=False) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/reversions_to_virus_properties.py",".py","1349","22","# %% +import json + +# Reversions +ukp2 = ""A1262G,A2591G,A3111G,A3522G,T3818C,T7771C,T14000G,A15428G,A21723G,A30367G,A31053G,A34459G,A37202G,A38360G,T38662C,T39139C,A52885G,A54117G,A54635G,A64297G,T73066C,A73239G,A74205G,A77383G,A81275G,T82373C,A82451G,T84587C,A95034G,A124130G,A124674G,T128698C,T150469C,C151461A,A155795G,T162331C,A170262G,A178133G,A181980G,T183519C,A186578G,A193392G,T193688C,T194099C,T194619C,T195948C"" +rivers = ""A1262G,A2591G,A3111G,A3522G,T3818C,T7771C,T14000G,A15428G,G18769A,A21723G,T23564C,A25661G,C28175T,A30367G,A31053G,A34459G,A37202G,A38360G,T38662C,T39119C,T39139C,A52885G,A54117G,A54635G,A64297G,T72362C,T73066C,A73239G,A74205G,A77383G,A81275G,G81977A,T82373C,A82451G,T83326C,T84587C,A87230G,A87297G,A91728G,A95034G,G100261A,T119296C,T121320C,A124130G,A124674G,A125249G,T128698C,A148412G,T150469C,C151461A,C154408T,A155795G,A162243G,T162331C,T164832C,T168120C,A170262G,A178133G,A181980G,T183519C,A186578G,T187428C,A193392G,T193688C,T194099C,T194619C,T195948C"" +# %% +reversions = set(ukp2.split("","") + rivers.split("","")) +# %% +# Format to +# ""Genotype"": [""rev""] +revs = {r[1:]: [""rev""] for r in reversions} +# %% +# Sort by position, numerically not alphabetically + +json.dump( + {k: v for k, v in sorted(revs.items(), key=lambda item: int(item[0][:-1]))}, + open(""reversions.json"", ""w""), + indent=2, + sort_keys=False, +) +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/fix_tree.py",".py","6475","155","import argparse +from collections import defaultdict + +from Bio import Phylo +from treetime import TreeAnc + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument(""--alignment"", type=str, required=True, help=""input sequences"") + parser.add_argument(""--input-tree"", type=str, required=True, help=""input nwk"") + parser.add_argument(""--root"", type=str, required=False, help=""root node"") + parser.add_argument(""--output"", type=str, required=True, help=""output nwk"") + args = parser.parse_args() + + T = Phylo.read(args.input_tree, ""newick"") + + if args.root: + T.root_with_outgroup(args.root) + else: + T.root_at_midpoint() + + tt = TreeAnc(tree=T, aln=args.alignment, gtr=""JC69"") + tt.optimize_tree(prune_short=True) + + # make list of mutations that are phylogenetically informative (not gaps of N) + for n in T.find_clades(): + n.relevant_mutations = set() + for mut in n.mutations: + if (mut[0] in ""ACGT"") and (mut[2] in ""ACGT""): + n.relevant_mutations.add(mut) + + print(""### Checking for immediate reversions\n"") + reversions = list() + for clade in T.find_clades(): + for child in clade.clades: + if child.is_terminal(): + continue + for grandchild in child.clades: + if grandchild.is_terminal(): + continue + # Check if one of grandchild mutation reverts one of child + for mut_child in child.relevant_mutations: + for mut_grandchild in grandchild.relevant_mutations: + if mut_child[1] == mut_grandchild[1] and mut_child[2] == mut_grandchild[0]: + reversions.append( + { + ""parent"": clade, + ""child"": child, + ""grandchild"": grandchild, + ""mut_child"": mut_child, + ""mut_grandchild"": mut_grandchild, + } + ) + print(f""Below {clade}: {mut_child} in {child.name} reverted in {grandchild.name}"") + + for reversion in reversions: + # Remove reversion from grandchild + reversion[""grandchild""].relevant_mutations.remove(reversion[""mut_grandchild""]) + # Remove grandchild from child + reversion[""child""].clades.remove(reversion[""grandchild""]) + # If there are mutations, add grandchild as child of parent + if reversion[""grandchild""].relevant_mutations != reversion[""parent""].relevant_mutations: + reversion[""parent""].clades.append(reversion[""grandchild""]) + else: + # Otherwise add grandchild clades to parent + reversion[""parent""].clades.extend(reversion[""grandchild""].clades) + + # find mutations that occur multiple times in branches leading to children of a node. + # use these mutations to group clades to merge later. + max_iter = 5 + for ii in range(max_iter): + print(f""###\nIteration: {ii+1}\n"") + nodes_to_merge = defaultdict(list) + + # For each node, for each mutation, find all children that have this mutation + for n in T.get_nonterminals(): + shared_mutations = defaultdict(list) + for c in n: + for mut in c.relevant_mutations: + shared_mutations[mut].append(c) + + # For each mutation, if it occurs in more than one child, add the node and the children to the list of nodes to merge + for mut in shared_mutations: + if len(shared_mutations[mut]) > 1: + nodes_to_merge[(n, tuple(shared_mutations[mut]))].append(mut) + + if len(nodes_to_merge) == 0: + print(""No more shared mutations -- breaking out of loop."") + break + + already_touched = set() + + # Merge children starting with the ones that have the most shared mutations + for (parent, children), mutations in sorted( + nodes_to_merge.items(), key=lambda x: len(x[1]), reverse=True + ): + # Each child can only be merged once per iteration + if any([c in already_touched for c in children]): + continue + + print( + ""####\nmerging clades:\n\t"", + ""\n\t"".join( + [ + f""{c.name} with mutations {c.relevant_mutations} and {c.count_terminals()} tips"" + for c in children + ] + ), + ) + print(""shared mutations:"", mutations) + print(""\n"") + + # Remove children to be merged from parent + parent.clades = [c for c in parent if c not in children] + + # Create new internal node for the merged children + new_clade = Phylo.BaseTree.Clade( + branch_length=tt.one_mutation * len(mutations), + name=f""{'_'.join([c.name for c in children])}_merged"", + ) + new_clade.relevant_mutations = set(mutations) + + # Add merged children to new internal node + for c in children: + left_over_mutations = c.relevant_mutations.difference(mutations) + + # Terminal nodes and internal nodes with mutations should be added as children to the new internal node + if len(left_over_mutations) or c.is_terminal(): + c.relevant_mutations = left_over_mutations + c.branch_length = tt.one_mutation * len(c.relevant_mutations) + new_clade.clades.append(c) + # Internal branches of 0 length should be removed and children added to the new internal node directly + else: + new_clade.clades.extend(c.clades) + already_touched.add(c) + + parent.clades.append(new_clade) + + # Prune all terminals without names + count = 0 + while True: + for n in T.find_clades(): + if n.is_terminal() and n.name is None: + T.prune(n) + print(""Warning: Pruned terminal node without name. This should not happen."") + count += 1 + if count == 0: + break + + Phylo.write(T, args.output, ""newick"") +","Python" +"Pathogens","nextstrain/mpox","nextclade/scripts/collapse-zero-branches.py",".py","2865","86","import argparse +import sys +from collections import Counter + +from Bio import Phylo + + +def get_branch_length_distribution(tree) -> Counter[float, int]: + return Counter(node.branch_length for node in tree.find_clades() if node.branch_length is not None) + + +def collapse_near_zero_branches(tree, threshold=0.001, verbose=False): + """""" + Collapses internal branches with lengths below the specified threshold. + Args: + tree (Bio.Phylo.BaseTree.Tree): Phylogenetic tree. + threshold (float): Length threshold to consider for collapsing. + verbose (bool): Print statistics if True. + """""" + pre_collapse_lengths = set() + for node in tree.find_clades(): + if node.branch_length is not None: + pre_collapse_lengths.add(node.branch_length) + + branch_length_counts_before = get_branch_length_distribution(tree) + tree.collapse_all(lambda c: c.branch_length < threshold) + branch_length_counts_after = get_branch_length_distribution(tree) + + # Print statistics of which branches were collapsed + # Calculate the difference in the number of internal branches before and after collapsing + difference = branch_length_counts_before - branch_length_counts_after + + if verbose: + print(f""Collapsed {difference.total()} internal branches with lengths below {threshold}"") + print(""Collapsed branches:"") + for length, count in difference.items(): + print(f""Branch length {length}: {count} branches"") + + +def main(args): + # Load a Newick tree from file + tree = Phylo.read(args.input_tree, ""newick"") + + # Collapse near-zero internal branches using the provided threshold + collapse_near_zero_branches(tree, threshold=args.threshold, verbose=args.verbose) + + # Output the resulting tree + if args.output_tree: + Phylo.write(tree, args.output_tree, ""newick"", format_branch_length=""%1.8f"") + if args.verbose: + print(f""Output tree written to {args.output_tree}"") + else: + Phylo.write(tree, sys.stdout, ""newick"") + + +if __name__ == ""__main__"": + # Setup command line argument parsing + parser = argparse.ArgumentParser( + description=""Process a Newick tree to collapse near-zero internal branches."" + ) + parser.add_argument( + ""--threshold"", + type=float, + default=1.0e-7, + help=""Threshold for collapsing branches (default: 1.0e-7)"", + ) + parser.add_argument( + ""--input-tree"", + type=str, + required=True, + help=""Path to the input Newick tree file"", + ) + parser.add_argument( + ""--output-tree"", + type=str, + help=""Path to the output Newick tree file (optional, defaults to stdout)"", + ) + parser.add_argument( + ""--verbose"", + action=""store_true"", + help=""Enable verbose output for more information"", + ) + + args = parser.parse_args() + main(args) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/build-configs/inrb/description.md",".md","3089","39"," +### Laboratories involved in genomic surveillance of mpox in the DRC +Institut National de Recherche Biomédicale (INRB) through : +* Pathogen Genomics Laboratory, Epidemiology and Global Health Department, INRB, Kinshasa +* Rodolphe Merieux INRB Goma Laboratory, Goma +* Mpox National Reference Laboratory, Virology Department, INRB, Kinshasa + +### Genomic surveillance of mpox in the DRC +This work is made possible by the open sharing of genetic data among research groups and constitutes a part of the genomic surveillance of mpox in the DRC, led by the Ministry of Public Health, Hygiene and Prevention through INRB, DSE, PNLFHMPX and INSP. The provincial health divisions and health zones affected by the mpox outbreak are also involved in genomic surveillance efforts. + +Data will be shared via virological.org and [Nextstrain](https://nextstrain.org/) , and will be continuously updated as new mpox sequences are generated . If you intend to use these sequences before their publication, please contact Profs. Placide Mbala and Steve Ahuka for request and coordination. + +### Partner institutions +* These sequences were generated by the Pathogen Genomics Laboratory at INRB in the DRC in partnership with : +* Africa-CDC/ASLM +* AFROSCREEN consortium +* Institute of Tropical Medicine, Antwerp, Belgium +* ARCTIC Network +* Biosurv international, UK +* TransVIHMI :Université de Montpellier, Institut de Recherche pour le Développement (IRD), Institut National de la Santé et de la Recherche Médicale (INSERM) ; Montpellier ; France, +* UCLA +* USDA +* WHO +* U.S. Centers for Disease Control and Prevention (CDC) + +### Acknowledgements +This work was funded by : +* Africa Pathogen Genomics Initiative through CARES grants ; +* Agence Francaise de Dévelopement through the AFROSCREEN project (grant agreement CZZ3209, coordinated by ANRS-MIE Maladies infectieuses émergentes in partnership with Institut de Recherche pour le Développement (IRD) and Pasteur Institute) and PANAFPOX project funded by ANRS-MIE. +* Belgian Directorate-general Development Cooperation and Humanitarian Aid and the Research Foundation - Flanders (FWO, grant number G096222 N ); +* Department of Defense, Defense Threat Reduction Agency, Monkeypox Threat Reduction Network; +* USDA Non-Assistance Cooperative Agreement #20230048; +* International Mpox Research Consortium (IMReC) through funding from the Canadian Institutes of Health Research and International Development Research Centre (grant no. MRR-184813); +* US NIAID/NIH grant number U01AI151799 through the Center for Research in Emerging Infectious Disease-East and Central Africa (CREID-ECA) + + +#### List of abbreviations: +**DRC**: Democratic Republic of the Congo; **DSE**: Direction de la Surveillance Epidémiologique ; **INRB**: Institut National de Recherche Biomédicale ; **INSP**: Institut National de Santé Publique ; **PNLFHMPX**: Programme National de Lutte contre les Fièvres Hénorragiques et le Mpox ; **UCLA**: University of California Los -Angeles ; **WHO**: World Health Organization ; **USDA**: United States Department of Agriculture +","Markdown" +"Pathogens","nextstrain/mpox","phylogenetic/build-configs/inrb/curate_private_data.py",".py","11305","268","from typing import Any +from Bio import SeqIO +import argparse +from openpyxl import load_workbook +from datetime import datetime +from os import path, mkdir +from sys import exit +import csv + +Sequences = dict[str, SeqIO.SeqRecord] +Metadata = dict[str, dict[str, str]] +MetadataHeader = list[str] + +# The following seem reasonable to hardcode, as they're central to the current mpox workflows +DATE_COLUMN = 'date' +ACCESSION_COLUMN = 'accession' +REQUIRED_COLUMNS = [ACCESSION_COLUMN, DATE_COLUMN, 'strain'] +LAT_LONG_FNAME = path.join(path.dirname(path.realpath(__file__)), "".."", "".."", ""defaults"", ""lat_longs.tsv"") +GEOGRAPHIC_RENAMINGS = { + ""division"": { + ""Sud Ubangi"": ""Sud-Ubangi"", + ""Nord Ubangi"": ""Nord-Ubangi"", + ""Mai ndombe"": ""Maindombe"", + ""Mai-Ndombe"": ""Maindombe"", + ""South Kivu"": ""Sud Kivu"", + ""Sud-Kivu"": ""Sud Kivu"", + ""Nord-Kivu"": ""Nord Kivu"", + ""Mongala "": ""Mongala"", # note trailing space + }, + ""location"": { + ""Miti-muresa"": ""Miti-Murhesa"", + ""Ototi"": ""Ototo"", # Not sure which is correct, but Ototo is in lat-longs file from Eddy + # ""Yelenge"", - now included in lat-longs file + ""Lilanga"": ""Lilanga-Bobangi"", + ""Lilanga Bobangi"": ""Lilanga-Bobangi"", + ""Nyiragongo"": ""Nyirangongo"", + ""Bunyakiru"": ""Bunyakiri"", + ""Nyatende"": ""Nyantende"", + ""Nyagezi"": ""Nyangezi"", + ""Kalamu I"": ""Kalamu-I"", + ""Kalamu II"": ""Kalamu-II"", + ""Masina I"": ""Masina-I"", + ""Masina II"": ""Masina-II"", + ""Omendjadji"": ""Omendjadi"", + ""Police"": ""Kokolo"", # Eddy WhatsApp 2024-09-13. 24MPX2706V + ""NYIRAGONGO"": ""Nyirangongo"", + ""KARISIMBI"": ""Karisimbi"", + ""GOMA"": ""Goma"", + } +} + +# The following could be better provided via parsing the (S3) metadata here, but I want to keep this script isolated +# from the Snakemake workflow as much as possible +RECOMMENDED_COLUMNS = ['country', 'division', 'location'] + +def parse_args(): + parser = argparse.ArgumentParser( + description=""Parse metadata (xlsx format) and sequences (FASTA) for integration into our canonical mpox pipelines"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + parser.add_argument('--sequences', type=str, required=True, nargs='+', metavar='FASTA', help=""input sequences"") + parser.add_argument('--fasta-header-idx', type=int, + help='If FASTA headers are ""|"" separated, this index (1-based) is the accession') + parser.add_argument('--xlsx', type=str, required=True, help=""Metadata file (Excel .xlsx format)"") + parser.add_argument('--remap-columns', type=str, nargs='+', default=[], metavar='old:new', required=False, + help=""Change column names. Note all column names are converted to lower case."") + return parser.parse_args() + + +def convert(accession: str, k: str, v: Any) -> str: + if k==DATE_COLUMN: + # If we need to attempt to parse a string as a date see + # + assert type(v)==datetime, f""The provided {DATE_COLUMN!r} for {accession!r} must be encoded as a date within Excel"" + return f""{v.year}-{v.month:02}-{v.day:02}"" + return str(v) + + +def column_map(names: tuple[str], remap: list[tuple[str, str]]) -> list[tuple[str, str]]: + remap_idx_used = [] + columns = [] + for name in names: + # any matching renames / duplications? + changes = [(idx, name_map) for idx, name_map in enumerate(remap) if name_map[0]==name.lower()] + if len(changes): + for idx, name_map in changes: + remap_idx_used.append(idx) + columns.append((name, name_map[1])) + else: + columns.append((name, name.lower())) + + assert len(set([n[1] for n in columns]))==len(columns), ""Requested column names aren't unique!"" + + for i,name_map in enumerate(remap): + if i not in remap_idx_used: + print(f""WARNING: You asked to remap column {name_map[0]!r} but that column doesn't exist!"") + return columns + +def parse_excel(fname: str, remap: list[tuple[str, str]]) -> tuple[Metadata, MetadataHeader]: + workbook = load_workbook(filename=fname) + worksheet = workbook.active + n_rows = 0 + + rows = worksheet.values # type: ignore + assert rows is not None, f""The metadata file {fname!r} seemed to be empty!"" + + existing_column_names: tuple[str] = next(rows) # type: ignore + column_names = column_map(existing_column_names, remap) + + for name in REQUIRED_COLUMNS: + assert name in [c[1] for c in column_names], f""Metadata didn't have an {name!r} column (after column names were remapped)"" + for name in RECOMMENDED_COLUMNS: + if name not in [c[1] for c in column_names]: + print(f""Warning: Metadata didn't have an {name!r} column (after column names were remapped) which is recommended "") + + accession_idx = [c[1] for c in column_names].index(ACCESSION_COLUMN) + + metadata: Metadata = {} + for row in rows: + n_rows+=1 + accession = str(row[accession_idx]) + metadata[accession] = {new_name:convert(accession, new_name, row[existing_column_names.index(old_name)]) for old_name,new_name in column_names} + + print(f""Parsed {n_rows} metadata rows (excluding header) from xlsx file"") + return (metadata, [c[1] for c in column_names]) + + +def compare_ids(sequences: Sequences, metadata: Metadata) -> tuple[Sequences, Metadata]: + + acc_meta = set(list(metadata.keys())) + acc_seqs = set(list(sequences.keys())) + + meta_not_seqs = acc_meta - acc_seqs + seqs_not_meta = acc_seqs - acc_meta + + if meta_not_seqs: + print(f""WARNING! Metadata contained entries for {meta_not_seqs!r} but these are not present in the provided sequences and will be removed"") + metadata = {k:v for k,v in metadata.items() if k not in meta_not_seqs} + + if seqs_not_meta: + print(f""WARNING! Sequences provided for {seqs_not_meta!r} but there is no corresponding metadata. These will be removed"") + sequences = {k:v for k,v in sequences.items() if k not in seqs_not_meta} + + return (sequences, metadata) + +def read_lat_longs(): + """"""Adapted from augur.utils to avoid this script needing augur to be installed"""""" + coordinates = {} + # TODO: make parsing of tsv files more robust while allow for whitespace delimiting for backwards compatibility + def add_line_to_coordinates(line): + if line.startswith('#') or line.strip() == """": + return + fields = line.strip().split() if not '\t' in line else line.strip().split('\t') + if len(fields) == 4: + geo_field, loc = fields[0].lower(), fields[1].lower() + lat, long = float(fields[2]), float(fields[3]) + coordinates[(geo_field, loc)] = { + ""latitude"": lat, + ""longitude"": long + } + else: + print(""WARNING: geo-coordinate file contains invalid line. Please make sure not to mix tabs and spaces as delimiters (use only tabs):"",line) + with open(LAT_LONG_FNAME) as fh: + for line in fh: + add_line_to_coordinates(line) + return coordinates + + +def curate_metadata(metadata: Metadata) -> Metadata: + lat_longs = read_lat_longs() + logs = set() + errors = set() + + for resolution in [""division"", ""location""]: + for strain, data in metadata.items(): + original_deme = data[resolution] + if original_deme in GEOGRAPHIC_RENAMINGS[resolution]: + deme = GEOGRAPHIC_RENAMINGS[resolution][original_deme] + logs.add(f""\t'{strain}' {resolution} '{original_deme}' -> '{deme}'"") + data[resolution] = deme + + if (resolution, data[resolution].lower()) not in lat_longs: + errors.add(f""\t{resolution} {data[resolution]}"") + + if len(logs): + print(""\nThe following metadata changes were made:"") + for l in logs: + print(l) + if len(errors): + print(""\nERROR! The following geographic locations did not have associated lat-longs. "" + ""We cannot proceed until this is fixed. There are two potential ways to solve this: "" + ""\n(1) Within the phylogenetic/defaults/clade-i/lat_longs.tsv file we can add coordinates"" + ""\n(2) We can change the value in the metadata to match a lat-long which already exists in that file."" + ""\nHere are the problematic values:"" + ) + for l in errors: + print(l) + exit(2) + + return metadata + + +def parse_sequences(fnames: list[str], fasta_header_idx: int|None) -> Sequences: + sequences = {} + errors = False + seq_count = 0 + for fname in fnames: + for seq_record in SeqIO.parse(fname, ""fasta""): + seq_count+=1 + name = seq_record.id + if fasta_header_idx is not None: + try: + name = name.split('|')[fasta_header_idx-1] # convert 1-based to 0-based + except IndexError: + print(""Sequence name {name!r}, when split by '|', did not have enough fields"") + seq_record.id = name + seq_record.description = seq_record.id + if name in sequences: + print(f""ERROR - the sequence {name!r} (from {fname!r}) has already been seen!"") + errors = True + sequences[name] = seq_record + + assert errors is not True, ""Please remove those duplicate sequences!"" + print(f""Parsed {seq_count} sequences from FASTA file(s)"") + return sequences + +def fname_in_data_dir(fname: str) -> str: + # This assumes the folder structure used in mpox doesn't change... + data_dir = path.normpath(path.join(path.dirname(path.realpath(__file__)), "".."", "".."", ""data"")) + if not path.isdir(data_dir): + mkdir(data_dir) + return path.join(data_dir, fname) + +def write_sequences(sequences: Sequences) -> None: + fname = fname_in_data_dir(""sequences-private.fasta"") + print(f""Writing sequences to {fname}"") + SeqIO.write([x for x in sequences.values()], fname, ""fasta"") + +def write_metadata(metadata: Metadata, header: MetadataHeader) -> None: + fname = fname_in_data_dir(""metadata-private.tsv"") + print(f""Writing metadata to {fname}"") + with open(fname, ""w"", newline='') as fh: + writer = csv.DictWriter(fh, header, extrasaction='ignore', delimiter='\t', lineterminator='\n') + writer.writeheader() + for line in metadata.values(): + writer.writerow(line) + +def parse_remap_columns(arg: list[str]) -> list[tuple[str, str]]: + try: + return [(x[0].lower(),x[1].lower()) for x in [a.split(':') for a in arg]] + except: + print(""Error while parsing the remap-columns argument. Each entry must be two column names with a ':' between them."") + print(""For instance: \""--remap-columns 'collection date:date' 'province:division'\"""") + exit(2) + +if __name__==""__main__"": + args = parse_args() + print() + metadata, header = parse_excel(args.xlsx, parse_remap_columns(args.remap_columns)) + sequences = parse_sequences(args.sequences, args.fasta_header_idx) + sequences, metadata = compare_ids(sequences, metadata) + + metadata = curate_metadata(metadata) + + print() + write_sequences(sequences) + write_metadata(metadata, header) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/defaults/description.md",".md","5310","39","We gratefully acknowledge the authors, originating and submitting laboratories of the genetic sequences and metadata for sharing their work via INSDC or Pathoplexus. Please note that data from Pathoplexus comes with specific data use terms that need to be abided by. If data are shared under RESTRICTED terms, you can not use these data in publications without collaborating with the group that generated the data, please consult the [Data Use Terms of Pathoplexus](https://pathoplexus.org/about/terms-of-use/restricted-data) for details. Even if data are shared without restrictions, that does not mean there should be free license to publish on this data. Data generators should be cited where possible and collaborations should be sought in some circumstances. Please try to avoid scooping someone else's work. Reach out if uncertain. + +We maintain four views of mpox virus evolution: + +The first is [`mpox/lineage-B.1`](https://nextstrain.org/mpox/lineage-B.1), which focuses on lineage B.1 of the global outbreak that started in 2022 and includes around 5000 sequences. A few thousand sequences from the year 2022 collected in countries with high sequencing volume are excluded to keep the tree at a manageable size. Almost all near-complete B.1\* sequences from 2023 onwards are included. Here, we conduct a molecular clock analysis in which evolutionary rate is estimated from the data (with a resulting estimate of ~5 × 10-5 subs per site per year). + +The second is [`mpox/clade-IIb`](https://nextstrain.org/mpox/clade-IIb), which focuses on the entire sustained human-to-human outbreak that started in mid-2015 within clade IIb. A large proportion of good quality sequences that are not lineage B.1 are included, while lineage B.1 sequences are heavily subsampled to allow non-B.1 diversity to be studied. Here, we also conduct a molecular clock analysis in which evolutionary rate is estimated from the data (with a resulting estimate of ~6 × 10-5 subs per site per year). + +The third is [`mpox/all-clades`](https://nextstrain.org/mpox/all-clades), which focuses on broader viral diversity and includes viruses from the animal reservoir and previous human outbreaks, encompassing clades Ia, Ib, IIa and IIb as described in [Happi et al](https://doi.org/10.1371/journal.pbio.3001769) and endorsed by a [WHO convened consultation](https://worldhealthorganization.cmail20.com/t/ViewEmail/d/422BD62D623B6A3D2540EF23F30FEDED/F75AF81C90108C72B4B1B1F623478121?alternativeLink=False). + +The fourth is [`mpox/clade-I`](https://nextstrain.org/mpox/clade-I), which focuses on clade Ia and clade Ib sequences and includes all good quality, mostly-complete clade I sequences. In this analysis, reference alignment is done against a clade Ia sequence - in contrast to the other analyses which use a clade IIb reference. + +#### Analysis + +Our bioinformatic processing workflow can be found at [github.com/nextstrain/mpox](https://github.com/nextstrain/mpox) and includes: + +- sequence alignment by [Nextclade](https://docs.nextstrain.org/projects/nextclade/en/stable/user/nextclade-cli/index.html) +- masking several regions of the genome, including the first 1350 and last 6422 base pairs and multiple repetitive regions of variable length +- phylogenetic reconstruction using [IQTREE-2](http://www.iqtree.org/) +- ancestral state reconstruction and temporal inference using [TreeTime](https://github.com/neherlab/treetime) +- clade assignment via [clade definitions defined here](https://github.com/nextstrain/mpox/blob/-/phylogenetic/defaults/clades.tsv), to label broader MPXV clades I, IIa and IIb and to label hMPXV1 lineages A, A.1, A.1.1, etc. (defined by [mpxv-lineages/lineage-designation](https://github.com/mpxv-lineages/lineage-designation)) + +#### Underlying data + +We source sequence data and metadata from [Pathoplexus](https://pathoplexus.org) which ingests data from INSDC and provides data from INSDC together with data that were submitted directly to Pathoplexus. See our [ingest configuration file](https://github.com/nextstrain/mpox/blob/-/ingest/defaults/config.yaml). +Curated sequences and metadata under OPEN [data use terms](https://pathoplexus.org/about/terms-of-use/data-use-terms) are available as flat files at the links below. +If you are interested in the RESTRICTED USE data, we ask you to obtain those directly from Pathoplexus. + +- [data.nextstrain.org/files/workflows/mpox/sequences.fasta.zst](https://data.nextstrain.org/files/workflows/mpox/sequences.fasta.zst) +- [data.nextstrain.org/files/workflows/mpox/metadata.tsv.zst](https://data.nextstrain.org/files/workflows/mpox/metadata.tsv.zst) + +These files are updated regularly as new sequences become available. For reproducibility, please download and save your own copies of the data files you use in your analyses, as the file contents at these URLs will change over time. + +Archived data files from before the Pathoplexus transition (published 05 November 2025) are available at [data.nextstrain.org/files/workflows/mpox/archive/20251105/sequences.fasta.zst](https://data.nextstrain.org/files/workflows/mpox/archive/20251105/sequences.fasta.zst) etc. + +--- + +Screenshots may be used under a [CC-BY-4.0 license](https://creativecommons.org/licenses/by/4.0/) and attribution to nextstrain.org must be provided. +","Markdown" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/combine_data_sources.py",".py","4121","93","# TODO: with the release of `augur merge` this script should be replaced +# (it was written prior to `augur merge` existing, however it should be a drop-in replacement) + +from typing import Any +from Bio import SeqIO +import argparse +import csv + +Sequences = dict[str, SeqIO.SeqRecord] +Metadata = list[dict[str, Any]] +MetadataHeader = list[str] + +ACCESSION = 'accession' + +def parse_args(): + parser = argparse.ArgumentParser( + description=""Merge sequences and metadata. Duplicate sequences: last one used. Duplicate metadata: values are backfilled, in the case of conflicts the last seen is used."", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + parser.add_argument('--metadata', type=str, required=True, nargs='+', metavar='TSV', + help=""Input metadata files. If entries are specified as name=FILE then one-hot columns named 'source_{name}' will be added."") + parser.add_argument('--sequences', type=str, required=True, nargs='+', metavar='FASTA', help=""Input fasta sequences"") + parser.add_argument('--metadata-id-column', type=str, default=ACCESSION, help=""Metadata column to match with sequence name"") + parser.add_argument('--output-metadata', type=str, required=True, help=""output metadata"") + parser.add_argument('--output-sequences', type=str, required=True, help=""output sequences"") + return parser.parse_args() + +def parse_tsv(fname: str) -> Metadata: + source_name = None + assert list(fname).count('=')<=1, f""Too many '=' characters in argument {fname!r}"" + if '=' in fname: + source_name, fname = fname.split('=') + with open(fname, ""r"", newline='') as fh: + reader = csv.DictReader(fh, delimiter=""\t"") + metadata = [row for row in reader] + if source_name: + for row in metadata: + row[f""source_{source_name}""] = 'true' + return metadata + +def parse_sequences(fnames: list[str]) -> tuple[Sequences, set[str]]: + sequences = {} + for fname in fnames: + for seq_record in SeqIO.parse(fname, ""fasta""): + name = seq_record.id + seq_record.id = name + seq_record.description = seq_record.id + if name in sequences: + print(f""WARNING: the sequence {name!r} (from {fname!r}) has already been seen! Overwriting..."") + sequences[name] = seq_record + return sequences, set(list(sequences.keys())) + +def merge_meta(data: list[Metadata], id_col:str) -> tuple[Metadata, MetadataHeader]: + header: MetadataHeader = list(data[0][0].keys()) # first metadata file... + for metadata in data[1:]: + for col_name in list(metadata[0].keys()): + if col_name not in header: + header.append(col_name) + + row_by_id: dict[str, dict[str, Any]] = {} + for metadata in data: + for row in metadata: + assert id_col in row, f""ERROR: metadata file missing {id_col!r}"" + if row[id_col] in row_by_id: + print(f""Multiple entries for {row[id_col]} - merging!"") + master_row = row_by_id[row[id_col]] + for key,value in row.items(): + master_row[key] = value + else: + row_by_id[row[id_col]] = row + + return list(row_by_id.values()), header + +def write_sequences(fname: str, sequences: Sequences) -> None: + print(f""Writing sequences to {fname}"") + SeqIO.write([x for x in sequences.values()], fname, ""fasta"") + +def write_metadata(fname: str, metadata: Metadata, header: MetadataHeader) -> None: + print(f""Writing metadata to {fname}"") + with open(fname, ""w"", newline='') as fh: + writer = csv.DictWriter(fh, header, extrasaction='ignore', delimiter='\t', lineterminator='\n') + writer.writeheader() + for row in metadata: + writer.writerow(row) + +if __name__==""__main__"": + args = parse_args() + metadatas = [parse_tsv(f) for f in args.metadata] + sequences, sequence_names = parse_sequences(args.sequences) + metadata, header = merge_meta(metadatas, args.metadata_id_column) + write_sequences(args.output_sequences, sequences) + write_metadata(args.output_metadata, metadata, header) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/map_accessions.py",".py","7298","214","#!/usr/bin/env python3 +"""""" +Map INSDC accessions to PPX accessions using metadata. + +This script reads an accession list file (exclude.txt or include.txt) that contains +INSDC accessions and/or PPX accessions. INSDC accessions (versioned or unversioned) +are transformed to PPX accessions by looking up the mapping in the metadata file. +PPX accessions pass through unchanged. Comments and formatting are preserved. +"""""" + +import argparse +import pandas as pd +import sys +from pathlib import Path + + +def parse_args(): + parser = argparse.ArgumentParser( + description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter + ) + parser.add_argument( + '--input', + required=True, + help='Input accession list file (contains INSDC and/or PPX accessions)' + ) + parser.add_argument( + '--metadata', + required=True, + help='Metadata TSV file containing INSDC to PPX accession mapping' + ) + parser.add_argument( + '--output', + required=True, + help='Output accession list file (will contain PPX accessions)' + ) + parser.add_argument( + '--insdc-column', + default='INSDC_accession_version', + help='Column name for INSDC accessions in metadata (default: INSDC_accession_version)' + ) + parser.add_argument( + '--ppx-column', + default='PPX_accession', + help='Column name for PPX accessions in metadata (default: PPX_accession)' + ) + parser.add_argument( + '--warn-unmapped', + action='store_true', + help='Warn about accessions that cannot be mapped (default: silent)' + ) + return parser.parse_args() + + +def load_metadata(metadata_path, insdc_column, ppx_column): + """"""Load metadata and create INSDC -> PPX mapping dictionary and PPX accession set."""""" + try: + metadata = pd.read_csv(metadata_path, sep='\t', low_memory=False) + except Exception as e: + print(f""Error reading metadata file: {e}"", file=sys.stderr) + sys.exit(1) + + # Check required columns exist + if insdc_column not in metadata.columns: + print(f""Error: Column '{insdc_column}' not found in metadata"", file=sys.stderr) + print(f""Available columns: {', '.join(metadata.columns)}"", file=sys.stderr) + sys.exit(1) + + if ppx_column not in metadata.columns: + print(f""Error: Column '{ppx_column}' not found in metadata"", file=sys.stderr) + print(f""Available columns: {', '.join(metadata.columns)}"", file=sys.stderr) + sys.exit(1) + + # Create mapping dictionary for INSDC -> PPX + insdc_to_ppx = {} + # Create set of valid PPX accessions + valid_ppx = set() + + for _, row in metadata.iterrows(): + insdc = row[insdc_column] + ppx = row[ppx_column] + + # Skip rows where either value is NaN + if pd.notna(ppx): + ppx_str = str(ppx).strip() + valid_ppx.add(ppx_str) + + if pd.notna(insdc): + # Handle INSDC accessions with version numbers (e.g., ""AB123456.1"") + insdc_str = str(insdc).strip() + + # Map versioned INSDC accession to unversioned PPX + insdc_to_ppx[insdc_str] = ppx_str + + # Also map the base accession without version + if '.' in insdc_str: + base_accession = insdc_str.split('.')[0] + # Prefer versioned mapping, but add base if not present + if base_accession not in insdc_to_ppx: + insdc_to_ppx[base_accession] = ppx_str + + return insdc_to_ppx, valid_ppx + + +def map_accession_line(line, insdc_to_ppx, valid_ppx, warn_unmapped): + """""" + Map a single line from the accession list file. + + Preserves comments and blank lines. Maps INSDC accessions to PPX accessions. + PPX accessions pass through unchanged. + """""" + # Preserve blank lines + if not line.strip(): + return line + + # Check if line starts with comment + if line.strip().startswith('#'): + return line + + # Split line into accession and comment parts + parts = line.split('#', 1) + accession = parts[0].strip() + comment = f""#{parts[1]}"" if len(parts) > 1 else """" + + # If no accession on this line, return as-is + if not accession: + return line + + # Check if it's already a PPX accession - if so, pass through + if accession in valid_ppx: + return line + + # Try to map INSDC accession to PPX + if accession in insdc_to_ppx: + mapped_accession = insdc_to_ppx[accession] + # Preserve original formatting with tabs + if comment: + return f""{mapped_accession}\t{comment}\n"" + else: + return f""{mapped_accession}\n"" + else: + # Accession not found in mapping + if warn_unmapped: + print(f""Warning: Could not map accession '{accession}' (not found as INSDC or PPX)"", + file=sys.stderr) + + # Keep original accession with a note in comment + if comment: + return f""{accession}\t{comment} [unmapped]\n"" + else: + return f""{accession}\t# [unmapped - not found in metadata]\n"" + + +def main(): + args = parse_args() + + # Load metadata and create mapping + print(f""Loading metadata from {args.metadata}..."", file=sys.stderr) + insdc_to_ppx, valid_ppx = load_metadata(args.metadata, args.insdc_column, args.ppx_column) + print(f""Loaded {len(insdc_to_ppx)} INSDC -> PPX accession mappings"", file=sys.stderr) + print(f""Found {len(valid_ppx)} valid PPX accessions"", file=sys.stderr) + + # Read input file and transform + print(f""Reading input from {args.input}..."", file=sys.stderr) + try: + with open(args.input, 'r') as f: + input_lines = f.readlines() + except Exception as e: + print(f""Error reading input file: {e}"", file=sys.stderr) + sys.exit(1) + + # Map each line + output_lines = [] + mapped_count = 0 + passthrough_count = 0 + unmapped_count = 0 + + for line in input_lines: + original_line = line + mapped_line = map_accession_line(line, insdc_to_ppx, valid_ppx, args.warn_unmapped) + output_lines.append(mapped_line) + + # Track statistics + original_accession = original_line.split('#', 1)[0].strip() if original_line.strip() and not original_line.strip().startswith('#') else None + + if original_accession: + if '[unmapped]' in mapped_line: + unmapped_count += 1 + elif original_accession in valid_ppx: + passthrough_count += 1 + elif mapped_line != original_line: + mapped_count += 1 + + # Write output file + print(f""Writing output to {args.output}..."", file=sys.stderr) + try: + with open(args.output, 'w') as f: + f.writelines(output_lines) + except Exception as e: + print(f""Error writing output file: {e}"", file=sys.stderr) + sys.exit(1) + + # Print summary + print(f""Successfully mapped {mapped_count} INSDC accessions to PPX"", file=sys.stderr) + print(f""Passed through {passthrough_count} existing PPX accessions"", file=sys.stderr) + if unmapped_count > 0: + print(f""Warning: {unmapped_count} accessions could not be mapped"", file=sys.stderr) + + print(f""Done!"", file=sys.stderr) + + +if __name__ == '__main__': + main() +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/mutation_context.py",".py","2136","64","from collections import defaultdict +import json, argparse + + + + +if __name__==""__main__"": + parser = argparse.ArgumentParser( + description=""calculate mutation context json"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--tree', type=str, required=True, help=""tree file"") + parser.add_argument('--mutations', type=str, required=True, help=""mutations"") + parser.add_argument('--output', type=str, metavar=""JSON"", required=True, help=""output Auspice JSON"") + args = parser.parse_args() + + + with open(args.mutations) as fh: + data = json.load(fh)['nodes'] + + + terminal_muts = defaultdict(lambda: defaultdict(int)) + internal_muts = defaultdict(lambda: defaultdict(int)) + + node_data = {} + + for name, node in data.items(): + GA_count = 0 + CT_count = 0 + total_muts = 0 + for mut in node[""muts""]: + a, pos, d = mut[0], int(mut[1:-1]), mut[-1] + if a in 'ACGT' and d in 'ACGT': + total_muts += 1 + if a+d == 'GA': + GA_count += 1 + elif a+d == 'CT': + CT_count += 1 + GA_CT_count = GA_count + CT_count + if total_muts: + node_data[name] = {""GA_CT_fraction"": GA_CT_count/total_muts} + else: + node_data[name] = {""GA_CT_fraction"": None } + + + dinuc_count = 0 + if GA_CT_count: + #node_data[name][""CT_fraction""] = CT_count/GA_CT_count + for mut in node[""muts""]: + a, pos, d = mut[0], int(mut[1:-1]), mut[-1] + if a in 'ACGT' and d in 'ACGT': + if a+d == 'GA' and node['sequence'][pos]=='A': + dinuc_count+=1 + elif a+d == 'CT' and node['sequence'][pos-2]=='T': + dinuc_count+=1 + node_data[name][""dinuc_context_fraction""] = dinuc_count/GA_CT_count + else: + node_data[name][""dinuc_context_fraction""] = None + #node_data[name][""CT_fraction""] = None + + with open(args.output, 'w') as fh: + json.dump({""nodes"":node_data}, fh) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/reverse_reversed_sequences.py",".py","1209","30","import pandas as pd +import argparse +from Bio import SeqIO + +if __name__==""__main__"": + parser = argparse.ArgumentParser( + description=""Reverse-complement reverse-complemented sequence"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--metadata', type=str, required=True, help=""input metadata"") + parser.add_argument('--sequences', type=str, required=True, help=""input sequences"") + parser.add_argument('--output', type=str, required=True, help=""output sequences"") + args = parser.parse_args() + + metadata = pd.read_csv(args.metadata, sep='\t') + + # Read in fasta file + with open(args.sequences, 'r') as f_in: + with open(args.output, 'w') as f_out: + for seq in SeqIO.parse(f_in, 'fasta'): + # Check if metadata['reverse'] is True + if metadata.loc[metadata['accession'] == seq.id, 'is_reverse_complement'].values[0] == True: + # Reverse-complement sequence + seq.seq = seq.seq.reverse_complement() + print(""Reverse-complementing sequence:"", seq.id) + + # Write sequences to file + SeqIO.write(seq, f_out, 'fasta') +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/remove_timeinfo.py",".py","1533","51","import argparse +import json +from collections import defaultdict + + +def sample_date(node): + """""" + Returns the sample date in numeric form. + In the future, we could examine the 'raw_date' attr here to decide whether to ignore + some sequences, as 'numdate' is the inferred (timetree) date which can hide + uncertainty in actual sampling date, + """""" + if ""raw_date"" not in node: # internal node or tip with no date info + return + return node['numdate'] + + + +if __name__==""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--input-node-data', type=str, required=True, help=""input data"") + parser.add_argument('--output-node-data', type=str, metavar=""JSON"", required=True, help=""output Auspice JSON"") + args = parser.parse_args() + + + with open(args.input_node_data) as fh: + data = json.load(fh) + + new_node_data = {} + + for name, node in data[""nodes""].items(): + try: + new_node_data[name] = { + ""mutation_length"": node[""mutation_length""], + ""branch_length"": node[""branch_length""] + } + sdate = sample_date(node) + if sdate: + new_node_data[name][""sample_date""] = sdate + except KeyError: + # internal node or tip with no date info + pass + + data[""nodes""] = new_node_data + with open(args.output_node_data, 'w') as fh: + json.dump(data, fh) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/construct-recency-from-submission-date.py",".py","2041","56","import argparse +from datetime import datetime +from augur.io import read_metadata +import json + +## Script originally from https://github.com/nextstrain/ncov/blob/master/scripts/construct-recency-from-submission-date.py + +def get_recency(date_str, ref_date): + date_released = datetime.strptime(date_str, '%Y-%m-%d').toordinal() + ref_day = ref_date.toordinal() + + delta_days = ref_day - date_released + if delta_days<=0: + return 'New' + elif delta_days<3: + return '1-2 days ago' + elif delta_days<8: + return '3-7 days ago' + elif delta_days<15: + return 'One week ago' + elif delta_days<31: + return 'One month ago' + elif delta_days < 121: + return '1-3 months ago' + elif delta_days < 365: + return '3-12 months ago' + elif delta_days < 365*4: + return '1-3 years ago' + elif delta_days < 365*16: + return '3-15 years ago' + elif delta_days>=31: + return 'Older than 15 years' + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description=""Assign each sequence a field that specifies when it was added"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--metadata', type=str, required=True, help=""metadata file"") + parser.add_argument('--metadata-id-columns', nargs=""+"", help=""names of possible metadata columns containing identifier information, ordered by priority. Only one ID column will be inferred."") + parser.add_argument('--output', type=str, required=True, help=""output json"") + args = parser.parse_args() + + meta = read_metadata(args.metadata, id_columns=args.metadata_id_columns).to_dict(orient=""index"") + + node_data = {'nodes':{}} + ref_date = datetime.now() + + for strain, d in meta.items(): + if 'date_released' in d and d['date_released'] and d['date_released'] != ""undefined"": + node_data['nodes'][strain] = {'recency': get_recency(d['date_released'], ref_date)} + + with open(args.output, 'wt') as fh: + json.dump(node_data, fh) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/assign-colors.py",".py","3741","85","import argparse +import pdb +import pandas as pd + +# Forced colours MUST NOT appear in the ordering TSV +forced_colors = { +} + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description=""Assign colors based on ordering"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--ordering', type=str, required=True, help=""input ordering file"") + parser.add_argument('--color-schemes', type=str, required=True, help=""input color schemes file"") + parser.add_argument('--metadata', type=str, help=""if provided, restrict colors to only those found in metadata"") + parser.add_argument('--output', type=str, required=True, help=""output colors tsv"") + parser.add_argument('--ignore-categories', type=str, required=False, nargs='*', + help=""Do not create colors for these categories"") + args = parser.parse_args() + + assignment = {} + with open(args.ordering) as f: + for line in f.readlines(): + array = line.lstrip().rstrip().split(""\t"") + if len(array) == 2: + name = array[0] + trait = array[1] + if name in args.ignore_categories: + continue + if name not in assignment: + assignment[name] = [trait] + else: + assignment[name].append(trait) + + # if metadata supplied, go through and + # 1. remove assignments that don't exist in metadata + # 2. remove assignments that have 'focal' set to 'False' in metadata + if args.metadata: + metadata = pd.read_csv(args.metadata, delimiter='\t') + for name, trait in assignment.items(): + # Items not to exclude if not (yet) present in metadata to solve bootstrapping issue + if name in metadata and name not in ['clade_membership', 'outbreak', 'lineage']: + subset_present = [x for x in assignment[name] if x in metadata[name].unique()] + assignment[name] = subset_present + if name in metadata and 'focal' in metadata: + focal_list = metadata.loc[metadata['focal'] == True, name].unique() + subset_focal = [x for x in assignment[name] if x in focal_list] + assignment[name] = subset_focal + + schemes = {} + counter = 0 + with open(args.color_schemes) as f: + for line in f.readlines(): + counter += 1 + array = line.lstrip().rstrip().split(""\t"") + schemes[counter] = array + + with open(args.output, 'w') as f: + for trait_name, trait_array in assignment.items(): + if len(trait_array)==0: + print(f""No traits found for {trait_name}"") + continue + if len(schemes)0): + if (remain>len(schemes)): + color_array = [*color_array, *schemes[len(schemes)]] + remain -= len(schemes) + else: + color_array = [*color_array, *schemes[remain]] + remain = 0 + else: + color_array = schemes[len(trait_array)] + extra_trait_values = list(forced_colors.get(trait_name, {}).keys()) + extra_color_values = list(forced_colors.get(trait_name, {}).values()) + + zipped = list(zip(trait_array+extra_trait_values, color_array+extra_color_values)) + for trait_value, color in zipped: + f.write(trait_name + ""\t"" + trait_value + ""\t"" + color + ""\n"") + f.write(""\n"") +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/clades_renaming.py",".py","3101","84","import argparse +import json + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser( + description=""Split clade membership into clade, outbreak and lineage"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument(""--input-node-data"", type=str, required=True, help=""input data"") + parser.add_argument( + ""--output-node-data"", + type=str, + metavar=""JSON"", + required=True, + help=""output Auspice JSON"", + ) + parser.add_argument(""--outgroup-clade-name"", type=str, default=""outgroup"", help=""name for outgroup clade"") + args = parser.parse_args() + with open(args.input_node_data) as fh: + data = json.load(fh) + new_node_data = {} + for name, node in data[""nodes""].items(): + old_clade_name = node[""clade_membership""] + outbreak_name = """" + lineage_name = """" + + # if it starts with clade -> it's a clade + # if it starts with outbreak -> it's outbreak, need to look up clade + # if it starts with lineage -> it's clade IIb, outbreak sh2017 + if old_clade_name.startswith(""clade""): + clade_name = old_clade_name.split()[1] + match clade_name: + case ""Ib"": + outbreak_name = ""sh2023"" + case ""Ib/IIb"": + outbreak_name = ""rec2025"" + elif old_clade_name == ""sh2024"": + clade_name = ""Ia"" + outbreak_name = old_clade_name + elif old_clade_name == ""sh2017"": + clade_name = ""IIb"" + outbreak_name = old_clade_name + lineage_name = ""A"" + elif old_clade_name.startswith(args.outgroup_clade_name): + clade_name = args.outgroup_clade_name + elif old_clade_name.startswith(""outgroup""): + clade_name = ""outgroup"" + elif old_clade_name.startswith(""unassigned""): + clade_name = ""unassigned"" + else: + clade_name = ""IIb"" + outbreak_name = ""sh2017"" + lineage_name = old_clade_name + + new_node_data[name] = { + ""clade_membership"": clade_name, + ""outbreak"": outbreak_name, + ""lineage"": lineage_name, + } + + new_branch_labels = {} + + for name, node in data[""branches""].items(): + # Rename sh2017 -> sh2017/A + # Rename clade Ib -> clade IIb/outbreak sh2023 + if ""labels"" in node and ""clade"" in node[""labels""]: + + def make_label(label: str) -> dict: + return {""labels"": {""clade"": label}} + + match node[""labels""][""clade""]: + case ""sh2017"": + new_branch_labels[name] = make_label(""sh2017/A"") + case ""clade Ib"": + new_branch_labels[name] = make_label(""clade Ib/sh2023"") + case ""A"": + new_branch_labels[name] = make_label(""sh2017/A"") + case _: + new_branch_labels[name] = node + data[""branches""] = new_branch_labels + data[""nodes""] = new_node_data + with open(args.output_node_data, ""w"") as fh: + json.dump(data, fh) +","Python" +"Pathogens","nextstrain/mpox","phylogenetic/scripts/fix_tree.py",".py","7522","169","from collections import defaultdict +import argparse +from treetime import TreeAnc +from Bio import Phylo + +if __name__==""__main__"": + parser = argparse.ArgumentParser( + description=""remove time info"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--alignment', type=str, required=True, help=""input sequences"") + parser.add_argument('--input-tree', type=str, required=True, help=""input nwk"") + parser.add_argument('--root', type=str, required=False, help=""root node"") + parser.add_argument('--output', type=str, required=True, help=""output nwk"") + args = parser.parse_args() + + T = Phylo.read(args.input_tree, 'newick') + + if args.root: + T.root_with_outgroup(args.root) + else: + T.root_at_midpoint() + + tt = TreeAnc(tree=T, aln=args.alignment, gtr='JC69') + tt.optimize_tree(prune_short=True) + + # make list of mutations that are phylogenetically informative (not gaps of N) + for n in T.find_clades(): + n.relevant_mutations = set() + for mut in n.mutations: + if (mut[0] in 'ACGT') and (mut[2] in 'ACGT'): + n.relevant_mutations.add(mut) + + # Helper function to check if a node is a descendant of any node in a set + def is_descendant_of_any(node, ancestor_set, tree): + """"""Check if node is a descendant of any node in ancestor_set using tree paths"""""" + # Get the path from root to node + path = tree.get_path(node) + # Check if any ancestor is in the path + for ancestor in ancestor_set: + if ancestor in path: + return True + return False + + # Main iteration loop: fix reversions and merge homoplasies until nothing changes + max_iter = 5 + for ii in range(max_iter): + print(f""###\nIteration: {ii+1}\n"") + + changes_made = False + + # Step 1: Check for and fix immediate reversions + print(f""Checking for immediate reversions..."") + reversions = list() + for clade in T.find_clades(): + for child in clade.clades: + if child.is_terminal(): + continue + for grandchild in child.clades: + if grandchild.is_terminal(): + continue + # Check if one of grandchild mutation reverts one of child + for mut_child in child.relevant_mutations: + for mut_grandchild in grandchild.relevant_mutations: + if mut_child[1] == mut_grandchild[1] and mut_child[2] == mut_grandchild[0]: + reversions.append( + { + ""parent"": clade, + ""child"": child, + ""grandchild"": grandchild, + ""mut_child"": mut_child, + ""mut_grandchild"": mut_grandchild + } + ) + print(f"" Below {clade.name}: {mut_child} in {child.name} reverted in {grandchild.name}"") + + if reversions: + # Group reversions by unique (parent, child, grandchild) triple to avoid duplicate processing + reversion_groups = defaultdict(list) + for reversion in reversions: + key = (id(reversion[""parent""]), id(reversion[""child""]), id(reversion[""grandchild""])) + reversion_groups[key].append(reversion) + + # Track nodes that have been modified to avoid nested modifications within this iteration + touched_nodes = set() + + # Process each unique (parent, child, grandchild) triple only once, greedily + for key, rev_list in reversion_groups.items(): + # Use first reversion to get the nodes (all reversions in group have same nodes) + parent = rev_list[0][""parent""] + child = rev_list[0][""child""] + grandchild = rev_list[0][""grandchild""] + + # Skip if parent is a descendant of an already-touched node (avoid nested modifications) + if is_descendant_of_any(parent, touched_nodes, T): + print(f"" Skipping reversion at {parent.name} (descendant of already-touched node)"") + continue + + # Remove all reversion mutations from grandchild + for rev in rev_list: + if rev[""mut_grandchild""] in grandchild.relevant_mutations: + grandchild.relevant_mutations.remove(rev[""mut_grandchild""]) + + # Remove grandchild from child (only once) + if grandchild in child.clades: + child.clades.remove(grandchild) + + # Add grandchild to parent (only once) + if grandchild.relevant_mutations != parent.relevant_mutations: + parent.clades.append(grandchild) + else: + # Otherwise add grandchild clades to parent + parent.clades.extend(grandchild.clades) + + # Mark parent as touched to prevent nested modifications + touched_nodes.add(parent) + changes_made = True + + print(f"" Fixed {len(touched_nodes)} reversion groups"") + + # Step 2: Check for and merge homoplasies + print(f""Checking for homoplasies..."") + nodes_to_merge = defaultdict(list) + for n in T.get_nonterminals(): + shared_mutations = defaultdict(list) + for c in n: + for mut in c.relevant_mutations: + shared_mutations[mut].append(c) + + for mut in shared_mutations: + if len(shared_mutations[mut])>1: + nodes_to_merge[(n,tuple(shared_mutations[mut]))].append(mut) + + if nodes_to_merge: + already_touched = set() + for (parent, children), mutations in sorted(nodes_to_merge.items(), key=lambda x:len(x[1]), reverse=True): + if any([c in already_touched for c in children]): + continue + + print("" Merging clades:\n\t"", '\n\t'.join([f""{c.name} with mutations {c.relevant_mutations} and {c.count_terminals()} tips"" for c in children])) + print("" Shared mutations:"", mutations) + print() + + parent.clades = [c for c in parent if c not in children] + new_clade = Phylo.BaseTree.Clade(branch_length=tt.one_mutation*len(mutations)) + new_clade.relevant_mutations = set(mutations) + for c in children: + left_over_mutations = c.relevant_mutations.difference(mutations) + if len(left_over_mutations): + c.relevant_mutations = left_over_mutations + c.branch_length = tt.one_mutation*len(c.relevant_mutations) + new_clade.clades.append(c) + else: + new_clade.clades.extend(c.clades) + already_touched.add(c) + + parent.clades.append(new_clade) + changes_made = True + + print(f"" Merged {len(already_touched)} homoplasy groups"") + + # If no changes were made this iteration, stop + if not changes_made: + print(""No changes made in this iteration -- stopping."") + break + + Phylo.write(T, args.output, 'newick') +","Python" +"Pathogens","nextstrain/mpox","ingest/bin/reverse_reversed_sequences.py",".py","1195","30","import pandas as pd +import argparse +from Bio import SeqIO + +if __name__==""__main__"": + parser = argparse.ArgumentParser( + description=""Reverse-complement reverse-complemented sequence"", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument('--metadata', type=str, required=True, help=""input metadata"") + parser.add_argument('--sequences', type=str, required=True, help=""input sequences"") + parser.add_argument('--output', type=str, required=True, help=""output sequences"") + args = parser.parse_args() + + metadata = pd.read_csv(args.metadata, sep='\t') + + # Read in fasta file + with open(args.sequences, 'r') as f_in: + with open(args.output, 'w') as f_out: + for seq in SeqIO.parse(f_in, 'fasta'): + # Check if metadata['reverse'] is True + if metadata.loc[metadata['accession'] == seq.id, 'reverse'].values[0] == True: + # Reverse-complement sequence + seq.seq = seq.seq.reverse_complement() + print(""Reverse-complementing sequence:"", seq.id) + + # Write sequences to file + SeqIO.write(seq, f_out, 'fasta') +","Python" +"Pathogens","nextstrain/mpox","ingest/scripts/find_null_metadata_fields.sh",".sh","647","27","#!/usr/bin/env bash +# +# Find metadata fields that are null across all records in Pathoplexus data +# +# Usage: ./scripts/find_null_metadata_fields.sh results/ppx.ndjson.zst +# + +set -euo pipefail + +input_file=""${1:-results/ppx.ndjson.zst}"" + +echo ""Analyzing metadata fields in: $input_file"" >&2 +echo ""This may take a moment..."" >&2 +echo """" >&2 + +zstdcat ""$input_file"" | jq -s ' + # Collect all keys that have non-null values across all records + map(.metadata | to_entries) | + flatten | + group_by(.key) | + map({key: .[0].key, hasNonNull: any(.value != null)}) | + map(select(.hasNonNull == false) | .key) +' | jq -r '.[]' + +echo """" >&2 +echo ""Done!"" >&2 +","Shell" +"Pathogens","nextstrain/mpox","ingest/scripts/generate_continent.py",".py","9970","232","#!/usr/bin/env python3 +"""""" +Add continent information to NDJSON records based on country. +"""""" +import argparse +import json +import sys + +import zstandard as zstd + +# Continent to countries mapping +# Based on Pathoplexus country list (https://github.com/pathoplexus/pathoplexus/blob/main/loculus_values/values.yaml) +CONTINENT_COUNTRIES = { + ""Africa"": [ + ""Algeria"", ""Angola"", ""Bassas da India"", ""Belgian Congo"", ""Benin"", ""Botswana"", + ""Burkina Faso"", ""Burundi"", ""Cameroon"", ""Cape Verde"", ""Central African Republic"", + ""Chad"", ""Comoros"", ""Congo"", ""Cote d'Ivoire"", ""Democratic Republic of the Congo"", + ""Djibouti"", ""Egypt"", ""Equatorial Guinea"", ""Eritrea"", ""Eswatini"", ""Ethiopia"", + ""Europa Island"", ""Gabon"", ""Gambia"", ""Ghana"", ""Glorioso Islands"", ""Guinea"", + ""Guinea-Bissau"", ""Juan de Nova Island"", ""Kenya"", ""Lesotho"", ""Liberia"", ""Libya"", + ""Madagascar"", ""Malawi"", ""Mali"", ""Mauritania"", ""Mauritius"", ""Mayotte"", ""Morocco"", + ""Mozambique"", ""Namibia"", ""Niger"", ""Nigeria"", ""Republic of the Congo"", ""Reunion"", + ""Rwanda"", ""Sao Tome and Principe"", ""Senegal"", ""Seychelles"", ""Sierra Leone"", + ""Somalia"", ""South Africa"", ""South Sudan"", ""Sudan"", ""Swaziland"", ""Tanzania"", + ""Togo"", ""Tromelin Island"", ""Tunisia"", ""Uganda"", ""Western Sahara"", ""Zaire"", + ""Zambia"", ""Zimbabwe"", + ], + ""Asia"": [ + ""Afghanistan"", ""Armenia"", ""Azerbaijan"", ""Bahrain"", ""Bangladesh"", ""Bhutan"", + ""Brunei"", ""Burma"", ""Cambodia"", ""China"", ""Christmas Island"", ""Cocos Islands"", + ""East Timor"", ""Gaza Strip"", ""Georgia"", ""Hong Kong"", ""India"", ""Indonesia"", + ""Iran"", ""Iraq"", ""Israel"", ""Japan"", ""Jordan"", ""Kazakhstan"", ""Korea"", ""Kuwait"", + ""Kyrgyzstan"", ""Laos"", ""Lebanon"", ""Macau"", ""Malaysia"", ""Maldives"", ""Mongolia"", + ""Myanmar"", ""Nepal"", ""North Korea"", ""Oman"", ""Pakistan"", ""Palestine"", + ""Palestinian Territory"", ""Paracel Islands"", ""Philippines"", ""Qatar"", + ""Saudi Arabia"", ""Singapore"", ""South Korea"", ""Spratly Islands"", ""Sri Lanka"", + ""State of Palestine"", ""Syria"", ""Taiwan"", ""Tajikistan"", ""Thailand"", + ""Timor-Leste"", ""Turkey"", ""Turkmenistan"", ""United Arab Emirates"", ""Uzbekistan"", + ""Viet Nam"", ""West Bank"", ""Yemen"", + ], + ""Europe"": [ + ""Albania"", ""Andorra"", ""Austria"", ""Belarus"", ""Belgium"", ""Bosnia and Herzegovina"", + ""Bulgaria"", ""Croatia"", ""Cyprus"", ""Czech Republic"", ""Czechia"", ""Czechoslovakia"", + ""Denmark"", ""Estonia"", ""Faroe Islands"", ""Finland"", ""France"", ""Germany"", + ""Gibraltar"", ""Greece"", ""Guernsey"", ""Hungary"", ""Iceland"", ""Ireland"", + ""Isle of Man"", ""Italy"", ""Jan Mayen"", ""Jersey"", ""Kosovo"", ""Latvia"", + ""Liechtenstein"", ""Lithuania"", ""Luxembourg"", ""Macedonia"", ""Malta"", ""Moldova"", + ""Monaco"", ""Montenegro"", ""Netherlands"", ""North Macedonia"", ""Norway"", ""Poland"", + ""Portugal"", ""Romania"", ""Russia"", ""San Marino"", ""Serbia"", ""Serbia and Montenegro"", + ""Slovakia"", ""Slovenia"", ""Spain"", ""Svalbard"", ""Sweden"", ""Switzerland"", + ""The former Yugoslav Republic of Macedonia"", ""Ukraine"", ""United Kingdom"", + ""USSR"", ""Yugoslavia"", + ], + ""North America"": [ + ""Anguilla"", ""Antigua and Barbuda"", ""Aruba"", ""Bahamas"", ""Barbados"", ""Belize"", + ""Bermuda"", ""British Virgin Islands"", ""Canada"", ""Cayman Islands"", + ""Clipperton Island"", ""Costa Rica"", ""Cuba"", ""Curacao"", ""Dominica"", + ""Dominican Republic"", ""El Salvador"", ""Greenland"", ""Grenada"", ""Guadeloupe"", + ""Guatemala"", ""Haiti"", ""Honduras"", ""Jamaica"", ""Martinique"", ""Mexico"", + ""Montserrat"", ""Nicaragua"", ""Panama"", ""Puerto Rico"", ""Saint Barthelemy"", + ""Saint Kitts and Nevis"", ""Saint Lucia"", ""Saint Martin"", ""Saint Pierre and Miquelon"", + ""Saint Vincent and the Grenadines"", ""Sint Maarten"", ""Trinidad and Tobago"", + ""Turks and Caicos Islands"", ""USA"", ""Virgin Islands"", + ], + ""South America"": [ + ""Argentina"", ""Bolivia"", ""Brazil"", ""British Guiana"", ""Chile"", ""Colombia"", + ""Ecuador"", ""Falkland Islands (Islas Malvinas)"", ""French Guiana"", ""Guyana"", + ""Paraguay"", ""Peru"", ""South Georgia and the South Sandwich Islands"", ""Suriname"", + ""Uruguay"", ""Venezuela"", + ], + ""Oceania"": [ + ""American Samoa"", ""Ashmore and Cartier Islands"", ""Australia"", ""Baker Island"", + ""Borneo"", ""Cook Islands"", ""Coral Sea Islands"", ""Fiji"", ""French Polynesia"", + ""Guam"", ""Heard Island and McDonald Islands"", ""Howland Island"", ""Jarvis Island"", + ""Johnston Atoll"", ""Kerguelen Archipelago"", ""Kingman Reef"", ""Kiribati"", + ""Line Islands"", ""Marshall Islands"", ""Micronesia"", ""Micronesia, Federated States of"", + ""Midway Islands"", ""Nauru"", ""Navassa Island"", ""New Caledonia"", ""New Zealand"", + ""Niue"", ""Norfolk Island"", ""Northern Mariana Islands"", ""Palau"", ""Palmyra Atoll"", + ""Papua New Guinea"", ""Pitcairn Islands"", ""Samoa"", ""Solomon Islands"", ""Tokelau"", + ""Tonga"", ""Tuvalu"", ""Vanuatu"", ""Wake Island"", ""Wallis and Futuna"", + ], + ""Antarctica"": [ + ""Antarctica"", ""Bouvet Island"", ""French Southern and Antarctic Lands"", + ], +} + +# Special cases: oceans, seas, and other non-country locations (mapped to None) +SPECIAL_LOCATIONS = [ + ""Arctic Ocean"", ""Atlantic Ocean"", ""Baltic Sea"", ""Indian Ocean"", + ""Mediterranean Sea"", ""North Sea"", ""Pacific Ocean"", ""Ross Sea"", + ""Southern Ocean"", ""Tasman Sea"", + # Also handle missing/unknown + ""missing"", +] + +# Build reverse lookup dict for fast lookups +COUNTRY_TO_CONTINENT = {} +for continent, countries in CONTINENT_COUNTRIES.items(): + for country in countries: + COUNTRY_TO_CONTINENT[country] = continent + +# Add special locations with None as continent +for location in SPECIAL_LOCATIONS: + COUNTRY_TO_CONTINENT[location] = None + + +def get_continent(country): + """""" + Get continent for a country. + + Args: + country: Country name string + + Returns: + Continent name or None if country not found or is a special location (ocean, etc.) + """""" + if not country: + return None + + # Direct lookup (includes explicit None for special locations) + if country in COUNTRY_TO_CONTINENT: + return COUNTRY_TO_CONTINENT[country] + + # Try case-insensitive lookup + country_lower = country.lower() + for known_country, cont in COUNTRY_TO_CONTINENT.items(): + if known_country.lower() == country_lower: + return cont + + # Country not found - print warning to stderr but continue processing + print(f""Warning: Unknown country '{country}'"", file=sys.stderr) + return None + + +def process_records(input_file, output_file): + """""" + Read NDJSON, add continent field, write output. + + Args: + input_file: Path to input .ndjson.zst file + output_file: Path to output .ndjson.zst file + """""" + dctx = zstd.ZstdDecompressor() + cctx = zstd.ZstdCompressor() + + with open(input_file, 'rb') as ifh, open(output_file, 'wb') as ofh: + with dctx.stream_reader(ifh) as reader, cctx.stream_writer(ofh) as writer: + # Stream in chunks and process line by line + buffer = b'' + chunk_size = 1024 * 1024 # 1MB chunks + + while True: + chunk = reader.read(chunk_size) + if not chunk: + break + + buffer += chunk + + # Process complete lines + while b'\n' in buffer: + line_bytes, buffer = buffer.split(b'\n', 1) + line = line_bytes.decode('utf-8').strip() + + if not line: + continue + + record = json.loads(line) + + # Add continent field based on country + country = record.get('geoLocCountry') + continent = get_continent(country) + record['geoLocContinent'] = continent + + # Replace `null` values with empty strings + # `augur curate` doesn't like nulls + # Also replace newlines in string values to prevent TSV corruption + for key, value in record.items(): + if value is None: + record[key] = """" + elif isinstance(value, str) and '\n' in value: + record[key] = value.replace('\n', ' ').replace('\r', '') + + # Replace Viet Nam with Vietnam + if record.get('geoLocCountry') == ""Viet Nam"": + record['geoLocCountry'] = ""Vietnam"" + + # Write modified record + output_line = json.dumps(record) + '\n' + writer.write(output_line.encode('utf-8')) + + # Process any remaining data in buffer + if buffer.strip(): + line = buffer.decode('utf-8').strip() + record = json.loads(line) + country = record.get('geoLocCountry') + continent = get_continent(country) + record['geoLocContinent'] = continent + + # Replace `null` values with empty strings and strip newlines + for key, value in record.items(): + if value is None: + record[key] = """" + elif isinstance(value, str) and '\n' in value: + record[key] = value.replace('\n', ' ').replace('\r', '') + + output_line = json.dumps(record) + '\n' + writer.write(output_line.encode('utf-8')) + + +def main(): + parser = argparse.ArgumentParser( + description=""Add continent field to NDJSON records based on country"" + ) + parser.add_argument( + '--input', + required=True, + help='Input NDJSON file (compressed with zstd)' + ) + parser.add_argument( + '--output', + required=True, + help='Output NDJSON file (compressed with zstd)' + ) + + args = parser.parse_args() + + process_records(args.input, args.output) + + +if __name__ == '__main__': + main() +","Python" +"Pathogens","nextstrain/mpox","ingest/scripts/curate-urls.py",".py","2107","55","""""""custom curate script to add URLs"""""" +import argparse +import sys +from typing import Iterable + +from augur.curate import validate_records +from augur.io.json import dump_ndjson, load_ndjson + + +def run(args: argparse.Namespace, records: Iterable[dict]) -> Iterable[dict]: + + for index, record in enumerate(records): + record = record.copy() + + ppx_accession = record.get('PPX_accession', None) # unversioned + ppx_accession_version = record.get('PPX_accession_version', None) # versioned + insdc_accession_version = record.get('INSDC_accession_version', None) # versioned + group_id = record.get('Pathoplexus_group_id', None) + + # Add INSDC_accession__url and PPX_accession__url fields to NDJSON records + record['PPX_accession__url'] = f""https://pathoplexus.org/seq/{ppx_accession}"" \ + if ppx_accession \ + else """" + record['PPX_accession_version__url'] = f""https://pathoplexus.org/seq/{ppx_accession_version}"" \ + if ppx_accession_version \ + else """" + record['INSDC_accession_version__url'] = f""https://www.ncbi.nlm.nih.gov/nuccore/{insdc_accession_version}"" \ + if insdc_accession_version \ + else """" + record['Pathoplexus_group__url'] = f""https://pathoplexus.org/group/{group_id}"" \ + if group_id \ + else """" + record['submission_database'] = ""INSDC"" if str(group_id) == ""1"" else ""Pathoplexus"" + + yield record + + +if __name__ == ""__main__"": + docstring = __annotations__.get(""__doc__"", """") + parser = argparse.ArgumentParser(description=docstring) + args = parser.parse_args() + + records = load_ndjson(sys.stdin) + + # Validate records have the same input fields + validated_input_records = validate_records(records, docstring, True) + + # Run this custom curate command to get modified records + modified_records = run(args, validated_input_records) + + # Validate modified records have the same output fields + validated_output_records = validate_records(modified_records, docstring, False) + + dump_ndjson(validated_output_records) +","Python" +"Pathogens","nextstrain/cli","setup.py",".py","6367","172","from setuptools import setup, find_packages +from pathlib import Path + +base_dir = Path(__file__).parent.resolve() +version_file = base_dir / ""nextstrain/cli/__version__.py"" +readme_file = base_dir / ""README.md"" + +# Eval the version file to get __version__; avoids importing our own package +with version_file.open() as f: + exec(f.read()) + +# Get the long description from the README file +with readme_file.open(encoding = ""utf-8"") as f: + long_description = f.read() + +# Nextstrain is a ""namespace"" package, which is supported natively in Python 3 +# but not supported by find_packages(). A namespace package is a) shareable by +# several subpackages and b) is defined by the lack of an __init__.py. The +# actual concrete packages in this distribution are nextstrain.cli, +# nextstrain.cli.command, etc. Although find_packages() doesn't support +# namespace packages (it won't look within them), we can use find_packages() by +# looking past the namespace and then adding the namespace prefix back. +def find_namespaced_packages(namespace): + return [ + ""%s.%s"" % (namespace, pkg) + for pkg in find_packages(namespace.replace(""."", ""/"")) + ] + +setup( + name = ""nextstrain-cli"", + version = __version__, # noqa: F821 + packages = find_namespaced_packages(""nextstrain""), + package_data = { + ""nextstrain.cli.resources"": [ + ""bashrc"", + ""schema-pathogen-v0.json"", + ], + }, + + description = ""Nextstrain command-line tool"", + long_description = long_description, + long_description_content_type = ""text/markdown"", + + author = ""Thomas Sibley"", + author_email = ""tsibley@fredhutch.org"", + + license = ""MIT"", + + url = ""https://docs.nextstrain.org/projects/cli/"", + project_urls = { + ""Bug Reports"": ""https://github.com/nextstrain/cli/issues"", + ""Change Log"": ""https://github.com/nextstrain/cli/blob/master/CHANGES.md"", + ""Source"": ""https://github.com/nextstrain/cli"", + }, + + classifiers = [ + # Stable now + ""Development Status :: 5 - Production/Stable"", + + # This is a CLI + ""Environment :: Console"", + + # This is for bioinformatic software devs and researchers + ""Intended Audience :: Developers"", + ""Intended Audience :: Science/Research"", + ""Topic :: Software Development :: Build Tools"", + ""Topic :: Scientific/Engineering :: Bio-Informatics"", + + # License + ""License :: OSI Approved :: MIT License"", + + # Python 3 only + ""Programming Language :: Python :: 3"", + ""Programming Language :: Python :: 3.8"", + ""Programming Language :: Python :: 3.9"", + ""Programming Language :: Python :: 3.10"", + ""Programming Language :: Python :: 3.11"", + ""Programming Language :: Python :: 3.12"", + ""Programming Language :: Python :: 3.13"", + ], + + # Install a ""nextstrain"" program which calls nextstrain.cli.__main__.main() + # https://setuptools.readthedocs.io/en/latest/setuptools.html#automatic-script-creation + entry_points = { + ""console_scripts"": [ + ""nextstrain = nextstrain.cli.__main__:main"", + ], + }, + + python_requires = '>=3.8', + + install_requires = [ + ""certifi"", + ""docutils"", + ""fasteners"", + ""importlib_resources >=5.3.0; python_version < '3.11'"", + ""jsonschema >=4"", # for draft 2020-12 support + ""packaging"", + ""pyjwt[crypto] >=2.0.0"", + ""pyparsing >=3.0.0"", + ""pyyaml >=5.3.1"", + ""requests"", + ""typing_extensions >=3.7.4"", + ""wcmatch >=6.0"", + ""wrapt"", + + # We use fsspec's S3 support, which has a runtime dep on s3fs. s3fs + # itself requires aiobotocore, which in turn requires very specific + # versions of botocore (because aiobotocore is a giant monkey-patch). + # + # We also use boto3, which also requires botocore, usually with minimum + # versions closely matching the boto3 version (they're released in near + # lock step). + # + # If we declare a dep on boto3 directly, this leads to conflicts during + # dependency resolution when a newer boto3 (from our declaration here) + # requires a newer botocore than is supported by s3fs → aiobotocore's + # declarations. + # + # Resolve the issue by using a specially-provided package extra from + # s3fs (first introduced with 2021.4.0, removed in 2025.12.0) which + # causes them to declare an explicit dependency on aiobotocore's + # specially-provided package extra on boto3 so that dependency resolver + # can figure it out properly. + # + # Note that the upper limit is not future-proof and will likely cause + # issues down the road. There may be a better combination to use here, + # but that needs extra digging. + # + # More background: + # + # + # + # + # What a mess. + # + # Avoiding 2023.9.1 due to change in `auto_mkdir` parameter in + # https://github.com/fsspec/filesystem_spec/pull/1358 that causes the + # error described in https://github.com/fsspec/s3fs/issues/790 + ""fsspec !=2023.9.1"", + ""s3fs[boto3] >=2021.04.0, !=2023.9.1, <2025.12.0"", + + # From 2.0.0 onwards, urllib3 is better typed, but not usable (given + # our dep tree) on 3.8 and 3.9 so we use types-urllib3 there (see + # below). + ""urllib3 >=2.0.0; python_version >= '3.10'"", + ], + + extras_require = { + ""dev"": [ + ""cram >=0.7"", + ""flake8 >=4.0.0"", + ""myst-parser"", + ""nextstrain-sphinx-theme>=2022.5"", + ""pytest; python_version != '3.9'"", + ""pytest !=7.0.0; python_version == '3.9'"", + ""pytest-forked"", + ""sphinx>=3"", + ""sphinx-autobuild"", + ""sphinx-markdown-tables !=0.0.16"", + ""sphinx_rtd_theme"", + ""types-boto3"", + ""types-boto3-s3"", + ""types-botocore"", + + # Only necessary for urllib3 <2.0.0, which we only have to use on + # Python 3.8 and 3.9. + ""types-urllib3; python_version < '3.10'"" + ], + }, +) +","Python" +"Pathogens","nextstrain/cli","CHANGES.md",".md","120445","2943","This is the changelog for Nextstrain CLI. All notable changes in a release +will be documented in this file. + +This changelog is intended for _humans_ and follows many of the principles from +[Keep a Changelog](https://keepachangelog.com/en/1.0.0/). + +Versions for this project follow the [Semantic Versioning +rules](https://semver.org/spec/v2.0.0.html). Each heading below is a version +released to [PyPI](https://pypi.org/project/nextstrain-cli/) and the date it +was released. The ""__NEXT__"" heading below describes changes in the unreleased +development source code and as such may not be routinely kept up to date. + + +# __NEXT__ + + +# 10.4.2 (7 January 2026) + +## Improvements + +* We now produce standalone installation archives for Linux running on aarch64 + hardware (aka arm64). The standalone installer will use these archives + starting with this release. + ([#489](https://github.com/nextstrain/cli/pull/489), + [#490](https://github.com/nextstrain/cli/pull/490)) + +## Bug fixes + +* Updated the s3fs dependency to avoid versions starting with 2025.12.0. This + maintains a dependency on `boto3` which is used for various commands. + ([#495](https://github.com/nextstrain/cli/pull/495)) + +# 10.4.1 (14 October 2025) + +## Bug fixes + +* The dependency on `types-boto3-s3` is now development-only (the `dev` extra). + This eases Conda packaging and is consistent with dev-only dependencies on + other type definition packages. + ([#485](https://github.com/nextstrain/cli/pull/485)) + + +# 10.4.0 (13 October 2025) + +## Improvements + +* `nextstrain run` now resolves workflow names by looking in the pathogen + registration (`nextstrain-pathogen.yaml`) for an explicitly registered path. + If no path is registered for a workflow, `nextstrain run` still falls back to + using the workflow name for the workflow path. + + This allows for workflow names that are not also directory paths within the + pathogen source, which is useful for pathogens that are structured + non-conventionally for one reason or another. The decoupling of workflow + names from paths also means that the workflow can be relocated within the + pathogen repo without breaking the name (i.e. the external interface to the + workflow). + + As an example, the following workflow registration: + + ```yaml + workflows: + phylogenetic: + path: . + compatibility: + nextstrain run: yes + ``` + + would allow invocation of a `phylogenetic` workflow located at the top-level + of the pathogen source, such as in [zika-tutorial](https://github.com/nextstrain/zika-tutorial). + ([#481](https://github.com/nextstrain/cli/pull/481)) + +* Pathogen registration files (`nextstrain-pathogen.yaml`) now have a formal + schema, , and registrations will + be validated against the schema if they declare so with `$schema`. + + Unknown `$schema` ids are ignored. Validation errors will cause the pathogen + registration file to be ignored (as if it didn't exist). + + Malformed registration files are warned about during the initial pathogen + setup with `nextstrain setup` and during subsequent pathogen version updates + with `nextstrain update`, but not when using an existing pathogen setup with + `nextstrain run` (so as not to be too noisy). + ([#482](https://github.com/nextstrain/cli/pull/482)) + +* The AWS Batch runtime now supports storing workdir and envdir archives in S3 + under a key prefix. This optional key prefix is provided after the bucket + name in the [`--aws-batch-s3-bucket` option][] or the equivalent + [`aws-batch.s3-bucket` config field][] or [`NEXTSTRAIN_AWS_BATCH_S3_BUCKET` + environment variable][]. For example, providing + + --aws-batch-s3-bucket=some-bucket/a/prefix/ + + would result in workdir archives stored at + + s3://some-bucket/a/prefix/6116f3e3-9bc0-4769-99e3-adb71b4d82c0.zip + + For extra clarity, particularly when providing a prefix, the value may now be + specified as a URL (e.g. `s3://some-bucket/a/prefix` or + `s3://another-bucket`), though, for backwards compatibility, doing so is not + required. A key prefix may be useful for the organization of the objects in + a bucket, particularly when the bucket is accessed directly, outside of + Nextstrain CLI. + ([#483](https://github.com/nextstrain/cli/pull/483)) + +[`--aws-batch-s3-bucket` option]: https://docs.nextstrain.org/projects/cli/en/10.4.0/commands/build/#cmdoption-nextstrain-build-aws-batch-s3-bucket +[`aws-batch.s3-bucket` config field]: https://docs.nextstrain.org/projects/cli/en/10.4.0/runtimes/aws-batch/#term-aws-batch.s3-bucket +[`NEXTSTRAIN_AWS_BATCH_S3_BUCKET` environment variable]: https://docs.nextstrain.org/projects/cli/en/10.4.0/runtimes/aws-batch/#envvar-NEXTSTRAIN_AWS_BATCH_S3_BUCKET + +## Bug fixes + +* The AWS configuration for S3 operations for the AWS Batch runtime no longer + sets 3 as the max number of attempts for retries. To explicitly control + [retries](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/retries.html) + yourself, use AWS' own support + via [config files](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/configuration.html#using-a-configuration-file) + (`max_attempts`) + and [environment variables](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/configuration.html#using-environment-variables) + (`AWS_MAX_ATTEMPTS`). The previous configuration precluded the use these AWS + config files and env vars to control max attempts. Note that 3 attempts is + already the AWS default, so no behaviour change is expected and no action is + needed during upgrade. + ([#483](https://github.com/nextstrain/cli/pull/483)) + + +# 10.3.0 (26 September 2025) + +This release adds explicit (i.e. tested) support for Python version 3.13. +([#473](https://github.com/nextstrain/cli/pull/473)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/10.3.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +## Improvements + +* `nextstrain setup ` and `nextstrain version --pathogens` now list + the available workflows (e.g. `ingest`, `phylogenetic`) for a pathogen if the + workflows are registered as compatible with `nextstrain run` in the + pathogen's `nextstrain-pathogen.yaml` file. + ([#461](https://github.com/nextstrain/cli/pull/461), [#472](https://github.com/nextstrain/cli/pull/472)) + +* Snakemake's storage support downloaded files (stored in `.snakemake/storage/`) + are now downloaded from AWS Batch builds by default. + + The runtime image used must be at least `nextstrain/base:build-20250721T201347Z` + for these Snakemake storage files to be available for download from the AWS + Batch job. + ([#460](https://github.com/nextstrain/cli/pull/460)) + +* `nextstrain run` now supports an alternative invocation where a path to a + local directory that is a pathogen repository can be given instead of a + pathogen name (and optionally version). This allows `nextstrain run` to be + used with pathogen repos managed outside of Nextstrain CLI (i.e. not by + `nextstrain setup` and `nextstrain update`), which can be useful for the + analysis directory support and local testing. The workflow to run is still + given separately by name (not path). + ([#476](https://github.com/nextstrain/cli/issues/476)) + +* When `nextstrain setup ` and `nextstrain update ` + encounter an authentication error downloading from pathogen source URLs, the + error message now includes a hint, if applicable, noting the presence of + netrc-provided credentials and possible resolutions. This aids in resolving + errors arising from stale GitHub credentials present in some users' netrc + files (as managed by older versions of the GitHub CLI, `gh`). + ([#479](https://github.com/nextstrain/cli/issues/479)) + +* When Nextstrain CLI detects that a new version of itself is available, it + will now output the instructions on how to upgrade to that new version after + (instead of before) the normal output from the running command. This makes + it easier to find and follow the instructions when output is long. The + notices of the new version will be output both before and after normal + output. + ([#475](https://github.com/nextstrain/cli/issues/475)) + +* For most installation methods (i.e. standalone, Pip, pipx, and Conda), the + process of updating Nextstrain CLI itself is now automated by a single + `nextstrain update cli` command. This is suggested in new version notices + emitted by automatic new version checks (along with the previously-suggested + update commands that vary by installation method). Integrating with + `nextstrain update` puts updates to the CLI alongside updates to the runtimes + and pathogens. + ([#475](https://github.com/nextstrain/cli/issues/475)) + +## Bug fixes + +* `nextstrain setup @` and `nextstrain update @` + no longer result in a 404 error if `` includes a slash and it is a + valid version specifier. ([#459](https://github.com/nextstrain/cli/pull/459)) + +* Reverting changes made in 10.2.1, `nextstrain setup ` and + `nextstrain update ` will once again attempt to use a local netrc + file for authentication when downloading pathogen source URLs. This also + reinstates support in those cases for configuring outgoing network proxies + and CA certificate trust stores via environment variables. Support for + private repositories is not unintentional and is something we intend to + provide. + ([#478](https://github.com/nextstrain/cli/issues/478)) + +* `nextstrain run` now overrides (i.e. suppresses) any [""workdir:"" + directives](https://snakemake.readthedocs.io/en/stable/snakefiles/configuration.html) + in a workflow by explicitly setting the working directory when it invokes + Snakemake. This avoids writing files into the pathogen/workflow source + directories when non-compatible (or broken) workflows are used with + `nextstrain run` despite the warnings issued. Such workflows are more likely + to error and fail now early on rather than ""succeed"" but produce output files + in the wrong location. + ([#476](https://github.com/nextstrain/cli/issues/476)) + +* When a standalone installation of Nextstrain CLI suggests a command to run to + update itself, that command now takes into account non-default installation + paths so that the new version is installed to the same place as the current + version. + ([#474](https://github.com/nextstrain/cli/pull/474)) + +# 10.2.1.post1 (1 July 2025) + +_See also changes in 10.2.1 which was an unreleased version._ + +## Development + +* The release script now keeps changelogs in sync. + ([#446](https://github.com/nextstrain/cli/issues/446)) + +# 10.2.1 (1 July 2025) + +_Unreleased due to [test failures](https://github.com/nextstrain/cli/issues/446). Changes first released as part of 10.2.1.post1._ + +## Bug fixes + +* `nextstrain setup ` will no longer attempt to use a local netrc file + for authentication. This fixes a bug which caused pathogen repo download to + fail when the local netrc file contained an expired GitHub authentication + token. + + Previous behavior allowed setup of private repositories using the + fully-specified `@=` format, however support for that was + unintentional and has been removed by this change. + ([#444](https://github.com/nextstrain/cli/issues/444)) + +## Documentation + +* This changelog is [now + included](https://docs.nextstrain.org/projects/cli/en/10.2.1/changes/) in + our published documentation for easier reference. It includes stable + permalink anchors for each version and the subheadings under each version. + ([#438](https://github.com/nextstrain/cli/pull/438)) + + +# 10.2.0 (27 May 2025) + +## Development + +* `nextstrain setup conda` and `nextstrain update conda` now respect an + optional `NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR` environment variable that when + set overrides the default behaviour of detecting the best Conda subdir that's + usable for the platform. + + This may be used, for example, to force the use of the x86\_64 architecture + (`osx-64` subdir) on macOS hardware that's natively the `aarch64` (aka arm64, + Apple Silicon, M1/M2/…) architecture (`osx-arm64` subdir): + + NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR=osx-64 nextstrain setup conda + + The variable must be set for every invocation of `nextstrain setup conda` or + `nextstrain update conda`, otherwise the default behaviour will apply and the + subdir in use by the runtime may be automatically switched. + ([#437](https://github.com/nextstrain/cli/pull/437)) + + +# 10.1.0 (19 May 2025) + +## Improvements + +* Use of an alternate Conda package repository is now supported during + `nextstrain setup conda` and `nextstrain update conda` if you cannot or do + not want to use the default package repository hosted by Anaconda. Set the + [`NEXTSTRAIN_CONDA_CHANNEL_ALIAS`][] environment variable to the base URL of + the repository. This corresponds to the [`channel_alias` Conda config + setting][]. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +* The Conda runtime no longer requires Rosetta 2 for macOS running on aarch64 + (aka arm64, Apple Silicon, M1/M2/…) hardware. This improves performance when + using the runtime. Run `nextstrain update conda` to receive the update. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +[`NEXTSTRAIN_CONDA_CHANNEL_ALIAS`]: https://docs.nextstrain.org/projects/cli/en/10.1.0/runtimes/conda/#envvar-NEXTSTRAIN_CONDA_CHANNEL_ALIAS +[`channel_alias` Conda config setting]: https://docs.conda.io/projects/conda/en/latest/user-guide/configuration/settings.html#set-ch-alias + +## Development + +* The `NEXTSTRAIN_CONDA_MICROMAMBA_VERSION` environment variable is no longer + supported (i.e. for use with `nextstrain setup conda`). Please use + [`NEXTSTRAIN_CONDA_MICROMAMBA_URL`][] instead. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +[`NEXTSTRAIN_CONDA_MICROMAMBA_URL`]: https://docs.nextstrain.org/projects/cli/en/10.1.0/runtimes/conda/#envvar-NEXTSTRAIN_CONDA_MICROMAMBA_URL + + +# 10.0.0 (7 May 2025) + +This release is the first to include initial support for setting up and running +pathogen workflows without the co-mingling of our workflow source code with +your inputs and outputs (e.g. your `config.yaml`, `data/`, and `results/`) and +without needing to download source code or use Git yourself. Pathogens are +first set up with `nextstrain setup` and their workflows may then be run using +`nextstrain run`, a new command in this release. These features are part of +our broader ""workflows as programs"" endeavor. + +## Features + +* A new command, [`nextstrain run`][], for running pathogen workflows in a more + managed way as part of our broader ""workflows as programs"" endeavor. + + Workflows (e.g. `ingest`, `phylogenetic`) for a pathogen are run in a + Nextstrain runtime with config and input (e.g. `config.yaml`, `data/`) from + an analysis directory you provide and outputs (e.g. `results/`) written to + that same directory. + + Pathogens (e.g. `measles`) are initially set up using `nextstrain setup` and + can be updated over time as desired using `nextstrain update`. Multiple + versions of a pathogen may be set up and run independently without conflict, + allowing for comparisons of output across versions. The same pathogen + workflow may also be concurrently run multiple times with separate analysis + directories (i.e. different configs, input data, etc.) without conflict, + allowing for independent outputs and analyses. Set up pathogens and their + versions are listed by `nextstrain version --pathogens`. + + Compared to `nextstrain build`, this new `nextstrain run` command is a + higher-level interface to running pathogen workflows that does not require + knowledge of Git or management of pathogen repositories and source code. For + now, the `nextstrain build` command remains more suitable for active + authorship and development of workflows. + ([#407][]) + +[#407]: https://github.com/nextstrain/cli/pull/407 +[`nextstrain run`]: https://docs.nextstrain.org/projects/cli/en/10.0.0/commands/run/ + +## Improvements + +* The results of setup checks performed by `nextstrain setup` and `nextstrain + check-setup` are now shown individually as they complete instead of waiting + for all checks to complete before showing results. This makes it more clear + that work is being done when checks take a second or two. + ([#418](https://github.com/nextstrain/cli/pull/418)) + +* Commands which make web requests on your behalf (e.g. `nextstrain remote`, + `nextstrain login`, `nextstrain setup`, `nextstrain update`) now include an + appropriate and informative [User-Agent header][], e.g. + + Nextstrain-CLI/10.0.0 (https://nextstrain.org/cli) Python/3.10.9 python-requests/2.32.3 platform/Linux-x86_64 installer/standalone tty/yes + + instead of the previous generic User-Agent, e.g. + + python-requests/2.32.3 + + The new User-Agent includes the Nextstrain CLI version as well as basic + information on several important software components. This information is + non-identifying and useful for our troubleshooting and aggregation of usage + metrics. You may opt to omit it, however, by setting the + `NEXTSTRAIN_CLI_USER_AGENT_MINIMAL` environment variable to `1` (or another + truthy value). In that case, the User-Agent only includes the CLI version, + e.g.: + + Nextstrain-CLI/10.0.0 (https://nextstrain.org/cli) + + We recommend leaving the default User-Agent enabled unless the minimal + variant is necessary for your circumstances. + ([#432](https://github.com/nextstrain/cli/pull/432)) + +[User-Agent header]: https://en.wikipedia.org/wiki/User-Agent_header + +* When checking for upgrades for Nextstrain CLI itself during `nextstrain + check-setup` and `nextstrain update`, the latest version is now fetched from + nextstrain.org instead of pypi.org. This gives us insights into usage and + also more flexibility to shift how we're releasing and distributing this + project. + ([#434](https://github.com/nextstrain/cli/pull/434)) + + +# 9.0.0 (24 March 2025) + +This release contains a **potentially-breaking change** for any usages of the +`--sacra` option, though we expect no one is using it. The change is described +below. + +## Improvements + +* `nextstrain version` now reports itself as ""Nextstrain CLI"" (instead of + ""nextstrain.cli"") and indicates if it is a ""standalone"" installation + (self-contained, bundles Python) or not. + ([#419][]) + +* Colorized and bolded output is disabled when stdout is not attached to a + terminal (e.g. is redirected to a file, piped to another program, etc.) or + when the [`NO_COLOR` environment variable](https://no-color.org) is set to a + non-empty value. + ([#419][]) + +* The readability of `--help` output is improved by the addition of blank lines + between argument/option descriptions. + ([#419][]) + +* AWS Batch builds now support development overlays such as [`--augur`][] and + [`--auspice`][]. To use this functionality, you'll need at least + `nextstrain/base:build-20250321T184358Z` or newer of the Nextstrain Docker + runtime image. Compatibility of the runtime image is checked automatically + when overlays are used with AWS Batch. + ([#419][], [#423](https://github.com/nextstrain/cli/pull/423)) + +[`--augur`]: https://docs.nextstrain.org/projects/cli/en/9.0.0/commands/build/#cmdoption-nextstrain-build-augur +[`--auspice`]: https://docs.nextstrain.org/projects/cli/en/9.0.0/commands/build/#cmdoption-nextstrain-build-auspice + +* The `--sacra` option, intended for use during development, is no longer + supported by `nextstrain build`, `nextstrain view`, or `nextstrain shell`. + [Sacra](https://github.com/nextstrain/sacra), long-defunct and never used, + was removed from the Nextstrain runtime image itself over 4 years ago (first + absent in `nextstrain/base:build-20201213T084302Z`, last present in + `nextstrain/base:build-20201212T165623Z`). This is technically a + **potentially-breaking change**, although almost certainly affects no one. + ([#419][]) + +## Bug fixes + +* Fixed a rare but possible error case in `nextstrain view` and `nextstrain + login` when running under a copy of Python with IPv6 disabled on a system + with IPv6 enabled. In such situations, IPv6 addresses will now be ignored. + ([#415](https://github.com/nextstrain/cli/pull/415)) + +* An authentication callback URL containing an unresolvable hostname is no + longer considered to have a loopback (local-only) address, i.e. is not + considered safe/suitable for use. + ([#416](https://github.com/nextstrain/cli/pull/416)) + +* `nextstrain view` now correctly handles IPv6 host addresses in the URL opened + in a browser (if any). + ([#417](https://github.com/nextstrain/cli/pull/417)) + +* `nextstrain login` now correctly handles OAuth 2.0 authorization endpoint + URLs (which are obtained automatically from OpenID Connect 1.0 metadata + discovery) with existing query parameters in them. This bug likely affected + approximately no one; logging into nextstrain.org was unaffected and all + known users of non-nextstrain.org remotes were also unaffected. + ([#419][]) + +* File timestamps for results files downloaded from an AWS Batch build are now + correctly restored even if the expected extraction path differs from the + actual extraction path due to ZIP security precautions. This bug likely + affected approximately no one. + ([#419][]) + +## Development + +* Goodbye, Mypy! We now use only Pyright for type checking. Both type + checkers used to contribute to our development in their own way, but over + time Pyright's become more sophisticated and Mypy's required more workarounds + to appease it than issues it caught. So long, and thanks for all the ~fish~ + type checks! + ([#419][]) + +* [Cram](https://bitheap.org/cram/) test files are now supported, with one + example file for now. + ([#419][]) + +* `NEXTSTRAIN_HOME` is now set for tests so as to avoid interference with the + local user's personal config and data. + ([#419][]) + +* Running tests no longer opens a browser. \o/ + ([#419][]) + +[#419]: https://github.com/nextstrain/cli/pull/419 + + +# 8.5.4 (1 November 2024) + +## Bug fixes + +* It is no longer a fatal error if the logs for a completed AWS Batch job + cannot be fetched for some reason. `nextstrain build` will warn about the + error but continue on with printing the job status (e.g. success or reason + for failure) and, if applicable, downloading job results. + ([#406](https://github.com/nextstrain/cli/pull/406)) + + +# 8.5.3 (3 September 2024) + +## Bug fixes + +* Authentication established via `nextstrain login` and used by the `nextstrain + remote` family of commands no longer verifies the ""issued at"" (`iat`) time of + the received tokens in order to avoid the following error: + + ImmatureSignatureError: The token is not yet valid (iat). + + This error was seen by users who's system time was slightly lagged, and it + prevented them from logging in or renewing their authentication. + ([#394](https://github.com/nextstrain/cli/pull/394)) + + +# 8.5.2 (27 August 2024) + +## Bug fixes + +* The suggested commands to run (i.e. potential solutions) in expected errors + from `nextstrain remote` now explicitly include the remote origin to avoid + being incorrect or misleading for origins other than nextstrain.org. For + example, if the error message suggested running `nextstrain login`, it now + suggests `nextstrain login https://nextstrain.org`. + ([#391](https://github.com/nextstrain/cli/pull/391)) + + +# 8.5.1 (31 July 2024) + +## Bug fixes + +* `nextstrain remote download` now produces the expected local file names when + there are periods (dots) in the remote dataset name (e.g. `nextstrain remote + download /a/b.c/d` now produces `a_b.c_d.json` instead of `a_b.json`) and + when there are periods in the given local file name (e.g. `nextstrain remote + download /x/y/z x.y.z` now produces `x.y.z.json` instead of `x.y.json`). + ([#381](https://github.com/nextstrain/cli/pull/381)) + + +# 8.5.0 (18 June 2024) + +## Improvements + +* Snakemake's per-input/output file metadata (stored in `.snakemake/metadata/`) + is now downloaded from AWS Batch builds by default. Like file modification + times (mtimes), which are already preserved from the remote build, this + additional metadata is used by Snakemake to track when inputs have changed + and when it should regenerate outputs. The metadata is also used in + [Snakemake report generation](https://snakemake.readthedocs.io/en/v8.14.0/snakefiles/reporting.html#rendering-reports) + and can be useful for gathering ad-hoc workflow statistics. + + The runtime image used must be at least `nextstrain/base:build-20240617T235011Z` + for these Snakemake metadata files to be available for download from the AWS + Batch job. + ([#374](https://github.com/nextstrain/cli/pull/374)) + + +# 8.4.0 (29 May 2024) + +This release adds explicit (i.e. tested) support for Python version 3.12. +([#369](https://github.com/nextstrain/cli/pull/369)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/8.4.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +## Features + +* `nextstrain build` now supports two new options when using the AWS Batch + runtime: [`--exclude-from-upload`][] and [`--exclude-from-download`][]. The + former is useful for avoiding the upload of large, ancillary files not needed + by the build. The latter exists to parallel the former and make it easier to + exclude files from both upload and download. + ([#370](https://github.com/nextstrain/cli/pull/370)) + +## Improvements + +* The Conda runtime now uses Micromamba 1.5.8 (upgraded from 1.1.0) to manage + the runtime environment. The newer version supports Zstandard-compressed + index files which speeds up `nextstrain setup` and `nextstrain update` for + the Conda runtime. + ([#367](https://github.com/nextstrain/cli/pull/367)) + +## Bug fixes + +* The [`--download`][] option of `nextstrain build` now supports passing _only_ + negated patterns (e.g. `!…` and `!(…)`). All files which _don't_ match the + negated patterns will be downloaded. Previously, no files were downloaded + unless at least one positive pattern was given. + ([#370](https://github.com/nextstrain/cli/pull/370)) + + +[`--exclude-from-upload`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-exclude-from-upload +[`--exclude-from-download`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-exclude-from-download +[`--download`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-download + + +# 8.3.0 (30 April 2024) + +## Improvements + +* Commands which utilize a runtime—`nextstrain build`, `nextstrain shell`, and + `nextstrain view`—now support specifying envdirs to forward into the runtime + environment by setting `NEXTSTRAIN_RUNTIME_ENVDIRS` to a `:`-separated (`;` + on Windows) list of paths. This is in addition to the existing support for + specifying one or more `--envdir` options. + ([#365](https://github.com/nextstrain/cli/pull/365)) + + +# 8.2.0 (6 February 2024) + +## Features + +* `nextstrain build` and `nextstrain shell` now better support pathogen + repositories which place workflows in subdirectories. The top-level of the + repo must contain a `nextstrain-pathogen.yaml` file for this support to + activate. The file may be empty for now, though we anticipate using it for + pathogen-level metadata in the future to aid indexing, listing, and + attribution of pathogen repos. + + As an example of the new support, consider the following repo layout + + mpox/ + ├── nextstrain-pathogen.yaml + ├── ingest/ + │ ├── Snakefile + │ └── … + ├── phylogenetic/ + │ ├── Snakefile + │ └── … + ├── shared/ + │ ├── reference.fasta + │ └── … + └── … + + where `ingest/` and `phylogenetic/` contain workflows that use + `shared/reference.fasta` via a relative path (i.e. + `../shared/reference.fasta`). + + It's now possible to invoke those workflows with any of the following: + + nextstrain build mpox/ingest/ + nextstrain build mpox/phylogenetic/ + + cd mpox + nextstrain build ingest/ + nextstrain build phylogenetic/ + + cd phylogenetic + nextstrain build . + nextstrain build ../ingest/ + + regardless of runtime. + + Previously, such workflows required careful invocation, e.g. + + nextstrain build mpox/ -d phylogenetic/ -s phylogenetic/Snakefile + + when using runtimes with filesystem isolation (i.e. the [containerized][] + ones; Docker, Singularity, and AWS Batch) but not when using runtimes without + it. + + When active, this feature makes the top-level of the pathogen repo (e.g. + `mpox/`) available in the container at `/nextstrain/build` while the + initial working directory is set to the workflow subdirectory in the + container (e.g. `/nextstrain/build/phylogenetic`). That is, the filesystem + isolation boundary is drawn at the top-level of the pathogen repo instead of + at the workflow directory (i.e. what's given to `nextstrain build`). + ([#355](https://github.com/nextstrain/cli/pull/355)) + +[containerized]: https://docs.nextstrain.org/projects/cli/en/8.2.0/runtimes/#comparison + +## Improvements + +* We now produce standalone installation archives for macOS running on aarch64 + hardware (aka arm64, Apple Silicon, M1/M2). The standalone installer will + use these archives starting with this release. + ([#357](https://github.com/nextstrain/cli/pull/357), + [#358](https://github.com/nextstrain/cli/pull/358)) + +* The Conda and Docker runtime checks performed by `nextstrain setup` and + `nextstrain check-setup` now test if Rosetta 2 is enabled for macOS on + aarch64 (aka arm64, Apple Silicon, M1/M2) hardware. Rosetta is required for + the Conda runtime and optional, but recommended, for the Docker runtime. + Previously only the standalone installer checked for Rosetta, but starting + with this release it will not. + ([#361](https://github.com/nextstrain/cli/pull/361), + [#358](https://github.com/nextstrain/cli/pull/358)) + +* `nextstrain build` now errors if a [development overlay option][] such as + `--augur` or `--auspice` is given when using a runtime without support for + those (anything but Docker or Singularity). Previously, it would silently + ignore those options when unsupported by the runtime. The new behaviour + matches the behaviour of `nextstrain shell` since 5.0.0. + ([#354](https://github.com/nextstrain/cli/pull/354)) + +[development overlay option]: https://docs.nextstrain.org/projects/cli/en/8.2.0/commands/build/#development-options-for-docker + + +# 8.0.1 (29 January 2024) + +## Improvements + +* Several kinds of errors from `nextstrain login` and `nextstrain whoami` + related to their interactions with a remote server are now clearer. + ([#347](https://github.com/nextstrain/cli/pull/347)) + + +# 8.0.0 (18 January 2024) + +This release drops support for Python versions 3.6 and 3.7 and adds support for +3.11. ([#325](https://github.com/nextstrain/cli/pull/325), +[#327](https://github.com/nextstrain/cli/pull/327)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/8.0.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +## Improvements + +* The `nextstrain remote` family of commands now support alternative + nextstrain.org-like remotes such as internal Nextstrain Groups Server + instances and development instances of nextstrain.org. Authentication with + these remotes is supported via `nextstrain login` and related commands. + Remotes maintain their authentication alongside each other, e.g. you can be + logged into nextstrain.org as well as an alternative nextstrain.org-like + instance. + + As an example, a Nextstrain Groups Server instance accessible at + nextstrain.example.com could now be logged into and interacted with like so: + + nextstrain login nextstrain.example.com + nextstrain whoami nextstrain.example.com + nextstrain remote ls nextstrain.example.com/groups/bedford-lab/ + + The default remote is still nextstrain.org. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* `nextstrain login` now performs authentication via a web browser by default + (using OpenID Connect 1.0 and OAuth 2.0). The previously method of direct + password entry is still used when a username is provided (e.g. with + `--username` or `-u`). See `nextstrain login --help` for more information. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* With the new support for being logged into multiple remotes, `nextstrain + logout` now also supports an `--all` flag to remove all locally-saved + credentials without having to logout of each remote separately. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* `nextstrain remote upload` now skips gzip compression when uploading + zstandard-compressed (`.zst`) files, matching its behaviour for other types + of compressed files. + ([#330](https://github.com/nextstrain/cli/pull/330)) + +* Commands that may automatically open a web browser, e.g. `nextstrain view` or + `nextstrain login`, now respect the semi-conventional `NOBROWSER` environment + variable to disable opening a browser. Set `NOBROWSER` to a non-empty value + to disable automatic opening. When disabled, the URL to manually open will + be shown. + ([#332](https://github.com/nextstrain/cli/pull/332)) + +* The error message emitted by the `nextstrain remote` family of commands when + they're unable to access an S3 bucket now lists a few possible reasons for + the failure. + ([#341](https://github.com/nextstrain/cli/pull/341)) + +* `nextstrain remote download` now supports downloading core datasets which are + only visible on the web by direct access via their URL. For example, the + following now work (where in previous versions they did not): + + nextstrain remote download https://nextstrain.org/nextclade/sars-cov-2/21L + nextstrain remote download https://nextstrain.org/enterovirus/d68/vp1/2020-01-23 + + This support also covers [past snapshots of + datasets](https://docs.nextstrain.org/en/latest/guides/versions.html), which + is a recently-added feature to nextstrain.org. For example: + + nextstrain remote download https://nextstrain.org/flu/seasonal/h3n2/ha/6y@2023-07-01 + nextstrain remote download https://nextstrain.org/ncov/gisaid/21L/global/6m@2024-01-09 + + ([#345](https://github.com/nextstrain/cli/pull/345)) + +## Bug fixes + +* Commands making use of user authentication (e.g. `nextstrain login`, + `nextstrain whoami`, some invocations of `nextstrain remote`, etc.) no longer + fail if the logged in user is a member of no groups. + ([#323](https://github.com/nextstrain/cli/pull/323)) + +* On Linux and macOS, the standalone installer's final instructions now + correctly suggest modifying `~/.profile` instead of, incorrectly, `~/.shrc` + when the default shell is sh. + ([#321](https://github.com/nextstrain/cli/pull/321)) + +* The Singularity runtime once again supports Apptainer's `singularity` + executable. The minimum version checking added in 7.0.0 broke usage of the + Singularity runtime with Apptainer (compared with SingularityCE). Our intent + is to support both lineages of Singularity. Thanks to @osageorange for + raising this issue and testing the fix! + ([#343](https://github.com/nextstrain/cli/pull/343)) + + +# 7.4.0 (21 September 2023) + +## Improvements + +* When attached to an AWS Batch job, `nextstrain build` now only requires + confirmation to stop the job (e.g. a double Control-C/`SIGINT`) when stdin is + a terminal (TTY). When stdin is not a terminal, as is frequently the case in + automated or programmatic contexts, then `SIGINT` requests job cancellation + immediately. + ([#308][]) + +* When attached to an AWS Batch job, `nextstrain build` now also detaches upon + receiving `SIGHUP` (in addition to detaching upon receiving + Control-Z/`SIGTSTP`). `SIGHUP` is sent, for example, when a user closes (or + loses) the terminal in which `build` is still running. + ([#308][]) + +* When launching or attaching to an AWS Batch job, `nextstrain build` now + supports the `--detach-on-interrupt` option to change Control-C/`SIGINT` to a + request to detach from the job rather than to cancel it. This is useful in + automated contexts where `SIGINT` may be sent outside of a user's control, + and it's also handy as a molly-guard to avoid accidental cancellation when + the intent is to just observe a job. + ([#308][]) + +* When attaching to an AWS Batch job, `nextstrain build` now supports the + `--cancel` option to immediately request cancellation. + ([#308][]) + +[#308]: https://github.com/nextstrain/cli/pull/308 + +## Bug fixes + +* We've plugged some isolation leaks in the Conda runtime where the + [Python user site directory](https://docs.python.org/3/library/site.html), + e.g. `~/.local/lib/pythonX.Y/site-packages`, as well as the + [`PYTHONPATH` and `PYTHONHOME` environment variables](https://docs.python.org/3/using/cmdline.html#environment-variables) + could influence and break the runtime. + ([#311](https://github.com/nextstrain/cli/pull/311)) + + +# 7.3.0.post1 (19 September 2023) + +_See also changes in 7.3.0 which was an unreleased version._ + +## Development + +* Update CI to test against the SingularityCE 3.x series only ([#314](https://github.com/nextstrain/cli/pull/314)) + + +# 7.3.0 (19 September 2023) + +_Unreleased due to test failures. Changes first released as part of 7.3.0.post1._ + +## Improvements + +* build: Providing a path to a pathogen build directory is no longer required + when the AWS Batch runtime is in use (e.g. with `--aws-batch`) and both the + `--attach` and `--no-download` options are given. This allows usages which + just want to check job status or logs to stop providing a meaningless/unused + directory. + ([#305](https://github.com/nextstrain/cli/pull/305)) + +* The initial setup of the Conda runtime, i.e. with `nextstrain setup conda`, + now explicitly installs the latest available runtime package version. This + was the implicit intent and expectation, but, for various Conda packaging + reasons, it was (silently) not always the result. Now an error will occur if + the latest version is not installable. This matches the existing behaviour + when updating the Conda runtime, i.e. with `nextstrain update conda`. + ([#312](https://github.com/nextstrain/cli/pull/312)) + +## Bug fixes + +* The `HOST` and `PORT` environment variables are now respected by `nextstrain + view`. They provide defaults when `--host` and/or `--port` aren't provided. + ([#310](https://github.com/nextstrain/cli/pull/310)) + +* Updated fsspec and s3fs dependencies to avoid version 2023.9.1, since they + caused `nextstrain build --aws-batch` invocations to fail. + ([#313](https://github.com/nextstrain/cli/pull/313)) + + +# 7.2.0 (17 August 2023) + +## Bug fixes + +* The Conda runtime now uses Micromamba 1.1.0 (upgraded from 1.0.0) to manage + the runtime environment. The newer version has improved error handling in + edge cases where the previous version silently failed when used during + `nextstrain update`. + ([#301](https://github.com/nextstrain/cli/pull/301)) + +* The Singularity runtime now cleans up unnecessary caches during `nextstrain + update` and `nextstrain setup`. This reduces the storage space required by + the runtime and prevents it from growing unbounded over time. However, this + also results in increases in network transfer during `nextstrain update`. We + may mitigate the additional transfer in the future. + ([#303][]) + +## Documentation + +* The command-line `--help` output for commands and the corresponding + documentation pages on the web are more integrated and improved in various + small ways. In particular, command options are more cross-referencable and + directly linkable and the wrap-width of `--help` output is more consistent + and reliably readable. + ([#299](https://github.com/nextstrain/cli/pull/299)) + +* We've added a large section of new and expanded [documentation on + runtimes](https://docs.nextstrain.org/projects/cli/page/runtimes/), both in + general and for each individual runtime. + ([#303][]) + +* We've added and expanded documentation about configuration, including the + [config file](https://docs.nextstrain.org/projects/cli/page/config/file/) and + the [paths](https://docs.nextstrain.org/projects/cli/page/config/paths/) used + by Nextstrain CLI. Documentation in general now includes more about the + environment variables that can be used to configure Nextstrain CLI. + ([#303][]) + + +[#303]: https://github.com/nextstrain/cli/pull/303 + + +# 7.1.0 (22 June 2023) + +## Improvements + +* Commands that use a runtime (`nextstrain build`, `nextstrain shell`, and + `nextstrain view`) now support two new options for setting or passing thru + environment variables into the runtime environment: + + --env [=] + --envdir + + When either of these options are given, the default behaviour of + automatically passing thru several ""well-known"" environment variables is + disabled. That is, the following ""well-known"" environment variables are only + automatically passed thru when the new `--env` and `--envdir` options are + _not_ used: + + - `AUGUR_RECURSION_LIMIT` + - `AUGUR_MINIFY_JSON` + - `AWS_ACCESS_KEY_ID` + - `AWS_SECRET_ACCESS_KEY` + - `AWS_SESSION_TOKEN` + - `ID3C_URL` + - `ID3C_USERNAME` + - `ID3C_PASSWORD` + - `RETHINK_HOST` + - `RETHINK_AUTH_KEY` + + Pass these variables explicitly via `--env` or `--envdir` if you need them in + combination with other `--env` or `--envdir` usage. For more usage details, + use the `--help-all` flag of any of those commands, e.g. `nextstrain build + --help-all`. + ([#289](https://github.com/nextstrain/cli/pull/289)) + +* Environment variables are now passed to the Docker and AWS Batch runtimes via + more secure means when the container image in use is new enough to support it + (`nextstrain/base:build-20230613T204512Z` and newer). This ensures the env + values aren't visible in the container's config (e.g. via `docker inspect`, + `aws batch describe-jobs`, the AWS web console). If you're using an older + image, you can update it with `nextstrain update docker`. + + For Docker, environment variables are written to an internal and temporary + envdir directory visible only to the current user which is deleted + immediately after use at container start. + + For AWS Batch, environment variables are written to a ZIP archive on S3, + alongside but separate from the ZIP archive of the build dir. This env + archive is deleted from S3 immediately after use at container start. + + Both of these approaches minimize the amount of time environment variable + values exist outside of memory, persisted to storage (disk, S3). + ([#289](https://github.com/nextstrain/cli/pull/289)) + +## Bug fixes + +* `nextstrain view` now waits (up to 10s) for Auspice to start responding + before automatically opening it in the browser. This should eliminate the + previous behaviour of sometimes opening the browser too soon. + ([#291](https://github.com/nextstrain/cli/pull/291)) + + +# 7.0.1 (31 May 2023) + +## Bug fixes + +* `nextstrain update` for the Conda runtime no longer reports an ""invalid + version"" error. This was a regression introduced in 7.0.0. + ([#286](https://github.com/nextstrain/cli/pull/286)) + + +# 7.0.0 (26 May 2023) + +This release is mostly a bug fix release for our Conda and Singularity +runtimes. However, it contains a **potentially-breaking change** for existing +usages of the Singularity runtime: **the minimum required Singularity version +has changed from 2.6.0 to 3.0.0**. This change was required for a critical bug +fix. If you do not use the Singularity runtime, there are no +potentially-breaking changes in this release. + +## Improvements + +* `nextstrain shell` now notes which runtime is being entered in its initial + messaging to establish more context for the user (and for developers when + troubleshooting). + ([#283][]) + +* The Singularity runtime now checks for the minimum required Singularity + version (3.0.0 with this release) during `nextstrain check-setup`. + ([#283][]) + +## Bug fixes + +* Setup and upgrade of the Conda runtime now only uses stable ""main"" channel + releases when determining the latest release version, as intended. + Previously, testing and development releases could be selected if they were + newer than the last stable release. Additionally, if there are multiple + builds for a release version, the highest numbered build (i.e. newest) is now + used instead of the lowest. + ([#280](https://github.com/nextstrain/cli/pull/280)) + +* The Singularity runtime now works with our container runtime images from + `build-20230411T103027Z` onwards. The Snakemake upgrade in that image + version resulted in ""read-only file system"" errors which referenced the + user's home directory. Those errors are now fixed. + ([#283][]) + +* The prompt for `nextstrain shell`—a stylized variant of the Nextstrain + wordmark—now works when using the Singularity runtime regardless of + Singularity version. Previously Singularity's default prompt of + `Singularity> ` overrode ours when using Singularity versions ≥3.5.3. + ([#283][]) + +* More robust command-line processing is used for the Singularity runtime on + Singularity versions ≥3.10.0. Singularity's early (and unexpected) + evaluation of arguments that look like (but aren't) shell variable + substitutions is disabled. + ([#283][]) + +## Development + +* The command lines and environment overrides of many (but not all) process + invocations are now logged when `NEXTSTRAIN_DEBUG` is enabled. + ([#283][]) + + +[#283]: https://github.com/nextstrain/cli/pull/283 + + +# 6.2.1 (24 March 2023) + +## Bug fixes + +* We've fixed and future-proofed a compatibility bug with a third-party library + that can occur under very specific conditions when `nextstrain build` submits + AWS Batch jobs. + ([#261](https://github.com/nextstrain/cli/pull/261)) + +* The update process for the Conda runtime is now more robust and less likely + to get stuck at an old version. + ([#266](https://github.com/nextstrain/cli/pull/266)) + + +# 6.2.0 (28 February 2023) + +## Improvements + +* `nextstrain build --aws-batch --attach …` no longer offers to cancel (via + Control-C) or detach (via Control-Z) from the job if it's already complete. + Instead, Control-C will exit the program without delay and without trying to + cancel the job. + ([#253][]) + +* `nextstrain build` now supports a `--no-logs` option to suppress the fetching + and printing of job logs when attaching to a completed AWS Batch build. As + log fetching can often take longer than a selective download of the results + (i.e. via `--download`), this is a time (and terminal scrollback) saver when + all you want are a few of the results files. + ([#253][]) + +[#253]: https://github.com/nextstrain/cli/pull/253 + +## Bug fixes + +* An error message that's printed by `nextstrain remote upload` when unknown + files are given for upload to destinations on nextstrain.org now properly + includes the actual list of unknown files instead of the placeholder + `{files}`. + ([#260](https://github.com/nextstrain/cli/pull/260)) + +* When running on Python ≥3.10, the `--help` output of `nextstrain build`, + `nextstrain view`, and `nextstrain shell` once again shows just the most + common options. All options are still shown with `--help-all`. A regression + since Python 3.10 meant that `--help` acted the same as `--help-all` before + this fix. This affected any installation on Python ≥3.10, including + standalone installations, since the standalone binaries bundle Python 3.10. + ([#259](https://github.com/nextstrain/cli/pull/259)) + + +# 6.1.0.post1 (18 January 2023) + +## Documentation + +* Minor improvements to the way we list and describe our computing platforms. + + +# 6.1.0 (18 January 2023) + +## Improvements + +* We've added a new Singularity runtime based on our existing Docker runtime. + + Singularity is a container system freely-available for Linux platforms. It + is commonly available on institutional HPC systems as an alternative to + Docker, which is often not supported on such systems. When you use + Singularity with the Nextstrain CLI, you don't need to install any other + Nextstrain software dependencies as validated versions are already bundled + into a container image by the Nextstrain team. + + Run `nextstrain setup singularity` to get started. + ([#248](https://github.com/nextstrain/cli/pull/248)) + + +# 6.0.3 (17 January 2023) + +## Improvements + +* The output of `nextstrain check-setup` for the Conda runtime will now hint + about running `nextstrain setup conda` first if the runtime seems supported + but not yet set up. + ([#250][]) + +## Documentation + +* Documentation and `--help` output now standardizes on the term _runtime_ to + describe the various ways Nextstrain CLI provides access to the Nextstrain + software tools. Previously we used a mix of _build environment_, _runner_, + and _runtime_ in user-facing messages. This brings Nextstrain CLI in line + with the rest of our documentation. + ([#250][]) + +* The installation documentation now includes the standalone installer as well + as installing from Bioconda. It now covers all the ways our releases are + distributed. + ([#250][]) + +* The output of `nextstrain --help` now notes how to find command-specific + usage info and our online documentation. + ([#250][]) + +* An out-of-date description in `nextstrain build --help` has been revised and + updated. + ([#250][]) + +## Development + +* A new [glossary page in our documentation](https://docs.nextstrain.org/projects/cli/page/glossary/) + will help keep our shared understanding of terms straight. + ([#250][]) + +* Links to our online documention in the `--help` output of commands will now + omit any [local part](https://peps.python.org/pep-0440/#local-version-identifiers), + e.g. `+git`, of the running CLI version. This makes links correct even when + running development builds. + ([#250][]) + +[#250]: https://github.com/nextstrain/cli/pull/250 + + +# 6.0.2 (3 January 2023) + +_See also changes in 6.0.1 which was an unreleased version._ + +## Bug fixes + +* A new deprecation warning from the `cryptography` module (version 39) when + running on Python 3.6 is now suppressed as it's just noise to an end user. + This probably moves us closer to dropping 3.6 support ourselves, but it's not + so onerous yet. + ([#246](https://github.com/nextstrain/cli/issues/246)) + + +# 6.0.1 (3 January 2023) + +_Unreleased due to [test failures](https://github.com/nextstrain/cli/issues/245). Changes first released as part of 6.0.2._ + +## Improvements + +* The standalone installation archives used by the standalone installer will + now work on even older Linux distributions: + + |distro |now |was | + |-------------|-------|-------| + |Ubuntu |14\.04 |18\.04 | + |Debian |8 |10 | + |RHEL/CentOS |7 |8 | + |Fedora |19 |28 | + |OpenSUSE |12\.3 |15\.3 | + + If you've previously encountered errors like the following: + + /lib64/libc.so.6: version `GLIBC_2.27' not found (required by […]/.nextstrain/cli-standalone/nextstrain) + + when using the standalone installer (or standalone archives directly), i.e.: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + + then this change should resolve that error! The new minimum required glibc + version is 2.17 (was 2.27 previously). + ([#243](https://github.com/nextstrain/cli/pull/243)) + +## Bug fixes + +* The automatic opening of a browser tab (or window) by `nextstrain view`—a + feature introduced in the last release (6.0.0)—now also works for standalone + installations. + ([#244](https://github.com/nextstrain/cli/pull/244)) + + +# 6.0.0 (13 December 2022) + +This release contains a **potentially-breaking change** for existing usages of +`nextstrain view`, though we expect the change to impact very few usages. The +change is described below. + +## Improvements + +* `nextstrain view` now supports viewing narratives, as was always intended. + Previously the launched Auspice would either show baked in test narratives or + no narratives at all, depending on the Auspice version in the runtime. + ([#240][]) + +* `nextstrain view` now supports being given more kinds of paths, including + paths to a specific dataset or narrative file and paths to directories + containing _auspice/_ and/or _narratives/_ subdirectories. + + This is a **potentially-breaking change**, as `nextstrain view ` will + now prefer to show datasets from _``/auspice/_ if that subdirectory + exists. Previously it would only ever look for datasets in the given + _``_. We expect this to change behaviour for very few usages as it only + affects situations where _``_ contains both datasets and an _auspice/_ + directory. + + See `nextstrain view --help` for more details on the kinds of paths + supported. + ([#240][]) + +* `nextstrain view` now automatically opens Auspice in a new browser tab (or + window) by default when possible. + + If a specific dataset or narrative file was given as the path to `nextstrain + view`, then that dataset or narrative is opened. Otherwise, if there's only + a single dataset or narrative available in the directory path given to + `nextstrain view`, then it is opened. Otherwise, Auspice's listing of + available datasets and narratives is opened. + ([#240][]) + +[#240]: https://github.com/nextstrain/cli/pull/240 + +* Local images used in a narrative are now automatically embedded into it when + uploading the narrative to nextstrain.org via `nextstrain remote upload`. + In local text editors which can render Markdown, this permits previewing of + narratives that reference images on the local filesystem without requiring + manual conversion to remote images or embedded images before upload. + ([#235](https://github.com/nextstrain/cli/pull/235)) + +* The `nextstrain remote upload` command now outputs a nicer error message + that's more interpretable and actionable when nextstrain.org returns a ""bad + request"" error. The error message also includes the error details returned + by nextstrain.org. + ([#238](https://github.com/nextstrain/cli/pull/238)) + +## Development + +* The Conda runtime now uses Micromamba 1.0.0 (an upgrade from 0.27.0). + ([#233](https://github.com/nextstrain/cli/pull/233)) + + +# 5.0.1 (1 November 2022) + +## Bug fixes + +* `nextstrain shell` no longer errors when its history file, e.g. + _~/.nextstrain/shell-history_, doesn't exist. This primarily affected the + Docker runtime and was a regression from 4.2.0 introduced in 5.0.0. + ([#232](https://github.com/nextstrain/cli/pull/232)) + + +# 5.0.0 (25 October 2022) + +_Version 5.0.0 had two development pre-releases (5.0.0.dev0 and 5.0.0.dev1) +prior to final release. For convenience, the changes from those pre-releases +are also re-described here._ + +The major improvement in this release is the introduction of a new Conda +runtime, filling a gap between the Docker runtime and the ambient runtime +(formerly ""native"" runtime). See more details below. + +This release also contains **potentially-breaking changes** for existing +usages of `nextstrain remote download` and `nextstrain update`. The changes +are described below. + +## Improvements + +* A new Conda runtime (aka runner or build environment) now complements the + existing Docker and ambient runtimes and fills a gap between them. This + runtime is more isolated and reproducible than your ambient environment, but + is less isolated and robust than the Docker runtime. Like the Docker + runtime, the Conda runtime is fully-managed by Nextstrain CLI and receives + updates via `nextstrain update`. + + The new runtime uses the [Conda](https://docs.conda.io) ecosystem with + packages from [our own channel](https://anaconda.org/Nextstrain/nextstrain-base), + [Bioconda](https://bioconda.github.io/) and + [Conda-Forge](https://conda-forge.org/), installed by + [Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html) + into an isolated location, typically `~/.nextstrain/runtimes/conda/env`. It + does not interact with or impact other usage of Conda/Mamba environments and + will not, for example, appear in the output of `conda env list`. + + Set up of the runtime is automated and can be performed by running: + + nextstrain setup conda + + When complete, you'll be able to use the `--conda` runtime option supported + by Nextstrain CLI commands such as `nextstrain build`, `nextstrain view`, + `nextstrain shell`, etc. + ([#218][]) + +* The ""native"" runtime (aka runner or build environment) is now the ""ambient"" + runtime. This name better reflects what it is and further distinguishes it + from the new Conda runtime, which is also ""native"" in the binary executable + sense. + + Existing usages of ""native"" should be unaffected. The `--native` option + continues to work anywhere it used to previously, though it is hidden from + `--help` output to discourage new use. The string ""native"" is also accepted + anywhere runner names are accepted, e.g. in config as the `core.runner` + setting or in command-line arguments to `check-setup` or `setup`. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* `nextstrain setup docker` now downloads the Docker runtime image if it's not + already available locally. This can be a useful initial step after + installation to avoid the automatic download on first use. + ([#222](https://github.com/nextstrain/cli/pull/222)) + +* The local filenames produced by `nextstrain remote download` now include + more of the remote dataset/narrative path. This reduces the potential for + ambiguous filenames and makes it easier to copy datasets/narratives between + destinations (e.g. from one group to another) while retaining the same path. + It is, however, a **potentially-breaking change** if you're relying on the + filenames of the downloaded datasets/narratives (e.g. for automation). + + For example, downloading `nextstrain.org/flu/seasonal/h3n2/ha/2y` previously + produced the local files: + + ``` + 2y.json + 2y_root-sequence.json + 2y_tip-frequencies.json + ``` + + which could easily conflict with the similarly-named + `nextstrain.org/flu/seasonal/h3n2/na/2y`, + `nextstrain.org/flu/seasonal/h1n1pdm/ha/2y`, etc. The downloaded files are + now named: + + ``` + flu_seasonal_h3n2_ha_2y.json + flu_seasonal_h3n2_ha_2y_root-sequence.json + flu_seasonal_h3n2_ha_2y_tip-frequencies.json + ``` + + Within groups, filenames are similarly longer but the group name is not + included. For example, downloading `groups/blab/ncov/cross-species/cat` + previously produced: + + ``` + cat.json + cat_root-sequence.json + cat_tip-frequencies.json + ``` + + and now produces: + + ``` + ncov_cross-species_cat.json + ncov_cross-species_cat_root-sequence.json + ncov_cross-species_cat_tip-frequencies.json + ``` + ([#213](https://github.com/nextstrain/cli/pull/213)) + +* Advanced globbing features are now supported in patterns for the `--download` + option of `nextstrain build`, including multi-part wildcards (`**`), extended + globbing (`@(…)`, `+(…)`, etc.), and negation (`!…`). Basic globbing + features like single-part wildcards (`*`), character classes (`[…]`), and + brace expansion (`{…, …}`) are still supported. Note that the `--download` + option continues to be applicable only to the AWS Batch runtime (e.g. the + `--aws-batch` option). + ([#215](https://github.com/nextstrain/cli/pull/215)) + +* `check-setup` now accepts one or more runtime names as arguments. + + The default behaviour doesn't change, but specifying runtimes now lets you + restrict checks to a single runtime or, with multiple runtimes, re-order them + by your preference for use with --set-default. + ([#218][]) + +* `update` now only updates a specific runtime instead of all of them at once. + + With no arguments, the default runtime is updated. The name of another + runtime to update instead may be provided as an argument. + + In practice this isn't much of a behaviour change because only one runtime + currently supports updating (Docker); the others (ambient, AWS Batch) just + pass. Existing users are unlikely to notice the change unless they use + multiple runtimes and Docker is not their default. In that case, `update` + may stop updating Docker for them when it would have done so previously, + which is a **potentially-breaking change**. + ([#218][]) + +* A new command, `setup`, now exists to perform automatic set up of runtimes + that support it (currently only Conda). For all runtimes, even those that + don't support automatic set up, the `setup` command will also run the same + checks as `check-setup` and optionally set the default runtime. + ([#218][]) + +* The shell launched by the `shell` command now remembers its own command + history and differentiates its command prompt from other shells with a + stylized variant of the Nextstrain wordmark. + ([#218][]) + +* The output of commands in dry run mode (e.g. with the `--dry-run` option) is + now uniformly indicated to be a dry run by the prefix `DRY RUN │ `. This + includes the `remote` family of commands and the new `setup` command. + ([#218][]) + +* Runtime checks in `check-setup` and `setup` now test for not just the + presence of Snakemake, Augur, and Auspice, but also that they can be + executed. + ([#218][]) + +## Development + +* We now provide standalone installers (i.e. shell programs) to download and + unpack the standalone installation archives into standard locations, + potentially upgrading/overwriting a prior standalone install. These + installers will be served from GitHub directly out of this project's + repository via convenience redirects on nextstrain.org. + + These will eventually form the basis for Nextstrain install instructions that + don't suffer from Python bootstrapping issues. As a preview for now, you can + play around with the following platform-specific commands: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/mac | bash + Invoke-RestMethod https://nextstrain.org/cli/installer/windows | Invoke-Expression + + A new companion command, `init-shell`, exists to simplify shell configuration + (i.e. `PATH` modification) for such installations. + +* The `NEXTSTRAIN_HOME` environment variable can now be used to specify the + desired location for per-user settings, files, etc., overriding the default + of _~/.nextstrain/_. + ([#218][]) + +* A new `nextstrain authorization` command makes it easier to generate direct + requests to nextstrain.org's web API using the same credentials as the CLI. + ([#229](https://github.com/nextstrain/cli/pull/229)) + +* The development documentation now documents how to build the documentation + locally, and sphinx-autobuild is used to make a very nice edit-preview cycle + with quick turnaround. + ([#218][]) + +* Development dependency issues with `flake8` and `sphinx-markdown-tables`, + caused by upstream changes, are now resolved. + ([#218][]) + + +# 5.0.0.dev1 (25 October 2022) + +_This is the second development pre-release made prior to the final release of 5.0.0._ + +## Improvements + +* The ""native"" runtime (aka runner or build environment) is now the ""ambient"" + runtime. This name better reflects what it is and further distinguishes it + from the new Conda runtime, which is also ""native"" in the binary executable + sense. + + Existing usages of ""native"" should be unaffected. The `--native` option + continues to work anywhere it used to previously, though it is hidden from + `--help` output to discourage new use. The string ""native"" is also accepted + anywhere runner names are accepted, e.g. in config as the `core.runner` + setting or in command-line arguments to `check-setup` or `setup`. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* `nextstrain setup docker` now downloads the Docker runtime image if it's not + already available locally. This can be a useful initial step after + installation to avoid the automatic download on first use. + ([#222](https://github.com/nextstrain/cli/pull/222)) + +* `nextstrain build`'s check for use of the `--image` option with unsupported + runtimes now includes the Conda runtime. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* The Conda runtime now uses the new [`nextstrain-base` Conda + meta-package](https://anaconda.org/Nextstrain/nextstrain-base) instead of + using a hardcoded list of packages. + + This decouples Conda runtime updates from Nextstrain CLI updates, as we can + make new releases of `nextstrain-base` and users can update to those without + upgrading Nextstrain CLI itself. This brings the update story for the Conda + runtime into much better parity with the Docker runtime. + + Using the meta-package also brings increased reproducibility to the runtime, + as the package completely locks its full transitive dependency tree. This + means that if version _X_ of `nextstrain-base` worked in the past, it'll + still work the same way in the future. + + The `NEXTSTRAIN_CONDA_BASE_PACKAGE` environment variable may be used with + `nextstrain setup conda` to install a specific version. The value is a + [Conda package specification][], e.g. `nextstrain-base ==X`. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +* The Conda runtime now uses a pinned version of Micromamba (currently 0.27.0) + so that new releases of the latter can't break `nextstrain setup conda` or + `nextstrain update conda` between one day and the next. The pinned version + will be bumped up over time as needed with subsequent releases of Nextstrain + CLI. + + The `NEXTSTRAIN_CONDA_MICROMAMBA_VERSION` environment variable may be used + with `nextstrain setup conda` to override the built-in pin, either with + another specific version or `latest`. + +[Conda package specification]: https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/pkg-specs.html#package-match-specifications + +## Bug fixes + +* The Conda runtime now runs Micromamba in greater isolation to avoid undesired + interactions when a) Nextstrain CLI itself is running inside an + externally-activated Conda environment and/or b) user-specific Mamba + configuration exists. This applies to usages of `nextstrain setup` and + `nextstrain update` with the Conda runtime. + ([#223](https://github.com/nextstrain/cli/pull/223)) + +* The Conda runtime now configures the appropriate channels during `update` too, + not just during `setup`, ensuring package updates are found. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +* The Conda runtime now avoids pinning Python in the isolated environment to + allow it to be upgraded by `update`. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +## Development + +* The Conda runtime is now tested in CI, joining the Docker and ambient + runtimes. + ([#223](https://github.com/nextstrain/cli/pull/223)) + + +# 5.0.0.dev0 (6 October 2022) + +_This is a development pre-release made prior to the final release of 5.0.0._ + +The major improvement in this release is the introduction of a new Conda +runtime, filling a gap between the Docker runtime and the ""native"" (soon to be +""ambient"") runtime. See more details below. + +This release also contains **a potentially-breaking change** for existing +usages of `nextstrain remote download` and `nextstrain update`. The changes +are described below. + +## Improvements + +* A new Conda runtime (aka runner or build environment) now complements the + existing Docker and ""native"" runtimes and fills a gap between them. This + runtime is more isolated and reproducible than your native ambient + environment, but is less isolated and robust than the Docker runtime. Like + the Docker runtime, the Conda runtime is fully-managed by Nextstrain CLI and + receives updates via `nextstrain update`. + + The new runtime uses the [Conda](https://docs.conda.io) ecosystem with + packages from [Bioconda](https://bioconda.github.io/) and + [Conda-Forge](https://conda-forge.org/), installed by + [Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html) + into an isolated location, typically `~/.nextstrain/runtimes/conda/env`. It + does not interact with or impact other usage of Conda/Mamba environments and + will not, for example, appear in the output of `conda env list`. + + Set up of the runtime is automated and can be performed by running: + + nextstrain setup conda + + When complete, you'll be able to use the `--conda` runtime option supported + by Nextstrain CLI commands such as `nextstrain build`, `nextstrain view`, + `nextstrain shell`, etc. + ([#218][]) + +* The local filenames produced by `nextstrain remote download` now include + more of the remote dataset/narrative path. This reduces the potential for + ambiguous filenames and makes it easier to copy datasets/narratives between + destinations (e.g. from one group to another) while retaining the same path. + It is, however, a **potentially-breaking change** if you're relying on the + filenames of the downloaded datasets/narratives (e.g. for automation). + + For example, downloading `nextstrain.org/flu/seasonal/h3n2/ha/2y` previously + produced the local files: + + ``` + 2y.json + 2y_root-sequence.json + 2y_tip-frequencies.json + ``` + + which could easily conflict with the similarly-named + `nextstrain.org/flu/seasonal/h3n2/na/2y`, + `nextstrain.org/flu/seasonal/h1n1pdm/ha/2y`, etc. The downloaded files are + now named: + + ``` + flu_seasonal_h3n2_ha_2y.json + flu_seasonal_h3n2_ha_2y_root-sequence.json + flu_seasonal_h3n2_ha_2y_tip-frequencies.json + ``` + + Within groups, filenames are similarly longer but the group name is not + included. For example, downloading `groups/blab/ncov/cross-species/cat` + previously produced: + + ``` + cat.json + cat_root-sequence.json + cat_tip-frequencies.json + ``` + + and now produces: + + ``` + ncov_cross-species_cat.json + ncov_cross-species_cat_root-sequence.json + ncov_cross-species_cat_tip-frequencies.json + ``` + ([#213](https://github.com/nextstrain/cli/pull/213)) + +* Advanced globbing features are now supported in patterns for the `--download` + option of `nextstrain build`, including multi-part wildcards (`**`), extended + globbing (`@(…)`, `+(…)`, etc.), and negation (`!…`). Basic globbing + features like single-part wildcards (`*`), character classes (`[…]`), and + brace expansion (`{…, …}`) are still supported. Note that the `--download` + option continues to be applicable only to the AWS Batch runtime (e.g. the + `--aws-batch` option). + ([#215](https://github.com/nextstrain/cli/pull/215)) + +* `check-setup` now accepts one or more runtime names as arguments. + + The default behaviour doesn't change, but specifying runtimes now lets you + restrict checks to a single runtime or, with multiple runtimes, re-order them + by your preference for use with --set-default. + ([#218][]) + +* `update` now only updates a specific runtime instead of all of them at once. + + With no arguments, the default runtime is updated. The name of another + runtime to update instead may be provided as an argument. + + In practice this isn't much of a behaviour change because only one runtime + currently supports updating (Docker); the others (native, AWS Batch) just + pass. Existing users are unlikely to notice the change unless they use + multiple runtimes and Docker is not their default. In that case, `update` + may stop updating Docker for them when it would have done so previously, + which is a **potentially-breaking change**. + ([#218][]) + +* A new command, `setup`, now exists to perform automatic set up of runtimes + that support it (currently only Conda). For all runtimes, even those that + don't support automatic set up, the `setup` command will also run the same + checks as `check-setup` and optionally set the default runtime. + ([#218][]) + +* The shell launched by the `shell` command now remembers its own command + history and differentiates its command prompt from other shells with a + stylized variant of the Nextstrain wordmark. + ([#218][]) + +* The output of commands in dry run mode (e.g. with the `--dry-run` option) is + now uniformly indicated to be a dry run by the prefix `DRY RUN │ `. This + includes the `remote` family of commands and the new `setup` command. + ([#218][]) + +* Runtime checks in `check-setup` and `setup` now test for not just the + presence of Snakemake, Augur, and Auspice, but also that they can be + executed. + ([#218][]) + +## Development + +* We now provide standalone installers (i.e. shell programs) to download and + unpack the standalone installation archives into standard locations, + potentially upgrading/overwriting a prior standalone install. These + installers will be served from GitHub directly out of this project's + repository via convenience redirects on nextstrain.org. + + These will eventually form the basis for Nextstrain install instructions that + don't suffer from Python bootstrapping issues. As a preview for now, you can + play around with the following platform-specific commands: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/mac | bash + Invoke-RestMethod https://nextstrain.org/cli/installer/windows | Invoke-Expression + + A new companion command, `init-shell`, exists to simplify shell configuration + (i.e. `PATH` modification) for such installations. + +* The `NEXTSTRAIN_HOME` environment variable can now be used to specify the + desired location for per-user settings, files, etc., overriding the default + of _~/.nextstrain/_. + ([#218][]) + +* The development documentation now documents how to build the documentation + locally, and sphinx-autobuild is used to make a very nice edit-preview cycle + with quick turnaround. + ([#218][]) + +* Development dependency issues with `flake8` and `sphinx-markdown-tables`, + caused by upstream changes, are now resolved. + ([#218][]) + + +[#218]: https://github.com/nextstrain/cli/pull/218 + + +# 4.2.0 (29 July 2022) + +## Bug fixes + +* Using `remote delete` on nextstrain.org now correctly outputs the ""Deleting…"" + message *before* performing each delete, as intended (and as S3 remotes do). + Previously, the message was misleadingly output *after* each delete was + already performed. + ([#209](https://github.com/nextstrain/cli/pull/209)) + +* Detection of the installation method during self-upgrade checks in + `nextstrain update` and `nextstrain check-setup` now looks for explicit + installer metadata files and no longer assumes Pip as the final fallback. If + the installation method is not explicitly detected, then no upgrade + instructions are shown. Better to suggest nothing than to suggest the wrong + thing. + ([#207][]) + +* An uncaught `StopIteration` error that could have occurred in very specific + and limited circumstances during self-upgrade checks in `nextstrain update` + and `nextstrain check-setup` can no longer occur. + ([#207][]) + +## Improvements + +* The `nextstrain remote download`, `upload`, and `delete` commands now support + a `--dry-run` mode. + + This mode, as is broader convention, goes through the motions of doing the + thing, as much as possible, but doesn't _actually_ do the thing. That is, no + changes should occur when `--dry-run` is active. + + This is particularly useful for seeing what will happen if you're unsure of + how a path or argument is handled. Dry runs of the `list` (`ls`) command + don't make sense and aren't included. + ([#210](https://github.com/nextstrain/cli/pull/210)) + +* Installations via a Conda package are now detected during self-upgrade checks + and the suggested upgrade command uses `mamba install` or `conda install`. + ([#207][]) + +* Suggested upgrade commands now specify the expected new version so they fail + if that version is not found rather than succeed but do nothing (or do + something different). + ([#207][]) + +## Development + +* A new debugging mode can be enabled by setting the `NEXTSTRAIN_DEBUG` + environment variable to `1` (or another truthy value). Currently the only + effect is to print more information about handled (i.e. anticipated) errors. + For example, stack traces and parent exceptions in an exception chain are + normally omitted for handled errors, but setting this env var includes them. + Future debugging and troubleshooting features, like verbose operation + logging, will likely also condition on this new debugging mode. + +* We now avoid a runtime dep on setuptools by switching from + `pkg_resources.parse_version` to `packaging.version.parse`. The latter was + already transitively in our dep tree. + ([#207][]) + + +[#207]: https://github.com/nextstrain/cli/pull/207 + + +# 4.1.1 (18 July 2022) + +## Improvements + +* The new version check now links out to the changelog for the latest version + so you know what you're gonna get. + +* The new version check now detects standalone installations and provides + correct upgrade instructions. + +## Development + +* The ""__NEXT__"" heading (and description) is no longer included in the + _CHANGES.md_ file in release artifacts and tags, as it's a development-only + section that's always empty in releases. + +* The `NEXTSTRAIN_CLI_LATEST_VERSION` environment variable can be set to `0` to + disable the new version check performed by default during `nextstrain update` + and `nextstrain check-setup`. Other values can be provided to override the + result of querying PyPI for the latest version. + +* A new command, `debugger`, was added as a tool to help with troubleshooting + environment and execution context issues. The only thing it does is invoke + pdb from within the command's context. + + +# 4.1.0 (11 July 2022) + +## Improvements + +* The `nextstrain remote` family of commands now output a nicer error message + that's more interpretable and actionable when a server error (HTTP status + 5xx) is received during an operation against the nextstrain.org remote. + +* The `nextstrain remote upload` command now outputs a nicer error message + that's more interpretable and actionable when the connection to the + nextstrain.org remote server is broken during transfer. + +* Timestamps are now shown for each line of output from an AWS Batch build. + + +# 4.0.0 (24 June 2022) + +This release contains **two potentially-breaking changes** for existing usages. +The circumstances and implications of each are described below. + +## Improvements + +* It is now an error (instead of a warning) to use the `--image` option to + `nextstrain build` when using the ""native"" runner (either explicitly via + `--native` or implicitly via config set by `nextstrain check-setup + --set-default`). The error message is: + + The --image option is incompatible with the ""native"" runner (…). + + If you need to use the ""native"" runner, please omit the --image option. + + If you need the --image option, please select another runner (e.g. + with the --docker option) that supports it. Currently --image is + supported by the Docker (--docker) and AWS Batch (--aws-batch) + runners. You can check if your setup supports these runners with + `nextstrain check-setup`. + + This is a **potentially-breaking change** as invocations using the ""native"" + runner with the `--image` option may exist and be working for users as they + expect. If you encounter this new error after upgrading but your results of + running `nextstrain` commands has always been as-expected, then you can + safely drop the `--image` option from your invocations and avoid the new + error. + +* When running a Snakemake workflow, `nextstrain build` now defaults + Snakemake's `--cores` option to `all` unless `build`'s own `--cpus` option is + provided. If you provide your own `--cores` (or equivalent, e.g. `-j`) + option to Snakemake via `nextstrain build`, as in `nextstrain build . + --cores 2`, then this new default isn't applicable. + + This is a **potentially-breaking change** if you're… + + - …using Snakemake version 5.10 or earlier (such as via our standard Docker + runtime image), _and_ + + - …are not already providing a `--cores` (or equivalent, e.g. `-j`) option + to Snakemake via `nextstrain build`, _and_ + + - …expect your `nextstrain build` invocations to use only a single CPU/core + instead of all CPUs/cores available on your computer. + + If this is the case, you can pass `--cpus 1` to `nextstrain build` to regain + the original behaviour, e.g. `nextstrain build --cpus 1 .`. + + This change will allow upgrading of Snakemake in our Docker runtime image + without inflicting the addition of `--cores` (or equivalent) arguments onto + every existing `nextstrain build` invocation that lacks it. + + For context, Snakemake [requires the `--cores` option as of + 5.11](https://github.com/snakemake/snakemake/issues/283). This has spawned + much discussion + ([1](https://github.com/snakemake/snakemake/issues/308), + [2](https://github.com/snakemake/snakemake/issues/312), + [3](https://github.com/snakemake/snakemake/issues/450), + [4](https://github.com/snakemake/snakemake/issues/885)) + where it was made clear this is an intentional, permanent change and a + default will not be added. By adding our own default, we can insulate our + users from the upstream change and make Nextstrain builds fast-by-default. + Our `--cpus` option can be used to limit CPU usage back from this default if + necessary, and users can always specify `--cores` (or equivalents) + themselves. + +* The `version --verbose` and `check-setup` commands now indicate the default + runner in their output, which is useful context when troubleshooting or just + plain unsure what the default is. + +* The `check-setup` command now exits with an error code if the default runner + is not supported. Prior to this it only exited with an error code if no + runners were supported. + +## Bug fixes + +* When using the AWS Batch runner, the `--cpus` and `--memory` options for + `build` now correctly override the corresponding resource requests in newer + style AWS Batch job definitions. Prior to this they would be ignored by AWS + Batch. Older style AWS Batch job definitions were never affected by this and + continue to work with `--cpus` and `--memory` as expected. See + [#144](https://github.com/nextstrain/cli/issues/144) for more details. + +* A deprecation warning from the `cryptography` module (version 37 and higher) + when running on Python 3.6 is now suppressed as it's just noise to an end + user. This probably moves us closer to dropping 3.6 support ourselves, but + it's not so onerous yet. + +* The rST to plain text conversion used to format `--help` text was fixed to + avoid emitting `\r\n` in the wrong context. + +* The stdout and stderr streams are now configured at program start to always + emit UTF-8. Previously they used the Python defaults, determined in part by + the system defaults, which often resolved to UTF-8, but not always. The code + base assumes UTF-8, and now the streams are guaranteed to match. In + particular, this fixes `UnicodeEncodeError` issues in some contexts on + Windows even when UTF-8 is supported. + +## Documentation + +* This changelog now sports a preamble to set the scene and provide context for + the content. + +## Development + +* The source repo now uses a `+git` local version part to distinguish + actual releases from installations of unreleased code. Relatedly, the + development builds created by CI use a `+git.${commit}` local version part to + pin down the specific commit from which they were built. This is mostly + helpful when reading CI logs or downloading the builds from the CI artifacts. + +* The CI workflow has seen some significant sprucing up and additions, + including sporting a more typical lifecycle with separate steps for build, + test, and release (a new addition). The single test step is also now split + between source tests (unit tests, type checking, linting, etc) and dist tests + (functional tests, integration tests, interface tests, etc). The release + step uploads to PyPI after a release tag is pushed, built, and tested, + replacing manual uploads from a local development environment. Various other + small improvements to CI were also made. + +* We now run CI tests on Windows. \o/ It's not perfect, but this should help + avoid basic Windows-only pitfalls which we might not otherwise notice in a + timely fashion. + +* Our CI now builds (and tests) standalone installation archives (`.tar.gz` for + Linux and macOS, `.zip` for Windows) comprising of: + + 1. A `nextstrain` executable containing a bundled Python interpreter + the + Python stdlib + the Nextstrain CLI code + its dependencies. + + 2. External files (lib, data, etc) that are necessary but can't (for a + variety of reasons) be bundled into the executable. + + These installation archives can be downloaded, extracted, and run in-place + without even a Python interpreter being installed on the host computer, hence + the ""standalone"" moniker. + + Currently these are for development/testing/experimentation purposes only. + We include them as assets on GitHub Releases, but do not provide an automated + means of ""installing"" or unpacking them; those are ultimate goals, but this + is just a first step towards those. If you try out the standalone archives + in the meantime, though, please let us know how it goes (good or bad) by + opening an issue with your experience/feedback/questions. + +* GitHub Releases are now created by CI after making a release to PyPI. These + are visible on the GitHub repo's [releases + page](https://github.com/nextstrain/cli/releases) and various other places on + GitHub. Each GitHub Release includes a copy of the relevant changelog + section and release assets like the Python distributions and standalone + installation archives (see above). Releases on GitHub are currently intended + mostly for informational and notification purposes; the primary release + distribution method is still PyPI and sources downstream of PyPI (e.g. + Conda). + + +# 3.2.5 (23 May 2022) + +## Improvements + +* A better error message with a potential remediation is emitted when requests + to nextstrain.org fail due to stale user tokens. + +## Documentation + +* The cross-reference to Nextstrain Groups documentation is now up to date with + the latest Groups docs. + + +# 3.2.4 (6 April 2022) + +## Bug fixes + +* `update` will no longer overwrite a `docker.image` config setting when the + current/default value includes an explicit `latest` tag. This change makes + it possible to track the ""latest"" Docker runtime image by manually setting + + ```ini + [docker] + image = nextstrain/base:latest + ``` + + in _~/.nextstrain/config_. + ([#163](https://github.com/nextstrain/cli/pull/163)) + +* `update` now correctly prunes old images starting from and including the + just-updated-from image, instead of accidentally skipping it until the next + `update`. + ([#163](https://github.com/nextstrain/cli/pull/163)) + +* `check-setup --set-default` now sets the `docker.image` setting to the most + recent `build-*` image when the Docker runtime is selected as the default. + ([#168](https://github.com/nextstrain/cli/pull/168)) + + +# 3.2.3 (1 April 2022) + +## Bug fixes + +* `remote upload` to nextstrain.org destinations is no longer exceedingly slow. + This was most noticeable for large dataset JSONs. The slowness was a result + of poor IO patterns during gzip compression that weren't triggered by S3 + destinations. Additionally, after benchmarking, the gzip compression level + was reduced from the max (9) to the default (currently 6) as a better + compromise between speed and compressed size. + ([#165](https://github.com/nextstrain/cli/pull/165)) + + +# 3.2.2 (28 March 2022) + +## Documentation + +* A new page describes how to upgrade Nextstrain CLI. + +* The doc page for `nextstrain remote` now links to the pages for its + subcommands. + +* A placeholder in the `nextstrain remote list` command usage now matches the + placeholder used elsewhere in its `--help` output. + + +# 3.2.1 (22 March 2022) + +## Bug fixes + +* `remote upload` no longer gzip compresses files which are already compressed + when uploading them to an S3 remote. This isn't expected in typical usage + when uploading Nextstrain dataset (JSON) or narrative (Markdown) files but + arises when uploading related files to an S3 remote (e.g. a `metadata.tsv.gz` + file to `s3://nextstrain-data/files/zika/`). + ([#161](https://github.com/nextstrain/cli/pull/161)) + +## Development + +* The CI workflow setup steps were simplified a bit. + + +# 3.2.0 (9 March 2022) + +## Bug fixes + +* `check-setup` no longer errors when, on some systems, awk outputs a large + number (bytes of memory reported by /proc/meminfo) in exponential notation. + ([#159](https://github.com/nextstrain/cli/pull/159)) + +## Features + +* The `view` and `remote` family of commands now support ""measurements"" dataset + sidecar files. + ([#156](https://github.com/nextstrain/cli/pull/156)) + + +# 3.1.1 (4 March 2022) + +## Bug fixes + +* The Docker runtime now avoids merging stdout and stderr together when at + least one of stdout or stderr isn't a console (TTY), e.g. when redirecting + one or both streams to a file or piping output to another command. + ([#155](https://github.com/nextstrain/cli/pull/155)) + +* A global lockfile is now used for reading/writing config files instead of + locking the config files themselves. This resolves a regression on Windows + introduced in 3.0.4 which manifested as an `[Errno 13] Permission denied` + error when running `nextstrain update` and `nextstrain check-setup + --set-default`. + ([#157](https://github.com/nextstrain/cli/pull/157)) + +## Documentation + +* The changelog now notes two minor (har har) semantic versioning mistakes in + previous releases. + + +# 3.1.0 (1 March 2022) + +## Features + +* `remote` family of commands now support interacting with nextstrain.org's web + API using the credentials established by the `login` command. + + See the [nextstrain.org + remote](https://docs.nextstrain.org/projects/cli/page/remotes/nextstrain.org/) + documentation for more information. + +* `login` now sports a `--renew` flag to request new tokens with refreshed user + information (e.g. group memberships). + +## Bug fixes + +* `build` now exits 1 (an error) when the AWS Batch job fails due to + infrastructural issues like the EC2 instance its running on being terminated. + Previously it exited 0 (success) despite the job not being successful. + +* `check-setup` now supports Docker hosts with cgroups v2 and better handles + failures in the memory limits check. + +* Messages related to automatic login (authn) management are now send to stderr + instead of stdout. + +* `remote delete` messages now correctly imply each deletion is just about to + happen instead of just happened already. + +* The messages produced when an internal error is detected now suggest filing + an issue on GitHub to report the bug. + +## Documentation + +* The specific release version will now be displayed under the project name in + the sidebar of the documentation pages. + +## Development + +* Many breakages of our CI caused by external changes in upstream testing deps + are now resolved. + + +# 3.0.6 (26 January 2022) + +## Documentation + +* The organization of the documentation sidebar menu is now improved to show + more of the pages instead of burying them in subpage table of contents. + +* The formatting of `--help` output is now slightly improved with regard to + links, but more importantly, richer formatting of content shared between + `--help` and the online documentation is now possible. + + +# 3.0.5 (20 December 2021) + +_This release should have bumped the minor version, not the patch version, +since it added a new feature. —trs, 1 March 2022_ + +## Features + +* `view` now supports a `--host` option to specify the IP address or hostname + on which to listen, complementing the existing `--port` option. + `--allow-remote-access` is now an alias for `--host=0.0.0.0`. + +## Paper cut remedies + +* [netifaces](https://pypi.org/project/netifaces/) is no longer a dependency + since its lack of wheels for recent Python versions means it often requires a + C toolchain for installation. This impacted multiple platforms, including + Windows and Linux. For more context, see discussion starting with [this + issue comment](https://github.com/nextstrain/cli/issues/31#issuecomment-966609539). + + Unfortunately the package no longer has a maintainer, so we can't count on + any timeline for updates and do not have the resources to maintain it + ourselves. Dropping the dep makes the UX of `nextstrain view + --allow-remote-access` a bit poorer, but makes installation a lot easier. + + +# 3.0.4 (3 November 2021) + +_This release should have bumped the minor version, not the patch version, +since it added new features/commands. —trs, 1 March 2022_ + +## Features + +* Three new commands—`login`, `logout`, and `whoami`—for authenticating with + nextstrain.org. These commands manage tokens stored in + _~/.nextstrain/secrets_. No other commands currently use the tokens, but + future features will start using them, e.g. for managing datasets and + narratives on nextstrain.org with the `remote` family of commands. + +## Bug fixes + +* Adjusted dependencies on s3fs and aiobotocore to avoid incompatible versions + being selected by pip. + + aiobotocore released a new version, 2.0.0, with breaking changes and pip's + resolution algorithm chose an older s3fs version which was ""compatible"" by + dep declaration by not actually in practice, leading to `nextstrain build + --aws-batch` throwing errors at runtime. + +* update: Explicitly handle errors from the Docker Hub registry. + +## Documentation + +* AWS Batch: Documented the unintuitive interaction of compute envs and launch + template versions and updated the disk space section for Amazon Linux 2 + compute environments. + +* Updated various links that had moved. + +## Development + +* Ditched Pipenv for a plain venv setup. + +* Dependencies for Read The Docs and CI docs builds are no longer pinned but + will use the latest versions that otherwise meet standard dep declarations. + +* Added pyright tests for additional type checking. This covers some kinds of + checks that mypy does not, and in particular lets us use protocol types to + check the Runner and Remote module interfaces. + +* Enabled more mypy checks and resolve findings. + +* Tests now treat warnings as errors so we can address them, and CI is now + warnings clean. + + Python warnings are important to see earlier than later so we can avoid + spewing warnings to users. + + Sphinx warnings are often authoring mistakes that need to be addressed. + + +# 3.0.3 (23 February 2021) + +## Documentation + +* The help output for `build` now correctly describes the default behaviour of + the `--download` and `--no-download` options. + +* The help output for `build` now warns about the need to escape wildcards or + quote the whole pattern when using `--download` so as to avoid expansion by + the shell. + + +# 3.0.2 (16 February 2021) + +## Bug fixes + +* `update` more gracefully handles Docker not being installed. Although the + command still exits with error (as it currently serves only to pull the + latest Docker image), an uncaught exception isn't thrown. More improvements + to come later with [#87](https://github.com/nextstrain/cli/issues/87). + +* `version` now gracefully handles Docker not being installed when `--verbose` + is given instead of throwing an uncaught exception. + +* `version` now includes Python information when `--verbose` is given, which is + helpful for debugging Python issues, e.g. which Python install is being used. + +* The Docker (`--docker`) runner for `build`, `shell`, and `view` no longer + requests a TTY connected to the container when stdin is not itself a TTY + (e.g. run from a non-interactive shell). This avoids a fatal error from + Docker (""the input device is not a TTY""). + +* Distribution metadata was fixed so that the LICENSE file is no longer + attempted to be installed under the Python installation prefix (e.g. + `/usr/local`). It is instead included inside the ""egg-info"" directory + alongside the code in the Python site libraries. + +## Development + +* Revamp CI by switching from Travis CI to GitHub Actions, expanding the test + matrix to macOS and Python 3.9, and adding an integration test for the + ""native"" build runner. + + +# 3.0.1 (12 February 2021) + +Hotfix for a missing transitive dependency on s3fs via fsspec, which caused +`nextstrain build --aws-batch` invocations to fail when s3fs was not installed. + + +# 3.0.0 (11 February 2021) + +The minimum Python version for installing the Nextstrain CLI itself is now 3.6. + +## Features + +* build: Uploads and downloads for remote AWS Batch builds are now streamed + without the use of temporary local files. This halves the local storage + overhead needed and also speeds up the transfer of large builds since: + + 1. Uploading can start immediately without first writing the whole archive locally + 2. Unmodified files do not need to be downloaded, just their metadata + +* build: The results of remote builds may now be selectively downloaded (or not + downloaded at all). Two new `nextstrain build` options are available: + + --download + --no-download + + The former may be given multiple times and specifies patterns to match + against build dir files which were modified by the remote build. The + latter skips downloading results entirely, which is useful if all you + care about are the logs (such as when re-attaching to a build or when a + build uploads results itself elsewhere). The default is still to + download every modified file. + + Currently this functionality is limited to AWS Batch (`--aws-batch`) builds, + as it is the only remote environment supported. + +## Bug fixes + +* build: Python bytecode files (`__pycache__` and `*.pyc`) are no longer + uploaded or downloaded from remote builds on AWS Batch. + +* build: Log messages about individual file uploads/downloads to AWS Batch are + now printed _before_ each operation, instead _after_, so you can see what + files are taking a while instead of being in the dark until it completes. + +* remote download: A better error message is now produced when a prefix-less + `s3://` URL is provided without the `--recursively` option. + +## Documentation + +* Clarify how remote builds on AWS Batch acquire AWS credentials. + +* Fix broken links into AWS documentation for boto3. + +* Switch to our [Nextstrain theme for + Sphinx](https://github.com/nextstrain/sphinx-theme) + +* Some documentation has been shuffled around to better fit within the larger + [docs.nextstrain.org](https://docs.nextstrain.org) effort. Redirects were + put into place for any moved RTD URLs. + +## Development + +* Various improvements to the Read The Docs and Sphinx setup. + +* Upgrade locked Pipenv development environment. + +* Fix type checking failures under newer versions of mypy. + + + +# 2.0.0.post1 (15 June 2020) + +## Documentation + +* The AWS Batch documentation and 2.0.0 release notes (below) now include + information about the additional necessity of granting users the ability to + `iam:PassRole` for the role used by Batch jobs. + + +# 2.0.0 (2 June 2020) + +## Features + +* build: The AWS Batch runner now supports overriding the image hardcoded in + the Batch job definition. Use the `--image` command-line option, the + `NEXTSTRAIN_DOCKER_IMAGE` environment variable, or the `docker.image` config + setting. This means that both `--docker` and `--aws-batch` builds will now + use the same container image, increasing reproducibility and customizability. + + This is a **potentially-breaking change**, as it requires your AWS IAM users + are allowed to perform the `batch:RegisterJobDefinition` action and + `iam:PassRole` for the your configured job role (typically + _NextstrainJobsRole_). The [example _NextstrainJobsAccessToBatch_ IAM + policy](doc/aws-batch.md#nextstrainjobsaccesstobatch) in the [AWS Batch + docs](doc/aws-batch.md) is updated to reflect these new privileges. + +* build: The new `--cpus` and `--memory` options allow limits to be specified + for containerized (Docker, AWS Batch) builds. These both automatically + inform Snakemake's resource scheduler and the AWS Batch instance size + selection. If your builds use Snakemake-based workflows, using these new + options is better than specifying `--cores …` or `--resources mem_mb=…` + directly. + +* version: Verbose output now includes the ""native"" versions of Augur and + Auspice, if available. + +## Bug fixes + +* view: Auspice v2 dataset JSONs are now detected and included in the list of + available datasets message printed to the console. + +* view: Auspice v1 datasets are now only listed if both the tree and meta JSON + files exist. Previously, incomplete datasets with only the tree JSON were + listed. + +## Documentation + +* The README now documents known issues with Windows. + +## Development + +* Pipenv is now used to provide an easier and more consistent development + environment. + +* pytest is now used to run mypy, flake8, and doctests. + + +# 1.16.7 (20 May 2020) + +## Bug fixes + +* AWS Batch builds are now more resilient in the face of transient network or + client errors when uploading the build directory and following build logs. + Thanks Tony Tung! + +# 1.16.6 (20 May 2020) + +## Bug fixes + +* The previous release did not pass mypy's type checks due to a technicality; + mypy has now been placated. + +## Documentation + +* check-setup: Success or failure is (hopefully) more clearly messaged now. + This was muddied over time by adding support for the native and AWS Batch + runners, and we've seen several support requests because of confusion here. + +* Installation instructions in the README now document all supported computing + environments, or ""runners"". Pipx is also mentioned as a nice alternative to + Pip. + +* Detaching from AWS Batch builds with `--detach` and Control-Z is now + mentioned in the AWS Batch documentation. + +* A direct reference to the AWS Batch User Guide on memory management details + was added, because AWS docs can be hard to navigate. + +* The units documented to be used by the `--aws-batch-memory` option are now + correct. + +* Runner-selection options (`--docker`, `--native`, `--aws-batch`) are now in + their own option group to reduce clutter among the help output. They are + only visible with `--help-all` now, like development options. With the use + of `nextstrain check-setup --set-default` now emphasized, these options need + not be as prominent. + +* The top-level description in `nextstrain --help` output now says more than + three words. :D + +# 1.16.5 (22 April 2020) + +## Features + +* build: AWS Batch jobs now require Ctrl-C to be pressed twice _within 10s_ to + cancel a job. This is an additional guard on top of 1.16.4's change so that + if you accidentally press Ctrl-C once you can't accidentally press it again + 30 minutes later and ruin your build. + +# 1.16.4 (22 April 2020) + +## Features + +* build: AWS Batch jobs now require Ctrl-C to be pressed twice to cancel the + job. This guards a potentially unwanted action from being used accidentally + by requiring confirmation with a second Ctrl-C. + +* build: AWS Batch jobs now report the current job status when re-attaching. + Previously the current job status was never reported, only the next status + transition. For a PENDING or RUNNING job, it might be some time to the next + transition. + +# 1.16.3 (22 April 2020) + +## Features + +* build: AWS Batch jobs now include more detail about why the container exited + when available. This surfaces useful messages like ""OutOfMemoryError: + Container killed due to memory usage"" in addition to the exit status. + +## Documentation + +* check-setup: Describe how `--set-default` chooses an environment. Thanks Mary + Larrousse! + +## Bug fixes + +* Fix missing import in our gzip utilities which could cause a runtime error + (NameError) when running `nextstrain remote download` on S3 objects with a + `Content-Encoding` header set to a value other than `gzip` or `deflate`. + This circumstance is unlikely, but not impossible. + +## Development + +* Use Flake8 for static runtime safety and correctness checks + + +# 1.16.2 (16 March 2020) + +## Bug fixes + +* deploy/remote upload: Some files, but not all, were being truncated during + upload due to a bug in gzip compression handling. Now the whole file makes + it to its destination. More details in + [#62](https://github.com/nextstrain/cli/pull/63). + +* build: The default arguments for `snakemake` are no longer used if a + different program to run is specified with `--exec`. + + +# 1.16.1 (25 February 2020) + +## Documentation + +* Update README to include the latest usage information, which mentions the new + `remote` command. + + +# 1.16.0 (25 February 2020) + +## Features + +* The `deploy` command is now an alias for the `remote upload` command. + +* The new `remote list`, `remote download`, and `remote delete` commands allow + listing, downloading, and deleting remote datasets and narratives which were + uploaded using `deploy` / `remote upload`. Currently only direct s3:// + destinations are supported, but its anticipated that Nextstrain Groups will + be supported as first-class destinations in the future. + +## Bug fixes + +* deploy/remote upload: Invalid credentials are now properly caught and messaged about. + +* deploy/remote upload: Files are now deployed/uploaded using streaming + compression instead of buffering the whole file in memory first. + + +# 1.15.0 (18 February 2020) + +## Features + +* Environment variables for [AWS + credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-environment-variables) + (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `AWS_SESSION_TOKEN`) are + now passed through to builds. This lets builds which use data on S3 to work + transparently, for example. + +* Environment variables for [ID3C](https://github.com/seattleflu/id3c) + (`ID3C_URL`, `ID3C_USERNAME`, and `ID3C_PASSWORD`) are now passed through to + builds. This lets Seattle Flu Study builds which use data in an ID3C + instance to work transparently. + + +# 1.14.0 (24 September 2019) + +_No changes since 1.14.0b1, described below._ + + +# 1.14.0b1 (17 September 2019) + +## Features + +* The `build` command now supports detaching from and re-attaching to builds + run on AWS Batch (`--aws-batch`). + + This adds a feature we've wanted from the beginning of the CLI. By starting + the build with `--detach`, a remote job is submitted and the command + necessary to `--attach` to the job later is printed. This command includes + the job id and can be used as many times as desired, including while the + remote job is running or after it has completed. It will even work on other + computers or for other people, although you may need to modify the local + build path to a directory of your choosing. The directory may be empty, in + which case all build context will be restored there from the remote job. + + AWS Batch builds may also be interactively detached by pressing Control-Z. + Normally this would suspend a Unix process (which could then be resumed with + `fg` or `bg` or SIGCONT), but in the same spirit, `nextstrain build` will + detach from the remote job instead and exit the local process. This also + parallels nicely with our existing Control-C job cancellation support. + + There are currently no facilities to track job state locally or list + outstanding jobs, but these features may be added later if it seems they'd be + useful. As it stands with this new feature, one pattern for launching + multiple detached jobs and picking them up later is: + + # Loop over several `nextstrain build` commands, appending the last + # line to a shell script. + nextstrain build --aws-batch --detach build-a/ | tail -n1 | tee -a pickup-jobs.sh + nextstrain build --aws-batch --detach build-b/ | tail -n1 | tee -a pickup-jobs.sh + … + + # Then, sometime later: + bash pickup-jobs.sh + +* The `--aws-batch` runner for the `build` command no longer requires + permission to perform the globally-scoped AWS IAM action + `s3:ListAllMyBuckets`. Instead, it uses the `HEAD ` S3 API which + requires either `s3:ListBucket`, which can be scoped to specific buckets in + IAM grants, or `s3:HeadBucket`, which is globally-scoped but does not reveal + bucket names. More details on these IAM actions are in the + [S3 documentation](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html#using-with-s3-actions-related-to-buckets). + + +# 1.13.0 (10 September 2019) + +## Features + +* The `deploy` command no longer requires permission to perform the + globally-scoped AWS IAM action `s3:ListAllMyBuckets`. Instead, it uses the + `HEAD ` S3 API which requires either `s3:ListBucket`, which can be + scoped to specific buckets in IAM grants, or `s3:HeadBucket`, which is + globally-scoped but does not reveal bucket names. More details on these IAM + actions are in the [S3 documentation](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html#using-with-s3-actions-related-to-buckets). + + +# 1.12.0 (5 September 2019) + +## Features + +* The `deploy` command now supports files other than JSON data files, such as + Markdown narratives, by setting the correct content type on upload. + + +# 1.11.2 (3 September 2019) + +## Bug fixes + +* This release fixes a regression in the `view` command which caused + ""connection reset"" or ""empty response"" errors. The regression only affected + versions 1.11.0 and 1.11.1 of the Nextstrain CLI when used with Auspice 1.38.0 + via the `nextstrain/base:build-20190828T223744Z` image. Thanks to Thomas + Adams for the excellent bug report! + + +# 1.11.1 (30 August 2019) + +## Bug fixes + +* The `check-setup` command no longer errors when Docker isn't installed. + + +# 1.11.0 (30 August 2019) + +## Features + +* The `view` command now supports `--native` flag to run in the native ambient + environment. + +* The `check-setup` command now supports a `--set-default` flag to save the + first supported environment to the Nextstrain CLI's config file. This means + that you don't have to specify `--native` (or `--aws-batch`) every time if + you don't have/want Docker support. + +## Bug fixes + +* The `--verbose` flag to the `version` command will no longer cause the Docker + image to be downloaded when it isn't available locally. + +## Documentation + +* Describe the somewhat annoying process of how to increase the disk space + available to AWS Batch jobs in the AWS Web Console. + + +# 1.10.2 (23 August 2019) + +## Bug fixes + +* The [environment variables used by Augur](https://docs.nextstrain.org/projects/augur/page/usage/envvars.html) + are now passed through to --docker and --aws-batch builds. + + +# 1.10.1 (26 March 2019) + +## Features + +* The `view` command now sports a `--port` option to use an alternate port for + the viewer. + + +# 1.10.0 (22 February 2019) + +## Features + +* Add ability to specify vCPU and memory when running AWS Batch jobs via + `--aws-batch-cpus` and `--aws-batch-memory` or via specification in + `~/.nextstrain/config` or via environment variables + `NEXTSTRAIN_AWS_BATCH_CPUS` and `NEXTSTRAIN_AWS_BATCH_MEMORY`. This requires + corresponding proper setup of compute environment in AWS Batch console. + +# 1.9.1 (11 February 2019) + +## Features + +* Restore the modification times of files when unzipping results from an AWS + Batch run. This allows Snakemake's dependency resolution to properly + determine file staleness, which in turn allows local builds to continue where + AWS Batch builds leave off (e.g. running the bulk of the computation on AWS + Batch and then iterating on subsequent trivial steps locally). + + +# 1.9.0 (8 February 2019) + +## Features + +* Builds run on AWS Batch no longer delete the build dir zip file from S3 or + the job log stream from CloudWatch, making it easier to debug and + troubleshoot Batch builds. The Batch setup documentation is updated to note + that the previously suggested retention policies are now the only thing + preventing runaway data storage costs (and thus a must). + +## Bug fixes + +* Declare missing dep on setuptools, used via `pkg_resources` by the + `check-setup` and `update` commands. setuptools nearly always exists already + on Python installs, especially when nextstrain-cli is installed using pip, + but nearly always is not always. + +## Development + +* Static type checking now passes again thanks to a work around for a mypy bug + related to namespace packages. + + +# 1.8.1 (21 January 2019) + +## Features + +* The `check-setup` command now tests if the local Docker image is new enough + for this version of the CLI. + + +# 1.8.0 (18 January 2019) + +## Bug fixes + +* Docker images between `build-20190115T232255Z` and `build-20190116T000613Z` + (inclusive) broke the `nextstrain view` command. It is fixed in this version + of the CLI, 1.8.0, in tandem with new images, starting with + `build-20190119T045444Z`. If your `view` command is broken, running + `nextstrain update` and following the instructions to upgrade to version + 1.8.0 of the CLI should resolve the issue. + +* AWS Batch builds now avoid uploading files matching `environment*` in the + build directory, as such files are commonly used for storing sensitive + environment values. + + +# 1.7.3 (28 December 2018) + +## Features + +* The automatic check for newer versions of the CLI, which happens on the + `update` and `check-setup` commands, now produces a better, + more-likely-to-work suggested invocation of pip to perform the upgrade. + + +# 1.7.2 (28 December 2018) + +## Features + +* The `build` command now runs `snakemake` with the `--printshellcmds` option + for improved log output. + +## Bug fixes + +* User-provided paths are now resolved strictly—they must exist—on both Python + 3.5 and ≥3.6, not just 3.5. This discrepancy was unlikely to result in any + noticeable problems because of other existence checks which were performed. + Nevertheless, the change is good housekeeping and helps ensure robustness. + +* The `update` command no longer errors on Python 3.6.0 and 3.6.1 when the + `~/.nextstrain/` does not exist (for example, when upgrading from CLI + versions before 1.7.0). [#37](https://github.com/nextstrain/cli/issues/37) + +## Development + +* Continuous integration testing now includes a much fuller range of Python + versions in order to more quickly catch bugs like the one affecting `update` + above. + +* Continuous integration testing switched to running the + [zika-tutorial](https://github.com/nextstrain/zika-tutorial), a simplified + build more suitable for our needs. + + +# 1.7.1 (5 December 2018) + +## Bug fixes + +* The `shell` command no longer throws an unexpected exception about a missing + `warn()` function when a non-existent build directory is given. The + user-friendly error is printed instead, as expected. + + +# 1.7.0 (26 November 2018) + +## Features + +* Builds can now be run remotely on [AWS Batch](https://aws.amazon.com/batch/) + by passing the `--aws-batch` flag to the `build` command. See `nextstrain + build --help` for more information. Setup required to support this is + documented in [`doc/aws-batch.md`](doc/aws-batch.md). + +* The `update` command now pulls down new images by their `build-*` tag instead + of tracking the mutable `latest` tag. Our build tags are, most importantly, + not updated after creation and thus are suitable references for reproducible + runs. The output of `nextstrain version --verbose` now includes the specific + build tag. + +* The `check-setup` command now tests the amount of memory available to + containers and warns if it less than 2GB. This is particularly important on + Windows and macOS where Linux containers are run inside a VM on the host. + The VM may have limited memory allocated to it, leading to out-of-memory + errors in builds. + +## Documentation + +* Installation instructions in the README are now more detailed. + +* A big picture overview of where the CLI fits into the Nextstrain ecosystem is + included in the README for situating newcomers. + +* The README now refers to Docker Desktop, the new name for Docker Community + Edition. + + +# 1.6.1 (25 September 2018) + +## Features + +* The `shell` command announces you're entering the build environment, prints + information about mapped volumes, and describes how to leave the environment. + + +# 1.6.0 (18 September 2018) + +## Bug fixes + +* On Windows, fix an issue where the `build` and `shell` commands spawn the + `docker run` process but also immediately return the user to the + command-line. For `shell`, the situation was weirder still because the user + ended up with _two_ command prompts (cmd.exe and bash) but only one appeared + to win when reading from the shared stdin. + + +# 1.5.0 (4 September 2018) + +## Features + +* The `build` command now supports a `--native` flag to run the build outside + of any container image, that is, within the ambient environment. That + environment might be provided by conda or a cluster module system or custom + installs or some other thing. Docker remains the default, although it + may be explicitly specified with `--docker`. Other runners are planned for + the future. The idea is that the cli as a user-facing tool for Nextstrain is + separate from a containerized Nextstrain environment (although the two work + well together). + +* The `build`, `view`, and `shell` commands now show an abbreviated set of + common options when passed `--help`. The full set of options is available + using `--help-all`. The idea is to make the initial output more approachable. + +## Development + +* The README now describes how to annotate the type of variable and use other + typing features in a way that's compatible with Python 3.5 + +* Package metadata for PyPi is slightly improved. + + +# 1.4.1 (11 August 2018) + +## Documentation + +* Minor updates to README and command help strings + + +# 1.4.0 (9 August 2018) + +## Features + +* A new `shell` command launches an interactive shell (bash) inside the build + environment, which is useful for running ad-hoc commands and debugging. + + +# 1.3.0 (9 August 2018) + +## Features + +* The `update` command now prunes old Docker images after downloading new ones. + This functionality relies on our new, labeled images. Older images will have + to be manually pruned as a one-time step. See `docker image prune` for more + information. Note that locally built images which are tagged + nextstrain/base:latest will be pruned when `update` is run. Protect such + images by giving them an additional tag. + +* The versions of the Docker image and individual Nextstrain components in the + image are shown when the `version` command is run with the `--verbose` flag. + + +# 1.2.0 (1 August 2018) + +## Features + +* A new `deploy` command supports uploading data files to S3, allowing the + complete pathogen build lifecycle to happen using this package. + +* The `check-setup` and `update` commands now check if the CLI itself is out of + date and could be updated. + +## Documentation + +* Brief descriptions of the changes in each release are now kept in the + `CHANGES.md` file. You're reading it! + +## Development + +* Describe basic development practices for this package in the README. + +* Commit to [semantic versioning](https://semver.org), which I'd been + neglecting previously when bumping versions. + +* Static type checking is now supported for a small fraction of the source code + and runs clean under mypy. This is included in Travis CI testing. The goal + is to add more type annotations going forward. +","Markdown" +"Pathogens","nextstrain/cli","doc/development.md",".md","9930","248","# Nextstrain CLI Development + +Development of `nextstrain-cli` happens at . + +We currently target compatibility with Python 3.8 and higher. + +Versions for this project follow the [Semantic Versioning rules][]. + +## Setup + +Setup an isolated development environment in `.venv/` with: + + ./devel/setup-venv + +Activate the venv to run any of the commands below: + + source .venv/bin/activate + +(Or alternatively, run the commands below via `./devel/venv-run …`.) + +Now test that you can run: + + nextstrain --help + +The development environment includes our dev tools (described below): + + pytest # runs doctests as well as cram, pyright, and flake8 + cram tests/*.cram + pyright + flake8 + make -C doc livehtml + +## Running with local changes + +The project is installed into editable mode when using the venv setup above, so +any changes you make during development will be used automatically. + +If you need to run with local changes in setups without editable mode, you can +run `./bin/nextstrain` to test your local changes without installing them. +(Note that `./bin/nextstrain` is not the script that gets installed by pip as +`nextstrain`; that script is generated by the `entry_points` configuration in +`setup.py`.) + +## External resources + +Environment variables can be used to change the location or identity of +external resources/services used by some Nextstrain CLI commands. This is +helpful when performing manual integration testing against development or +testing resources. + +When running the [nextstrain.org server][] locally, you can make the +`nextstrain remote` family of commands talk to it instead of the real +nextstrain.org by setting `NEXTSTRAIN_DOT_ORG`, e.g.: + + NEXTSTRAIN_DOT_ORG=http://localhost:5000 \ + nextstrain remote ls nextstrain.org/groups/test + +If you need authenticated access and the local server is using the AWS Cognito +resources from our [""testing"" configuration][], you can configure `nextstrain` +with the same, e.g.: + + export NEXTSTRAIN_DOT_ORG=http://localhost:5000 + + nextstrain login + nextstrain whoami + nextstrain remote ls groups/test-private + +Most of the times the above is not necessary, however, as you can specify the +local remote explicitly instead of pretending it's nextstrain.org, e.g.: + + nextstrain remote ls http://localhost:5000/groups/test + + nextstrain login http://localhost:5000 + nextstrain whoami http://localhost:5000 + nextstrain remote ls http://localhost:5000/groups/test-private + +Setting `NEXTSTRAIN_DOT_ORG` is mostly useful when testing the default-remote +code paths themselves. + +## Releasing + +New releases are made frequently and tagged in git using a [_signed_ tag][]. +There is a `./devel/release` script which will prepare a new release from your +local repository. Run this script using the isolated development environment. +It ends with instructions for you on how to push the release commit/tag. + +When a release tag is pushed, the [CI workflow][] builds [source +distributions][] and [built distributions][] (wheels), tests them, and if tests +pass, uploads them to [the nextstrain-cli project on +PyPi](https://pypi.org/project/nextstrain-cli). + +The GitHub repository is configured with [rulesets][] restricting tag management +such that only maintainers have bypass permission to create tags and only admins +have bypass permission to delete and update tags. + +### Recovering from release CI failures + +When CI for a release fails due to transient errors (like DNS or other network +issues), it can be recovered by retrying the GitHub Action workflow run. + +However, when CI for a release fails due to non-transient errors that require a +code change, the recovery method is to cut a new release. If only non-packaged +changes were made (e.g. fixes to the CI process itself but not in +`nextstrain`), then bump the version to a [post-release version][] (e.g. +`X.Y.Z.postN`). Otherwise, use an appropriate semantic version bump. Update +the changelog to note the unreleased version as such and that the new version +contains all the changes from the unreleased version. You can compare to +previous unreleased versions for wording. + +Two examples of recovering from a failed release: + + * The release of + [7.3.0](https://github.com/nextstrain/cli/blob/7ba087b4/CHANGES.md#730-19-september-2023) + failed due to issues with CI. + [CI was fixed](https://github.com/nextstrain/cli/pull/314) and + [7.3.0.post1](https://github.com/nextstrain/cli/blob/7ba087b4/CHANGES.md#730post1-19-september-2023) + was released. + + * The release of + [6.0.1](https://github.com/nextstrain/cli/blob/7ba087b4/CHANGES.md#601-3-january-2023) + failed and required changes to packaged code. + [6.0.2](https://github.com/nextstrain/cli/blob/7ba087b4/CHANGES.md#602-3-january-2023) + was released with the fix. + +### Updating the Bioconda recipe + +Typically the [autobump PR][] created by BiocondaBot when it notices the PyPI +release will be sufficient. Look it over and comment: + +> @BiocondaBot please add label + +to get it reviewed and merged. + +However, if there are changes to the minimum Python version or dependency list in `setup.py`, then +create a PR in [bioconda-recipes][] translating the changes in `setup.py` to +[Conda package match specifications][]. +Follow instructions at [nextstrain/bioconda-recipes/README.md][]. +You'll need to ask that the [autobump PR][] is closed in favor of your own PR. + +## Tests + +Tests are run with [pytest](https://pytest.org). To run everything, use: + + ./devel/pytest + +This includes Cram and the type annotation and static analysis checks described +below. + +## Cram + +Tests for the command-line interface use [Cram](https://bitheap.org/cram/) and +are written in `tests/*.cram` files. You can run individual test files, e.g.: + + $ cram -v tests/version.cram + tests/version.cram: passed + # Ran 1 tests, 0 skipped, 0 failed. + +Cram tests should always start by sourcing `tests/env` so that they run +identically regardless of if they're run directly with `cram` or via +`./devel/pytest`. + +## Type annotations and static analysis + +Our goal is to gradually add [type annotations][] to our code so that we can +catch errors earlier and be explicit about the interfaces expected and +provided. Annotation pairs well with the functional approach taken by the +package. + +During development you can run static type checks using [pyright][]: + + $ npx pyright + ... + Found 40 source files + 0 errors, 0 warnings, 0 infos + Completed in 2sec + +There are also many [editor integrations for Pyright][]. + +The [`typing_extensions`][] module should be used for features not yet available +in the the standard `typings` module of supported Python versions. + +We also use [Flake8][] for some static analysis checks focusing on runtime +safety and correctness. You can run them like this: + + $ flake8 + # No output is good! + +## Documentation + +A Sphinx project for Nextstrain CLI's documentation, primarily [reference and +explanatory material](https://documentation.divio.com), lives in the `doc/` +directory. Pages are written in reStructuredText (rST), though some older +pages originally written in Markdown haven't been converted yet. + +To locally build the HTML version of the documentation (i.e. what's served at +), run: + + $ make -C doc livehtml + +This will start a server on which you can browse. +Changes to source documentation files will be reflected automatically. + +The rST source documentation files for the individual `nextstrain` commands are +generated from the Python source files and checked into version control. +Changes should be kept in sync by regenerating with: + + $ ./devel/generate-command-doc + +This will emit the file paths it updates, if any. The +`devel/generate-command-doc` program also has `--diff` and `--check` modes +which may be helpful during development; see `--help` for details. + +The project changelog, `CHANGES.md`, is included with [MyST-Parser][] Markdown +extensions in the documentation as the generated file `doc/changes.md`. Keep +it in sync by regenerating with: + + $ ./devel/generate-changes-doc + +This behaves similarly to `devel/generate-command-doc`. + +You may sync all generated doc with: + + $ ./devel/generate-doc + +This also happens automatically as part of the documentation build process to +ensure the built docs always reflect the current source. Tests run in CI +ensure the generated files are current and don't vary based on ambient +environmental factors. + +[Semantic Versioning rules]: https://semver.org +[nextstrain.org server]: https://github.com/nextstrain/nextstrain.org +[""testing"" configuration]: https://github.com/nextstrain/nextstrain.org/tree/@/env/testing/ +[_signed_ tag]: https://git-scm.com/book/en/v2/Git-Tools-Signing-Your-Work +[CI workflow]: ../.github/workflows/ci.yaml +[source distributions]: https://packaging.python.org/en/latest/glossary/#term-Source-Distribution +[built distributions]: https://packaging.python.org/en/latest/glossary/#term-Built-Distribution +[rulesets]: https://github.com/nextstrain/cli/settings/rules +[type annotations]: https://www.python.org/dev/peps/pep-0484/ +[pyright]: https://github.com/microsoft/pyright +[editor integrations for Pyright]: https://microsoft.github.io/pyright/#/installation +[`typing_extensions`]: https://pypi.org/project/typing-extensions +[Flake8]: https://flake8.pycqa.org +[post-release version]: https://peps.python.org/pep-0440/#post-releases +[autobump PR]: https://github.com/bioconda/bioconda-recipes/pulls?q=is%3Apr+author%3Abiocondabot+nextstrain-cli +[bioconda-recipes]: https://github.com/bioconda/bioconda-recipes +[Conda package match specifications]: https://docs.conda.io/projects/conda-build/en/stable/resources/package-spec.html#package-match-specifications +[nextstrain/bioconda-recipes/README.md]: https://github.com/nextstrain/bioconda-recipes/blob/readme/README.md +","Markdown" +"Pathogens","nextstrain/cli","doc/changes.md",".md","125167","3198","# Changelog + +This is the changelog for Nextstrain CLI. All notable changes in a release +will be documented in this file. + +This changelog is intended for _humans_ and follows many of the principles from +[Keep a Changelog](https://keepachangelog.com/en/1.0.0/). + +Versions for this project follow the [Semantic Versioning +rules](https://semver.org/spec/v2.0.0.html). Each heading below is a version +released to [PyPI](https://pypi.org/project/nextstrain-cli/) and the date it +was released. The ""__NEXT__"" heading below describes changes in the unreleased +development source code and as such may not be routinely kept up to date. + + +(v-next)= +## __NEXT__ + + +(v10-4-2)= +## 10.4.2 (7 January 2026) + +(v10-4-2-improvements)= +### Improvements + +* We now produce standalone installation archives for Linux running on aarch64 + hardware (aka arm64). The standalone installer will use these archives + starting with this release. + ([#489](https://github.com/nextstrain/cli/pull/489), + [#490](https://github.com/nextstrain/cli/pull/490)) + +(v10-4-2-bug-fixes)= +### Bug fixes + +* Updated the s3fs dependency to avoid versions starting with 2025.12.0. This + maintains a dependency on `boto3` which is used for various commands. + ([#495](https://github.com/nextstrain/cli/pull/495)) + +(v10-4-1)= +## 10.4.1 (14 October 2025) + +(v10-4-1-bug-fixes)= +### Bug fixes + +* The dependency on `types-boto3-s3` is now development-only (the `dev` extra). + This eases Conda packaging and is consistent with dev-only dependencies on + other type definition packages. + ([#485](https://github.com/nextstrain/cli/pull/485)) + + +(v10-4-0)= +## 10.4.0 (13 October 2025) + +(v10-4-0-improvements)= +### Improvements + +* `nextstrain run` now resolves workflow names by looking in the pathogen + registration (`nextstrain-pathogen.yaml`) for an explicitly registered path. + If no path is registered for a workflow, `nextstrain run` still falls back to + using the workflow name for the workflow path. + + This allows for workflow names that are not also directory paths within the + pathogen source, which is useful for pathogens that are structured + non-conventionally for one reason or another. The decoupling of workflow + names from paths also means that the workflow can be relocated within the + pathogen repo without breaking the name (i.e. the external interface to the + workflow). + + As an example, the following workflow registration: + + ```yaml + workflows: + phylogenetic: + path: . + compatibility: + nextstrain run: yes + ``` + + would allow invocation of a `phylogenetic` workflow located at the top-level + of the pathogen source, such as in [zika-tutorial](https://github.com/nextstrain/zika-tutorial). + ([#481](https://github.com/nextstrain/cli/pull/481)) + +* Pathogen registration files (`nextstrain-pathogen.yaml`) now have a formal + schema, , and registrations will + be validated against the schema if they declare so with `$schema`. + + Unknown `$schema` ids are ignored. Validation errors will cause the pathogen + registration file to be ignored (as if it didn't exist). + + Malformed registration files are warned about during the initial pathogen + setup with `nextstrain setup` and during subsequent pathogen version updates + with `nextstrain update`, but not when using an existing pathogen setup with + `nextstrain run` (so as not to be too noisy). + ([#482](https://github.com/nextstrain/cli/pull/482)) + +* The AWS Batch runtime now supports storing workdir and envdir archives in S3 + under a key prefix. This optional key prefix is provided after the bucket + name in the [`--aws-batch-s3-bucket` option][] or the equivalent + [`aws-batch.s3-bucket` config field][] or [`NEXTSTRAIN_AWS_BATCH_S3_BUCKET` + environment variable][]. For example, providing + + --aws-batch-s3-bucket=some-bucket/a/prefix/ + + would result in workdir archives stored at + + s3://some-bucket/a/prefix/6116f3e3-9bc0-4769-99e3-adb71b4d82c0.zip + + For extra clarity, particularly when providing a prefix, the value may now be + specified as a URL (e.g. `s3://some-bucket/a/prefix` or + `s3://another-bucket`), though, for backwards compatibility, doing so is not + required. A key prefix may be useful for the organization of the objects in + a bucket, particularly when the bucket is accessed directly, outside of + Nextstrain CLI. + ([#483](https://github.com/nextstrain/cli/pull/483)) + +[`--aws-batch-s3-bucket` option]: https://docs.nextstrain.org/projects/cli/en/10.4.0/commands/build/#cmdoption-nextstrain-build-aws-batch-s3-bucket +[`aws-batch.s3-bucket` config field]: https://docs.nextstrain.org/projects/cli/en/10.4.0/runtimes/aws-batch/#term-aws-batch.s3-bucket +[`NEXTSTRAIN_AWS_BATCH_S3_BUCKET` environment variable]: https://docs.nextstrain.org/projects/cli/en/10.4.0/runtimes/aws-batch/#envvar-NEXTSTRAIN_AWS_BATCH_S3_BUCKET + +(v10-4-0-bug-fixes)= +### Bug fixes + +* The AWS configuration for S3 operations for the AWS Batch runtime no longer + sets 3 as the max number of attempts for retries. To explicitly control + [retries](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/retries.html) + yourself, use AWS' own support + via [config files](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/configuration.html#using-a-configuration-file) + (`max_attempts`) + and [environment variables](https://boto3.amazonaws.com/v1/documentation/api/1.40.48/guide/configuration.html#using-environment-variables) + (`AWS_MAX_ATTEMPTS`). The previous configuration precluded the use these AWS + config files and env vars to control max attempts. Note that 3 attempts is + already the AWS default, so no behaviour change is expected and no action is + needed during upgrade. + ([#483](https://github.com/nextstrain/cli/pull/483)) + + +(v10-3-0)= +## 10.3.0 (26 September 2025) + +This release adds explicit (i.e. tested) support for Python version 3.13. +([#473](https://github.com/nextstrain/cli/pull/473)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/10.3.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +(v10-3-0-improvements)= +### Improvements + +* `nextstrain setup ` and `nextstrain version --pathogens` now list + the available workflows (e.g. `ingest`, `phylogenetic`) for a pathogen if the + workflows are registered as compatible with `nextstrain run` in the + pathogen's `nextstrain-pathogen.yaml` file. + ([#461](https://github.com/nextstrain/cli/pull/461), [#472](https://github.com/nextstrain/cli/pull/472)) + +* Snakemake's storage support downloaded files (stored in `.snakemake/storage/`) + are now downloaded from AWS Batch builds by default. + + The runtime image used must be at least `nextstrain/base:build-20250721T201347Z` + for these Snakemake storage files to be available for download from the AWS + Batch job. + ([#460](https://github.com/nextstrain/cli/pull/460)) + +* `nextstrain run` now supports an alternative invocation where a path to a + local directory that is a pathogen repository can be given instead of a + pathogen name (and optionally version). This allows `nextstrain run` to be + used with pathogen repos managed outside of Nextstrain CLI (i.e. not by + `nextstrain setup` and `nextstrain update`), which can be useful for the + analysis directory support and local testing. The workflow to run is still + given separately by name (not path). + ([#476](https://github.com/nextstrain/cli/issues/476)) + +* When `nextstrain setup ` and `nextstrain update ` + encounter an authentication error downloading from pathogen source URLs, the + error message now includes a hint, if applicable, noting the presence of + netrc-provided credentials and possible resolutions. This aids in resolving + errors arising from stale GitHub credentials present in some users' netrc + files (as managed by older versions of the GitHub CLI, `gh`). + ([#479](https://github.com/nextstrain/cli/issues/479)) + +* When Nextstrain CLI detects that a new version of itself is available, it + will now output the instructions on how to upgrade to that new version after + (instead of before) the normal output from the running command. This makes + it easier to find and follow the instructions when output is long. The + notices of the new version will be output both before and after normal + output. + ([#475](https://github.com/nextstrain/cli/issues/475)) + +* For most installation methods (i.e. standalone, Pip, pipx, and Conda), the + process of updating Nextstrain CLI itself is now automated by a single + `nextstrain update cli` command. This is suggested in new version notices + emitted by automatic new version checks (along with the previously-suggested + update commands that vary by installation method). Integrating with + `nextstrain update` puts updates to the CLI alongside updates to the runtimes + and pathogens. + ([#475](https://github.com/nextstrain/cli/issues/475)) + +(v10-3-0-bug-fixes)= +### Bug fixes + +* `nextstrain setup @` and `nextstrain update @` + no longer result in a 404 error if `` includes a slash and it is a + valid version specifier. ([#459](https://github.com/nextstrain/cli/pull/459)) + +* Reverting changes made in 10.2.1, `nextstrain setup ` and + `nextstrain update ` will once again attempt to use a local netrc + file for authentication when downloading pathogen source URLs. This also + reinstates support in those cases for configuring outgoing network proxies + and CA certificate trust stores via environment variables. Support for + private repositories is not unintentional and is something we intend to + provide. + ([#478](https://github.com/nextstrain/cli/issues/478)) + +* `nextstrain run` now overrides (i.e. suppresses) any [""workdir:"" + directives](https://snakemake.readthedocs.io/en/stable/snakefiles/configuration.html) + in a workflow by explicitly setting the working directory when it invokes + Snakemake. This avoids writing files into the pathogen/workflow source + directories when non-compatible (or broken) workflows are used with + `nextstrain run` despite the warnings issued. Such workflows are more likely + to error and fail now early on rather than ""succeed"" but produce output files + in the wrong location. + ([#476](https://github.com/nextstrain/cli/issues/476)) + +* When a standalone installation of Nextstrain CLI suggests a command to run to + update itself, that command now takes into account non-default installation + paths so that the new version is installed to the same place as the current + version. + ([#474](https://github.com/nextstrain/cli/pull/474)) + +(v10-2-1-post1)= +## 10.2.1.post1 (1 July 2025) + +_See also changes in 10.2.1 which was an unreleased version._ + +(v10-2-1-post1-development)= +### Development + +* The release script now keeps changelogs in sync. + ([#446](https://github.com/nextstrain/cli/issues/446)) + +(v10-2-1)= +## 10.2.1 (1 July 2025) + +_Unreleased due to [test failures](https://github.com/nextstrain/cli/issues/446). Changes first released as part of 10.2.1.post1._ + +(v10-2-1-bug-fixes)= +### Bug fixes + +* `nextstrain setup ` will no longer attempt to use a local netrc file + for authentication. This fixes a bug which caused pathogen repo download to + fail when the local netrc file contained an expired GitHub authentication + token. + + Previous behavior allowed setup of private repositories using the + fully-specified `@=` format, however support for that was + unintentional and has been removed by this change. + ([#444](https://github.com/nextstrain/cli/issues/444)) + +(v10-2-1-documentation)= +### Documentation + +* This changelog is [now + included](https://docs.nextstrain.org/projects/cli/en/10.2.1/changes/) in + our published documentation for easier reference. It includes stable + permalink anchors for each version and the subheadings under each version. + ([#438](https://github.com/nextstrain/cli/pull/438)) + + +(v10-2-0)= +## 10.2.0 (27 May 2025) + +(v10-2-0-development)= +### Development + +* `nextstrain setup conda` and `nextstrain update conda` now respect an + optional `NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR` environment variable that when + set overrides the default behaviour of detecting the best Conda subdir that's + usable for the platform. + + This may be used, for example, to force the use of the x86\_64 architecture + (`osx-64` subdir) on macOS hardware that's natively the `aarch64` (aka arm64, + Apple Silicon, M1/M2/…) architecture (`osx-arm64` subdir): + + NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR=osx-64 nextstrain setup conda + + The variable must be set for every invocation of `nextstrain setup conda` or + `nextstrain update conda`, otherwise the default behaviour will apply and the + subdir in use by the runtime may be automatically switched. + ([#437](https://github.com/nextstrain/cli/pull/437)) + + +(v10-1-0)= +## 10.1.0 (19 May 2025) + +(v10-1-0-improvements)= +### Improvements + +* Use of an alternate Conda package repository is now supported during + `nextstrain setup conda` and `nextstrain update conda` if you cannot or do + not want to use the default package repository hosted by Anaconda. Set the + [`NEXTSTRAIN_CONDA_CHANNEL_ALIAS`][] environment variable to the base URL of + the repository. This corresponds to the [`channel_alias` Conda config + setting][]. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +* The Conda runtime no longer requires Rosetta 2 for macOS running on aarch64 + (aka arm64, Apple Silicon, M1/M2/…) hardware. This improves performance when + using the runtime. Run `nextstrain update conda` to receive the update. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +[`NEXTSTRAIN_CONDA_CHANNEL_ALIAS`]: https://docs.nextstrain.org/projects/cli/en/10.1.0/runtimes/conda/#envvar-NEXTSTRAIN_CONDA_CHANNEL_ALIAS +[`channel_alias` Conda config setting]: https://docs.conda.io/projects/conda/en/latest/user-guide/configuration/settings.html#set-ch-alias + +(v10-1-0-development)= +### Development + +* The `NEXTSTRAIN_CONDA_MICROMAMBA_VERSION` environment variable is no longer + supported (i.e. for use with `nextstrain setup conda`). Please use + [`NEXTSTRAIN_CONDA_MICROMAMBA_URL`][] instead. + ([#436](https://github.com/nextstrain/cli/pull/436)) + +[`NEXTSTRAIN_CONDA_MICROMAMBA_URL`]: https://docs.nextstrain.org/projects/cli/en/10.1.0/runtimes/conda/#envvar-NEXTSTRAIN_CONDA_MICROMAMBA_URL + + +(v10-0-0)= +## 10.0.0 (7 May 2025) + +This release is the first to include initial support for setting up and running +pathogen workflows without the co-mingling of our workflow source code with +your inputs and outputs (e.g. your `config.yaml`, `data/`, and `results/`) and +without needing to download source code or use Git yourself. Pathogens are +first set up with `nextstrain setup` and their workflows may then be run using +`nextstrain run`, a new command in this release. These features are part of +our broader ""workflows as programs"" endeavor. + +(v10-0-0-features)= +### Features + +* A new command, [`nextstrain run`][], for running pathogen workflows in a more + managed way as part of our broader ""workflows as programs"" endeavor. + + Workflows (e.g. `ingest`, `phylogenetic`) for a pathogen are run in a + Nextstrain runtime with config and input (e.g. `config.yaml`, `data/`) from + an analysis directory you provide and outputs (e.g. `results/`) written to + that same directory. + + Pathogens (e.g. `measles`) are initially set up using `nextstrain setup` and + can be updated over time as desired using `nextstrain update`. Multiple + versions of a pathogen may be set up and run independently without conflict, + allowing for comparisons of output across versions. The same pathogen + workflow may also be concurrently run multiple times with separate analysis + directories (i.e. different configs, input data, etc.) without conflict, + allowing for independent outputs and analyses. Set up pathogens and their + versions are listed by `nextstrain version --pathogens`. + + Compared to `nextstrain build`, this new `nextstrain run` command is a + higher-level interface to running pathogen workflows that does not require + knowledge of Git or management of pathogen repositories and source code. For + now, the `nextstrain build` command remains more suitable for active + authorship and development of workflows. + ([#407][]) + +[#407]: https://github.com/nextstrain/cli/pull/407 +[`nextstrain run`]: https://docs.nextstrain.org/projects/cli/en/10.0.0/commands/run/ + +(v10-0-0-improvements)= +### Improvements + +* The results of setup checks performed by `nextstrain setup` and `nextstrain + check-setup` are now shown individually as they complete instead of waiting + for all checks to complete before showing results. This makes it more clear + that work is being done when checks take a second or two. + ([#418](https://github.com/nextstrain/cli/pull/418)) + +* Commands which make web requests on your behalf (e.g. `nextstrain remote`, + `nextstrain login`, `nextstrain setup`, `nextstrain update`) now include an + appropriate and informative [User-Agent header][], e.g. + + Nextstrain-CLI/10.0.0 (https://nextstrain.org/cli) Python/3.10.9 python-requests/2.32.3 platform/Linux-x86_64 installer/standalone tty/yes + + instead of the previous generic User-Agent, e.g. + + python-requests/2.32.3 + + The new User-Agent includes the Nextstrain CLI version as well as basic + information on several important software components. This information is + non-identifying and useful for our troubleshooting and aggregation of usage + metrics. You may opt to omit it, however, by setting the + `NEXTSTRAIN_CLI_USER_AGENT_MINIMAL` environment variable to `1` (or another + truthy value). In that case, the User-Agent only includes the CLI version, + e.g.: + + Nextstrain-CLI/10.0.0 (https://nextstrain.org/cli) + + We recommend leaving the default User-Agent enabled unless the minimal + variant is necessary for your circumstances. + ([#432](https://github.com/nextstrain/cli/pull/432)) + +[User-Agent header]: https://en.wikipedia.org/wiki/User-Agent_header + +* When checking for upgrades for Nextstrain CLI itself during `nextstrain + check-setup` and `nextstrain update`, the latest version is now fetched from + nextstrain.org instead of pypi.org. This gives us insights into usage and + also more flexibility to shift how we're releasing and distributing this + project. + ([#434](https://github.com/nextstrain/cli/pull/434)) + + +(v9-0-0)= +## 9.0.0 (24 March 2025) + +This release contains a **potentially-breaking change** for any usages of the +`--sacra` option, though we expect no one is using it. The change is described +below. + +(v9-0-0-improvements)= +### Improvements + +* `nextstrain version` now reports itself as ""Nextstrain CLI"" (instead of + ""nextstrain.cli"") and indicates if it is a ""standalone"" installation + (self-contained, bundles Python) or not. + ([#419][]) + +* Colorized and bolded output is disabled when stdout is not attached to a + terminal (e.g. is redirected to a file, piped to another program, etc.) or + when the [`NO_COLOR` environment variable](https://no-color.org) is set to a + non-empty value. + ([#419][]) + +* The readability of `--help` output is improved by the addition of blank lines + between argument/option descriptions. + ([#419][]) + +* AWS Batch builds now support development overlays such as [`--augur`][] and + [`--auspice`][]. To use this functionality, you'll need at least + `nextstrain/base:build-20250321T184358Z` or newer of the Nextstrain Docker + runtime image. Compatibility of the runtime image is checked automatically + when overlays are used with AWS Batch. + ([#419][], [#423](https://github.com/nextstrain/cli/pull/423)) + +[`--augur`]: https://docs.nextstrain.org/projects/cli/en/9.0.0/commands/build/#cmdoption-nextstrain-build-augur +[`--auspice`]: https://docs.nextstrain.org/projects/cli/en/9.0.0/commands/build/#cmdoption-nextstrain-build-auspice + +* The `--sacra` option, intended for use during development, is no longer + supported by `nextstrain build`, `nextstrain view`, or `nextstrain shell`. + [Sacra](https://github.com/nextstrain/sacra), long-defunct and never used, + was removed from the Nextstrain runtime image itself over 4 years ago (first + absent in `nextstrain/base:build-20201213T084302Z`, last present in + `nextstrain/base:build-20201212T165623Z`). This is technically a + **potentially-breaking change**, although almost certainly affects no one. + ([#419][]) + +(v9-0-0-bug-fixes)= +### Bug fixes + +* Fixed a rare but possible error case in `nextstrain view` and `nextstrain + login` when running under a copy of Python with IPv6 disabled on a system + with IPv6 enabled. In such situations, IPv6 addresses will now be ignored. + ([#415](https://github.com/nextstrain/cli/pull/415)) + +* An authentication callback URL containing an unresolvable hostname is no + longer considered to have a loopback (local-only) address, i.e. is not + considered safe/suitable for use. + ([#416](https://github.com/nextstrain/cli/pull/416)) + +* `nextstrain view` now correctly handles IPv6 host addresses in the URL opened + in a browser (if any). + ([#417](https://github.com/nextstrain/cli/pull/417)) + +* `nextstrain login` now correctly handles OAuth 2.0 authorization endpoint + URLs (which are obtained automatically from OpenID Connect 1.0 metadata + discovery) with existing query parameters in them. This bug likely affected + approximately no one; logging into nextstrain.org was unaffected and all + known users of non-nextstrain.org remotes were also unaffected. + ([#419][]) + +* File timestamps for results files downloaded from an AWS Batch build are now + correctly restored even if the expected extraction path differs from the + actual extraction path due to ZIP security precautions. This bug likely + affected approximately no one. + ([#419][]) + +(v9-0-0-development)= +### Development + +* Goodbye, Mypy! We now use only Pyright for type checking. Both type + checkers used to contribute to our development in their own way, but over + time Pyright's become more sophisticated and Mypy's required more workarounds + to appease it than issues it caught. So long, and thanks for all the ~fish~ + type checks! + ([#419][]) + +* [Cram](https://bitheap.org/cram/) test files are now supported, with one + example file for now. + ([#419][]) + +* `NEXTSTRAIN_HOME` is now set for tests so as to avoid interference with the + local user's personal config and data. + ([#419][]) + +* Running tests no longer opens a browser. \o/ + ([#419][]) + +[#419]: https://github.com/nextstrain/cli/pull/419 + + +(v8-5-4)= +## 8.5.4 (1 November 2024) + +(v8-5-4-bug-fixes)= +### Bug fixes + +* It is no longer a fatal error if the logs for a completed AWS Batch job + cannot be fetched for some reason. `nextstrain build` will warn about the + error but continue on with printing the job status (e.g. success or reason + for failure) and, if applicable, downloading job results. + ([#406](https://github.com/nextstrain/cli/pull/406)) + + +(v8-5-3)= +## 8.5.3 (3 September 2024) + +(v8-5-3-bug-fixes)= +### Bug fixes + +* Authentication established via `nextstrain login` and used by the `nextstrain + remote` family of commands no longer verifies the ""issued at"" (`iat`) time of + the received tokens in order to avoid the following error: + + ImmatureSignatureError: The token is not yet valid (iat). + + This error was seen by users who's system time was slightly lagged, and it + prevented them from logging in or renewing their authentication. + ([#394](https://github.com/nextstrain/cli/pull/394)) + + +(v8-5-2)= +## 8.5.2 (27 August 2024) + +(v8-5-2-bug-fixes)= +### Bug fixes + +* The suggested commands to run (i.e. potential solutions) in expected errors + from `nextstrain remote` now explicitly include the remote origin to avoid + being incorrect or misleading for origins other than nextstrain.org. For + example, if the error message suggested running `nextstrain login`, it now + suggests `nextstrain login https://nextstrain.org`. + ([#391](https://github.com/nextstrain/cli/pull/391)) + + +(v8-5-1)= +## 8.5.1 (31 July 2024) + +(v8-5-1-bug-fixes)= +### Bug fixes + +* `nextstrain remote download` now produces the expected local file names when + there are periods (dots) in the remote dataset name (e.g. `nextstrain remote + download /a/b.c/d` now produces `a_b.c_d.json` instead of `a_b.json`) and + when there are periods in the given local file name (e.g. `nextstrain remote + download /x/y/z x.y.z` now produces `x.y.z.json` instead of `x.y.json`). + ([#381](https://github.com/nextstrain/cli/pull/381)) + + +(v8-5-0)= +## 8.5.0 (18 June 2024) + +(v8-5-0-improvements)= +### Improvements + +* Snakemake's per-input/output file metadata (stored in `.snakemake/metadata/`) + is now downloaded from AWS Batch builds by default. Like file modification + times (mtimes), which are already preserved from the remote build, this + additional metadata is used by Snakemake to track when inputs have changed + and when it should regenerate outputs. The metadata is also used in + [Snakemake report generation](https://snakemake.readthedocs.io/en/v8.14.0/snakefiles/reporting.html#rendering-reports) + and can be useful for gathering ad-hoc workflow statistics. + + The runtime image used must be at least `nextstrain/base:build-20240617T235011Z` + for these Snakemake metadata files to be available for download from the AWS + Batch job. + ([#374](https://github.com/nextstrain/cli/pull/374)) + + +(v8-4-0)= +## 8.4.0 (29 May 2024) + +This release adds explicit (i.e. tested) support for Python version 3.12. +([#369](https://github.com/nextstrain/cli/pull/369)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/8.4.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +(v8-4-0-features)= +### Features + +* `nextstrain build` now supports two new options when using the AWS Batch + runtime: [`--exclude-from-upload`][] and [`--exclude-from-download`][]. The + former is useful for avoiding the upload of large, ancillary files not needed + by the build. The latter exists to parallel the former and make it easier to + exclude files from both upload and download. + ([#370](https://github.com/nextstrain/cli/pull/370)) + +(v8-4-0-improvements)= +### Improvements + +* The Conda runtime now uses Micromamba 1.5.8 (upgraded from 1.1.0) to manage + the runtime environment. The newer version supports Zstandard-compressed + index files which speeds up `nextstrain setup` and `nextstrain update` for + the Conda runtime. + ([#367](https://github.com/nextstrain/cli/pull/367)) + +(v8-4-0-bug-fixes)= +### Bug fixes + +* The [`--download`][] option of `nextstrain build` now supports passing _only_ + negated patterns (e.g. `!…` and `!(…)`). All files which _don't_ match the + negated patterns will be downloaded. Previously, no files were downloaded + unless at least one positive pattern was given. + ([#370](https://github.com/nextstrain/cli/pull/370)) + + +[`--exclude-from-upload`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-exclude-from-upload +[`--exclude-from-download`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-exclude-from-download +[`--download`]: https://docs.nextstrain.org/projects/cli/en/8.4.0/commands/build/#cmdoption-nextstrain-build-download + + +(v8-3-0)= +## 8.3.0 (30 April 2024) + +(v8-3-0-improvements)= +### Improvements + +* Commands which utilize a runtime—`nextstrain build`, `nextstrain shell`, and + `nextstrain view`—now support specifying envdirs to forward into the runtime + environment by setting `NEXTSTRAIN_RUNTIME_ENVDIRS` to a `:`-separated (`;` + on Windows) list of paths. This is in addition to the existing support for + specifying one or more `--envdir` options. + ([#365](https://github.com/nextstrain/cli/pull/365)) + + +(v8-2-0)= +## 8.2.0 (6 February 2024) + +(v8-2-0-features)= +### Features + +* `nextstrain build` and `nextstrain shell` now better support pathogen + repositories which place workflows in subdirectories. The top-level of the + repo must contain a `nextstrain-pathogen.yaml` file for this support to + activate. The file may be empty for now, though we anticipate using it for + pathogen-level metadata in the future to aid indexing, listing, and + attribution of pathogen repos. + + As an example of the new support, consider the following repo layout + + mpox/ + ├── nextstrain-pathogen.yaml + ├── ingest/ + │ ├── Snakefile + │ └── … + ├── phylogenetic/ + │ ├── Snakefile + │ └── … + ├── shared/ + │ ├── reference.fasta + │ └── … + └── … + + where `ingest/` and `phylogenetic/` contain workflows that use + `shared/reference.fasta` via a relative path (i.e. + `../shared/reference.fasta`). + + It's now possible to invoke those workflows with any of the following: + + nextstrain build mpox/ingest/ + nextstrain build mpox/phylogenetic/ + + cd mpox + nextstrain build ingest/ + nextstrain build phylogenetic/ + + cd phylogenetic + nextstrain build . + nextstrain build ../ingest/ + + regardless of runtime. + + Previously, such workflows required careful invocation, e.g. + + nextstrain build mpox/ -d phylogenetic/ -s phylogenetic/Snakefile + + when using runtimes with filesystem isolation (i.e. the [containerized][] + ones; Docker, Singularity, and AWS Batch) but not when using runtimes without + it. + + When active, this feature makes the top-level of the pathogen repo (e.g. + `mpox/`) available in the container at `/nextstrain/build` while the + initial working directory is set to the workflow subdirectory in the + container (e.g. `/nextstrain/build/phylogenetic`). That is, the filesystem + isolation boundary is drawn at the top-level of the pathogen repo instead of + at the workflow directory (i.e. what's given to `nextstrain build`). + ([#355](https://github.com/nextstrain/cli/pull/355)) + +[containerized]: https://docs.nextstrain.org/projects/cli/en/8.2.0/runtimes/#comparison + +(v8-2-0-improvements)= +### Improvements + +* We now produce standalone installation archives for macOS running on aarch64 + hardware (aka arm64, Apple Silicon, M1/M2). The standalone installer will + use these archives starting with this release. + ([#357](https://github.com/nextstrain/cli/pull/357), + [#358](https://github.com/nextstrain/cli/pull/358)) + +* The Conda and Docker runtime checks performed by `nextstrain setup` and + `nextstrain check-setup` now test if Rosetta 2 is enabled for macOS on + aarch64 (aka arm64, Apple Silicon, M1/M2) hardware. Rosetta is required for + the Conda runtime and optional, but recommended, for the Docker runtime. + Previously only the standalone installer checked for Rosetta, but starting + with this release it will not. + ([#361](https://github.com/nextstrain/cli/pull/361), + [#358](https://github.com/nextstrain/cli/pull/358)) + +* `nextstrain build` now errors if a [development overlay option][] such as + `--augur` or `--auspice` is given when using a runtime without support for + those (anything but Docker or Singularity). Previously, it would silently + ignore those options when unsupported by the runtime. The new behaviour + matches the behaviour of `nextstrain shell` since 5.0.0. + ([#354](https://github.com/nextstrain/cli/pull/354)) + +[development overlay option]: https://docs.nextstrain.org/projects/cli/en/8.2.0/commands/build/#development-options-for-docker + + +(v8-0-1)= +## 8.0.1 (29 January 2024) + +(v8-0-1-improvements)= +### Improvements + +* Several kinds of errors from `nextstrain login` and `nextstrain whoami` + related to their interactions with a remote server are now clearer. + ([#347](https://github.com/nextstrain/cli/pull/347)) + + +(v8-0-0)= +## 8.0.0 (18 January 2024) + +This release drops support for Python versions 3.6 and 3.7 and adds support for +3.11. ([#325](https://github.com/nextstrain/cli/pull/325), +[#327](https://github.com/nextstrain/cli/pull/327)) + +Note that this Python version support only matters if you're installing +Nextstrain CLI from PyPI or Bioconda +([c.f.](https://docs.nextstrain.org/projects/cli/en/8.0.0/installation/)). It +does not apply if you're installing Nextstrain CLI using the standalone +installation method we recommend in the [Nextstrain installation +documentation](https://docs.nextstrain.org/page/install.html). In that case, a +supported Python version is always bundled with `nextstrain`. + +(v8-0-0-improvements)= +### Improvements + +* The `nextstrain remote` family of commands now support alternative + nextstrain.org-like remotes such as internal Nextstrain Groups Server + instances and development instances of nextstrain.org. Authentication with + these remotes is supported via `nextstrain login` and related commands. + Remotes maintain their authentication alongside each other, e.g. you can be + logged into nextstrain.org as well as an alternative nextstrain.org-like + instance. + + As an example, a Nextstrain Groups Server instance accessible at + nextstrain.example.com could now be logged into and interacted with like so: + + nextstrain login nextstrain.example.com + nextstrain whoami nextstrain.example.com + nextstrain remote ls nextstrain.example.com/groups/bedford-lab/ + + The default remote is still nextstrain.org. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* `nextstrain login` now performs authentication via a web browser by default + (using OpenID Connect 1.0 and OAuth 2.0). The previously method of direct + password entry is still used when a username is provided (e.g. with + `--username` or `-u`). See `nextstrain login --help` for more information. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* With the new support for being logged into multiple remotes, `nextstrain + logout` now also supports an `--all` flag to remove all locally-saved + credentials without having to logout of each remote separately. + ([#333](https://github.com/nextstrain/cli/pull/333)) + +* `nextstrain remote upload` now skips gzip compression when uploading + zstandard-compressed (`.zst`) files, matching its behaviour for other types + of compressed files. + ([#330](https://github.com/nextstrain/cli/pull/330)) + +* Commands that may automatically open a web browser, e.g. `nextstrain view` or + `nextstrain login`, now respect the semi-conventional `NOBROWSER` environment + variable to disable opening a browser. Set `NOBROWSER` to a non-empty value + to disable automatic opening. When disabled, the URL to manually open will + be shown. + ([#332](https://github.com/nextstrain/cli/pull/332)) + +* The error message emitted by the `nextstrain remote` family of commands when + they're unable to access an S3 bucket now lists a few possible reasons for + the failure. + ([#341](https://github.com/nextstrain/cli/pull/341)) + +* `nextstrain remote download` now supports downloading core datasets which are + only visible on the web by direct access via their URL. For example, the + following now work (where in previous versions they did not): + + nextstrain remote download https://nextstrain.org/nextclade/sars-cov-2/21L + nextstrain remote download https://nextstrain.org/enterovirus/d68/vp1/2020-01-23 + + This support also covers [past snapshots of + datasets](https://docs.nextstrain.org/en/latest/guides/versions.html), which + is a recently-added feature to nextstrain.org. For example: + + nextstrain remote download https://nextstrain.org/flu/seasonal/h3n2/ha/6y@2023-07-01 + nextstrain remote download https://nextstrain.org/ncov/gisaid/21L/global/6m@2024-01-09 + + ([#345](https://github.com/nextstrain/cli/pull/345)) + +(v8-0-0-bug-fixes)= +### Bug fixes + +* Commands making use of user authentication (e.g. `nextstrain login`, + `nextstrain whoami`, some invocations of `nextstrain remote`, etc.) no longer + fail if the logged in user is a member of no groups. + ([#323](https://github.com/nextstrain/cli/pull/323)) + +* On Linux and macOS, the standalone installer's final instructions now + correctly suggest modifying `~/.profile` instead of, incorrectly, `~/.shrc` + when the default shell is sh. + ([#321](https://github.com/nextstrain/cli/pull/321)) + +* The Singularity runtime once again supports Apptainer's `singularity` + executable. The minimum version checking added in 7.0.0 broke usage of the + Singularity runtime with Apptainer (compared with SingularityCE). Our intent + is to support both lineages of Singularity. Thanks to @osageorange for + raising this issue and testing the fix! + ([#343](https://github.com/nextstrain/cli/pull/343)) + + +(v7-4-0)= +## 7.4.0 (21 September 2023) + +(v7-4-0-improvements)= +### Improvements + +* When attached to an AWS Batch job, `nextstrain build` now only requires + confirmation to stop the job (e.g. a double Control-C/`SIGINT`) when stdin is + a terminal (TTY). When stdin is not a terminal, as is frequently the case in + automated or programmatic contexts, then `SIGINT` requests job cancellation + immediately. + ([#308][]) + +* When attached to an AWS Batch job, `nextstrain build` now also detaches upon + receiving `SIGHUP` (in addition to detaching upon receiving + Control-Z/`SIGTSTP`). `SIGHUP` is sent, for example, when a user closes (or + loses) the terminal in which `build` is still running. + ([#308][]) + +* When launching or attaching to an AWS Batch job, `nextstrain build` now + supports the `--detach-on-interrupt` option to change Control-C/`SIGINT` to a + request to detach from the job rather than to cancel it. This is useful in + automated contexts where `SIGINT` may be sent outside of a user's control, + and it's also handy as a molly-guard to avoid accidental cancellation when + the intent is to just observe a job. + ([#308][]) + +* When attaching to an AWS Batch job, `nextstrain build` now supports the + `--cancel` option to immediately request cancellation. + ([#308][]) + +[#308]: https://github.com/nextstrain/cli/pull/308 + +(v7-4-0-bug-fixes)= +### Bug fixes + +* We've plugged some isolation leaks in the Conda runtime where the + [Python user site directory](https://docs.python.org/3/library/site.html), + e.g. `~/.local/lib/pythonX.Y/site-packages`, as well as the + [`PYTHONPATH` and `PYTHONHOME` environment variables](https://docs.python.org/3/using/cmdline.html#environment-variables) + could influence and break the runtime. + ([#311](https://github.com/nextstrain/cli/pull/311)) + + +(v7-3-0-post1)= +## 7.3.0.post1 (19 September 2023) + +_See also changes in 7.3.0 which was an unreleased version._ + +(v7-3-0-post1-development)= +### Development + +* Update CI to test against the SingularityCE 3.x series only ([#314](https://github.com/nextstrain/cli/pull/314)) + + +(v7-3-0)= +## 7.3.0 (19 September 2023) + +_Unreleased due to test failures. Changes first released as part of 7.3.0.post1._ + +(v7-3-0-improvements)= +### Improvements + +* build: Providing a path to a pathogen build directory is no longer required + when the AWS Batch runtime is in use (e.g. with `--aws-batch`) and both the + `--attach` and `--no-download` options are given. This allows usages which + just want to check job status or logs to stop providing a meaningless/unused + directory. + ([#305](https://github.com/nextstrain/cli/pull/305)) + +* The initial setup of the Conda runtime, i.e. with `nextstrain setup conda`, + now explicitly installs the latest available runtime package version. This + was the implicit intent and expectation, but, for various Conda packaging + reasons, it was (silently) not always the result. Now an error will occur if + the latest version is not installable. This matches the existing behaviour + when updating the Conda runtime, i.e. with `nextstrain update conda`. + ([#312](https://github.com/nextstrain/cli/pull/312)) + +(v7-3-0-bug-fixes)= +### Bug fixes + +* The `HOST` and `PORT` environment variables are now respected by `nextstrain + view`. They provide defaults when `--host` and/or `--port` aren't provided. + ([#310](https://github.com/nextstrain/cli/pull/310)) + +* Updated fsspec and s3fs dependencies to avoid version 2023.9.1, since they + caused `nextstrain build --aws-batch` invocations to fail. + ([#313](https://github.com/nextstrain/cli/pull/313)) + + +(v7-2-0)= +## 7.2.0 (17 August 2023) + +(v7-2-0-bug-fixes)= +### Bug fixes + +* The Conda runtime now uses Micromamba 1.1.0 (upgraded from 1.0.0) to manage + the runtime environment. The newer version has improved error handling in + edge cases where the previous version silently failed when used during + `nextstrain update`. + ([#301](https://github.com/nextstrain/cli/pull/301)) + +* The Singularity runtime now cleans up unnecessary caches during `nextstrain + update` and `nextstrain setup`. This reduces the storage space required by + the runtime and prevents it from growing unbounded over time. However, this + also results in increases in network transfer during `nextstrain update`. We + may mitigate the additional transfer in the future. + ([#303][]) + +(v7-2-0-documentation)= +### Documentation + +* The command-line `--help` output for commands and the corresponding + documentation pages on the web are more integrated and improved in various + small ways. In particular, command options are more cross-referencable and + directly linkable and the wrap-width of `--help` output is more consistent + and reliably readable. + ([#299](https://github.com/nextstrain/cli/pull/299)) + +* We've added a large section of new and expanded [documentation on + runtimes](https://docs.nextstrain.org/projects/cli/page/runtimes/), both in + general and for each individual runtime. + ([#303][]) + +* We've added and expanded documentation about configuration, including the + [config file](https://docs.nextstrain.org/projects/cli/page/config/file/) and + the [paths](https://docs.nextstrain.org/projects/cli/page/config/paths/) used + by Nextstrain CLI. Documentation in general now includes more about the + environment variables that can be used to configure Nextstrain CLI. + ([#303][]) + + +[#303]: https://github.com/nextstrain/cli/pull/303 + + +(v7-1-0)= +## 7.1.0 (22 June 2023) + +(v7-1-0-improvements)= +### Improvements + +* Commands that use a runtime (`nextstrain build`, `nextstrain shell`, and + `nextstrain view`) now support two new options for setting or passing thru + environment variables into the runtime environment: + + --env [=] + --envdir + + When either of these options are given, the default behaviour of + automatically passing thru several ""well-known"" environment variables is + disabled. That is, the following ""well-known"" environment variables are only + automatically passed thru when the new `--env` and `--envdir` options are + _not_ used: + + - `AUGUR_RECURSION_LIMIT` + - `AUGUR_MINIFY_JSON` + - `AWS_ACCESS_KEY_ID` + - `AWS_SECRET_ACCESS_KEY` + - `AWS_SESSION_TOKEN` + - `ID3C_URL` + - `ID3C_USERNAME` + - `ID3C_PASSWORD` + - `RETHINK_HOST` + - `RETHINK_AUTH_KEY` + + Pass these variables explicitly via `--env` or `--envdir` if you need them in + combination with other `--env` or `--envdir` usage. For more usage details, + use the `--help-all` flag of any of those commands, e.g. `nextstrain build + --help-all`. + ([#289](https://github.com/nextstrain/cli/pull/289)) + +* Environment variables are now passed to the Docker and AWS Batch runtimes via + more secure means when the container image in use is new enough to support it + (`nextstrain/base:build-20230613T204512Z` and newer). This ensures the env + values aren't visible in the container's config (e.g. via `docker inspect`, + `aws batch describe-jobs`, the AWS web console). If you're using an older + image, you can update it with `nextstrain update docker`. + + For Docker, environment variables are written to an internal and temporary + envdir directory visible only to the current user which is deleted + immediately after use at container start. + + For AWS Batch, environment variables are written to a ZIP archive on S3, + alongside but separate from the ZIP archive of the build dir. This env + archive is deleted from S3 immediately after use at container start. + + Both of these approaches minimize the amount of time environment variable + values exist outside of memory, persisted to storage (disk, S3). + ([#289](https://github.com/nextstrain/cli/pull/289)) + +(v7-1-0-bug-fixes)= +### Bug fixes + +* `nextstrain view` now waits (up to 10s) for Auspice to start responding + before automatically opening it in the browser. This should eliminate the + previous behaviour of sometimes opening the browser too soon. + ([#291](https://github.com/nextstrain/cli/pull/291)) + + +(v7-0-1)= +## 7.0.1 (31 May 2023) + +(v7-0-1-bug-fixes)= +### Bug fixes + +* `nextstrain update` for the Conda runtime no longer reports an ""invalid + version"" error. This was a regression introduced in 7.0.0. + ([#286](https://github.com/nextstrain/cli/pull/286)) + + +(v7-0-0)= +## 7.0.0 (26 May 2023) + +This release is mostly a bug fix release for our Conda and Singularity +runtimes. However, it contains a **potentially-breaking change** for existing +usages of the Singularity runtime: **the minimum required Singularity version +has changed from 2.6.0 to 3.0.0**. This change was required for a critical bug +fix. If you do not use the Singularity runtime, there are no +potentially-breaking changes in this release. + +(v7-0-0-improvements)= +### Improvements + +* `nextstrain shell` now notes which runtime is being entered in its initial + messaging to establish more context for the user (and for developers when + troubleshooting). + ([#283][]) + +* The Singularity runtime now checks for the minimum required Singularity + version (3.0.0 with this release) during `nextstrain check-setup`. + ([#283][]) + +(v7-0-0-bug-fixes)= +### Bug fixes + +* Setup and upgrade of the Conda runtime now only uses stable ""main"" channel + releases when determining the latest release version, as intended. + Previously, testing and development releases could be selected if they were + newer than the last stable release. Additionally, if there are multiple + builds for a release version, the highest numbered build (i.e. newest) is now + used instead of the lowest. + ([#280](https://github.com/nextstrain/cli/pull/280)) + +* The Singularity runtime now works with our container runtime images from + `build-20230411T103027Z` onwards. The Snakemake upgrade in that image + version resulted in ""read-only file system"" errors which referenced the + user's home directory. Those errors are now fixed. + ([#283][]) + +* The prompt for `nextstrain shell`—a stylized variant of the Nextstrain + wordmark—now works when using the Singularity runtime regardless of + Singularity version. Previously Singularity's default prompt of + `Singularity> ` overrode ours when using Singularity versions ≥3.5.3. + ([#283][]) + +* More robust command-line processing is used for the Singularity runtime on + Singularity versions ≥3.10.0. Singularity's early (and unexpected) + evaluation of arguments that look like (but aren't) shell variable + substitutions is disabled. + ([#283][]) + +(v7-0-0-development)= +### Development + +* The command lines and environment overrides of many (but not all) process + invocations are now logged when `NEXTSTRAIN_DEBUG` is enabled. + ([#283][]) + + +[#283]: https://github.com/nextstrain/cli/pull/283 + + +(v6-2-1)= +## 6.2.1 (24 March 2023) + +(v6-2-1-bug-fixes)= +### Bug fixes + +* We've fixed and future-proofed a compatibility bug with a third-party library + that can occur under very specific conditions when `nextstrain build` submits + AWS Batch jobs. + ([#261](https://github.com/nextstrain/cli/pull/261)) + +* The update process for the Conda runtime is now more robust and less likely + to get stuck at an old version. + ([#266](https://github.com/nextstrain/cli/pull/266)) + + +(v6-2-0)= +## 6.2.0 (28 February 2023) + +(v6-2-0-improvements)= +### Improvements + +* `nextstrain build --aws-batch --attach …` no longer offers to cancel (via + Control-C) or detach (via Control-Z) from the job if it's already complete. + Instead, Control-C will exit the program without delay and without trying to + cancel the job. + ([#253][]) + +* `nextstrain build` now supports a `--no-logs` option to suppress the fetching + and printing of job logs when attaching to a completed AWS Batch build. As + log fetching can often take longer than a selective download of the results + (i.e. via `--download`), this is a time (and terminal scrollback) saver when + all you want are a few of the results files. + ([#253][]) + +[#253]: https://github.com/nextstrain/cli/pull/253 + +(v6-2-0-bug-fixes)= +### Bug fixes + +* An error message that's printed by `nextstrain remote upload` when unknown + files are given for upload to destinations on nextstrain.org now properly + includes the actual list of unknown files instead of the placeholder + `{files}`. + ([#260](https://github.com/nextstrain/cli/pull/260)) + +* When running on Python ≥3.10, the `--help` output of `nextstrain build`, + `nextstrain view`, and `nextstrain shell` once again shows just the most + common options. All options are still shown with `--help-all`. A regression + since Python 3.10 meant that `--help` acted the same as `--help-all` before + this fix. This affected any installation on Python ≥3.10, including + standalone installations, since the standalone binaries bundle Python 3.10. + ([#259](https://github.com/nextstrain/cli/pull/259)) + + +(v6-1-0-post1)= +## 6.1.0.post1 (18 January 2023) + +(v6-1-0-post1-documentation)= +### Documentation + +* Minor improvements to the way we list and describe our computing platforms. + + +(v6-1-0)= +## 6.1.0 (18 January 2023) + +(v6-1-0-improvements)= +### Improvements + +* We've added a new Singularity runtime based on our existing Docker runtime. + + Singularity is a container system freely-available for Linux platforms. It + is commonly available on institutional HPC systems as an alternative to + Docker, which is often not supported on such systems. When you use + Singularity with the Nextstrain CLI, you don't need to install any other + Nextstrain software dependencies as validated versions are already bundled + into a container image by the Nextstrain team. + + Run `nextstrain setup singularity` to get started. + ([#248](https://github.com/nextstrain/cli/pull/248)) + + +(v6-0-3)= +## 6.0.3 (17 January 2023) + +(v6-0-3-improvements)= +### Improvements + +* The output of `nextstrain check-setup` for the Conda runtime will now hint + about running `nextstrain setup conda` first if the runtime seems supported + but not yet set up. + ([#250][]) + +(v6-0-3-documentation)= +### Documentation + +* Documentation and `--help` output now standardizes on the term _runtime_ to + describe the various ways Nextstrain CLI provides access to the Nextstrain + software tools. Previously we used a mix of _build environment_, _runner_, + and _runtime_ in user-facing messages. This brings Nextstrain CLI in line + with the rest of our documentation. + ([#250][]) + +* The installation documentation now includes the standalone installer as well + as installing from Bioconda. It now covers all the ways our releases are + distributed. + ([#250][]) + +* The output of `nextstrain --help` now notes how to find command-specific + usage info and our online documentation. + ([#250][]) + +* An out-of-date description in `nextstrain build --help` has been revised and + updated. + ([#250][]) + +(v6-0-3-development)= +### Development + +* A new [glossary page in our documentation](https://docs.nextstrain.org/projects/cli/page/glossary/) + will help keep our shared understanding of terms straight. + ([#250][]) + +* Links to our online documention in the `--help` output of commands will now + omit any [local part](https://peps.python.org/pep-0440/#local-version-identifiers), + e.g. `+git`, of the running CLI version. This makes links correct even when + running development builds. + ([#250][]) + +[#250]: https://github.com/nextstrain/cli/pull/250 + + +(v6-0-2)= +## 6.0.2 (3 January 2023) + +_See also changes in 6.0.1 which was an unreleased version._ + +(v6-0-2-bug-fixes)= +### Bug fixes + +* A new deprecation warning from the `cryptography` module (version 39) when + running on Python 3.6 is now suppressed as it's just noise to an end user. + This probably moves us closer to dropping 3.6 support ourselves, but it's not + so onerous yet. + ([#246](https://github.com/nextstrain/cli/issues/246)) + + +(v6-0-1)= +## 6.0.1 (3 January 2023) + +_Unreleased due to [test failures](https://github.com/nextstrain/cli/issues/245). Changes first released as part of 6.0.2._ + +(v6-0-1-improvements)= +### Improvements + +* The standalone installation archives used by the standalone installer will + now work on even older Linux distributions: + + |distro |now |was | + |-------------|-------|-------| + |Ubuntu |14\.04 |18\.04 | + |Debian |8 |10 | + |RHEL/CentOS |7 |8 | + |Fedora |19 |28 | + |OpenSUSE |12\.3 |15\.3 | + + If you've previously encountered errors like the following: + + /lib64/libc.so.6: version `GLIBC_2.27' not found (required by […]/.nextstrain/cli-standalone/nextstrain) + + when using the standalone installer (or standalone archives directly), i.e.: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + + then this change should resolve that error! The new minimum required glibc + version is 2.17 (was 2.27 previously). + ([#243](https://github.com/nextstrain/cli/pull/243)) + +(v6-0-1-bug-fixes)= +### Bug fixes + +* The automatic opening of a browser tab (or window) by `nextstrain view`—a + feature introduced in the last release (6.0.0)—now also works for standalone + installations. + ([#244](https://github.com/nextstrain/cli/pull/244)) + + +(v6-0-0)= +## 6.0.0 (13 December 2022) + +This release contains a **potentially-breaking change** for existing usages of +`nextstrain view`, though we expect the change to impact very few usages. The +change is described below. + +(v6-0-0-improvements)= +### Improvements + +* `nextstrain view` now supports viewing narratives, as was always intended. + Previously the launched Auspice would either show baked in test narratives or + no narratives at all, depending on the Auspice version in the runtime. + ([#240][]) + +* `nextstrain view` now supports being given more kinds of paths, including + paths to a specific dataset or narrative file and paths to directories + containing _auspice/_ and/or _narratives/_ subdirectories. + + This is a **potentially-breaking change**, as `nextstrain view ` will + now prefer to show datasets from _``/auspice/_ if that subdirectory + exists. Previously it would only ever look for datasets in the given + _``_. We expect this to change behaviour for very few usages as it only + affects situations where _``_ contains both datasets and an _auspice/_ + directory. + + See `nextstrain view --help` for more details on the kinds of paths + supported. + ([#240][]) + +* `nextstrain view` now automatically opens Auspice in a new browser tab (or + window) by default when possible. + + If a specific dataset or narrative file was given as the path to `nextstrain + view`, then that dataset or narrative is opened. Otherwise, if there's only + a single dataset or narrative available in the directory path given to + `nextstrain view`, then it is opened. Otherwise, Auspice's listing of + available datasets and narratives is opened. + ([#240][]) + +[#240]: https://github.com/nextstrain/cli/pull/240 + +* Local images used in a narrative are now automatically embedded into it when + uploading the narrative to nextstrain.org via `nextstrain remote upload`. + In local text editors which can render Markdown, this permits previewing of + narratives that reference images on the local filesystem without requiring + manual conversion to remote images or embedded images before upload. + ([#235](https://github.com/nextstrain/cli/pull/235)) + +* The `nextstrain remote upload` command now outputs a nicer error message + that's more interpretable and actionable when nextstrain.org returns a ""bad + request"" error. The error message also includes the error details returned + by nextstrain.org. + ([#238](https://github.com/nextstrain/cli/pull/238)) + +(v6-0-0-development)= +### Development + +* The Conda runtime now uses Micromamba 1.0.0 (an upgrade from 0.27.0). + ([#233](https://github.com/nextstrain/cli/pull/233)) + + +(v5-0-1)= +## 5.0.1 (1 November 2022) + +(v5-0-1-bug-fixes)= +### Bug fixes + +* `nextstrain shell` no longer errors when its history file, e.g. + _~/.nextstrain/shell-history_, doesn't exist. This primarily affected the + Docker runtime and was a regression from 4.2.0 introduced in 5.0.0. + ([#232](https://github.com/nextstrain/cli/pull/232)) + + +(v5-0-0)= +## 5.0.0 (25 October 2022) + +_Version 5.0.0 had two development pre-releases (5.0.0.dev0 and 5.0.0.dev1) +prior to final release. For convenience, the changes from those pre-releases +are also re-described here._ + +The major improvement in this release is the introduction of a new Conda +runtime, filling a gap between the Docker runtime and the ambient runtime +(formerly ""native"" runtime). See more details below. + +This release also contains **potentially-breaking changes** for existing +usages of `nextstrain remote download` and `nextstrain update`. The changes +are described below. + +(v5-0-0-improvements)= +### Improvements + +* A new Conda runtime (aka runner or build environment) now complements the + existing Docker and ambient runtimes and fills a gap between them. This + runtime is more isolated and reproducible than your ambient environment, but + is less isolated and robust than the Docker runtime. Like the Docker + runtime, the Conda runtime is fully-managed by Nextstrain CLI and receives + updates via `nextstrain update`. + + The new runtime uses the [Conda](https://docs.conda.io) ecosystem with + packages from [our own channel](https://anaconda.org/Nextstrain/nextstrain-base), + [Bioconda](https://bioconda.github.io/) and + [Conda-Forge](https://conda-forge.org/), installed by + [Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html) + into an isolated location, typically `~/.nextstrain/runtimes/conda/env`. It + does not interact with or impact other usage of Conda/Mamba environments and + will not, for example, appear in the output of `conda env list`. + + Set up of the runtime is automated and can be performed by running: + + nextstrain setup conda + + When complete, you'll be able to use the `--conda` runtime option supported + by Nextstrain CLI commands such as `nextstrain build`, `nextstrain view`, + `nextstrain shell`, etc. + ([#218][]) + +* The ""native"" runtime (aka runner or build environment) is now the ""ambient"" + runtime. This name better reflects what it is and further distinguishes it + from the new Conda runtime, which is also ""native"" in the binary executable + sense. + + Existing usages of ""native"" should be unaffected. The `--native` option + continues to work anywhere it used to previously, though it is hidden from + `--help` output to discourage new use. The string ""native"" is also accepted + anywhere runner names are accepted, e.g. in config as the `core.runner` + setting or in command-line arguments to `check-setup` or `setup`. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* `nextstrain setup docker` now downloads the Docker runtime image if it's not + already available locally. This can be a useful initial step after + installation to avoid the automatic download on first use. + ([#222](https://github.com/nextstrain/cli/pull/222)) + +* The local filenames produced by `nextstrain remote download` now include + more of the remote dataset/narrative path. This reduces the potential for + ambiguous filenames and makes it easier to copy datasets/narratives between + destinations (e.g. from one group to another) while retaining the same path. + It is, however, a **potentially-breaking change** if you're relying on the + filenames of the downloaded datasets/narratives (e.g. for automation). + + For example, downloading `nextstrain.org/flu/seasonal/h3n2/ha/2y` previously + produced the local files: + + ``` + 2y.json + 2y_root-sequence.json + 2y_tip-frequencies.json + ``` + + which could easily conflict with the similarly-named + `nextstrain.org/flu/seasonal/h3n2/na/2y`, + `nextstrain.org/flu/seasonal/h1n1pdm/ha/2y`, etc. The downloaded files are + now named: + + ``` + flu_seasonal_h3n2_ha_2y.json + flu_seasonal_h3n2_ha_2y_root-sequence.json + flu_seasonal_h3n2_ha_2y_tip-frequencies.json + ``` + + Within groups, filenames are similarly longer but the group name is not + included. For example, downloading `groups/blab/ncov/cross-species/cat` + previously produced: + + ``` + cat.json + cat_root-sequence.json + cat_tip-frequencies.json + ``` + + and now produces: + + ``` + ncov_cross-species_cat.json + ncov_cross-species_cat_root-sequence.json + ncov_cross-species_cat_tip-frequencies.json + ``` + ([#213](https://github.com/nextstrain/cli/pull/213)) + +* Advanced globbing features are now supported in patterns for the `--download` + option of `nextstrain build`, including multi-part wildcards (`**`), extended + globbing (`@(…)`, `+(…)`, etc.), and negation (`!…`). Basic globbing + features like single-part wildcards (`*`), character classes (`[…]`), and + brace expansion (`{…, …}`) are still supported. Note that the `--download` + option continues to be applicable only to the AWS Batch runtime (e.g. the + `--aws-batch` option). + ([#215](https://github.com/nextstrain/cli/pull/215)) + +* `check-setup` now accepts one or more runtime names as arguments. + + The default behaviour doesn't change, but specifying runtimes now lets you + restrict checks to a single runtime or, with multiple runtimes, re-order them + by your preference for use with --set-default. + ([#218][]) + +* `update` now only updates a specific runtime instead of all of them at once. + + With no arguments, the default runtime is updated. The name of another + runtime to update instead may be provided as an argument. + + In practice this isn't much of a behaviour change because only one runtime + currently supports updating (Docker); the others (ambient, AWS Batch) just + pass. Existing users are unlikely to notice the change unless they use + multiple runtimes and Docker is not their default. In that case, `update` + may stop updating Docker for them when it would have done so previously, + which is a **potentially-breaking change**. + ([#218][]) + +* A new command, `setup`, now exists to perform automatic set up of runtimes + that support it (currently only Conda). For all runtimes, even those that + don't support automatic set up, the `setup` command will also run the same + checks as `check-setup` and optionally set the default runtime. + ([#218][]) + +* The shell launched by the `shell` command now remembers its own command + history and differentiates its command prompt from other shells with a + stylized variant of the Nextstrain wordmark. + ([#218][]) + +* The output of commands in dry run mode (e.g. with the `--dry-run` option) is + now uniformly indicated to be a dry run by the prefix `DRY RUN │ `. This + includes the `remote` family of commands and the new `setup` command. + ([#218][]) + +* Runtime checks in `check-setup` and `setup` now test for not just the + presence of Snakemake, Augur, and Auspice, but also that they can be + executed. + ([#218][]) + +(v5-0-0-development)= +### Development + +* We now provide standalone installers (i.e. shell programs) to download and + unpack the standalone installation archives into standard locations, + potentially upgrading/overwriting a prior standalone install. These + installers will be served from GitHub directly out of this project's + repository via convenience redirects on nextstrain.org. + + These will eventually form the basis for Nextstrain install instructions that + don't suffer from Python bootstrapping issues. As a preview for now, you can + play around with the following platform-specific commands: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/mac | bash + Invoke-RestMethod https://nextstrain.org/cli/installer/windows | Invoke-Expression + + A new companion command, `init-shell`, exists to simplify shell configuration + (i.e. `PATH` modification) for such installations. + +* The `NEXTSTRAIN_HOME` environment variable can now be used to specify the + desired location for per-user settings, files, etc., overriding the default + of _~/.nextstrain/_. + ([#218][]) + +* A new `nextstrain authorization` command makes it easier to generate direct + requests to nextstrain.org's web API using the same credentials as the CLI. + ([#229](https://github.com/nextstrain/cli/pull/229)) + +* The development documentation now documents how to build the documentation + locally, and sphinx-autobuild is used to make a very nice edit-preview cycle + with quick turnaround. + ([#218][]) + +* Development dependency issues with `flake8` and `sphinx-markdown-tables`, + caused by upstream changes, are now resolved. + ([#218][]) + + +(v5-0-0-dev1)= +## 5.0.0.dev1 (25 October 2022) + +_This is the second development pre-release made prior to the final release of 5.0.0._ + +(v5-0-0-dev1-improvements)= +### Improvements + +* The ""native"" runtime (aka runner or build environment) is now the ""ambient"" + runtime. This name better reflects what it is and further distinguishes it + from the new Conda runtime, which is also ""native"" in the binary executable + sense. + + Existing usages of ""native"" should be unaffected. The `--native` option + continues to work anywhere it used to previously, though it is hidden from + `--help` output to discourage new use. The string ""native"" is also accepted + anywhere runner names are accepted, e.g. in config as the `core.runner` + setting or in command-line arguments to `check-setup` or `setup`. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* `nextstrain setup docker` now downloads the Docker runtime image if it's not + already available locally. This can be a useful initial step after + installation to avoid the automatic download on first use. + ([#222](https://github.com/nextstrain/cli/pull/222)) + +* `nextstrain build`'s check for use of the `--image` option with unsupported + runtimes now includes the Conda runtime. + ([#224](https://github.com/nextstrain/cli/pull/224)) + +* The Conda runtime now uses the new [`nextstrain-base` Conda + meta-package](https://anaconda.org/Nextstrain/nextstrain-base) instead of + using a hardcoded list of packages. + + This decouples Conda runtime updates from Nextstrain CLI updates, as we can + make new releases of `nextstrain-base` and users can update to those without + upgrading Nextstrain CLI itself. This brings the update story for the Conda + runtime into much better parity with the Docker runtime. + + Using the meta-package also brings increased reproducibility to the runtime, + as the package completely locks its full transitive dependency tree. This + means that if version _X_ of `nextstrain-base` worked in the past, it'll + still work the same way in the future. + + The `NEXTSTRAIN_CONDA_BASE_PACKAGE` environment variable may be used with + `nextstrain setup conda` to install a specific version. The value is a + [Conda package specification][], e.g. `nextstrain-base ==X`. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +* The Conda runtime now uses a pinned version of Micromamba (currently 0.27.0) + so that new releases of the latter can't break `nextstrain setup conda` or + `nextstrain update conda` between one day and the next. The pinned version + will be bumped up over time as needed with subsequent releases of Nextstrain + CLI. + + The `NEXTSTRAIN_CONDA_MICROMAMBA_VERSION` environment variable may be used + with `nextstrain setup conda` to override the built-in pin, either with + another specific version or `latest`. + +[Conda package specification]: https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/pkg-specs.html#package-match-specifications + +(v5-0-0-dev1-bug-fixes)= +### Bug fixes + +* The Conda runtime now runs Micromamba in greater isolation to avoid undesired + interactions when a) Nextstrain CLI itself is running inside an + externally-activated Conda environment and/or b) user-specific Mamba + configuration exists. This applies to usages of `nextstrain setup` and + `nextstrain update` with the Conda runtime. + ([#223](https://github.com/nextstrain/cli/pull/223)) + +* The Conda runtime now configures the appropriate channels during `update` too, + not just during `setup`, ensuring package updates are found. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +* The Conda runtime now avoids pinning Python in the isolated environment to + allow it to be upgraded by `update`. + ([#228](https://github.com/nextstrain/cli/pull/228)) + +(v5-0-0-dev1-development)= +### Development + +* The Conda runtime is now tested in CI, joining the Docker and ambient + runtimes. + ([#223](https://github.com/nextstrain/cli/pull/223)) + + +(v5-0-0-dev0)= +## 5.0.0.dev0 (6 October 2022) + +_This is a development pre-release made prior to the final release of 5.0.0._ + +The major improvement in this release is the introduction of a new Conda +runtime, filling a gap between the Docker runtime and the ""native"" (soon to be +""ambient"") runtime. See more details below. + +This release also contains **a potentially-breaking change** for existing +usages of `nextstrain remote download` and `nextstrain update`. The changes +are described below. + +(v5-0-0-dev0-improvements)= +### Improvements + +* A new Conda runtime (aka runner or build environment) now complements the + existing Docker and ""native"" runtimes and fills a gap between them. This + runtime is more isolated and reproducible than your native ambient + environment, but is less isolated and robust than the Docker runtime. Like + the Docker runtime, the Conda runtime is fully-managed by Nextstrain CLI and + receives updates via `nextstrain update`. + + The new runtime uses the [Conda](https://docs.conda.io) ecosystem with + packages from [Bioconda](https://bioconda.github.io/) and + [Conda-Forge](https://conda-forge.org/), installed by + [Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html) + into an isolated location, typically `~/.nextstrain/runtimes/conda/env`. It + does not interact with or impact other usage of Conda/Mamba environments and + will not, for example, appear in the output of `conda env list`. + + Set up of the runtime is automated and can be performed by running: + + nextstrain setup conda + + When complete, you'll be able to use the `--conda` runtime option supported + by Nextstrain CLI commands such as `nextstrain build`, `nextstrain view`, + `nextstrain shell`, etc. + ([#218][]) + +* The local filenames produced by `nextstrain remote download` now include + more of the remote dataset/narrative path. This reduces the potential for + ambiguous filenames and makes it easier to copy datasets/narratives between + destinations (e.g. from one group to another) while retaining the same path. + It is, however, a **potentially-breaking change** if you're relying on the + filenames of the downloaded datasets/narratives (e.g. for automation). + + For example, downloading `nextstrain.org/flu/seasonal/h3n2/ha/2y` previously + produced the local files: + + ``` + 2y.json + 2y_root-sequence.json + 2y_tip-frequencies.json + ``` + + which could easily conflict with the similarly-named + `nextstrain.org/flu/seasonal/h3n2/na/2y`, + `nextstrain.org/flu/seasonal/h1n1pdm/ha/2y`, etc. The downloaded files are + now named: + + ``` + flu_seasonal_h3n2_ha_2y.json + flu_seasonal_h3n2_ha_2y_root-sequence.json + flu_seasonal_h3n2_ha_2y_tip-frequencies.json + ``` + + Within groups, filenames are similarly longer but the group name is not + included. For example, downloading `groups/blab/ncov/cross-species/cat` + previously produced: + + ``` + cat.json + cat_root-sequence.json + cat_tip-frequencies.json + ``` + + and now produces: + + ``` + ncov_cross-species_cat.json + ncov_cross-species_cat_root-sequence.json + ncov_cross-species_cat_tip-frequencies.json + ``` + ([#213](https://github.com/nextstrain/cli/pull/213)) + +* Advanced globbing features are now supported in patterns for the `--download` + option of `nextstrain build`, including multi-part wildcards (`**`), extended + globbing (`@(…)`, `+(…)`, etc.), and negation (`!…`). Basic globbing + features like single-part wildcards (`*`), character classes (`[…]`), and + brace expansion (`{…, …}`) are still supported. Note that the `--download` + option continues to be applicable only to the AWS Batch runtime (e.g. the + `--aws-batch` option). + ([#215](https://github.com/nextstrain/cli/pull/215)) + +* `check-setup` now accepts one or more runtime names as arguments. + + The default behaviour doesn't change, but specifying runtimes now lets you + restrict checks to a single runtime or, with multiple runtimes, re-order them + by your preference for use with --set-default. + ([#218][]) + +* `update` now only updates a specific runtime instead of all of them at once. + + With no arguments, the default runtime is updated. The name of another + runtime to update instead may be provided as an argument. + + In practice this isn't much of a behaviour change because only one runtime + currently supports updating (Docker); the others (native, AWS Batch) just + pass. Existing users are unlikely to notice the change unless they use + multiple runtimes and Docker is not their default. In that case, `update` + may stop updating Docker for them when it would have done so previously, + which is a **potentially-breaking change**. + ([#218][]) + +* A new command, `setup`, now exists to perform automatic set up of runtimes + that support it (currently only Conda). For all runtimes, even those that + don't support automatic set up, the `setup` command will also run the same + checks as `check-setup` and optionally set the default runtime. + ([#218][]) + +* The shell launched by the `shell` command now remembers its own command + history and differentiates its command prompt from other shells with a + stylized variant of the Nextstrain wordmark. + ([#218][]) + +* The output of commands in dry run mode (e.g. with the `--dry-run` option) is + now uniformly indicated to be a dry run by the prefix `DRY RUN │ `. This + includes the `remote` family of commands and the new `setup` command. + ([#218][]) + +* Runtime checks in `check-setup` and `setup` now test for not just the + presence of Snakemake, Augur, and Auspice, but also that they can be + executed. + ([#218][]) + +(v5-0-0-dev0-development)= +### Development + +* We now provide standalone installers (i.e. shell programs) to download and + unpack the standalone installation archives into standard locations, + potentially upgrading/overwriting a prior standalone install. These + installers will be served from GitHub directly out of this project's + repository via convenience redirects on nextstrain.org. + + These will eventually form the basis for Nextstrain install instructions that + don't suffer from Python bootstrapping issues. As a preview for now, you can + play around with the following platform-specific commands: + + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | bash + curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/mac | bash + Invoke-RestMethod https://nextstrain.org/cli/installer/windows | Invoke-Expression + + A new companion command, `init-shell`, exists to simplify shell configuration + (i.e. `PATH` modification) for such installations. + +* The `NEXTSTRAIN_HOME` environment variable can now be used to specify the + desired location for per-user settings, files, etc., overriding the default + of _~/.nextstrain/_. + ([#218][]) + +* The development documentation now documents how to build the documentation + locally, and sphinx-autobuild is used to make a very nice edit-preview cycle + with quick turnaround. + ([#218][]) + +* Development dependency issues with `flake8` and `sphinx-markdown-tables`, + caused by upstream changes, are now resolved. + ([#218][]) + + +[#218]: https://github.com/nextstrain/cli/pull/218 + + +(v4-2-0)= +## 4.2.0 (29 July 2022) + +(v4-2-0-bug-fixes)= +### Bug fixes + +* Using `remote delete` on nextstrain.org now correctly outputs the ""Deleting…"" + message *before* performing each delete, as intended (and as S3 remotes do). + Previously, the message was misleadingly output *after* each delete was + already performed. + ([#209](https://github.com/nextstrain/cli/pull/209)) + +* Detection of the installation method during self-upgrade checks in + `nextstrain update` and `nextstrain check-setup` now looks for explicit + installer metadata files and no longer assumes Pip as the final fallback. If + the installation method is not explicitly detected, then no upgrade + instructions are shown. Better to suggest nothing than to suggest the wrong + thing. + ([#207][]) + +* An uncaught `StopIteration` error that could have occurred in very specific + and limited circumstances during self-upgrade checks in `nextstrain update` + and `nextstrain check-setup` can no longer occur. + ([#207][]) + +(v4-2-0-improvements)= +### Improvements + +* The `nextstrain remote download`, `upload`, and `delete` commands now support + a `--dry-run` mode. + + This mode, as is broader convention, goes through the motions of doing the + thing, as much as possible, but doesn't _actually_ do the thing. That is, no + changes should occur when `--dry-run` is active. + + This is particularly useful for seeing what will happen if you're unsure of + how a path or argument is handled. Dry runs of the `list` (`ls`) command + don't make sense and aren't included. + ([#210](https://github.com/nextstrain/cli/pull/210)) + +* Installations via a Conda package are now detected during self-upgrade checks + and the suggested upgrade command uses `mamba install` or `conda install`. + ([#207][]) + +* Suggested upgrade commands now specify the expected new version so they fail + if that version is not found rather than succeed but do nothing (or do + something different). + ([#207][]) + +(v4-2-0-development)= +### Development + +* A new debugging mode can be enabled by setting the `NEXTSTRAIN_DEBUG` + environment variable to `1` (or another truthy value). Currently the only + effect is to print more information about handled (i.e. anticipated) errors. + For example, stack traces and parent exceptions in an exception chain are + normally omitted for handled errors, but setting this env var includes them. + Future debugging and troubleshooting features, like verbose operation + logging, will likely also condition on this new debugging mode. + +* We now avoid a runtime dep on setuptools by switching from + `pkg_resources.parse_version` to `packaging.version.parse`. The latter was + already transitively in our dep tree. + ([#207][]) + + +[#207]: https://github.com/nextstrain/cli/pull/207 + + +(v4-1-1)= +## 4.1.1 (18 July 2022) + +(v4-1-1-improvements)= +### Improvements + +* The new version check now links out to the changelog for the latest version + so you know what you're gonna get. + +* The new version check now detects standalone installations and provides + correct upgrade instructions. + +(v4-1-1-development)= +### Development + +* The ""__NEXT__"" heading (and description) is no longer included in the + _CHANGES.md_ file in release artifacts and tags, as it's a development-only + section that's always empty in releases. + +* The `NEXTSTRAIN_CLI_LATEST_VERSION` environment variable can be set to `0` to + disable the new version check performed by default during `nextstrain update` + and `nextstrain check-setup`. Other values can be provided to override the + result of querying PyPI for the latest version. + +* A new command, `debugger`, was added as a tool to help with troubleshooting + environment and execution context issues. The only thing it does is invoke + pdb from within the command's context. + + +(v4-1-0)= +## 4.1.0 (11 July 2022) + +(v4-1-0-improvements)= +### Improvements + +* The `nextstrain remote` family of commands now output a nicer error message + that's more interpretable and actionable when a server error (HTTP status + 5xx) is received during an operation against the nextstrain.org remote. + +* The `nextstrain remote upload` command now outputs a nicer error message + that's more interpretable and actionable when the connection to the + nextstrain.org remote server is broken during transfer. + +* Timestamps are now shown for each line of output from an AWS Batch build. + + +(v4-0-0)= +## 4.0.0 (24 June 2022) + +This release contains **two potentially-breaking changes** for existing usages. +The circumstances and implications of each are described below. + +(v4-0-0-improvements)= +### Improvements + +* It is now an error (instead of a warning) to use the `--image` option to + `nextstrain build` when using the ""native"" runner (either explicitly via + `--native` or implicitly via config set by `nextstrain check-setup + --set-default`). The error message is: + + The --image option is incompatible with the ""native"" runner (…). + + If you need to use the ""native"" runner, please omit the --image option. + + If you need the --image option, please select another runner (e.g. + with the --docker option) that supports it. Currently --image is + supported by the Docker (--docker) and AWS Batch (--aws-batch) + runners. You can check if your setup supports these runners with + `nextstrain check-setup`. + + This is a **potentially-breaking change** as invocations using the ""native"" + runner with the `--image` option may exist and be working for users as they + expect. If you encounter this new error after upgrading but your results of + running `nextstrain` commands has always been as-expected, then you can + safely drop the `--image` option from your invocations and avoid the new + error. + +* When running a Snakemake workflow, `nextstrain build` now defaults + Snakemake's `--cores` option to `all` unless `build`'s own `--cpus` option is + provided. If you provide your own `--cores` (or equivalent, e.g. `-j`) + option to Snakemake via `nextstrain build`, as in `nextstrain build . + --cores 2`, then this new default isn't applicable. + + This is a **potentially-breaking change** if you're… + + - …using Snakemake version 5.10 or earlier (such as via our standard Docker + runtime image), _and_ + + - …are not already providing a `--cores` (or equivalent, e.g. `-j`) option + to Snakemake via `nextstrain build`, _and_ + + - …expect your `nextstrain build` invocations to use only a single CPU/core + instead of all CPUs/cores available on your computer. + + If this is the case, you can pass `--cpus 1` to `nextstrain build` to regain + the original behaviour, e.g. `nextstrain build --cpus 1 .`. + + This change will allow upgrading of Snakemake in our Docker runtime image + without inflicting the addition of `--cores` (or equivalent) arguments onto + every existing `nextstrain build` invocation that lacks it. + + For context, Snakemake [requires the `--cores` option as of + 5.11](https://github.com/snakemake/snakemake/issues/283). This has spawned + much discussion + ([1](https://github.com/snakemake/snakemake/issues/308), + [2](https://github.com/snakemake/snakemake/issues/312), + [3](https://github.com/snakemake/snakemake/issues/450), + [4](https://github.com/snakemake/snakemake/issues/885)) + where it was made clear this is an intentional, permanent change and a + default will not be added. By adding our own default, we can insulate our + users from the upstream change and make Nextstrain builds fast-by-default. + Our `--cpus` option can be used to limit CPU usage back from this default if + necessary, and users can always specify `--cores` (or equivalents) + themselves. + +* The `version --verbose` and `check-setup` commands now indicate the default + runner in their output, which is useful context when troubleshooting or just + plain unsure what the default is. + +* The `check-setup` command now exits with an error code if the default runner + is not supported. Prior to this it only exited with an error code if no + runners were supported. + +(v4-0-0-bug-fixes)= +### Bug fixes + +* When using the AWS Batch runner, the `--cpus` and `--memory` options for + `build` now correctly override the corresponding resource requests in newer + style AWS Batch job definitions. Prior to this they would be ignored by AWS + Batch. Older style AWS Batch job definitions were never affected by this and + continue to work with `--cpus` and `--memory` as expected. See + [#144](https://github.com/nextstrain/cli/issues/144) for more details. + +* A deprecation warning from the `cryptography` module (version 37 and higher) + when running on Python 3.6 is now suppressed as it's just noise to an end + user. This probably moves us closer to dropping 3.6 support ourselves, but + it's not so onerous yet. + +* The rST to plain text conversion used to format `--help` text was fixed to + avoid emitting `\r\n` in the wrong context. + +* The stdout and stderr streams are now configured at program start to always + emit UTF-8. Previously they used the Python defaults, determined in part by + the system defaults, which often resolved to UTF-8, but not always. The code + base assumes UTF-8, and now the streams are guaranteed to match. In + particular, this fixes `UnicodeEncodeError` issues in some contexts on + Windows even when UTF-8 is supported. + +(v4-0-0-documentation)= +### Documentation + +* This changelog now sports a preamble to set the scene and provide context for + the content. + +(v4-0-0-development)= +### Development + +* The source repo now uses a `+git` local version part to distinguish + actual releases from installations of unreleased code. Relatedly, the + development builds created by CI use a `+git.${commit}` local version part to + pin down the specific commit from which they were built. This is mostly + helpful when reading CI logs or downloading the builds from the CI artifacts. + +* The CI workflow has seen some significant sprucing up and additions, + including sporting a more typical lifecycle with separate steps for build, + test, and release (a new addition). The single test step is also now split + between source tests (unit tests, type checking, linting, etc) and dist tests + (functional tests, integration tests, interface tests, etc). The release + step uploads to PyPI after a release tag is pushed, built, and tested, + replacing manual uploads from a local development environment. Various other + small improvements to CI were also made. + +* We now run CI tests on Windows. \o/ It's not perfect, but this should help + avoid basic Windows-only pitfalls which we might not otherwise notice in a + timely fashion. + +* Our CI now builds (and tests) standalone installation archives (`.tar.gz` for + Linux and macOS, `.zip` for Windows) comprising of: + + 1. A `nextstrain` executable containing a bundled Python interpreter + the + Python stdlib + the Nextstrain CLI code + its dependencies. + + 2. External files (lib, data, etc) that are necessary but can't (for a + variety of reasons) be bundled into the executable. + + These installation archives can be downloaded, extracted, and run in-place + without even a Python interpreter being installed on the host computer, hence + the ""standalone"" moniker. + + Currently these are for development/testing/experimentation purposes only. + We include them as assets on GitHub Releases, but do not provide an automated + means of ""installing"" or unpacking them; those are ultimate goals, but this + is just a first step towards those. If you try out the standalone archives + in the meantime, though, please let us know how it goes (good or bad) by + opening an issue with your experience/feedback/questions. + +* GitHub Releases are now created by CI after making a release to PyPI. These + are visible on the GitHub repo's [releases + page](https://github.com/nextstrain/cli/releases) and various other places on + GitHub. Each GitHub Release includes a copy of the relevant changelog + section and release assets like the Python distributions and standalone + installation archives (see above). Releases on GitHub are currently intended + mostly for informational and notification purposes; the primary release + distribution method is still PyPI and sources downstream of PyPI (e.g. + Conda). + + +(v3-2-5)= +## 3.2.5 (23 May 2022) + +(v3-2-5-improvements)= +### Improvements + +* A better error message with a potential remediation is emitted when requests + to nextstrain.org fail due to stale user tokens. + +(v3-2-5-documentation)= +### Documentation + +* The cross-reference to Nextstrain Groups documentation is now up to date with + the latest Groups docs. + + +(v3-2-4)= +## 3.2.4 (6 April 2022) + +(v3-2-4-bug-fixes)= +### Bug fixes + +* `update` will no longer overwrite a `docker.image` config setting when the + current/default value includes an explicit `latest` tag. This change makes + it possible to track the ""latest"" Docker runtime image by manually setting + + ```ini + [docker] + image = nextstrain/base:latest + ``` + + in _~/.nextstrain/config_. + ([#163](https://github.com/nextstrain/cli/pull/163)) + +* `update` now correctly prunes old images starting from and including the + just-updated-from image, instead of accidentally skipping it until the next + `update`. + ([#163](https://github.com/nextstrain/cli/pull/163)) + +* `check-setup --set-default` now sets the `docker.image` setting to the most + recent `build-*` image when the Docker runtime is selected as the default. + ([#168](https://github.com/nextstrain/cli/pull/168)) + + +(v3-2-3)= +## 3.2.3 (1 April 2022) + +(v3-2-3-bug-fixes)= +### Bug fixes + +* `remote upload` to nextstrain.org destinations is no longer exceedingly slow. + This was most noticeable for large dataset JSONs. The slowness was a result + of poor IO patterns during gzip compression that weren't triggered by S3 + destinations. Additionally, after benchmarking, the gzip compression level + was reduced from the max (9) to the default (currently 6) as a better + compromise between speed and compressed size. + ([#165](https://github.com/nextstrain/cli/pull/165)) + + +(v3-2-2)= +## 3.2.2 (28 March 2022) + +(v3-2-2-documentation)= +### Documentation + +* A new page describes how to upgrade Nextstrain CLI. + +* The doc page for `nextstrain remote` now links to the pages for its + subcommands. + +* A placeholder in the `nextstrain remote list` command usage now matches the + placeholder used elsewhere in its `--help` output. + + +(v3-2-1)= +## 3.2.1 (22 March 2022) + +(v3-2-1-bug-fixes)= +### Bug fixes + +* `remote upload` no longer gzip compresses files which are already compressed + when uploading them to an S3 remote. This isn't expected in typical usage + when uploading Nextstrain dataset (JSON) or narrative (Markdown) files but + arises when uploading related files to an S3 remote (e.g. a `metadata.tsv.gz` + file to `s3://nextstrain-data/files/zika/`). + ([#161](https://github.com/nextstrain/cli/pull/161)) + +(v3-2-1-development)= +### Development + +* The CI workflow setup steps were simplified a bit. + + +(v3-2-0)= +## 3.2.0 (9 March 2022) + +(v3-2-0-bug-fixes)= +### Bug fixes + +* `check-setup` no longer errors when, on some systems, awk outputs a large + number (bytes of memory reported by /proc/meminfo) in exponential notation. + ([#159](https://github.com/nextstrain/cli/pull/159)) + +(v3-2-0-features)= +### Features + +* The `view` and `remote` family of commands now support ""measurements"" dataset + sidecar files. + ([#156](https://github.com/nextstrain/cli/pull/156)) + + +(v3-1-1)= +## 3.1.1 (4 March 2022) + +(v3-1-1-bug-fixes)= +### Bug fixes + +* The Docker runtime now avoids merging stdout and stderr together when at + least one of stdout or stderr isn't a console (TTY), e.g. when redirecting + one or both streams to a file or piping output to another command. + ([#155](https://github.com/nextstrain/cli/pull/155)) + +* A global lockfile is now used for reading/writing config files instead of + locking the config files themselves. This resolves a regression on Windows + introduced in 3.0.4 which manifested as an `[Errno 13] Permission denied` + error when running `nextstrain update` and `nextstrain check-setup + --set-default`. + ([#157](https://github.com/nextstrain/cli/pull/157)) + +(v3-1-1-documentation)= +### Documentation + +* The changelog now notes two minor (har har) semantic versioning mistakes in + previous releases. + + +(v3-1-0)= +## 3.1.0 (1 March 2022) + +(v3-1-0-features)= +### Features + +* `remote` family of commands now support interacting with nextstrain.org's web + API using the credentials established by the `login` command. + + See the [nextstrain.org + remote](https://docs.nextstrain.org/projects/cli/page/remotes/nextstrain.org/) + documentation for more information. + +* `login` now sports a `--renew` flag to request new tokens with refreshed user + information (e.g. group memberships). + +(v3-1-0-bug-fixes)= +### Bug fixes + +* `build` now exits 1 (an error) when the AWS Batch job fails due to + infrastructural issues like the EC2 instance its running on being terminated. + Previously it exited 0 (success) despite the job not being successful. + +* `check-setup` now supports Docker hosts with cgroups v2 and better handles + failures in the memory limits check. + +* Messages related to automatic login (authn) management are now send to stderr + instead of stdout. + +* `remote delete` messages now correctly imply each deletion is just about to + happen instead of just happened already. + +* The messages produced when an internal error is detected now suggest filing + an issue on GitHub to report the bug. + +(v3-1-0-documentation)= +### Documentation + +* The specific release version will now be displayed under the project name in + the sidebar of the documentation pages. + +(v3-1-0-development)= +### Development + +* Many breakages of our CI caused by external changes in upstream testing deps + are now resolved. + + +(v3-0-6)= +## 3.0.6 (26 January 2022) + +(v3-0-6-documentation)= +### Documentation + +* The organization of the documentation sidebar menu is now improved to show + more of the pages instead of burying them in subpage table of contents. + +* The formatting of `--help` output is now slightly improved with regard to + links, but more importantly, richer formatting of content shared between + `--help` and the online documentation is now possible. + + +(v3-0-5)= +## 3.0.5 (20 December 2021) + +_This release should have bumped the minor version, not the patch version, +since it added a new feature. —trs, 1 March 2022_ + +(v3-0-5-features)= +### Features + +* `view` now supports a `--host` option to specify the IP address or hostname + on which to listen, complementing the existing `--port` option. + `--allow-remote-access` is now an alias for `--host=0.0.0.0`. + +(v3-0-5-paper-cut-remedies)= +### Paper cut remedies + +* [netifaces](https://pypi.org/project/netifaces/) is no longer a dependency + since its lack of wheels for recent Python versions means it often requires a + C toolchain for installation. This impacted multiple platforms, including + Windows and Linux. For more context, see discussion starting with [this + issue comment](https://github.com/nextstrain/cli/issues/31#issuecomment-966609539). + + Unfortunately the package no longer has a maintainer, so we can't count on + any timeline for updates and do not have the resources to maintain it + ourselves. Dropping the dep makes the UX of `nextstrain view + --allow-remote-access` a bit poorer, but makes installation a lot easier. + + +(v3-0-4)= +## 3.0.4 (3 November 2021) + +_This release should have bumped the minor version, not the patch version, +since it added new features/commands. —trs, 1 March 2022_ + +(v3-0-4-features)= +### Features + +* Three new commands—`login`, `logout`, and `whoami`—for authenticating with + nextstrain.org. These commands manage tokens stored in + _~/.nextstrain/secrets_. No other commands currently use the tokens, but + future features will start using them, e.g. for managing datasets and + narratives on nextstrain.org with the `remote` family of commands. + +(v3-0-4-bug-fixes)= +### Bug fixes + +* Adjusted dependencies on s3fs and aiobotocore to avoid incompatible versions + being selected by pip. + + aiobotocore released a new version, 2.0.0, with breaking changes and pip's + resolution algorithm chose an older s3fs version which was ""compatible"" by + dep declaration by not actually in practice, leading to `nextstrain build + --aws-batch` throwing errors at runtime. + +* update: Explicitly handle errors from the Docker Hub registry. + +(v3-0-4-documentation)= +### Documentation + +* AWS Batch: Documented the unintuitive interaction of compute envs and launch + template versions and updated the disk space section for Amazon Linux 2 + compute environments. + +* Updated various links that had moved. + +(v3-0-4-development)= +### Development + +* Ditched Pipenv for a plain venv setup. + +* Dependencies for Read The Docs and CI docs builds are no longer pinned but + will use the latest versions that otherwise meet standard dep declarations. + +* Added pyright tests for additional type checking. This covers some kinds of + checks that mypy does not, and in particular lets us use protocol types to + check the Runner and Remote module interfaces. + +* Enabled more mypy checks and resolve findings. + +* Tests now treat warnings as errors so we can address them, and CI is now + warnings clean. + + Python warnings are important to see earlier than later so we can avoid + spewing warnings to users. + + Sphinx warnings are often authoring mistakes that need to be addressed. + + +(v3-0-3)= +## 3.0.3 (23 February 2021) + +(v3-0-3-documentation)= +### Documentation + +* The help output for `build` now correctly describes the default behaviour of + the `--download` and `--no-download` options. + +* The help output for `build` now warns about the need to escape wildcards or + quote the whole pattern when using `--download` so as to avoid expansion by + the shell. + + +(v3-0-2)= +## 3.0.2 (16 February 2021) + +(v3-0-2-bug-fixes)= +### Bug fixes + +* `update` more gracefully handles Docker not being installed. Although the + command still exits with error (as it currently serves only to pull the + latest Docker image), an uncaught exception isn't thrown. More improvements + to come later with [#87](https://github.com/nextstrain/cli/issues/87). + +* `version` now gracefully handles Docker not being installed when `--verbose` + is given instead of throwing an uncaught exception. + +* `version` now includes Python information when `--verbose` is given, which is + helpful for debugging Python issues, e.g. which Python install is being used. + +* The Docker (`--docker`) runner for `build`, `shell`, and `view` no longer + requests a TTY connected to the container when stdin is not itself a TTY + (e.g. run from a non-interactive shell). This avoids a fatal error from + Docker (""the input device is not a TTY""). + +* Distribution metadata was fixed so that the LICENSE file is no longer + attempted to be installed under the Python installation prefix (e.g. + `/usr/local`). It is instead included inside the ""egg-info"" directory + alongside the code in the Python site libraries. + +(v3-0-2-development)= +### Development + +* Revamp CI by switching from Travis CI to GitHub Actions, expanding the test + matrix to macOS and Python 3.9, and adding an integration test for the + ""native"" build runner. + + +(v3-0-1)= +## 3.0.1 (12 February 2021) + +Hotfix for a missing transitive dependency on s3fs via fsspec, which caused +`nextstrain build --aws-batch` invocations to fail when s3fs was not installed. + + +(v3-0-0)= +## 3.0.0 (11 February 2021) + +The minimum Python version for installing the Nextstrain CLI itself is now 3.6. + +(v3-0-0-features)= +### Features + +* build: Uploads and downloads for remote AWS Batch builds are now streamed + without the use of temporary local files. This halves the local storage + overhead needed and also speeds up the transfer of large builds since: + + 1. Uploading can start immediately without first writing the whole archive locally + 2. Unmodified files do not need to be downloaded, just their metadata + +* build: The results of remote builds may now be selectively downloaded (or not + downloaded at all). Two new `nextstrain build` options are available: + + --download + --no-download + + The former may be given multiple times and specifies patterns to match + against build dir files which were modified by the remote build. The + latter skips downloading results entirely, which is useful if all you + care about are the logs (such as when re-attaching to a build or when a + build uploads results itself elsewhere). The default is still to + download every modified file. + + Currently this functionality is limited to AWS Batch (`--aws-batch`) builds, + as it is the only remote environment supported. + +(v3-0-0-bug-fixes)= +### Bug fixes + +* build: Python bytecode files (`__pycache__` and `*.pyc`) are no longer + uploaded or downloaded from remote builds on AWS Batch. + +* build: Log messages about individual file uploads/downloads to AWS Batch are + now printed _before_ each operation, instead _after_, so you can see what + files are taking a while instead of being in the dark until it completes. + +* remote download: A better error message is now produced when a prefix-less + `s3://` URL is provided without the `--recursively` option. + +(v3-0-0-documentation)= +### Documentation + +* Clarify how remote builds on AWS Batch acquire AWS credentials. + +* Fix broken links into AWS documentation for boto3. + +* Switch to our [Nextstrain theme for + Sphinx](https://github.com/nextstrain/sphinx-theme) + +* Some documentation has been shuffled around to better fit within the larger + [docs.nextstrain.org](https://docs.nextstrain.org) effort. Redirects were + put into place for any moved RTD URLs. + +(v3-0-0-development)= +### Development + +* Various improvements to the Read The Docs and Sphinx setup. + +* Upgrade locked Pipenv development environment. + +* Fix type checking failures under newer versions of mypy. + + + +(v2-0-0-post1)= +## 2.0.0.post1 (15 June 2020) + +(v2-0-0-post1-documentation)= +### Documentation + +* The AWS Batch documentation and 2.0.0 release notes (below) now include + information about the additional necessity of granting users the ability to + `iam:PassRole` for the role used by Batch jobs. + + +(v2-0-0)= +## 2.0.0 (2 June 2020) + +(v2-0-0-features)= +### Features + +* build: The AWS Batch runner now supports overriding the image hardcoded in + the Batch job definition. Use the `--image` command-line option, the + `NEXTSTRAIN_DOCKER_IMAGE` environment variable, or the `docker.image` config + setting. This means that both `--docker` and `--aws-batch` builds will now + use the same container image, increasing reproducibility and customizability. + + This is a **potentially-breaking change**, as it requires your AWS IAM users + are allowed to perform the `batch:RegisterJobDefinition` action and + `iam:PassRole` for the your configured job role (typically + _NextstrainJobsRole_). The [example _NextstrainJobsAccessToBatch_ IAM + policy](aws-batch.md#nextstrainjobsaccesstobatch) in the [AWS Batch + docs](aws-batch.md) is updated to reflect these new privileges. + +* build: The new `--cpus` and `--memory` options allow limits to be specified + for containerized (Docker, AWS Batch) builds. These both automatically + inform Snakemake's resource scheduler and the AWS Batch instance size + selection. If your builds use Snakemake-based workflows, using these new + options is better than specifying `--cores …` or `--resources mem_mb=…` + directly. + +* version: Verbose output now includes the ""native"" versions of Augur and + Auspice, if available. + +(v2-0-0-bug-fixes)= +### Bug fixes + +* view: Auspice v2 dataset JSONs are now detected and included in the list of + available datasets message printed to the console. + +* view: Auspice v1 datasets are now only listed if both the tree and meta JSON + files exist. Previously, incomplete datasets with only the tree JSON were + listed. + +(v2-0-0-documentation)= +### Documentation + +* The README now documents known issues with Windows. + +(v2-0-0-development)= +### Development + +* Pipenv is now used to provide an easier and more consistent development + environment. + +* pytest is now used to run mypy, flake8, and doctests. + + +(v1-16-7)= +## 1.16.7 (20 May 2020) + +(v1-16-7-bug-fixes)= +### Bug fixes + +* AWS Batch builds are now more resilient in the face of transient network or + client errors when uploading the build directory and following build logs. + Thanks Tony Tung! + +(v1-16-6)= +## 1.16.6 (20 May 2020) + +(v1-16-6-bug-fixes)= +### Bug fixes + +* The previous release did not pass mypy's type checks due to a technicality; + mypy has now been placated. + +(v1-16-6-documentation)= +### Documentation + +* check-setup: Success or failure is (hopefully) more clearly messaged now. + This was muddied over time by adding support for the native and AWS Batch + runners, and we've seen several support requests because of confusion here. + +* Installation instructions in the README now document all supported computing + environments, or ""runners"". Pipx is also mentioned as a nice alternative to + Pip. + +* Detaching from AWS Batch builds with `--detach` and Control-Z is now + mentioned in the AWS Batch documentation. + +* A direct reference to the AWS Batch User Guide on memory management details + was added, because AWS docs can be hard to navigate. + +* The units documented to be used by the `--aws-batch-memory` option are now + correct. + +* Runner-selection options (`--docker`, `--native`, `--aws-batch`) are now in + their own option group to reduce clutter among the help output. They are + only visible with `--help-all` now, like development options. With the use + of `nextstrain check-setup --set-default` now emphasized, these options need + not be as prominent. + +* The top-level description in `nextstrain --help` output now says more than + three words. :D + +(v1-16-5)= +## 1.16.5 (22 April 2020) + +(v1-16-5-features)= +### Features + +* build: AWS Batch jobs now require Ctrl-C to be pressed twice _within 10s_ to + cancel a job. This is an additional guard on top of 1.16.4's change so that + if you accidentally press Ctrl-C once you can't accidentally press it again + 30 minutes later and ruin your build. + +(v1-16-4)= +## 1.16.4 (22 April 2020) + +(v1-16-4-features)= +### Features + +* build: AWS Batch jobs now require Ctrl-C to be pressed twice to cancel the + job. This guards a potentially unwanted action from being used accidentally + by requiring confirmation with a second Ctrl-C. + +* build: AWS Batch jobs now report the current job status when re-attaching. + Previously the current job status was never reported, only the next status + transition. For a PENDING or RUNNING job, it might be some time to the next + transition. + +(v1-16-3)= +## 1.16.3 (22 April 2020) + +(v1-16-3-features)= +### Features + +* build: AWS Batch jobs now include more detail about why the container exited + when available. This surfaces useful messages like ""OutOfMemoryError: + Container killed due to memory usage"" in addition to the exit status. + +(v1-16-3-documentation)= +### Documentation + +* check-setup: Describe how `--set-default` chooses an environment. Thanks Mary + Larrousse! + +(v1-16-3-bug-fixes)= +### Bug fixes + +* Fix missing import in our gzip utilities which could cause a runtime error + (NameError) when running `nextstrain remote download` on S3 objects with a + `Content-Encoding` header set to a value other than `gzip` or `deflate`. + This circumstance is unlikely, but not impossible. + +(v1-16-3-development)= +### Development + +* Use Flake8 for static runtime safety and correctness checks + + +(v1-16-2)= +## 1.16.2 (16 March 2020) + +(v1-16-2-bug-fixes)= +### Bug fixes + +* deploy/remote upload: Some files, but not all, were being truncated during + upload due to a bug in gzip compression handling. Now the whole file makes + it to its destination. More details in + [#62](https://github.com/nextstrain/cli/pull/63). + +* build: The default arguments for `snakemake` are no longer used if a + different program to run is specified with `--exec`. + + +(v1-16-1)= +## 1.16.1 (25 February 2020) + +(v1-16-1-documentation)= +### Documentation + +* Update README to include the latest usage information, which mentions the new + `remote` command. + + +(v1-16-0)= +## 1.16.0 (25 February 2020) + +(v1-16-0-features)= +### Features + +* The `deploy` command is now an alias for the `remote upload` command. + +* The new `remote list`, `remote download`, and `remote delete` commands allow + listing, downloading, and deleting remote datasets and narratives which were + uploaded using `deploy` / `remote upload`. Currently only direct s3:// + destinations are supported, but its anticipated that Nextstrain Groups will + be supported as first-class destinations in the future. + +(v1-16-0-bug-fixes)= +### Bug fixes + +* deploy/remote upload: Invalid credentials are now properly caught and messaged about. + +* deploy/remote upload: Files are now deployed/uploaded using streaming + compression instead of buffering the whole file in memory first. + + +(v1-15-0)= +## 1.15.0 (18 February 2020) + +(v1-15-0-features)= +### Features + +* Environment variables for [AWS + credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-environment-variables) + (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `AWS_SESSION_TOKEN`) are + now passed through to builds. This lets builds which use data on S3 to work + transparently, for example. + +* Environment variables for [ID3C](https://github.com/seattleflu/id3c) + (`ID3C_URL`, `ID3C_USERNAME`, and `ID3C_PASSWORD`) are now passed through to + builds. This lets Seattle Flu Study builds which use data in an ID3C + instance to work transparently. + + +(v1-14-0)= +## 1.14.0 (24 September 2019) + +_No changes since 1.14.0b1, described below._ + + +(v1-14-0b1)= +## 1.14.0b1 (17 September 2019) + +(v1-14-0b1-features)= +### Features + +* The `build` command now supports detaching from and re-attaching to builds + run on AWS Batch (`--aws-batch`). + + This adds a feature we've wanted from the beginning of the CLI. By starting + the build with `--detach`, a remote job is submitted and the command + necessary to `--attach` to the job later is printed. This command includes + the job id and can be used as many times as desired, including while the + remote job is running or after it has completed. It will even work on other + computers or for other people, although you may need to modify the local + build path to a directory of your choosing. The directory may be empty, in + which case all build context will be restored there from the remote job. + + AWS Batch builds may also be interactively detached by pressing Control-Z. + Normally this would suspend a Unix process (which could then be resumed with + `fg` or `bg` or SIGCONT), but in the same spirit, `nextstrain build` will + detach from the remote job instead and exit the local process. This also + parallels nicely with our existing Control-C job cancellation support. + + There are currently no facilities to track job state locally or list + outstanding jobs, but these features may be added later if it seems they'd be + useful. As it stands with this new feature, one pattern for launching + multiple detached jobs and picking them up later is: + + # Loop over several `nextstrain build` commands, appending the last + # line to a shell script. + nextstrain build --aws-batch --detach build-a/ | tail -n1 | tee -a pickup-jobs.sh + nextstrain build --aws-batch --detach build-b/ | tail -n1 | tee -a pickup-jobs.sh + … + + # Then, sometime later: + bash pickup-jobs.sh + +* The `--aws-batch` runner for the `build` command no longer requires + permission to perform the globally-scoped AWS IAM action + `s3:ListAllMyBuckets`. Instead, it uses the `HEAD ` S3 API which + requires either `s3:ListBucket`, which can be scoped to specific buckets in + IAM grants, or `s3:HeadBucket`, which is globally-scoped but does not reveal + bucket names. More details on these IAM actions are in the + [S3 documentation](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html#using-with-s3-actions-related-to-buckets). + + +(v1-13-0)= +## 1.13.0 (10 September 2019) + +(v1-13-0-features)= +### Features + +* The `deploy` command no longer requires permission to perform the + globally-scoped AWS IAM action `s3:ListAllMyBuckets`. Instead, it uses the + `HEAD ` S3 API which requires either `s3:ListBucket`, which can be + scoped to specific buckets in IAM grants, or `s3:HeadBucket`, which is + globally-scoped but does not reveal bucket names. More details on these IAM + actions are in the [S3 documentation](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html#using-with-s3-actions-related-to-buckets). + + +(v1-12-0)= +## 1.12.0 (5 September 2019) + +(v1-12-0-features)= +### Features + +* The `deploy` command now supports files other than JSON data files, such as + Markdown narratives, by setting the correct content type on upload. + + +(v1-11-2)= +## 1.11.2 (3 September 2019) + +(v1-11-2-bug-fixes)= +### Bug fixes + +* This release fixes a regression in the `view` command which caused + ""connection reset"" or ""empty response"" errors. The regression only affected + versions 1.11.0 and 1.11.1 of the Nextstrain CLI when used with Auspice 1.38.0 + via the `nextstrain/base:build-20190828T223744Z` image. Thanks to Thomas + Adams for the excellent bug report! + + +(v1-11-1)= +## 1.11.1 (30 August 2019) + +(v1-11-1-bug-fixes)= +### Bug fixes + +* The `check-setup` command no longer errors when Docker isn't installed. + + +(v1-11-0)= +## 1.11.0 (30 August 2019) + +(v1-11-0-features)= +### Features + +* The `view` command now supports `--native` flag to run in the native ambient + environment. + +* The `check-setup` command now supports a `--set-default` flag to save the + first supported environment to the Nextstrain CLI's config file. This means + that you don't have to specify `--native` (or `--aws-batch`) every time if + you don't have/want Docker support. + +(v1-11-0-bug-fixes)= +### Bug fixes + +* The `--verbose` flag to the `version` command will no longer cause the Docker + image to be downloaded when it isn't available locally. + +(v1-11-0-documentation)= +### Documentation + +* Describe the somewhat annoying process of how to increase the disk space + available to AWS Batch jobs in the AWS Web Console. + + +(v1-10-2)= +## 1.10.2 (23 August 2019) + +(v1-10-2-bug-fixes)= +### Bug fixes + +* The [environment variables used by Augur](https://docs.nextstrain.org/projects/augur/page/usage/envvars.html) + are now passed through to --docker and --aws-batch builds. + + +(v1-10-1)= +## 1.10.1 (26 March 2019) + +(v1-10-1-features)= +### Features + +* The `view` command now sports a `--port` option to use an alternate port for + the viewer. + + +(v1-10-0)= +## 1.10.0 (22 February 2019) + +(v1-10-0-features)= +### Features + +* Add ability to specify vCPU and memory when running AWS Batch jobs via + `--aws-batch-cpus` and `--aws-batch-memory` or via specification in + `~/.nextstrain/config` or via environment variables + `NEXTSTRAIN_AWS_BATCH_CPUS` and `NEXTSTRAIN_AWS_BATCH_MEMORY`. This requires + corresponding proper setup of compute environment in AWS Batch console. + +(v1-9-1)= +## 1.9.1 (11 February 2019) + +(v1-9-1-features)= +### Features + +* Restore the modification times of files when unzipping results from an AWS + Batch run. This allows Snakemake's dependency resolution to properly + determine file staleness, which in turn allows local builds to continue where + AWS Batch builds leave off (e.g. running the bulk of the computation on AWS + Batch and then iterating on subsequent trivial steps locally). + + +(v1-9-0)= +## 1.9.0 (8 February 2019) + +(v1-9-0-features)= +### Features + +* Builds run on AWS Batch no longer delete the build dir zip file from S3 or + the job log stream from CloudWatch, making it easier to debug and + troubleshoot Batch builds. The Batch setup documentation is updated to note + that the previously suggested retention policies are now the only thing + preventing runaway data storage costs (and thus a must). + +(v1-9-0-bug-fixes)= +### Bug fixes + +* Declare missing dep on setuptools, used via `pkg_resources` by the + `check-setup` and `update` commands. setuptools nearly always exists already + on Python installs, especially when nextstrain-cli is installed using pip, + but nearly always is not always. + +(v1-9-0-development)= +### Development + +* Static type checking now passes again thanks to a work around for a mypy bug + related to namespace packages. + + +(v1-8-1)= +## 1.8.1 (21 January 2019) + +(v1-8-1-features)= +### Features + +* The `check-setup` command now tests if the local Docker image is new enough + for this version of the CLI. + + +(v1-8-0)= +## 1.8.0 (18 January 2019) + +(v1-8-0-bug-fixes)= +### Bug fixes + +* Docker images between `build-20190115T232255Z` and `build-20190116T000613Z` + (inclusive) broke the `nextstrain view` command. It is fixed in this version + of the CLI, 1.8.0, in tandem with new images, starting with + `build-20190119T045444Z`. If your `view` command is broken, running + `nextstrain update` and following the instructions to upgrade to version + 1.8.0 of the CLI should resolve the issue. + +* AWS Batch builds now avoid uploading files matching `environment*` in the + build directory, as such files are commonly used for storing sensitive + environment values. + + +(v1-7-3)= +## 1.7.3 (28 December 2018) + +(v1-7-3-features)= +### Features + +* The automatic check for newer versions of the CLI, which happens on the + `update` and `check-setup` commands, now produces a better, + more-likely-to-work suggested invocation of pip to perform the upgrade. + + +(v1-7-2)= +## 1.7.2 (28 December 2018) + +(v1-7-2-features)= +### Features + +* The `build` command now runs `snakemake` with the `--printshellcmds` option + for improved log output. + +(v1-7-2-bug-fixes)= +### Bug fixes + +* User-provided paths are now resolved strictly—they must exist—on both Python + 3.5 and ≥3.6, not just 3.5. This discrepancy was unlikely to result in any + noticeable problems because of other existence checks which were performed. + Nevertheless, the change is good housekeeping and helps ensure robustness. + +* The `update` command no longer errors on Python 3.6.0 and 3.6.1 when the + `~/.nextstrain/` does not exist (for example, when upgrading from CLI + versions before 1.7.0). [#37](https://github.com/nextstrain/cli/issues/37) + +(v1-7-2-development)= +### Development + +* Continuous integration testing now includes a much fuller range of Python + versions in order to more quickly catch bugs like the one affecting `update` + above. + +* Continuous integration testing switched to running the + [zika-tutorial](https://github.com/nextstrain/zika-tutorial), a simplified + build more suitable for our needs. + + +(v1-7-1)= +## 1.7.1 (5 December 2018) + +(v1-7-1-bug-fixes)= +### Bug fixes + +* The `shell` command no longer throws an unexpected exception about a missing + `warn()` function when a non-existent build directory is given. The + user-friendly error is printed instead, as expected. + + +(v1-7-0)= +## 1.7.0 (26 November 2018) + +(v1-7-0-features)= +### Features + +* Builds can now be run remotely on [AWS Batch](https://aws.amazon.com/batch/) + by passing the `--aws-batch` flag to the `build` command. See `nextstrain + build --help` for more information. Setup required to support this is + documented in [`doc/aws-batch.md`](aws-batch.md). + +* The `update` command now pulls down new images by their `build-*` tag instead + of tracking the mutable `latest` tag. Our build tags are, most importantly, + not updated after creation and thus are suitable references for reproducible + runs. The output of `nextstrain version --verbose` now includes the specific + build tag. + +* The `check-setup` command now tests the amount of memory available to + containers and warns if it less than 2GB. This is particularly important on + Windows and macOS where Linux containers are run inside a VM on the host. + The VM may have limited memory allocated to it, leading to out-of-memory + errors in builds. + +(v1-7-0-documentation)= +### Documentation + +* Installation instructions in the README are now more detailed. + +* A big picture overview of where the CLI fits into the Nextstrain ecosystem is + included in the README for situating newcomers. + +* The README now refers to Docker Desktop, the new name for Docker Community + Edition. + + +(v1-6-1)= +## 1.6.1 (25 September 2018) + +(v1-6-1-features)= +### Features + +* The `shell` command announces you're entering the build environment, prints + information about mapped volumes, and describes how to leave the environment. + + +(v1-6-0)= +## 1.6.0 (18 September 2018) + +(v1-6-0-bug-fixes)= +### Bug fixes + +* On Windows, fix an issue where the `build` and `shell` commands spawn the + `docker run` process but also immediately return the user to the + command-line. For `shell`, the situation was weirder still because the user + ended up with _two_ command prompts (cmd.exe and bash) but only one appeared + to win when reading from the shared stdin. + + +(v1-5-0)= +## 1.5.0 (4 September 2018) + +(v1-5-0-features)= +### Features + +* The `build` command now supports a `--native` flag to run the build outside + of any container image, that is, within the ambient environment. That + environment might be provided by conda or a cluster module system or custom + installs or some other thing. Docker remains the default, although it + may be explicitly specified with `--docker`. Other runners are planned for + the future. The idea is that the cli as a user-facing tool for Nextstrain is + separate from a containerized Nextstrain environment (although the two work + well together). + +* The `build`, `view`, and `shell` commands now show an abbreviated set of + common options when passed `--help`. The full set of options is available + using `--help-all`. The idea is to make the initial output more approachable. + +(v1-5-0-development)= +### Development + +* The README now describes how to annotate the type of variable and use other + typing features in a way that's compatible with Python 3.5 + +* Package metadata for PyPi is slightly improved. + + +(v1-4-1)= +## 1.4.1 (11 August 2018) + +(v1-4-1-documentation)= +### Documentation + +* Minor updates to README and command help strings + + +(v1-4-0)= +## 1.4.0 (9 August 2018) + +(v1-4-0-features)= +### Features + +* A new `shell` command launches an interactive shell (bash) inside the build + environment, which is useful for running ad-hoc commands and debugging. + + +(v1-3-0)= +## 1.3.0 (9 August 2018) + +(v1-3-0-features)= +### Features + +* The `update` command now prunes old Docker images after downloading new ones. + This functionality relies on our new, labeled images. Older images will have + to be manually pruned as a one-time step. See `docker image prune` for more + information. Note that locally built images which are tagged + nextstrain/base:latest will be pruned when `update` is run. Protect such + images by giving them an additional tag. + +* The versions of the Docker image and individual Nextstrain components in the + image are shown when the `version` command is run with the `--verbose` flag. + + +(v1-2-0)= +## 1.2.0 (1 August 2018) + +(v1-2-0-features)= +### Features + +* A new `deploy` command supports uploading data files to S3, allowing the + complete pathogen build lifecycle to happen using this package. + +* The `check-setup` and `update` commands now check if the CLI itself is out of + date and could be updated. + +(v1-2-0-documentation)= +### Documentation + +* Brief descriptions of the changes in each release are now kept in the + `CHANGES.md` file. You're reading it! + +(v1-2-0-development)= +### Development + +* Describe basic development practices for this package in the README. + +* Commit to [semantic versioning](https://semver.org), which I'd been + neglecting previously when bumping versions. + +* Static type checking is now supported for a small fraction of the source code + and runs clean under mypy. This is included in Travis CI testing. The goal + is to add more type annotations going forward. +","Markdown" +"Pathogens","nextstrain/cli","doc/aws-batch.md",".md","23837","582","# Nextstrain CLI and AWS + +## Running Nextstrain builds on AWS Batch + +The Nextstrain CLI supports launching pathogen builds on [AWS Batch][] from +your own computer. No local computational infrastructure is required when +running on AWS Batch, and jobs have access to computers with very large CPU and +memory allocations if necessary. Some configuration of Batch in your AWS +account is required, but only as an initial, one-time step. See below for +details. + +Launching Nextstrain builds on Batch from your computer is done using the +`--aws-batch` flag to `nextstrain build`, for example: + + nextstrain build --aws-batch zika-tutorial/ + +This uploads the [`zika-tutorial/` directory][] to S3, submits the +Batch job, monitors the job status, streams the job logs to your terminal, and +downloads build results back to the `zika-tutorial/` directory. + +The interface aims to be very similar to that of local builds (run in the +Docker, Conda, Singularity, or ambient runtimes), so the `nextstrain build` +command stays in the foreground and result files are written back directly to +the local build directory. Alternatively, you can specify the `--detach` +option to run AWS Batch builds in the background once they're submitted. The +Nextstrain CLI will tell you how to reattach to the build later to view the +logs and download the results. If you forget to use the `--detach` option, you +can press Control-Z to detach at any point once the build is submitted. + +[AWS Batch]: https://aws.amazon.com/batch/ +[`zika-tutorial/` directory]: https://github.com/nextstrain/zika-tutorial + +### Using and requesting resources + +By default, each AWS Batch job will have available to it the number of vCPUs +and amount of memory configured in your [job definition](#job-definition). To +take full advantage of multiple CPUs available, [Snakemake's `--jobs` (or +`-j`)](https://snakemake.readthedocs.io/en/stable/executing/cli.html#all-options) +option should generally be matched to the configured number of vCPUs. Using +`nextstrain build`'s `--cpus` and `--memory` options will both scale the Batch +instance size and inform Snakemake's resource scheduler for you. + +The resources configured in the job definition can be overridden on a per-build +basis using the `--cpus` and/or `--memory` options, for example: + + nextstrain build --aws-batch --cpus=8 --memory=14gib zika-tutorial/ + +Alternatively, default resource overrides can be set via the +`~/.nextstrain/config` file: + + [aws-batch] + cpus = ... + memory = ... + +Or via the environment variables `NEXTSTRAIN_AWS_BATCH_CPUS` and +`NEXTSTRAIN_AWS_BATCH_MEMORY`. + +When using config or environment variables, however, note that Snakemake's +resource scheduler will not be automatically informed. This means you should +include `--jobs=…` yourself (and possibly `--resources=mem_mb=…`) as an extra +argument to Snakemake. + +Note that requesting more CPUs or memory than available in a compute +environment will result in a job that is queued but is never started. + +If requesting c5 instances the following amounts of CPU and memory are +available within the container: + +instance type | vCPUs | memory +------------- | ----- | ------ +c5-xlarge | 4 | 7400 +c5-2xlarge | 8 | 15200 +c5-4xlarge | 16 | 31000 + +Refer to [Compute Resource Memory Management](https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html) +in the AWS Batch User Guide for more detailed information on container memory. + +### Configuration on your computer + +#### AWS credentials + +Your computer must be configured with credentials to access AWS. + +Credentials can be provided via the [standard AWS environment variables](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#environment-variables) + + export AWS_ACCESS_KEY_ID=... + export AWS_SECRET_ACCESS_KEY=... + +or in the [`~/.aws/credentials` file](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#shared-credentials-file) + + [default] + aws_access_key_id=... + aws_secret_access_key=... + +The credentials file is useful because it does not require you to `export` the +environment variables in every terminal where you want to use AWS. + +#### AWS region + +If you plan to use an AWS region other than `us-east-1`, then you'll want to +set your selected region as a default, either via [the environment](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-environment-variables) + + export AWS_DEFAULT_REGION=... + +or in the [`~/.aws/config` file](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-a-configuration-file) + + [default] + region=... + +Again, the latter option is useful because it does not require you to remember +to `export` the environment variable. + +#### Nextstrain CLI configuration + +The Nextstrain CLI's AWS Batch support must be told, at a minimum, the name of +your S3 bucket (which you'll create below). + +You can do this by putting your bucket name in an environment variable + + export NEXTSTRAIN_AWS_BATCH_S3_BUCKET=... + +or in the `~/.nextstrain/config` file + + [aws-batch] + s3-bucket = ... + +or passing the `--aws-batch-s3-bucket=...` option to `nextstrain build`. + +## Setting up AWS to run Nextstrain builds + +The rest of this document describes the one-time AWS configuration necessary to +run Nextstrain builds on AWS Batch. It assumes you have an existing AWS +account and are familiar with the AWS web console. You'll need to be the AWS +account owner or their delegated administrator to complete these setup tasks. + +**You do not need to read this document if you're using someone else's AWS +account and they have already set it up for you to support Nextstrain jobs.** + + +### S3 + +Create a new private bucket with a name of your choosing in the [S3 web +console](https://console.aws.amazon.com/s3). This document will use the name +`nextstrain-jobs`, but you will have to choose something else. (S3 bucket +names must be globally unique.) + +You may set any bucket options you want, but the bucket should be private and +inaccessible to the public (which is the default). + +Note that the Nextstrain CLI will **not** remove what it uploaded to the bucket +after each run. You must add a [lifecycle retention policy][] to the bucket +which expires (deletes) objects 30 days after creation so that you don't +continue to pay for their storage. You may use a shorter (or longer) lifetime, +but Amazon's prorated billing uses a minimum duration of one month. + +[lifecycle retention policy]: https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html + + +### IAM + +The easiest place to create the necessary policies, role, and group is the [IAM +web console](https://console.aws.amazon.com/iam). + +#### Policies + +Create three policies using the policy documents below. You can paste these +into the JSON editor in the web console. + +##### NextstrainJobsAccessToBatch + +```json +{ + ""Version"": ""2012-10-17"", + ""Statement"": [ + { + ""Sid"": ""VisualEditor0"", + ""Effect"": ""Allow"", + ""Action"": [ + ""batch:DescribeJobQueues"", + ""batch:TerminateJob"", + ""batch:DescribeJobs"", + ""batch:CancelJob"", + ""batch:SubmitJob"", + ""batch:DescribeJobDefinitions"", + ""batch:RegisterJobDefinition"" + ], + ""Resource"": ""*"" + }, + { + ""Sid"": ""VisualEditor1"", + ""Effect"": ""Allow"", + ""Action"": ""iam:PassRole"", + ""Resource"": ""arn:aws:iam::*:role/NextstrainJobsRole"" + } + ] +} +``` + +##### NextstrainJobsAccessToBucket + +You must replace `nextstrain-jobs` in the policy document below with your own +S3 bucket name. + +```json +{ + ""Version"": ""2012-10-17"", + ""Statement"": [ + { + ""Sid"": ""VisualEditor0"", + ""Effect"": ""Allow"", + ""Action"": [ + ""s3:PutObject"", + ""s3:GetObject"", + ""s3:ListBucket"", + ""s3:DeleteObject"" + ], + ""Resource"": [ + ""arn:aws:s3:::nextstrain-jobs/*"", + ""arn:aws:s3:::nextstrain-jobs"" + ] + } + ] +} +``` + +##### NextstrainJobsAccessToLogs + +```json +{ + ""Version"": ""2012-10-17"", + ""Statement"": [ + { + ""Sid"": ""VisualEditor0"", + ""Effect"": ""Allow"", + ""Action"": [ + ""logs:GetLogEvents"", + ""logs:FilterLogEvents"", + ""logs:DeleteLogStream"" + ], + ""Resource"": [ + ""arn:aws:logs:*:*:log-group:/aws/batch/job"", + ""arn:aws:logs:*:*:log-group:/aws/batch/job:log-stream:*"" + ] + } + ] +} +``` + +#### Roles + +A role is required to allow the Batch jobs to access S3. The code running +inside of each job will have access to this role (via the EC2 instance +metadata) to talk to AWS services. + +When creating the role in the web console, choose _AWS service_ as the type of +trusted entity, the _Elastic Container Service_ as the specific trusted +service, and the _Elastic Container Service Task_ as the use case. Attach the +_NextstrainJobsAccessToBucket_ policy you created above. Finally, give the +role a name and description of your choosing. This document assumes the role + name is _NextstrainJobsRole_. + +Most AWS libraries and utilities (e.g. the `aws` command) will automatically +use the instance role by default unless you've customized the credential +provider. Note that if you have AWS credentials set in environment variables +on the local computer when running `nextstrain build --aws-batch`, then those +will be passed into the job, where they'll be used instead of the role by most +libraries and utilities. If this is undesirable, you can unset the environment +variables when launching builds or provision your local credentials via the +standard files instead of environment variables. + + +#### Group + +If your AWS account will be used by other people to run jobs, you should create +an IAM group to give those users the necessary permissions. + +Create a group with a name of your choosing and attach to it all three policies +you created above. Any users you add to this group will be able to use their +own credentials to launch Nextstrain jobs. + + +### Batch + +If you're not familiar with AWS Batch, first familiarize yourself with [what it +is][], and then use the [getting started guide][] and [AWS Batch wizard][] to +setup the job definition, compute environment, and job queue described below. + +[what it is]: https://docs.aws.amazon.com/batch/latest/userguide/what-is-batch.html +[getting started guide]: https://docs.aws.amazon.com/batch/latest/userguide/Batch_GetStarted.html +[AWS Batch wizard]: https://console.aws.amazon.com/batch/home#/wizard + +#### Job and orchestration type + +Choose _Amazon Elastic Compute Cloud (Amazon EC2)_ as the orchestration type. + +#### Compute environment + +Create a _managed_ compute environment with a name of your choosing. + +Choose _ecsInstanceRole_ as the instance role. + +Adjust the compute resources to meet your build requirements, taking into +account the intensity of your builds and the number of concurrent builds you +expect to run. The wizard defaults are a reasonable starting point, and you +can adjust many of the resources at a later time. + +Make sure to set the minimum number of vCPUs to _0_ so that you won't incur EC2 +costs when no jobs are running. + +Choose a VPC, subnet, and security group that has access to the internet. + +#### Job queue + +Create a job queue named `nextstrain-job-queue`. If you use a different name, +you'll need to use the `--aws-batch-queue` option to `nextstrain build`, set +the `NEXTSTRAIN_AWS_BATCH_QUEUE` environment variable, or set `queue` in the +`[aws-batch]` section of `~/.nextstrain/config`. + +If you're not using the wizard, make sure you connect the job queue to the +compute environment you created above. + + +#### Job definition + +Create a new job definition with the name `nextstrain-job`. If you use a +different name, you'll need to use the `--aws-batch-job` option to `nextstrain +build`, set the `NEXTSTRAIN_AWS_BATCH_JOB` environment variable, or set `job` +in the `[aws-batch]` section of `~/.nextstrain/config`. + +Set the execution timeout to _14400_ seconds (4 hours). The timeout ensures +that broken, never-ending jobs will be terminated after 4 hours instead of +racking up EC2 costs. Adjust it if necessary for your builds. + +Specify the container image `nextstrain/base:latest` and an empty command. +(In the wizard, delete the pre-filled command, leaving the JSON result as an +empty array (`[]`).) + +Do not choose any execution role. For the job role, choose _NextstrainJobsRole_ +which you just created in the IAM roles section above. + +Select the number of desired vCPUs and amount of memory you'd like each +Nextstrain build job to have access to. + +No job parameters or job environment variables are required. + +### Job + +If you're using the wizard, the last step is to submit a job. Give it any name. + +### CloudWatch Logs + +AWS Batch jobs automatically send the output of each job to individual log +streams in the `/aws/batch/job` log group. This log group won't exist until +you run your first Batch job, but you can create it yourself before then. + +Note that the Nextstrain CLI will **not** remove the job's log stream after +each run. You must adjust the [log retention policy][] for the +`/aws/batch/job` log group to expire log events after 30 days so that you don't +continue to pay for their storage. You may use a shorter (or longer) lifetime, +but Amazon's prorated billing uses a minimum duration of one month. + +[log retention policy]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SttingLogRetention + + +### Disk space for your jobs + +_The following applies to Batch compute environments using Amazon Linux 2 (AL2) +[ECS-optimized AMIs][], which is the default for new compute environments. If +you're using older compute environments with Amazon Linux 1 (AL1) AMIs, either +upgrade or see previous versions of this document. If you're using custom +AMIs, you can probably find your own way._ + +By default, your Batch jobs will have access to ~28 GiB of shared space. This +is enough for many Nextstrain builds, but the [SARS-CoV-2 build][] is the +notable exception. Your own builds may require more disk space as well. + +Configuring more space requires a little bit of setup. It also helps to +understand that Batch uses [ECS][] to run containers on clusters of [EC2][] +servers. + +Each EC2 instance in an ECS cluster has, by default, a single **30 GiB** root +volume which is **shared by all the containers/jobs running on that instance**. +The default size of this volume is set by the [AWS-managed ECS-optimized +machine images (AMIs)][ami-storage] used by Batch. The operating system and +base software is on the same volume, so usable space for your containers/job is +slightly less, around **28 GiB**. + +There are several approaches to give your Batch jobs more disk, but the +simplest is to increase the size of the root volume using a custom EC2 _[launch +template][]_ that you associate with a new Batch compute environment. + +It's quickest to [create the launch template][create-launch-template] using the +AWS Console, although you can also do it on the command-line. + +Give your launch template any name. + +Under the ""Storage"" section, add a new volume with EBS storage type. Specify a +custom device device name of `/dev/xvda`, a volume size you want (e.g. 200 GiB), +and a volume type of `gp3`. Make sure that the volume is marked for deletion on +termination, or you'll end up paying for old volumes indefinitely! This sets +the size of the shared volume available to all containers on a single EC2 +instance. + +Next, under the ""Advanced details"" section, make sure that ""EBS-optimized +instance"" is enabled. + +Create the launch template, then navigate to edit your existing Batch compute +environment. Under _Launch templates_, set the default launch template to the +one you just created. Set the default version to the version number of the +launch template (`1` if it was just created). Save the changes. + +> Note: if your compute environment uses the launch template with version set to +`$Latest`, you must create a new compute environment to apply any new changes to +the launch template. Compute environments set to use the `$Latest` version of a +launch template are frozen to the latest template version that exists at the +time the environment was created, per [AWS Batch documentation][compute +environment launch template]. For this reason, it's recommended to use an +explicit version number instead of `$Latest` so that you can easily see what +version a compute environment is using (instead of having to correlate compute +environment and launch template version creation times). + +To check if it worked, create an empty directory on your computer, make a +Snakefile containing the rule below, and run it on AWS Batch using the +Nextstrain CLI: + + rule df: + shell: ""/bin/df -h /"" + +If all goes well, you should see that the container has access to more space! + +#### Alternative: NVMe SSD instance storage + +Some EC2 instance families, such as `c5d`, provide host-local NVMe SSD instance +storage devices for a moderate increased cost. These may be faster and/or +cheaper for your latency, throughput, and IOPS needs. + +If you intend to use such instances for your Batch jobs, you'll need to add the +following user data blob to your launch template to configure them: + + Content-Type: multipart/mixed; boundary=""==BOUNDARY=="" + MIME-Version: 1.0 + + --==BOUNDARY== + Content-Type: text/cloud-boothook; charset=""us-ascii"" + + #!/bin/bash + # Use the local NVMe instance storage devices for Docker images and containers. + set -euo pipefail -x + + # Only run this whole script once. + if [[ ""${1:-}"" != init ]]; then + exec cloud-init-per once nvme-storage \ + ""$0"" init + fi + + yum install -y nvme-cli jq lvm2 + + declare -a instance_devices ebs_devices + + instance_devices=($( + nvme list -o json | jq -r ' + .Devices[] + | select(.ModelNumber == ""Amazon EC2 NVMe Instance Storage"") + | .DevicePath + ' + )) + + ebs_devices=($( + nvme list -o json \ + | jq -r ' + .Devices[] + | select(.ModelNumber == ""Amazon Elastic Block Store"") + | .DevicePath + ' \ + | grep -Ff <( + lsblk --json --path /dev/nvme?n? | jq -r ' + .blockdevices[] + | select((.children | length == 0) and (.mountpoint == null)) + | .name + ' + ) + )) + + if [[ ${#instance_devices[@]} -gt 0 || ${#ebs_devices[@]} -gt 0 ]]; then + # Create VG. set +u locally to work around Bash 4.2's behaviour with + # empty arrays (fixed in 4.4). + (set +u; vgcreate nvme-storage ""${instance_devices[@]}"" ""${ebs_devices[@]}"") + + # Allow LVM to settle and VG to appear before trying to create LV + sleep 5 + + # Create LV for Docker. Create + extend when both instance and EBS + # devices are present so that instance devices are allocated PEs (and + # thus used) first. + if [[ ${#instance_devices[@]} -gt 0 && ${#ebs_devices[@]} -gt 0 ]]; then + lvcreate --extents 100%PVS --name docker nvme-storage ""${instance_devices[@]}"" + lvextend nvme-storage/docker ""${ebs_devices[@]}"" + else + lvcreate --name nvme-storage/docker --extents 100%VG + fi + + # Format ext4 with zero reserved blocks for root + mkfs -t ext4 -m 0 /dev/nvme-storage/docker + + # Add to fstab so it mounts at subsequent boots + >>/etc/fstab echo ""/dev/nvme-storage/docker /var/lib/docker ext4 defaults 0 0"" + + # Mount it for this boot + mount /dev/nvme-storage/docker + fi + + --==BOUNDARY==-- + +This uses the [cloud-init user data format][] to setup each EC2 instance (ECS +node) on first boot. Every instance storage device (if any) is added to an LVM +local storage pool, which is then used as the backing disk by Docker. + +If instance storage for a given instance size is not quite enough for your jobs +when matching CPU/memory requirements, you can include additional SSD-backed +EBS volumes in your launch template. These are picked up by the user data +setup above and used only when instance storage is exhausted (or not present). + +The ECS documentation includes more information about [specifying options for +the ECS Docker daemon][ecs-docker-options]. If you want to set other options +in your launch template you may, but make sure you understand [Batch's support +for them][batch-launch-template]. + +#### Alternative: EFS + +Using [EFS volumes][] for Batch jobs is enticing as there's no need to predict +required disk sizes, but it's more expensive and has more complex initial setup +considerations. For example, job definitions must provide EFS volumes to +Docker to be mounted into containers and something must deal with deleting data +which only needs to be ephemeral so as not to incur increasing costs. + + +[SARS-CoV-2 build]: https://github.com/nextstrain/ncov +[ECS]: https://aws.amazon.com/ecs/ +[EC2]: https://aws.amazon.com/ec2/ +[ECS-optimized AMIs]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html +[ami-storage]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html +[launch template]: https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html +[create-launch-template]: https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#LaunchTemplates: +[batch-launch-template]: https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html +[cloud-init user data format]: https://cloudinit.readthedocs.io/en/latest/topics/format.html +[ecs-docker-options]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon +[compute environment launch template]: https://docs.aws.amazon.com/batch/latest/userguide/create-compute-environment-managed-ec2.html +[EFS volumes]: https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html + + +### Security + +A full analysis of the security implications of the above configuration depends +on your existing AWS resources and specific use cases. As such, it is beyond +the scope of this document. + +However, there are a few things to keep in mind: + +* The policies and configuration are intended to support a **trusted set of + users working in good faith**. While the above configuration limits access + to jobs using IAM policies, it does not prevent job users from interfering + with each other's jobs if they desire to do so. + +* Users who can submit jobs can run arbitrary code on EC2 instances you pay + for. They can write arbitrary data to your designated S3 bucket. Make + sure you trust your users. Do not allow public job submission. + +* Jobs are given a limited IAM role to access your designated S3 bucket, but + jobs with malicious intent may be able to elevate their privileges beyond + that and access other AWS services. For more details, see the note titled + ""Important"" on the [""IAM Roles for Tasks"" documentation page][task-iam-roles]. + AWS Batch jobs run in containers using `host`-mode networking, which prevents + blocking this privilege escalation. + +* The Batch compute cluster runs as EC2 instances in a network security group + with access to your private EC2 subnets. If you're running other EC2 + instances, you may wish to isolate your Batch cluster in a separate security + group and subnet. + + +[task-iam-roles]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html +","Markdown" +"Pathogens","nextstrain/cli","doc/conf.py",".py","4830","132","# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + +import re + + +# -- Project information ----------------------------------------------------- + +from datetime import date +from nextstrain.cli import __version__ as cli_version + +project = 'Nextstrain CLI' +version = cli_version +release = version +copyright = '2018–%d, Trevor Bedford and Richard Neher' % (date.today().year) +author = 'Thomas Sibley and the rest of the Nextstrain team' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'myst_parser', + 'sphinx.ext.autodoc', + 'sphinx.ext.intersphinx', + 'sphinx_markdown_tables', + 'nextstrain.sphinx.theme', +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', + 'development.md', +] + + +# -- Options for MyST-Parser ------------------------------------------------- + +# Generate Markdown-only link targets for Markdown headings up to
. These +# are NOT used for rST cross-references or implicit section targets. +# +# You can see the effect of changing this by running, e.g.: +# +# myst-anchors --level 1 CHANGES.md +# +# See also . +myst_heading_anchors = 5 + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'nextstrain-sphinx-theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named ""default.css"" will overwrite the builtin ""default.css"". +html_static_path = ['_static'] + + +# -- Cross-project references ------------------------------------------------ + +intersphinx_mapping = { + 'augur': ('https://docs.nextstrain.org/projects/augur/en/stable', None), + 'auspice': ('https://docs.nextstrain.org/projects/auspice/en/stable', None), + 'docs': ('https://docs.nextstrain.org/en/latest/', None), +} + + +# -- Linkchecking ------------------------------------------------------------ + +## NOTE: for both sets of regular expressions that follow, the +## underlying linkchecker code uses `re.match()` to apply them to URLs +## — so there's already an implicit ""only at the beginning of a +## string"" matching happening, and something like a plain `r'google'` +## regular expression will _NOT_ match all google.com URLs. +linkcheck_ignore = [ + # Fixed-string prefixes + *map(re.escape, [ + # we have links to localhost for explanatory purposes; obviously + # they will never work in the linkchecker + 'http://127.0.0.1:', + 'http://localhost:', + + # Cloudflare ""protection"" gets in the way with a 403 + 'https://conda.anaconda.org', + + # Can't easily check __NEXT__ links that might not exist yet (at least + # outside of the PR preview build). + # + # XXX TODO: An improvement in the future would be munging them to the + # PR preview build. This would helpfully catch mistakes! But we'd + # need to coordinate CI jobs and figure out how/where to do the + # munging. We could also munge them to a local doc build in the + # linkcheck job, I guess. In any case, ENOTIME right now. + # -trs, 29 May 2025 + 'https://docs.nextstrain.org/projects/cli/en/__NEXT__/', + ]), +] +linkcheck_anchors_ignore_for_url = [ + # Fixed-string prefixes + *map(re.escape, [ + # Github uses anchor-looking links for highlighting lines but + # handles the actual resolution with Javascript, so skip anchor + # checks for Github URLs: + 'https://github.com', + 'https://console.aws.amazon.com/batch/home', + 'https://console.aws.amazon.com/ec2/v2/home', + ]), +] +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/volume.py",".py","1204","40",""""""" +Volumes map well-known names to a source path. +"""""" + +import argparse +from typing import NamedTuple +from pathlib import Path + + +class NamedVolume(NamedTuple): + name: str + src: Path + dir: bool = True + writable: bool = True + + +def store_volume(volume_name): + """""" + Generates and returns an argparse.Action subclass for storing named volume + tuples. + + Multiple argparse arguments can use this to cooperatively accept source + path definitions for named volumes. + + Each named volume is stored as a NamedTuple (name, src). The tuple is + stored on the options object as an element in a shared list of volumes, + accessible via the ""volumes"" attribute on the options object. + + For convenient path manipulation and testing, the ""src"" value is stored as + a Path object. + """""" + class store(argparse.Action): + def __call__(self, parser, namespace, values, option_strings = None): + # Add the new volume to the list of volumes + volumes = getattr(namespace, ""volumes"", []) + new_volume = NamedVolume(volume_name, Path(values)) if values else None + setattr(namespace, ""volumes"", [*volumes, new_volume]) + + return store +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/errors.py",".py","884","31",""""""" +Exception classes for internal use. +"""""" +from textwrap import dedent + + +class NextstrainCliError(Exception): + """"""Exception base class for all custom :mod:`nextstrain.cli` exceptions."""""" + pass + +class InternalError(NextstrainCliError): + pass + +class UserError(NextstrainCliError): + """""" + Error intended for display to the user, e.g. an error aiming to be clear, + friendly, and, if possible, actionable. + """""" + def __init__(self, message, *args, **kwargs): + # Remove leading newlines, trailing whitespace, and then indentation + # to better support nicely-formatted """"""multi-line strings"""""". + formatted_message = dedent(message.lstrip(""\n"").rstrip()).format(*args, **kwargs) + + super().__init__(""Error: "" + formatted_message) + +class UsageError(UserError): + """""" + Prints brief command usage before the error message. + """""" + pass +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/requests.py",".py","3900","115",""""""" +HTTP requests and responses with consistent defaults for us. + +.. envvar:: NEXTSTRAIN_CLI_USER_AGENT_MINIMAL + + Set to a truthy value (e.g. 1) to send only a minimal `User-Agent header + `__ + in HTTP requests. + + The minimal User-Agent header includes just the Nextstrain CLI version, + e.g.:: + + Nextstrain-CLI/9.0.0 (https://nextstrain.org/cli) + + The full User-Agent header normally sent with requests includes basic + information on several important software components, e.g.:: + + Nextstrain-CLI/9.0.0 (https://nextstrain.org/cli) Python/3.10.9 python-requests/2.32.3 platform/Linux-x86_64 installer/standalone tty/yes + + This information is non-identifying and useful for our troubleshooting and + aggregate usage metrics, so we do not recommend omitting it unless + necessary. +"""""" +import certifi +import os +import platform +import requests +import sys +from functools import lru_cache +from typing import Tuple + +# Import these for re-export for better drop-in compatibility +# with existing callers. +import requests.auth as auth # noqa: F401 +import requests.exceptions as exceptions # noqa: F401 +import requests.utils as utils # noqa: F401 +from requests import PreparedRequest, RequestException, Response # noqa: F401 + +from .__version__ import __version__ + + +USER_AGENT_MINIMAL = bool(os.environ.get(""NEXTSTRAIN_CLI_USER_AGENT_MINIMAL"")) + +CA_BUNDLE = os.environ.get(""REQUESTS_CA_BUNDLE"") \ + or os.environ.get(""CURL_CA_BUNDLE"") \ + or certifi.where() + + +class Session(requests.Session): + def __init__(self): + super().__init__() + + # Add our own user agent with useful information + self.headers[""User-Agent""] = default_user_agent() + + +def get(*args, **kwargs) -> Response: + with Session() as session: + return session.get(*args, **kwargs) + +def post(*args, **kwargs) -> Response: + with Session() as session: + return session.post(*args, **kwargs) + + +@lru_cache(maxsize = None) +def default_user_agent(minimal: bool = USER_AGENT_MINIMAL) -> str: + """""" + Returns an informative user-agent for ourselves. + + If *minimal*, only our own version is included. Otherwise, useful + information on several components is also included. + + Format complies with `RFC 9110 + `__. + """""" + if minimal: + return f""Nextstrain-CLI/{__version__} (https://nextstrain.org/cli)"" + + py_version = version_info_to_str(sys.version_info) + + from .util import distribution_installer # import here to avoid import cycle + installer = distribution_installer() or ""unknown"" + + system = platform.system() + machine = platform.machine() + + tty = ""yes"" if any(os.isatty(fd) for fd in [0, 1, 2]) else ""no"" + + return f""Nextstrain-CLI/{__version__} (https://nextstrain.org/cli) Python/{py_version} python-requests/{requests.__version__} platform/{system}-{machine} installer/{installer} tty/{tty}"" + + +def version_info_to_str(version_info: Tuple[int, int, int, str, int]) -> str: + """""" + Convert a :attr:`sys.version_info` tuple (or lookalike) to its canonical + string representation. + + >>> version_info_to_str((1, 2, 3, ""final"", 0)) + '1.2.3' + >>> version_info_to_str((1, 2, 3, ""alpha"", 0)) + '1.2.3a0' + >>> version_info_to_str((1, 2, 3, ""beta"", 1)) + '1.2.3b1' + >>> version_info_to_str((1, 2, 3, ""candidate"", 2)) + '1.2.3rc2' + >>> version_info_to_str((1, 2, 3, ""bogus"", 3)) + '1.2.3bogus3' + """""" + major, minor, micro, releaselevel, serial = version_info + + if pre := {""alpha"":""a"", ""beta"":""b"", ""candidate"":""rc"", ""final"":""""}.get(releaselevel, releaselevel): + pre += str(serial) + + return f""{major}.{minor}.{micro}{pre}"" +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/debug.py",".py","516","21",""""""" +Debug flags and utilities. + +.. envvar:: NEXTSTRAIN_DEBUG + + Set to a truthy value (e.g. 1) to print more information about (handled) + errors. For example, when this is not set or falsey, stack traces and + parent exceptions in an exception chain are omitted from handled errors. +"""""" +from os import environ +from sys import stderr + +DEBUGGING = bool(environ.get(""NEXTSTRAIN_DEBUG"")) + +if DEBUGGING: + def debug(*args): + print(""DEBUG:"", *args, file = stderr) +else: + def debug(*args): + pass +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/__init__.py",".py","2892","100",""""""" +Nextstrain command-line interface (CLI) + +The `nextstrain` program and its subcommands aim to provide a consistent way to +run and visualize pathogen builds and access Nextstrain components like Augur +and Auspice across computing platforms such as Docker, Conda, Singularity, and +AWS Batch. + +Run `nextstrain --help` for usage information about each command. +See <:doc:`/index`> for more documentation. +"""""" + + +import sys +import traceback +from argparse import ArgumentParser, Action, SUPPRESS +from textwrap import dedent + +from .argparse import HelpFormatter, register_commands, register_default_command +from .command import all_commands +from .debug import DEBUGGING +from .errors import NextstrainCliError, UsageError +from .util import warn +from .__version__ import __version__ # noqa: F401 (for re-export) + + +def run(args): + """""" + Command-line entrypoint to the nextstrain-cli package, called by the + `nextstrain` program. + """""" + parser = make_parser() + opts = parser.parse_args(args) + + try: + return opts.__command__.run(opts) + + except NextstrainCliError as error: + exit_status = 1 + + if DEBUGGING: + traceback.print_exc() + else: + if isinstance(error, UsageError): + warn(opts.__parser__.format_usage()) + exit_status = 2 + + warn(error) + + return exit_status + + except AssertionError: + traceback.print_exc() + warn(""\n"") + warn(dedent(""""""\ + An error occurred (see above) that likely indicates a bug in the + Nextstrain CLI. + + To report this, please open a new issue and include the error above: + + """""")) + return 1 + + +def make_parser(): + parser = ArgumentParser( + prog = ""nextstrain"", + description = __doc__, + formatter_class = HelpFormatter, + ) + + register_default_command(parser) + register_commands(parser, all_commands) + register_version_alias(parser) + + return parser + + +def register_version_alias(parser): + """""" + Add --version as a (hidden) alias for the version command. + + It's not uncommon to blindly run a command with --version as the sole + argument, so its useful to make that Just Work. + """""" + + class run_version_command(Action): + def __call__(self, *args, **kwargs): + # Go thru parse_args() rather than creating an opts Namespace + # ourselves and passing it directly to version.run() so that the + # version command's options pick up their normal defaults. + opts = parser.parse_args([""version""]) + sys.exit( opts.__command__.run(opts) ) + + parser.add_argument( + ""--version"", + nargs = 0, + help = SUPPRESS, + action = run_version_command) +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/markdown.py",".py","15260","413",""""""" +Markdown parsing and rewriting for embedding narrative images. + +Contains a Parsing Expression Grammar (PEG) for parsing Markdown with +:py:mod:`pyparsing`. The grammar expects a complete Markdown document, but +only parses the minimal number of Markdown constructs required for our needs +(namely, embedding narrative images). + +The two most useful documentation pages for pyparsing are its +`general usage overview `__ and +`API reference `__, +which contains more details for each class than the usage doc. + +Existing Markdown parsers, though many, all fell short of our use case of +transforming some input Markdown to some other output Markdown. They all focus +on converting Markdown to HTML. As such, they throw away important original +source text during the parse, thus making it impossible to reconstruct with any +fidelity and very difficult/tedious to produce more Markdown (i.e. you have to +cover all constructs). I evaluted +`Markdown `__, +`commonmark `, +`markdown-it-py `__ +(what I thought going into this would be our preferred choice!), +`mistletoe `__, +and `mistune `__. +"""""" +from base64 import b64encode +from copy import copy +import mimetypes +import re +from dataclasses import dataclass +from enum import Enum +from operator import attrgetter +from pathlib import Path +from pyparsing import ( + Group, + LineEnd, + LineStart, + nested_expr, + ParserElement, + QuotedString, + SkipTo, + StringEnd, + White, + ZeroOrMore, +) +from typing import ClassVar, Generator, Iterable, Optional, Union +from urllib.parse import urlsplit, quote as urlquote + + +# The AST-like nodes we generate here for parsed elements follow the mdast +# spec¹. We have to have _some_ data model, so might as well use an existing +# one to a) avoid coming up with our own and b) help us to think about cases we +# might not consider. Note that we don't actually construct an AST, but +# produce a simpler flat list of nodes. +# -trs, 17 Nov 2022 +# +# ¹ https://github.com/syntax-tree/mdast +@dataclass +class Node: + type: ClassVar[str] = ""node"" + +@dataclass +class ResourceMixin: + url: str + title: Optional[str] = None + +@dataclass +class AlternativeMixin: + alt: Optional[str] + +@dataclass +class AssociationMixin: + identifier: str + label: Optional[str] + +class ReferenceType(Enum): + full = ""full"" + collapsed = ""collapsed"" + shortcut = ""shortcut"" + +@dataclass +class ReferenceMixin(AssociationMixin): + referenceType: ReferenceType + +@dataclass +class ImageNode(Node, ResourceMixin, AlternativeMixin): + type: ClassVar[str] = ""image"" + +@dataclass +class ImageReferenceNode(Node, AlternativeMixin, ReferenceMixin): + type: ClassVar[str] = ""imageReference"" + +@dataclass +class DefinitionNode(Node, ResourceMixin, AssociationMixin): + type: ClassVar[str] = ""definition"" + +@dataclass +class CodeNode(Node): + type: ClassVar[str] = ""code"" + lang: Optional[str] + meta: Optional[str] + value: str # from mdast's Literal + + +# Don't skip newlines when skipping whitespace. +# +# XXX TODO: This will affect *global* usage of pyparsing within this process, +# which may have unintended effects. Currently we don't seem to have any +# dependents which also use pyparsing (without vendoring), so this seems ok. +# It's not clear to me at the moment how to properly configure each of our +# individual elements instead, but we should probably figure that out at some +# point. +# -trs, 18 Nov 2022 +ParserElement.set_default_whitespace_chars("" \t"") + + +# Nested brackets are acceptable within outer brackets, e.g. of image alt text, +# as long as they're balanced. +BalancedBrackets = nested_expr(*""[]"") + + +# ![alt](url ""title"") +# ![alt](url) +Title = QuotedString('""', esc_char = ""\\"", unquote_results = False, convert_whitespace_escapes = False)(""title"") +ImageWithTitle = Group(""!["" + SkipTo(""]("", ignore = BalancedBrackets)(""alt"") + ""]("" + SkipTo(White()).leave_whitespace()(""url"") + Title + "")"") +ImageWithoutTitle = Group(""!["" + SkipTo(""]("", ignore = BalancedBrackets)(""alt"") + ""]("" + SkipTo("")"")(""url"") + "")"") +Image = ((ImageWithTitle | ImageWithoutTitle) + .set_name(""Image"")) + +# https://github.com/syntax-tree/mdast#image +Image.set_parse_action(lambda tokens: ImageNode( + alt = tokens[0][""alt""], + url = tokens[0][""url""], + title = tokens[0].get(""title""), +)) + + +# ![alt][label] a ""full"" reference +# ![alt][] a ""collapsed"" reference +# ![alt] a ""shortcut"" reference +ImageReferenceExplicit = Group(""!["" + SkipTo(""]["", ignore = BalancedBrackets)(""alt"") + ""]["" + SkipTo(""]"")(""label"") + ""]"") +ImageReferenceImplicit = Group(""!["" + SkipTo(""]"", ignore = BalancedBrackets)(""alt"") + ""]"") +ImageReference = ((ImageReferenceExplicit | ImageReferenceImplicit) + .set_name(""ImageReference"")) + +# https://github.com/syntax-tree/mdast#imagereference +ImageReference.set_parse_action(lambda tokens: ImageReferenceNode( + alt = tokens[0][""alt""], + label = tokens[0].get(""label""), + identifier = normalize_label(tokens[0].get(""label"") or tokens[0].get(""alt"")), + referenceType = reference_type(tokens[0].get(""label"")), +)) + + +# [label]: url +Definition = (Group(LineStart() + ""["" + SkipTo(""]:"")(""label"") + ""]:"" + SkipTo(LineEnd())(""url"")) + .set_name(""Definition"")) + +# https://github.com/syntax-tree/mdast#definition +Definition.set_parse_action(lambda tokens: DefinitionNode( + label = tokens[0][""label""], + identifier = normalize_label(tokens[0][""label""]), + url = tokens[0][""url""], +)) + + +# ```auspiceMainDisplayMarkdown +# ... (unparsed) +# ``` +AuspiceMainDisplayMarkdownStart = LineStart() + ""```auspiceMainDisplayMarkdown"" + LineEnd() +AuspiceMainDisplayMarkdownEnd = LineStart() + ""```"" + LineEnd() +AuspiceMainDisplayMarkdown = (Group(AuspiceMainDisplayMarkdownStart + ... + AuspiceMainDisplayMarkdownEnd) + .set_name(""AuspiceMainDisplayMarkdown"")) + +# Specific case of the more general https://github.com/syntax-tree/mdast#code; +# we don't parse all code blocks. +AuspiceMainDisplayMarkdown.set_parse_action(lambda tokens: CodeNode( + lang = ""auspiceMainDisplayMarkdown"", + meta = None, + value = """".join(tokens[0].get(""_skipped"", [])), +)) + + +# Parse just what we need to and pass thru the rest. +ParsedMarkdown = Image | ImageReference | Definition | AuspiceMainDisplayMarkdown +UnparsedMarkdown = SkipTo(ParsedMarkdown) +Markdown = ZeroOrMore(ParsedMarkdown | UnparsedMarkdown) + SkipTo(StringEnd()) + + +NodeListNode = Union[Node, str] +NodeList = Iterable[NodeListNode] + + +def parse(markdown: str) -> NodeList: + """""" + Parse a *markdown* string into a flat list of nodes consisting of + :py:cls:`Node` subclasses for parsed constructs and plain strings for raw, + unparsed content. + """""" + return list(Markdown.parse_string(markdown, parse_all = True)) + + +def generate(nodes: NodeList) -> str: + """""" + Generate Markdown from the given *nodes* list, such as that returned by + :func:`parse`. + """""" + return """".join(_generate(nodes)) + + +def _generate(nodes: NodeList): + for node in nodes: + if isinstance(node, str): + yield node + + elif isinstance(node, ImageNode): + alt, url, title = attrgetter(""alt"", ""url"", ""title"")(node) + + if title is not None: + yield f""![{alt}]({url} {title})"" + else: + yield f""![{alt}]({url})"" + + elif isinstance(node, ImageReferenceNode): + alt, label, identifier, referenceType = attrgetter(""alt"", ""label"", ""identifier"", ""referenceType"")(node) + + if referenceType is ReferenceType.full: + yield f""![{alt}][{label or identifier}]"" + elif referenceType is ReferenceType.collapsed: + yield f""![{alt}][]"" + elif referenceType is ReferenceType.shortcut: + yield f""![{alt}]"" + + else: + raise AssertionError(f""unknown image reference type {referenceType!r} in node: {node!r}"") + + elif isinstance(node, DefinitionNode): + label, identifier, url = attrgetter(""label"", ""identifier"", ""url"")(node) + yield f""[{label or identifier}]: {url}"" + + elif isinstance(node, CodeNode) and node.lang == ""auspiceMainDisplayMarkdown"": + yield f""```auspiceMainDisplayMarkdown\n"" + yield node.value + yield f""```\n"" + + else: + raise AssertionError(f""unknown Markdown node: {node!r}"") + + +def embed_images(nodes: NodeList, base_path: Path) -> NodeList: + """""" + Return a modified *nodes* list with local images (potentially relative to + *base_path*) converted to embedded ``data:`` URLs. + + In the case where *nodes* was parsed from a local Markdown file, + *base_path* should be the containing directory of that file. + + Neither *nodes* itself nor its contained :cls:`Node` instances are modified + in place. Instead, new :cls:`Node` instances are constructed as necessary + and unchanged nodes are passed thru unmodified to avoid potentially + expensive copies. + """""" + # Collect definitions so we can look them up when we encounter a reference. + # If there are duplicate ids, the first one (in source order) wins. + definitions = { + n.identifier: n + for n in reversed(nodes) + if isinstance(n, DefinitionNode) } + + # We'll modify ""definitions"" in the first pass as we go, so keep a copy of + # the originals around for diffing in the second pass. + original_definitions = copy(definitions) + + # First pass to create new definitions for the image data: URLs. + def first_pass(nodes: NodeList) -> Generator[NodeListNode, None, None]: + for node in nodes: + if isinstance(node, ImageNode): + data_url = as_data_url(node.url, base_path) + + if data_url: + # Image references can't have a title, so if we have a + # title we have to inline the long data: URL. + if node.title is not None: + yield ImageNode( + alt = node.alt, + url = data_url, + title = node.title) + else: + # Otherwise, we prefer to add a new definition and convert + # this image to an image reference so we can sequester the + # long data: URL definition to the bottom of the document. + definition = DefinitionNode( + label = node.url, + identifier = normalize_label(node.url), + url = data_url) + definitions[definition.identifier] = definition + + yield ImageReferenceNode( + alt = node.alt, + label = definition.label, + identifier = definition.identifier, + referenceType = ReferenceType.full) + else: + yield node + + elif isinstance(node, ImageReferenceNode): + if node.identifier in definitions: + definition = definitions[node.identifier] + data_url = as_data_url(definition.url, base_path) + + if data_url: + # Replace the original definition because we can't have + # definitions which point to other definitions. On the + # second pass, we'll filter out the original and emit + # the new one at the bottom of the document. + definitions[definition.identifier] = ( + DefinitionNode( + label = definition.label, + identifier = definition.identifier, + url = data_url)) + + # Always yield the original image reference since the + # identifier is unchanged. + yield node + + elif isinstance(node, CodeNode) and node.lang == ""auspiceMainDisplayMarkdown"": + # Recursively embed images inside the main display content too + yield CodeNode( + lang = node.lang, + meta = node.meta, + value = generate(embed_images(parse(node.value), base_path))) + + else: + yield node + + nodes = list(first_pass(nodes)) + + # Second pass to drop replaced definitions and add new ones at the end, + # sequestering the long data: URLs to the bottom of the document. + to_drop = [d for d in original_definitions.values() if d not in definitions.values()] + to_add = [d for d in definitions.values() if d not in original_definitions.values()] + + def second_pass(nodes: NodeList) -> Generator[NodeListNode, None, None]: + yield from (n for n in nodes if n not in to_drop) + yield ""\n\n"" + for n in reversed(to_add): # reversed() to undo the original reversed() above + yield n + yield ""\n"" + + nodes = list(second_pass(nodes)) + + return nodes + + +def as_data_url(url: str, base_path: Path) -> Optional[str]: + """""" + Convert *url* to a ``data:`` URL if it refers to a local file (potentially + relative to *base_path*). + + *url* must be a bare path (e.g. ``a/b/c.png``) or a ``file:`` URL without a + hostname part (e.g. ``file:///a/b/c.png``). + + Returns ``None`` if *url* doesn't refer to a local file (or the file + doesn't exist). + """""" + url_ = urlsplit(url) + + # Must be a bare path or a file:///path URL + if (url_.scheme, url_.netloc) not in {("""", """"), (""file"", """")}: + return None + + file = base_path / url_.path + + # Whelp, the file's missing, but there's nothing we can do about it. + if not file.exists(): + # XXX TODO: issue a warning? + return None + + content = urlquote(b64encode(file.read_bytes()).decode(""utf-8"")) + content_type, _ = mimetypes.guess_type(file.name) + + if not content_type: + content_type = ""application/octet-stream"" + + return f""data:{content_type};base64,{content}"" + + +def normalize_label(label: str) -> str: + """""" + Per the `mdast spec for an Association `__: + + To normalize a value, collapse markdown whitespace (``[\\t\\n\\r ]+``) + to a space, trim the optional initial and/or final space, and perform + case-folding. + """""" + return re.sub(r'[\t\n\r ]+', ' ', label).strip("" "").casefold() + + +def reference_type(label: str) -> ReferenceType: + """""" + Per the `mdast spec for a ReferenceType `__:: + + ![alt][label] a ""full"" reference + ![alt][] a ""collapsed"" reference + ![alt] a ""shortcut"" reference + """""" + return ( + ReferenceType.shortcut if label is None else + ReferenceType.collapsed if not label else + ReferenceType.full + ) +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/console.py",".py","4734","150",""""""" +Console interface. +"""""" +import re +import sys +from contextlib import contextmanager, ExitStack, redirect_stdout, redirect_stderr +from functools import wraps +from typing import Callable, TextIO +from wrapt import ObjectProxy + + +def auto_dry_run_indicator(getter: Callable[..., bool] = lambda opts, *args, **kwargs: opts.dry_run): + """""" + Automatically wraps a function in a :py:func:`dry_run_indicator` context + based on the function's arguments. + + *getter* is a callable which accepts any arguments and returns a boolean + indicating if a dry run mode is active or not. + + The default *getter* is intended for the typical ``run(opts)`` functions of + our command modules that use an ``opts.dry_run`` parameter (i.e. set by the + ``--dry-run`` command-line option). Provide a custom *getter* if that's + not the case. + + The primary usefulness of this decorator is avoiding additional near-global + levels of indentation. + """""" + def decorator(f): + @wraps(f) + def decorated(*args, **kwargs): + # Get dry run status from function args + dry_run = getter(*args, **kwargs) + + # Run under an indicator context + with dry_run_indicator(dry_run): + return f(*args, **kwargs) + return decorated + return decorator + + +@contextmanager +def dry_run_indicator(dry_run: bool = False): + """""" + Context manager to add an indication to :py:attr:`sys.stdout` and + :py:attr:`sys.stderr` output that a ""dry run"" is taking place. + + Prefixes each line with ``DRY RUN │ `` if *dry_run* is true. + + Does nothing if *dry_run* is not true. + + When entered, returns *dry_run* for the target of the ``with`` statement, + if any. + + >>> from io import StringIO + >>> with redirect_stdout(StringIO()) as out, redirect_stderr(out) as stderr: + ... with dry_run_indicator(True) as dry_run: + ... print(""stdout"") + ... print(""stderr"", file = sys.stderr) + + >>> print(out.getvalue(), end = """") + DRY RUN │ stdout + DRY RUN │ stderr + + >>> dry_run + True + + >>> with redirect_stdout(StringIO()) as out, redirect_stderr(out) as stderr: + ... with dry_run_indicator(False) as dry_run: + ... print(""stdout"") + ... print(""stderr"", file = sys.stderr) + + >>> print(out.getvalue(), end = """") + stdout + stderr + + >>> dry_run + False + """""" + with ExitStack() as stack: + if dry_run: + stack.enter_context(redirect_stdout(LinePrefixer(sys.stdout, ""DRY RUN │ ""))) + stack.enter_context(redirect_stderr(LinePrefixer(sys.stderr, ""DRY RUN │ ""))) + yield dry_run + + +class LinePrefixer(ObjectProxy): # pyright: ignore[reportUntypedBaseClass] + """""" + Add *prefix* to every line written to *file*. + + >>> import sys + >>> def output(file): + ... print(""Swizzling the sporks…"", file = file) + ... print(""Reticulating splines…"", file = file, end = """") + ... print(""\\n done!"", file = file) + ... print(""Gimbling the wabe (this may take a while)\\n\\n\\n"", file = file) + ... print(""Gyre away!"", file = file) + + >>> output(sys.stdout) + Swizzling the sporks… + Reticulating splines… + done! + Gimbling the wabe (this may take a while) + + + + Gyre away! + + >>> output(LinePrefixer(sys.stdout, ""DRY RUN: "")) + DRY RUN: Swizzling the sporks… + DRY RUN: Reticulating splines… + DRY RUN: done! + DRY RUN: Gimbling the wabe (this may take a while) + DRY RUN: + DRY RUN: + DRY RUN: + DRY RUN: Gyre away! + + Attributes of *file* are passed through the :py:cls:`LinePrefixer` object: + + >>> p = LinePrefixer(sys.__stdout__, "" "") + >>> p.fileno() + 1 + """""" + # Declaring these here keeps them local to this proxy object instead of + # being written through to the wrapped file object. + __prefix: str = """" + __next_write_needs_prefix: bool = True + + def __init__(self, file: TextIO, prefix: str): + super().__init__(file) + self.__prefix = prefix + self.__next_write_needs_prefix = True + + def write(self, s) -> int: + s_ = """" + + if self.__next_write_needs_prefix: + s_ += self.__prefix + + # Wait to write a prefix after a trailing newline until the next call. + # This avoids a dangling prefix if we're never called again. + self.__next_write_needs_prefix = s.endswith(""\n"") + + # Insert prefix after every newline except for an end-of-string + # newline, which we'll account for as above on the next, if any, call + # to us. + s_ += re.sub(r'(?<=\n)(?!\Z)', self.__prefix, s) + + return self.__wrapped__.write(s_) +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/env.py",".py","7623","214",""""""" +Environment variable support. +"""""" +import os +from pathlib import Path +from typing import Iterable, Iterator, List, Tuple, Union +from .types import Env, EnvItem + + +Envd = Union[Path, str] + + +def from_vars(vars: Iterable[str], fallback: Env = os.environ) -> Iterator[EnvItem]: + """""" + Parse an iterable of ``name`` or ``name=value`` strings, yielding (name, + value) tuples representing environment variables. + + Names without a value will take their value from *fallback*, by default the + current environment. A value of ``None`` indicates the variable doesn't + exist in the current environment. + + >>> dict(from_vars([""a=b"", ""c"", ""d""], {""c"": ""fallback""})) + {'a': 'b', 'c': 'fallback', 'd': None} + """""" + for var in vars: + if ""="" in var: + name, value = var.split(""="", 1) + else: + name, value = var, fallback.get(var, None) + + yield name, value + + +def from_dirs(envds: List[Envd]) -> Iterator[EnvItem]: + """""" + Read a list of *envd* directories in turn with :func:`from_dir` and yield a + single stream of (name, value) tuples representing environment variables. + + Purely a convenience function. + """""" + for envd in envds: + yield from from_dir(envd) + + +def from_dir(envd: Envd) -> Iterator[EnvItem]: + """""" + Read an *envd* directory like :program:`envdir` does, yielding (name, + value) tuples representing environment variables. + + >>> from tempfile import TemporaryDirectory + >>> with TemporaryDirectory() as tmp: + ... _ = Path(tmp, ""x"").write_bytes(b'y z\\n') + ... dict(sorted(from_dir(tmp))) + {'x': 'y z'} + + As in the original :program:`envdir` in daemontools, only the first line of + each file is read and null bytes in the first line are replaced with + newlines. + + >>> with TemporaryDirectory() as tmp: + ... _ = Path(tmp, ""first"").write_bytes(b'a\\nb\\nc\\n') + ... _ = Path(tmp, ""multiple"").write_bytes(b'a\\x00b\\x00c\\n') + ... dict(sorted(from_dir(tmp))) + {'first': 'a', 'multiple': 'a\\nb\\nc'} + + A value of ``None`` indicates an empty file, which in the semantics of + :program:`envdir` means that variable should be removed from the + environment. Note that an empty file is different than a file containing + an empty first line. + + >>> with TemporaryDirectory() as tmp: + ... _ = Path(tmp, ""none"").write_bytes(b'') + ... _ = Path(tmp, ""emptystr"").write_bytes(b'\\n') + ... dict(sorted(from_dir(tmp))) + {'emptystr': '', 'none': None} + + The *envd* directory must contain only files and no files may contain ``=`` + in their names. + + >>> with TemporaryDirectory() as tmp: + ... Path(tmp, ""d"").mkdir() + ... dict(from_dir(tmp)) + Traceback (most recent call last): + ... + IsADirectoryError: 'd' in envdir ... is a directory, not a file + + >>> with TemporaryDirectory() as tmp: + ... _ = Path(tmp, ""a=b"").write_bytes(b'c\\n') + ... dict(from_dir(tmp)) + Traceback (most recent call last): + ... + ValueError: illegal environment variable name 'a=b' in envdir ... + """""" + if not isinstance(envd, Path): + envd = Path(envd) + + assert envd.is_dir(), f""envd {str(envd)!r} is not a directory"" + + for file in envd.iterdir(): + # The original envdir in daemontools says, ""The [filename] must not + # contain =.""¹ but it doesn't check! Instead, it blindly passes the + # filename concatenated with the value to putenv(3). This results in + # getenv(3) and equivalents splitting on the = in the filename and thus + # seeing the wrong env var name. This sort of requirement that's + # easily checked by the computer but instead placed on the + # programmer/user is pretty typical for software of daemontools' + # vintage. + # + # In this more humane age of computing, it seems more useful to have + # the computer check, and indeed many places do, including: + # + # - libc's setenv(3), in contrast to putenv(3) + # - Python's os.environ + # - envdir port for Python² (skips instead of errors) + # + # So we will here as well. Erroring early when something is amiss + # seems better than silently skipping it and someone finding out later, + # in a context far far away, so let's do that. + # -trs, 12 June 2023 + # + # ¹ + # ² + if ""="" in file.name: + raise ValueError(f""illegal environment variable name {file.name!r} in envdir {envd}"") + + # Daemontools envdir errors on directories, while the Python envdir + # silently skips them. As above, erroring seems more appropriate than + # skipping. We explicitly check rather than rely on the following + # open() to fail with errno.EISDIR because on Windows you can open() a + # directory no problem! We don't check .is_file() because that is only + # true for plain files and other kinds of files should still be + # allowed. + # -trs, 12 & 16 June 2023 + if file.is_dir(): + raise IsADirectoryError(f""{file.name!r} in envdir {envd} is a directory, not a file"") + + if file.stat().st_size > 0: + with file.open() as f: + value = f.readline().rstrip().replace(""\0"", ""\n"") + else: + value = None + + yield file.name, value + + +def to_dir(envd: Envd, env: Env): + """""" + Write *env* to an *envd* directory like read by :func:`from_dir` and + :program:`envdir`. + + >>> from tempfile import TemporaryDirectory + >>> tmp = TemporaryDirectory() + >>> env = {""x"": ""y"", ""multiline"": ""a\\nb\\nc"", ""emptystr"": """", ""none"": None} + >>> to_dir(tmp.name, env) + + >>> env == dict(from_dir(tmp.name)) + True + + >>> sorted(f.name for f in Path(tmp.name).iterdir()) + ['emptystr', 'multiline', 'none', 'x'] + >>> Path(tmp.name, ""x"").read_bytes() + b'y\\n' + >>> Path(tmp.name, ""multiline"").read_bytes() + b'a\\x00b\\x00c\\n' + >>> Path(tmp.name, ""emptystr"").read_bytes() + b'\\n' + >>> Path(tmp.name, ""none"").read_bytes() + b'' + + The keys of *env* may not contain ``=``. + + >>> to_dir(tmp.name, {""a=b"": ""c""}) + Traceback (most recent call last): + ... + ValueError: illegal environment variable name 'a=b' + + >>> tmp.cleanup() + """""" + if not isinstance(envd, Path): + envd = Path(envd) + + assert envd.is_dir(), f""envd {str(envd)!r} is not a directory"" + + for name, contents in to_dir_items(env): + with (envd / name).open(""wb"") as f: + f.write(contents) + + +def to_dir_items(env: Env) -> Iterator[Tuple[str, bytes]]: + """""" + Convert *env* to a stream of (name, contents) pairs representing files in + an *envd* directory like read by :func:`from_dir` and :program:`envdir`. + + >>> env = {""x"": ""y"", ""multiline"": ""a\\nb\\nc"", ""emptystr"": """", ""none"": None} + >>> dict(to_dir_items(env)) + {'x': b'y\\n', 'multiline': b'a\\x00b\\x00c\\n', 'emptystr': b'\\n', 'none': b''} + + The keys of *env* may not contain ``=``. + + >>> dict(to_dir_items({""a=b"": ""c""})) + Traceback (most recent call last): + ... + ValueError: illegal environment variable name 'a=b' + """""" + for name, value in env.items(): + # See rationale for error above. + if ""="" in name: + raise ValueError(f""illegal environment variable name {name!r}"") + + if value is not None: + yield name, (value.replace(""\n"", ""\0"") + ""\n"").encode(""utf-8"") + else: + yield name, b"""" +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/url.py",".py","4263","135",""""""" +URL handling. + +Extended forms of :mod:`urllib.parse` with an API that fits a little better. +"""""" +import os +from typing import List, Mapping, NewType, Optional, Union +from urllib.parse import urlsplit, SplitResult, parse_qs as parse_query, urlencode as construct_query, urljoin + + +Origin = NewType(""Origin"", str) + + +class URL(SplitResult): + """""" + A parsed URL. + + Combines the parsing functionality of :func:`urllib.parse.urlsplit` with + its resulting data tuple of :cls:`urllib.parse.SplitResult`. + + May be constructed only from a single *url* string. + + >>> u = URL(""https://example.com:123/abc/def?x=y#z"") + >>> u + URL(scheme='https', netloc='example.com:123', path='/abc/def', query='x=y', fragment='z') + + >>> u.hostname + 'example.com' + + >>> u.origin + 'https://example.com:123' + + Standard named tuple methods are available. + + >>> u = u._replace(netloc=""example.org"") + >>> u + URL(scheme='https', netloc='example.org', path='/abc/def', query='x=y', fragment='z') + + >>> u.origin + 'https://example.org' + + An optional *base* URL string or :cls:`URL` is accepted and combined with + *url* using :func:`urllib.parse.urljoin` before parsing. + + >>> URL(""def?x=y#z"", ""https://example.com:123/abc/"") + URL(scheme='https', netloc='example.com:123', path='/abc/def', query='x=y', fragment='z') + + >>> URL(""https://example.com/abc/def?x=y#z"", ""https://example.com:123/xyz?n=42#abc"") + URL(scheme='https', netloc='example.com', path='/abc/def', query='x=y', fragment='z') + """""" + __slots__ = () + + def __new__(cls, url: str, base: Union[str, 'URL'] = None) -> 'URL': + return super().__new__(cls, *urlsplit(urljoin(str(base), url) if base else url)) + + # This is for the type checkers, which otherwise consider URL.__init__ to + # have a signature based on SplitResult.__new__ instead of our own __new__. + # It's not clear to me *why* they do that, but this hint helps sort it out. + # -trs, 16 Nov 2023 + def __init__(self, url: str, base: Union[str, 'URL'] = None) -> None: ... + + def __str__(self) -> str: + return self.geturl() + + @property + def origin(self) -> Optional[Origin]: + """""" + The URL's origin, in the `web sense + `__. + + >>> u = URL(""https://example.com:123/abc/def?x=y#z"") + >>> u + URL(scheme='https', netloc='example.com:123', path='/abc/def', query='x=y', fragment='z') + >>> u.origin + 'https://example.com:123' + + Origin is ``None`` if unless both :meth:`.scheme` and :meth:`.netloc` + are present. + + >>> u = URL(""/a/b/c"") + >>> u + URL(scheme='', netloc='', path='/a/b/c', query='', fragment='') + >>> u.origin is None + True + + >>> u = URL(""//example.com/a/b/c"") + >>> u + URL(scheme='', netloc='example.com', path='/a/b/c', query='', fragment='') + >>> u.origin is None + True + """""" + if self.scheme and self.netloc: + return Origin(self.scheme + ""://"" + self.netloc) + else: + return None + + @property + def query_fields(self) -> Mapping[str, List[str]]: + """""" + The URL's :attr:`.query` string parsed into a mapping of name-value fields. + + Values are always lists, even if the field name is not repeated in the + query string. + + >>> URL(""?x=y&a=1&b=2&x=z"").query_fields + {'x': ['y', 'z'], 'a': ['1'], 'b': ['2']} + + Fields without values are treated as having an empty string value. + + >>> URL(""?x=&y&z=1"").query_fields + {'x': [''], 'y': [''], 'z': ['1']} + """""" + return parse_query(self.query, keep_blank_values = True) + + +def query(fields: Mapping[str, Union[str, List[str]]]) -> str: + """""" + Convert query *fields* to a query string. + + >>> query({'x': ['y', 'z'], 'a': ['1'], 'b': ['2']}) + 'x=y&x=z&a=1&b=2' + + >>> query({'x': ['y', 'z'], 'a': '123', 'b': '456'}) + 'x=y&x=z&a=123&b=456' + + >>> query({'x': [''], 'y': '', 'z': '123'}) + 'x=&y=&z=123' + """""" + return construct_query(fields, doseq = True, encoding = ""utf-8"") + + +NEXTSTRAIN_DOT_ORG = URL( + os.environ.get(""NEXTSTRAIN_DOT_ORG"") + or ""https://nextstrain.org"") +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/gzip.py",".py","5168","153",""""""" +Gzip stream utilities. +"""""" +import zlib +from io import BufferedIOBase +from typing import BinaryIO +from .util import byte_quantity, warn + + +DEFAULT_ITER_SIZE = byte_quantity(""8 MiB"") + + +class GzipCompressingReader(BufferedIOBase): + """""" + Compress a data stream as it is being read. + + The constructor takes an existing, readable byte *stream*. Calls to this + class's :meth:`.read` method will read data from the source *stream* and + return a compressed copy. + """""" + def __init__(self, stream: BinaryIO, iter_size: int = DEFAULT_ITER_SIZE): + if not stream.readable(): + raise ValueError('""stream"" argument must be readable.') + + if type(iter_size) is not int: + raise TypeError('""iter_size"" argument must be an int') + + self.stream = stream + self.iter_size = iter_size + self.__buffer = b'' + self.__gzip = zlib.compressobj( + wbits = 16 + zlib.MAX_WBITS, # Offset of 16 is gzip encapsulation + memLevel = 9, # Memory is ~cheap; use it for better compression + ) + + def readable(self): + return True + + def read(self, size = None): + assert size != 0 + assert self.stream + + if size is None: + size = -1 + + # Keep reading chunks until we have a bit of compressed data to return, + # since returning an empty byte string would be interpreted as EOF. + while not self.__buffer and self.__gzip: + chunk = self.stream.read(size) + + self.__buffer += self.__gzip.compress(chunk) + + if not chunk or size < 0: + # Read to EOF on underlying stream, so flush any remaining + # compressed data and return whatever we have. We'll return an + # empty byte string as EOF ourselves on any subsequent calls. + self.__buffer += self.__gzip.flush(zlib.Z_FINISH) + self.__gzip = None + + if size > 0 and len(self.__buffer) > size: + # This should be pretty rare since we're reading N bytes and then + # *compressing* to fewer bytes. It could happen in the rare case + # of lots of data still stuck in the buffer from a previous call. + compressed = self.__buffer[0:size] + self.__buffer = self.__buffer[size:] + else: + compressed = self.__buffer + self.__buffer = b'' + + return compressed + + def close(self): + if self.stream: + try: + self.stream.close() + finally: + self.stream = None + + def __next__(self): + """""" + Iterate in :attr:`.iter_size` chunks. + + Overrides default line-wise iteration from :cls:`io.IOBase`. Line-wise + iteration has no reasonable semantics for binary IO streams like this + one. It only serves to slow down the stream by using many short reads + instead of fewer longer reads. + """""" + chunk = self.read(self.iter_size) + + if not len(chunk): + raise StopIteration + + return chunk + + +class GzipDecompressingWriter(BufferedIOBase): + """""" + Decompress a gzip data stream as it is being written. + + The constructor takes an existing, writable byte *stream*. Data written to + this class's :meth:`.write` will be decompressed and then passed along to + the destination *stream*. + """""" + # Offset of 32 means we will accept a zlib or gzip encapsulation, per + # . Seems no + # downside to applying Postel's Law here. + # + def __init__(self, stream: BinaryIO): + if not stream.writable(): + raise ValueError('""stream"" argument must be writable.') + + self.stream = stream + self.__gunzip = zlib.decompressobj(32 + zlib.MAX_WBITS) + + def writable(self): + return True + + def write(self, data: bytes): # pyright: ignore[reportIncompatibleMethodOverride] + assert self.stream and self.__gunzip + return self.stream.write(self.__gunzip.decompress(data)) + + def flush(self): + assert self.stream and self.__gunzip + super().flush() + self.stream.flush() + + def close(self): + if self.stream: + assert self.__gunzip + try: + self.stream.write(self.__gunzip.flush()) + self.stream.close() + finally: + self.stream = None + self.__gunzip = None + + +def ContentDecodingWriter(encoding, stream): + """""" + Wrap a writeable *stream* in a layer which decodes *encoding*. + + *encoding* is expected to be a ``Content-Encoding`` HTTP header value. + ``gzip`` and ``deflate`` are supported. Unsupported values will issue a + warning and return the *stream* unwrapped. An *encoding* of ``None`` will + also return the stream unwrapped, but without a warning. + """""" + if encoding is not None and encoding.lower() in {""gzip"", ""deflate""}: + return GzipDecompressingWriter(stream) + else: + if encoding is not None: + warn(""Ignoring unknown content encoding «%s»"" % encoding) + return stream +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/net.py",".py","1584","50",""""""" +Network handling. +"""""" +from ipaddress import ip_address, IPv4Address, IPv6Address +from typing import Optional, Set, Union +from socket import getaddrinfo, getnameinfo, gaierror, AddressFamily, AF_UNSPEC, NI_NUMERICHOST + + +def is_loopback(host: Optional[str]) -> Optional[bool]: + """""" + Check if *host* points to only loopback IPs. + + Returns True if so, otherwise False. Returns None if *host* is None or on + host resolution error (e.g. DNS error). + """""" + if host is None: + return None + + try: + ips = resolve_host(host) + except gaierror: + return None + + if not ips: + return None + + return all(ip.is_loopback for ip in ips) + + +def resolve_host(host: str, family: AddressFamily = AF_UNSPEC) -> Set[Union[IPv4Address, IPv6Address]]: + """""" + Resolves a named or numeric *host* to a set of IP addresses. + + By default, all IPv4 and IPv6 addresses are resolved, as applicable + depending on the local IP stack and DNS records for the named host. A + specific address family can be chosen by providing *family*. + """""" + # The isinstance() checks filter out IPv6 addresses when Python lacks + # support.¹ + # -trs, 11 Feb 2025 + # + # ¹ See + # and . + return { + ip_address(getnameinfo(sockaddr, NI_NUMERICHOST)[0]) + for _, _, _, _, sockaddr + in getaddrinfo(host, None, family = family) + if isinstance(sockaddr[0], str) + and isinstance(sockaddr[1], int) } +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/argparse.py",".py","11932","320",""""""" +Custom helpers for extending the behaviour of argparse standard library. +"""""" +import os +import sys +from argparse import Action, ArgumentDefaultsHelpFormatter, ArgumentParser, ArgumentTypeError, SUPPRESS, _SubParsersAction # pyright: ignore[reportPrivateUsage] +from itertools import chain, takewhile +from pathlib import Path +from textwrap import indent as indent_text +from types import SimpleNamespace +from typing import Callable, Iterable, Optional, Tuple +from .debug import debug +from .rst import rst_to_text +from .types import RunnerModule +from .util import format_usage, runner_module + + +# The standard argument group title for non-positional arguments. See +# and +# . +OPTIONS_TITLE = ""options"" if sys.version_info >= (3, 10) else ""optional arguments"" + + +# Include this in an argument help string to suppress the automatic appending +# of the default value by argparse.ArgumentDefaultsHelpFormatter. This works +# because the automatic appending is conditional on the presence of %(default), +# so we include it but then format it as a zero-length string .0s. 🙃 +# +# Another solution would be to add an extra attribute to the argument (the +# argparse.Action instance) and then subclass ArgumentDefaultsHelpFormatter to +# condition on that new attribute, but that seems more brittle. +SKIP_AUTO_DEFAULT_IN_HELP = ""%(default).0s"" + + +class HelpFormatter(ArgumentDefaultsHelpFormatter): + def __init__(self, prog, indent_increment = 2, max_help_position = 24, width = None): + # Ignore terminal size, unlike standard argparse, as the readability of + # paragraphs of text suffers at wide widths. Instead, default to 78 + # columns (80 wide - 2 column gutter), but let that be overridden by an + # explicit COLUMNS variable or reduced by a smaller actual terminal. + if width is None: + try: + width = int(os.environ[""COLUMNS""]) + except (KeyError, ValueError): + try: + width = min(os.get_terminal_size().columns, 80) - 2 + except (AttributeError, OSError): + width = 80 - 2 + + super().__init__(prog, indent_increment, max_help_position, width) + + # Based on argparse.RawDescriptionHelpFormatter's implementation + def _fill_text(self, text, width, indent): + return indent_text(rst_to_text(text, width), prefix=indent) + + # Based on argparse.RawTextHelpFormatter's implementation + def _split_lines(self, text, width): + # Render to rST here so rST gets control over wrapping/line breaks. + return rst_to_text(text, width).splitlines() + + # Emit blank lines between arguments for better readability. It might seem + # simpler to override _join_parts() instead, but that's called from two + # places and we only want to join on newlines for one of those places. + def add_arguments(self, actions): + for i, action in enumerate(actions): + if i != 0: + # Use "" \n"" to avoid a completely empty line (e.g. ""\n"") for + # the sake ShowBriefHelp.truncate_help()'s heuristic. + self._add_item(str, ["" \n""]) + + self.add_argument(action) + + +def register_default_command(parser): + """""" + Sets the default command to run when none is provided. + """""" + def run(x): + parser.print_help() + return 2 + + # Using a namespace object to mock a module with a run() function + parser.set_defaults( __command__ = SimpleNamespace(run = run) ) + + +def register_commands(parser, commands): + """""" + Lets each command module register a subparser. + """""" + subparsers = parser.add_subparsers(title = ""commands"") + + for cmd in commands: + subparser = cmd.register_parser(subparsers) + + # No need to worry about reference cycles of subparser to itself. + # CPython's GC uses automatic reference counting complemented with + # traversal-based reachability detection that can handle cycles.¹ + # Other implementations may not, but we largely don't care about those, + # and taking a big step back, our processes here just don't live long + # enough for the cycle to be a memory issue (plus it's just one cycle, + # not recreated over and over again in a hot loop). + # -trs, 24 August 2023 + # + # ¹ + subparser.set_defaults( __command__ = cmd, __parser__ = subparser ) + + # Ensure all subparsers format like the top-level parser + subparser.formatter_class = parser.formatter_class + + # Default usage message to the docstring of register_parser() + if not subparser.usage and cmd.register_parser.__doc__: + subparser.usage = format_usage(cmd.register_parser.__doc__) + + # Default long description to the docstring of the command + if not subparser.description and cmd.__doc__: + subparser.description = cmd.__doc__ + + # Recursively register any subcommands + if getattr(subparser, ""subcommands"", None): + register_commands(subparser, subparser.subcommands) + + # If a command with subcommands doesn't have its own run() + # function, then print its help when called without a subcommand. + if not getattr(cmd, ""run"", None): + register_default_command(subparser) + + +def add_extended_help_flags(parser): + """""" + Add --help/-h and --help-all flags to the ArgumentParser. + + Aims to make the default --help output more approachable by truncating it + to the most common options. The full help is available using --help-all. + """""" + parser.add_argument( + ""--help"", ""-h"", + help = ""Show a brief help message of common options and exit"", + action = ShowBriefHelp) + + parser.add_argument( + ""--help-all"", + help = ""Show a full help message of all options and exit"", + action = ""help"") + + +class ShowBriefHelp(Action): + def __init__(self, option_strings, help = None, **kwargs): + super().__init__( + option_strings, + help = help, + nargs = 0, + dest = SUPPRESS, + default = SUPPRESS) + + def __call__(self, parser, namespace, values, option_string = None): + """""" + Print a truncated version of the standard full help from argparse. + """""" + full_help = parser.format_help() + brief_help = self.truncate_help(full_help) + + print(brief_help) + + if len(brief_help) < len(full_help): + print(""Run again with --help-all instead to see more options."") + + parser.exit() + + def truncate_help(self, full_help): + """""" + Truncate the full help after the standard ""options"" (or ""optional + arguments"") listing and before any custom argument groups. + """""" + seen_optional_arguments_heading = False + + def before_extra_argument_groups(line): + """""" + Return True until we've seen the empty line following the + hard-coded optional arguments group (that is, all non-positional + arguments which aren't in another explicit group). + """""" + nonlocal seen_optional_arguments_heading + + if not seen_optional_arguments_heading: + if line == f""{OPTIONS_TITLE}:\n"": + seen_optional_arguments_heading = True + + return not seen_optional_arguments_heading \ + or line != ""\n"" + + lines = full_help.splitlines(keepends = True) + + return """".join(list(takewhile(before_extra_argument_groups, lines))) + + +class AppendOverwriteDefault(Action): + """""" + Similar to the core argparse ``append`` action, but overwrites the argument + ``default``, if any, instead of appending to it. + + Thus, the ``default`` value is not included when the option is given and + may be a non-list value if desired. + """""" + def __call__(self, parser, namespace, value, option_string = None): + current = getattr(namespace, self.dest, None) + + if current is parser.get_default(self.dest) or current is None: + current = [] + + setattr(namespace, self.dest, [*current, value]) + + +def runner_module_argument(name: str) -> RunnerModule: + """""" + Wraps :py:func:`runner_module` for friendlier error handling. + + Converts :py:exc:`ValueError` to :py:exc:`ArgumentTypeError`, which lets + :py:mod:`argparse` emit a nice error message when this function is used as + an argument ``type``. + + >>> runner_module_argument(""docker"") # doctest: +ELLIPSIS + + + >>> runner_module_argument(""AWS-Batch"") # doctest: +ELLIPSIS + + + >>> runner_module_argument(""AWS Batch"") # doctest: +ELLIPSIS + + + >>> runner_module_argument(""native"") # doctest: +ELLIPSIS + + + >>> runner_module_argument(""invalid"") + Traceback (most recent call last): + ... + argparse.ArgumentTypeError: invalid runtime name: 'invalid'; valid names are: 'docker', 'conda', 'singularity', 'ambient', 'aws-batch' + + >>> runner_module_argument(""Invalid Name"") + Traceback (most recent call last): + ... + argparse.ArgumentTypeError: invalid runtime name: 'Invalid Name' (normalized to 'invalid-name'); valid names are: 'docker', 'conda', 'singularity', 'ambient', 'aws-batch' + """""" + try: + return runner_module(name) + except ValueError as err: + raise ArgumentTypeError(*err.args) from err + + +def DirectoryPath(value: str) -> Path: + """""" + Argument ``type`` function which enforces a path is a directory that + exists. + + Raises :py:exc:`ArgumentTypeError` if not a directory, which lets + :py:mod:`argparse` emit a nice error message. + """""" + path = Path(value) + + if not path.is_dir(): + raise ArgumentTypeError(f""not a directory: {value}"") + + return path + + +def MkDirectoryPath(parents: bool = False, exist_ok: bool = True) -> Callable[[str], Path]: + """""" + Generates an argument ``type`` function which enforces a path is a + directory that can be made or already exists. + + Takes the same *parents* and *exist_ok* arguments as :py:meth:`Path.mkdir`, + although *exist_ok* defaults to ``True`` instead of ``False``. + + Raises :py:exc:`ArgumentTypeError` when the underlying + :py:meth:`Path.mkdir` call raises a :py:exc:`FileNotFoundError` or + :py:exc:`FileExistsError`, which lets :py:mod:`argparse` emit a nice error + message. + """""" + def mkdir(value: str) -> Path: + path = Path(value) + + try: + debug(f""mkdir: {path} ({parents=}, {exist_ok=})"") + path.mkdir(parents = parents, exist_ok = exist_ok) + + except FileNotFoundError: + assert not parents + raise ArgumentTypeError(f""cannot create directory {path.name!r}: parent directory does not exist: {str(path.parent)!r}"") + + except FileExistsError: + raise ArgumentTypeError( + f""not a directory: {value}"" if exist_ok else + f""already exists: {value}"") + + assert path.is_dir() + return path + + return mkdir + + +def walk_commands(parser: ArgumentParser, command: Optional[Tuple[str, ...]] = None) -> Iterable[Tuple[Tuple[str, ...], ArgumentParser]]: + if command is None: + command = (parser.prog,) + + yield command, parser + + subparsers = chain.from_iterable( + action.choices.items() + for action in parser._actions + if isinstance(action, _SubParsersAction)) + + visited = set() + + for subname, subparser in subparsers: + if subparser in visited: + continue + + visited.add(subparser) + + yield from walk_commands(subparser, (*command, subname)) +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/pathogens.py",".py","45957","1201",""""""" +Pathogen workflows. +"""""" +import json +import jsonschema +import os +import os.path +import re +import traceback +import yaml +from base64 import b32encode, b32decode, b64decode +from inspect import cleandoc +from itertools import groupby +from tempfile import TemporaryFile +from textwrap import indent +from os import chmod, stat +from pathlib import Path, PurePath +from shlex import quote as shquote +from shutil import copyfileobj, rmtree +from stat import S_IXUSR, S_IXGRP, S_IXOTH, S_IRGRP, S_IROTH +from typing import Dict, Iterable, List, NamedTuple, Optional, Tuple +from urllib.parse import quote as urlquote +from zipfile import ZipFile + +from . import config +from . import requests +from . import resources +from .debug import DEBUGGING, debug +from .errors import InternalError, UserError +from .net import is_loopback +from .paths import PATHOGENS +from .types import SetupStatus, SetupTestResults, SetupTestResult, UpdateStatus +from .url import URL, NEXTSTRAIN_DOT_ORG +from .util import parse_version_lax, print_and_check_setup_tests, request_list, warn + + +# XXX TODO: I'm not very happy with the entirety of the conceptual organization +# and physical code organization in this file—in particular 1) the new_setup +# flag for handling of new vs. existing setups, 2) the tension between the main +# PathogenVersion class and the surrounding functions, and 3) the way the +# PathogenVersion constructor inconsistently cares about what's on the +# filesystem or not (e.g. for defaults)—but it does the job for now. If it +# continues to feel ill-fitting for the various uses, I suspect I'll end up +# reorganizing it after a while. This is also to say, if you're working in +# this code and have ideas for improving its organization, please do +# suggest/discuss them! +# -trs, 15 Jan 2025 + + +class PathogenSpec(NamedTuple): + """""" + A parsed pathogen spec of the form ``[][@][=]``, + represented as a named tuple. + + No validation takes place and all fields are optional. This data structure + represents the very first step of handling a user-provided pathogen spec. + As such it focuses only on accurately representing what the user provided. + Validation is left for subsequent steps, where requirements can + appropriately vary depending on context (e.g. program entry point). + """""" + name: Optional[str] + version: Optional[str] + url: Optional[URL] + + def __str__(self) -> str: + return (self.name or """") + ""@"" + (self.version or """") + ""="" + (str(self.url) or """") + + @staticmethod + def parse(name_version_url: str) -> 'PathogenSpec': + """""" + >>> PathogenSpec.parse(""measles"") + PathogenSpec(name='measles', version=None, url=None) + + >>> PathogenSpec.parse(""measles@v2"") + PathogenSpec(name='measles', version='v2', url=None) + + >>> PathogenSpec.parse(""measles@v2 = https://example.com/a.zip"") + PathogenSpec(name='measles', version='v2', url=URL(scheme='https', netloc='example.com', path='/a.zip', query='', fragment='')) + + >>> PathogenSpec.parse(""measles = https://example.com/x.zip"") + PathogenSpec(name='measles', version=None, url=URL(scheme='https', netloc='example.com', path='/x.zip', query='', fragment='')) + + >>> PathogenSpec.parse(""measles@123@abc"") + PathogenSpec(name='measles', version='123@abc', url=None) + + >>> PathogenSpec.parse(""@xyz"") + PathogenSpec(name=None, version='xyz', url=None) + + >>> PathogenSpec.parse(""=https://example.com"") + PathogenSpec(name=None, version=None, url=URL(scheme='https', netloc='example.com', path='', query='', fragment='')) + + >>> PathogenSpec.parse("""") + PathogenSpec(name=None, version=None, url=None) + """""" + if ""="" in name_version_url: + name_version, url = name_version_url.split(""="", 1) + else: + name_version, url = name_version_url, """" + + if ""@"" in name_version: + name, version = name_version.split(""@"", 1) + else: + name, version = name_version, """" + + name = name.strip() or None + version = version.strip() or None + url = url.strip() or None + + # The parsing above is wrong if these assertions don't hold + assert name is None or not set(""@="") & set(name) + assert version is None or not set(""="") & set(version) + + if url is not None: + url = URL(url) + + return PathogenSpec(name, version, url) + + +class PathogenVersion: + """""" + A pathogen setup with a specific *name* and *version*. + + The entity used by ``nextstrain setup``, ``nextstrain update``, and + ``nextstrain run``. + """""" + spec: PathogenSpec + + name: str + version: str + + path: Path + registration_path: Path + setup_receipt_path: Path + + setup_receipt: Optional[dict] = None + url: Optional[URL] = None + registration: Optional[dict] = None + + + def __init__(self, name_version_url: str, new_setup: bool = False): + """""" + *name_version_url* is a pathogen spec string suitable for + :meth:`PathogenSpec.parse`. + + If *new_setup* is ``False`` (the default), then the given pathogen spec + is required to refer to an existing pathogen setup, e.g. used by + ``nextstrain run``. + + If *new_setup* is ``True``, then the given pathogen spec is expected to + have :meth:`.setup` called on it, e.g. used by ``nextstrain setup``. + """""" + + name, version, url = self.spec = PathogenSpec.parse(name_version_url) + + if not name: + if new_setup: + raise UserError(f"""""" + No name specified in {name_version_url!r}. + + All pathogen setups must be given a name, e.g. as in NAME[@VERSION[=URL]]. + """""") + else: + raise UserError(f"""""" + No pathogen name specified in {name_version_url!r}. + """""") + + if disallowed := set([os.path.sep, os.path.altsep or os.path.sep]) & set(name): + raise UserError(f"""""" + Disallowed character(s) {"""".join(disallowed)!r} in name {name!r}. + """""") + + if name.lower() == ""cli"": + raise UserError(f"""""" + The name {name!r} is reserved for use by Nextstrain CLI itself + in `nextstrain update cli`. + """""") + + if url and not new_setup: + raise UserError(f"""""" + URL specified in {name_version_url!r}. + + Pathogen setup URLs may only be specified for `nextstrain setup`. + """""") + + if url and not version: + raise UserError(f"""""" + URL specified without version in {name_version_url!r}. + + A version must be specified when a setup URL is specified, + e.g. as in NAME@VERSION=URL. + """""") + + # Valid forms: + # + # @ + # @= + assert (name and not version and not url) \ + or (name and version and not url) \ + or (name and version and url) + + if not version: + if new_setup: + version = nextstrain_repo_latest_version(name) + else: + version = default_version_of(name, implicit = True) + + if not version: + if new_setup: + raise UserError(f"""""" + No version specified in {name_version_url!r}. + + There's no default version intuitable, so a version must be + specified, e.g. as in NAME@VERSION. + """""") + else: + # XXX TODO: This error case should maybe be handled outside of + # the constructor, with the constructor modified to raise a + # more generic FileNotFoundError instead. + # -trs, 3 Feb 2025 + if versions := versions_of(name): + raise UserError(f"""""" + No version specified in {name_version_url!r}. + + There's no default version set (or intuitable), so a version + must be specified, e.g. as in NAME@VERSION. + + Existing versions of {name!r} you have set up are: + + {{versions}} + + Hint: You can set a default version for {name!r} by running: + + nextstrain setup --set-default {shquote(name)}@VERSION + + if you don't want to specify an explicit version every time. + """""", versions = indent(""\n"".join(f""{name}@{v}"" for v in versions), "" "")) + else: + raise UserError(f"""""" + No pathogen setup exists for {name_version_url!r}. + + Did you set it up yet? + + Hint: to set it up, run `nextstrain setup {shquote(name_version_url)}`. + """""") + + self.name = name + self.version = version + + assert self.name + assert self.version + + self.path = PATHOGENS / self.name / PathogenVersion.encode_version_dir(self.version) + + self.registration_path = self.path / ""nextstrain-pathogen.yaml"" + self.setup_receipt_path = self.path.with_suffix(self.path.suffix + "".json"") + + try: + self.registration = read_pathogen_registration(self.registration_path) + except RegistrationError: + # Ignore malformed registrations during __init__() here to avoid a + # noisy constructor for PathogenVersion. We're more noisy about + # registration issues in setup(), which will be seen during the + # initial `nextstrain setup` or subsequent `nextstrain update`. + self.registration = None + + if not new_setup: + if not self.path.is_dir(): + # XXX TODO: This error case should maybe be handled outside of + # the constructor, with the constructor modified to raise a + # more generic FileNotFoundError instead. + # -trs, 3 Feb 2025 + if versions := versions_of(name): + raise UserError(f"""""" + No pathogen setup exists for {name_version_url!r}{f"" in {str(self.path)!r}"" if DEBUGGING else """"}. + + Existing versions of {name!r} you have set up are: + + {{versions}} + + Did you mean one of those? + """""", versions = indent(""\n"".join(f""{name}@{v}"" for v in versions), "" "")) + else: + raise UserError(f"""""" + No pathogen setup exists for {name_version_url!r}{f"" in {str(self.path)!r}"" if DEBUGGING else """"}. + + Did you set it up yet? + + Hint: to set it up, run `nextstrain setup {shquote(name_version_url)}`. + """""") + + try: + with self.setup_receipt_path.open(encoding = ""utf-8"") as f: + self.setup_receipt = json.load(f) + assert isinstance(self.setup_receipt, dict) + except FileNotFoundError: + pass + + if not url and self.setup_receipt: + if url := self.setup_receipt.get(""url""): + url = URL(url) + + if new_setup: + if not url: + url = nextstrain_repo_zip_url(name, version) + + if not url: + raise UserError(f"""""" + No setup URL specified in {name_version_url!r}. + + A default URL can not be determined, so a setup URL must be + specified explicitly, e.g. as in NAME@VERSION=URL. + """""") + + if url.scheme != ""https"" and not (is_loopback(url.hostname) and url.scheme == ""http""): + raise UserError(f"""""" + URL scheme is {url.scheme!r}, not {""https""!r}. + + Pathogen setup URLs must be https://. + """""") + + self.url = url + + + def registered_workflows(self) -> Dict[str, Dict]: + """""" + Parses :attr:`.registration` to return a dict of registered workflows, + where the keys are workflow names. + """""" + if self.registration is None: + debug(""pathogen does not have a registration"") + return {} + + workflows = self.registration.get(""workflows"") + if not isinstance(workflows, dict): + debug(f""pathogen registration.workflows is not a dict (got a {type(workflows).__name__})"") + return {} + + return workflows + + + def compatible_workflows(self, feature: str) -> Dict[str, Dict]: + """""" + Filters registered workflows to return a subset of workflows that are + compatible with the provided *feature*. + """""" + return { + name: info + for name, info in self.registered_workflows().items() + if isinstance(info, dict) and info.get(""compatibility"", {}).get(feature) + } + + + def workflow_registration(self, name: str) -> Optional[dict]: + """""" + Returns the registration dictionary for the workflow *name*. + + Returns ``None`` if the workflow is not registered, does not have + registration information, or the registered information is not a + dictionary. + """""" + if (info := self.registered_workflows().get(name)) and not isinstance(info, dict): + debug(f""pathogen registration.workflows[{name!r}] is not a dict (got a {type(info).__name__})"") + return None + + return info + + + def workflow_path(self, name: str) -> Path: + if (info := self.workflow_registration(name)) and (path := info.get(""path"")): + debug(f""pathogen registration specifies {path!r} for workflow {name!r}"") + + # Forbid anchored paths in registration info, as it's never correct + # practice. An anchored path is just an absolute path on POSIX + # systems but covers more ""absolute-like"" cases on Windows systems + # too. + if PurePath(path).anchor: + raise UserError(f"""""" + The {self.registration_path.name} file for {str(self)!r} + registers an anchored path for the workflow {name!r}: + + {path} + + Registered workflow paths must be relative to (and within) + the pathogen source itself. This is a mistake that the + pathogen author(s) must fix. + """""") + + # Ensure the relative path resolves _within_ the pathogen repo to + # avoid shenanigans. + resolved_pathogen_path = self.path.resolve() + resolved_workflow_path = (resolved_pathogen_path / path).resolve() + + # Path.is_relative_to() was added in Python 3.9, so implement it + # ourselves around .relative_to(). + try: + resolved_workflow_path.relative_to(resolved_pathogen_path) + except ValueError: + raise UserError(f"""""" + The {self.registration_path.name} file for {str(self)!r} + registers an out-of-bounds path for the workflow {name!r}: + + {path} + + which resolves to: + + {str(resolved_workflow_path)} + + which is outside of the pathogen's source. + + Registered workflow paths must be within the pathogen + source itself. This is a mistake that the pathogen + author(s) must fix. + """""") + + debug(f""resolved workflow {name!r} to {str(resolved_workflow_path)!r}"") + return resolved_workflow_path + + debug(f""pathogen registration does not specify path for workflow {name!r}; using name as path"") + return self.path / name + + + def setup(self, dry_run: bool = False, force: bool = False) -> SetupStatus: + """""" + Downloads and installs this pathogen version from :attr:`.url`. + """""" + assert self.url + + if not force and self.path.exists(): + print(f""Using existing setup in {str(self.path)!r}."") + print(f"" Hint: if you want to ignore this existing setup, re-run `nextstrain setup` with --force."") + return True + + if self.path.exists(): + assert force + print(f""Removing existing setup {str(self.path)!r} to start fresh…"") + if not dry_run: + rmtree(str(self.path)) + self.setup_receipt_path.unlink(missing_ok = True) + + try: + # Heads up: if you add explicit authn to this request—either an + # ""auth"" parameter or an ""Authorization"" header—consider if it + # breaks the assumption of netrc-based auth in the 401/403 error + # handling below and make changes as necessary. Thanks! + # -trs, 25 Sept 2025 + response = requests.get(str(self.url), headers = {""Accept"": ""application/zip, */*""}, stream = True) + response.raise_for_status() + + except requests.exceptions.ConnectionError as err: + raise UserError(f"""""" + Could not connect to {self.url.netloc!r} to download + pathogen for setup: + + {type(err).__name__}: {err} + + The URL may be invalid or you may be experiencing network + connectivity issues. + """""") from err + + except requests.exceptions.HTTPError as err: + if 400 <= err.response.status_code <= 499: + if (err.response.status_code in {401, 403} + and (auth := err.response.request.headers[""Authorization""]) + and auth.startswith(""Basic "")): + user = b64decode(auth.split("" "", 1)[1]).decode(""utf-8"").split("":"", 1)[0] + + # Logic here matches requests.utils.get_netrc_auth() + if ""NETRC"" in os.environ: + netrcs = [os.environ[""NETRC""]] + else: + netrcs = [""~/.netrc"", ""~/_netrc""] + + if netrc := next(filter(os.path.exists, map(os.path.expanduser, netrcs)), None): + # We could also check that the netrc file we just found + # contains the credentials we see in the request… but + # that feels slightly excessive. + # -trs, 25 Sept 2025 + hint = cleandoc(f"""""" + Authentication credentials for user + + {user} + + stored in the netrc file + + {netrc} + + were automatically used. Perhaps they're invalid? + + You may wish to retry without using stored credentials, + either by removing them from your netrc file or setting + the NETRC environment variable to an empty value. + """""") + else: + hint = cleandoc(f"""""" + Authentication credentials for user + + {user} + + potentially stored in one of the following netrc files + + {''' + '''.join(netrcs)} + + were automatically used. Perhaps they're invalid? + + You may wish to retry without using stored credentials, + either by removing them from one of the netrc files + or setting the NETRC environment variable to an + empty value. + """""") + else: + hint = cleandoc(f"""""" + The URL may be incorrect (e.g. misspelled) or no longer + accessible. + """""") + + raise UserError(f"""""" + Failed to download pathogen setup URL: + + {{urls}} + + The server responded with an error: + + {type(err).__name__}: {err} + + {{hint}} + """""", urls = request_list(err.response), hint = hint) from err + + elif 500 <= err.response.status_code <= 599: + raise UserError(f"""""" + Failed to download pathogen setup URL: + + {{urls}} + + The server responded with an error: + + {type(err).__name__}: {err} + + This may be a permanent error or a temporary failure, so it + may be worth waiting a little bit and trying again a few + more times. + """""", urls = request_list(err.response)) from err + + else: + raise err + + + content_type = response.headers[""Content-Type""] + + if content_type != ""application/zip"": + raise UserError(f"""""" + Unexpected Content-Type {content_type!r} when downloading + pathogen setup URL: + + {{urls}} + + Expected 'application/zip', i.e. a ZIP file (.zip). + """""", urls = request_list(response)) + + # Write remote ZIP file to a temporary local file so its seekable… + with TemporaryFile(""w+b"") as zipfh: + copyfileobj(response.raw, zipfh) + + # …and extract its contents. + with ZipFile(zipfh) as zipfile: + safe_members = [ + (filename, member) + for filename, member + in ((PurePath(m.filename), m) for m in zipfile.infolist()) + if not filename.is_absolute() + and os.path.pardir not in filename.parts ] + + try: + prefix = PurePath(os.path.commonpath([filename for filename, member in safe_members])) + except ValueError: + prefix = PurePath("""") + + debug(""common path prefix of archive members:"", repr(prefix)) + debug(""mkdir:"", self.path) + + if not dry_run: + self.path.mkdir(parents = True) + + for filename, member in safe_members: + if filename == prefix or filename in prefix.parents: + continue + + member.filename = str(filename.relative_to(prefix)) \ + + (os.path.sep if member.is_dir() else '') + + debug(""extracting:"", member.filename) + + if not dry_run: + debug(""extracted:"", extracted := zipfile.extract(member, self.path)) + + # Jeez. This is making me question if we should be + # using tarballs here instead. + # -trs, 10 Jan 2025 + if (member.create_system == 3 # Unix, to know what to expect in external_attr + and (zipmode := member.external_attr >> 16) # Discard rightmost two bytes, leaving first two bytes (the file mode) + and zipmode & S_IXUSR): + oldmode = stat(extracted).st_mode + newmode = ( + oldmode + | S_IXUSR # u+x + | (S_IXGRP if oldmode & S_IRGRP else 0) # g+x if g has r + | (S_IXOTH if oldmode & S_IROTH else 0)) # o+x if o has r + debug(f""chmod {oldmode:o} → {newmode:o}:"", extracted) + chmod(extracted, newmode) + + print(f""Extracted {len(safe_members):,} files and directories to {str(self.path)!r}."") + + self.setup_receipt = { + ""name"": self.name, + ""version"": self.version, + ""url"": str(self.url) } + + with self.setup_receipt_path.open(""w"", encoding = ""utf-8"") as f: + json.dump(self.setup_receipt, f, indent = "" "") + print(file = f) + + try: + self.registration = read_pathogen_registration(self.registration_path) + except RegistrationError as err: + self.registration = None + + warn(cleandoc(f"""""" + The {self.registration_path.name} file for {str(self)!r} is malformed: + + {''' + '''.join(str(err).splitlines())} + + It will not be used and this pathogen setup may not be fully-functional. + \ + """""")) + if DEBUGGING: + traceback.print_exc() + + return True + + + def test_setup(self) -> SetupTestResults: + def test_compatibility() -> SetupTestResult: + msg = ""nextstrain-pathogen.yaml declares `nextstrain run` compatibility"" + + if self.registration is None: + return msg + ""\n(couldn't read registration)"", False + + if not self.registered_workflows(): + return msg + ""\n(no workflows registered)"", False + + if not self.compatible_workflows(""nextstrain run""): + return msg + ""\n(no workflows registered as compatible)"", False + + return msg, True + + return [ + ('downloaded', + self.path.is_dir()), + + ('contains nextstrain-pathogen.yaml', + self.registration_path.is_file()), + + test_compatibility(), + + *((f'`nextstrain run` workflow {name!r} exists', self.workflow_path(name).is_dir()) + for name in self.compatible_workflows(""nextstrain run"")), + ] + + + def set_default_config(self) -> None: + """""" + Sets this version as the default for this pathogen. + """""" + config.set(f""pathogen {self.name}"", ""default_version"", self.version) + + + def update(self) -> UpdateStatus: + """""" + Updates a specific version in-place or updates the default version to + the newest version. + + An in-place update is attempted if this :cls:`PathogenVersion` was + instantiated with a version in the pathogen spec (i.e. not defaulted). + This is appropriate for a version that's mutable, like a branch name. + The process is roughly equivalent to `nextstrain setup --force NAME@VERSION`. + + Otherwise, a default version update is attempted by setting up the + newest version and then making it the default. This is appropriate for + a version that's immutable, like a tag name. The process is roughly + equivalent to `nextstrain setup --set-default NAME`. + """""" + if self.spec.version: + new = PathogenVersion(self.name + ""@"" + self.version, new_setup = True) + else: + new = PathogenVersion(self.name, new_setup = True) + + if new.version != self.version: + print(f""Updating from {str(self)!r} to {str(new)!r}…"") + ok = new.setup() + + elif new.url != self.url: + print(f""Updating {str(new)!r} in-place…"") + ok = new.setup(force = True) + + else: + assert new == self + + if self.spec.version: + print(f""{str(self)!r} already up-to-date."") + else: + print(f""{self.name!r} already at newest version."") + print() + + return True + + # None of the update() routines for runners test their setups, but it + # makes sense to do so for pathogens. Here's why: + # + # The Docker/Singularity/AWS Batch runtime checks focus on the + # machinery required to use the runtime image, but do not test the + # contents/correctness of the runtime image *itself*; they assume + # that's ok. The pathogen checks OTOH solely test the + # contents/correctness of the pathogen itself; so it makes sense to + # check it after any change/update unlike the Docker checks. The Conda + # runtime checks do both! (and so ostensibly should run after update + # too…) + # -trs, 2 April 2025 + # see also + if ok: + print(f""Checking setup…"") + ok = print_and_check_setup_tests(new.test_setup()) + + if ok and not self.spec.version: + print(f""Setting default version to {str(new)!r}."") + new.set_default_config() + + # XXX TODO SOON: Delete old version (self.path) at this point? The + # runtimes delete old versions after update to recover disk space. + # Pathogens use a lot less space, but I think it's still worth it + # to tidy up? OTOH, it seems more likely for pathogens that people + # will blindly update to see if there's anything new and then want + # to trial it/compare it against the old version (or immediately + # revert back if the new version breaks something). + # -trs, 3 Feb 2025 + + return ok + + + @staticmethod + def encode_version_dir(version: str) -> str: + """""" + >>> PathogenVersion.encode_version_dir(""1.2.3"") + '1.2.3=GEXDELRT' + + >>> PathogenVersion.encode_version_dir(""abc/lmnop/xyz"") + 'abc-lmnop-xyz=MFRGGL3MNVXG64BPPB4XU===' + """""" + # Prefixing a munged version is solely for the benefit of humans + # looking at their filesystem. + version_munged = re.sub(r'[^A-Za-z0-9_.-]', '-', version) + version_b32 = b32encode(version.encode(""utf-8"")).decode(""utf-8"") + assert ""="" not in version_munged + return version_munged + ""="" + version_b32 + + @staticmethod + def decode_version_dir(fname: str) -> str: + """""" + >>> PathogenVersion.decode_version_dir(PathogenVersion.encode_version_dir(""v42"")) + 'v42' + + >>> PathogenVersion.decode_version_dir(""1.2.3=GEXDELRT"") + '1.2.3' + + Munged version prefix for humans is ignored. + + >>> PathogenVersion.decode_version_dir(""x.y.z=GEXDELRT"") + '1.2.3' + >>> PathogenVersion.decode_version_dir(""=GEXDELRT"") + '1.2.3' + + Case-mangled names are still ok. + + >>> PathogenVersion.decode_version_dir(""1.2.3=gExDeLrT"") + '1.2.3' + """""" + _, version_b32 = fname.split(""="", 1) + return b32decode(version_b32, casefold = True).decode(""utf-8"") + + + def __str__(self) -> str: + return f""{self.name}@{self.version}"" + + def __repr__(self) -> str: + return f"""" + + def __eq__(self, other) -> bool: + if self.__class__ != other.__class__: + return False + + return self.name == other.name \ + and self.version == other.version \ + and (self.url == other.url or self.url is None or other.url is None) + + +class UnmanagedPathogen: + """""" + A local directory that's a pathogen repo, not managed by Nextstrain CLI. + + Used by ``nextstrain run``. Includes only the :cls:`PathogenVersion` API + surface that ``nextstrain run`` requires. + """""" + path: Path + registration_path: Path + + registration: Optional[dict] = None + + def __init__(self, path: str): + spec = PathogenSpec.parse(path) + + if not spec.name or (spec.name not in set([os.path.curdir, os.path.pardir]) and not (set(spec.name) & set([os.path.sep, os.path.altsep or os.path.sep]))): + raise ValueError(f""the {spec.name!r} part of {path!r} does not look like a path"") + + self.path = Path(path) + + if not self.path.is_dir(): + raise UserError(f"""""" + Path {str(self.path)!r} is not a directory (or does not exist). + """""") + + self.registration_path = self.path / ""nextstrain-pathogen.yaml"" + + try: + self.registration = read_pathogen_registration(self.registration_path) + except RegistrationError as err: + self.registration = None + + warn(cleandoc(f"""""" + The {self.registration_path.name} file for {str(self)!r} is malformed: + + {''' + '''.join(str(err).splitlines())} + + It will not be used and this pathogen's workflows may not be fully-functional. + \ + """""")) + if DEBUGGING: + traceback.print_exc() + + registered_workflows = PathogenVersion.registered_workflows + compatible_workflows = PathogenVersion.compatible_workflows + workflow_registration = PathogenVersion.workflow_registration + workflow_path = PathogenVersion.workflow_path + + def __str__(self) -> str: + return str(self.path) + + def __repr__(self) -> str: + return f"""" + + +def every_pathogen_default_by_name(pathogens: Dict[str, Dict[str, PathogenVersion]] = None) -> Dict[str, PathogenVersion]: + """""" + Scans file system to return a dict of :cls:`PathogenVersion` objects, + representing pathogen default version setups, keyed by their name. + + Sorted by name (case-insensitively). + + To avoid a filesystem scan for consistency (and performance in the limit) + when it's been scanned already, the result of a previous call to + :func:`all_pathogen_versions_by_name` may be passed. + """""" + if pathogens is None: + pathogens = all_pathogen_versions_by_name() + + # The `default_version in versions` check avoids a KeyError in the edge + # case of a configured default version that's not present on the + # filesystem. + return { + name: versions[default_version] + for name, versions in pathogens.items() + if (default_version := default_version_of(name, versions = list(versions.keys()))) + and default_version in versions } + + +def all_pathogen_versions_by_name() -> Dict[str, Dict[str, PathogenVersion]]: + """""" + Scans file system to return a two-level dict of :cls:`PathogenVersion` + objects, representing all pathogen version setups, keyed by their name then + version. + + Sorted by name (case-insensitively) and version (PEP-440-compliant versions + (newest → oldest) first then other textual versions (A → Z and 0 → 9, by + parts)). + + >>> from pprint import pp + >>> pp(all_pathogen_versions_by_name()) # doctest: +ELLIPSIS + {'with-implicit-default': {'1.2.3': }, + 'with-no-implicit-default': {'4.5.6': , + '1.2.3': }} + """""" + return { + name: { v.version: v for v in versions } + for name, versions + in groupby(all_pathogen_versions(), lambda p: p.name) } + + +def all_pathogen_versions() -> List[PathogenVersion]: + """""" + Scans file system to return a list of :cls:`PathogenVersion` objects + representing found setups. + + Sorted by name (case-insensitively) and version (PEP-440-compliant versions + (newest → oldest) first then other textual versions (A → Z and 0 → 9, by + parts)). + """""" + if not PATHOGENS.exists(): + return [] + + return [ + PathogenVersion(pathogen_dir.name + ""@"" + version) + for pathogen_dir in sorted(PATHOGENS.iterdir(), key = lambda p: p.name.casefold()) + if pathogen_dir.is_dir() + for version in versions_within(pathogen_dir) ] + + +def pathogen_defaults(name: str) -> Tuple[Optional[PathogenVersion], Optional[PathogenVersion]]: + """""" + Returns a tuple of :cls:`PathogenVersion` objects (or ``None``) + representing the explicitly configured default for pathogen *name* (if any) + and the implicit default (if any). + + Most code won't care about the distinction, but ``nextstrain setup`` does. + """""" + if configured_default := default_version_of(name, implicit = False): + # XXX TODO: Handle the edge case of a configured default version that + # no longer exists on the filesystem. For now, the code below will + # raise a UserError (see also FileNotFoundError comments in + # PathogenVersion.__init__). Precedence for warning and ignoring + # exists in nextstrain/cli/runner/__init__.py, FWIW. + # -trs, 3 Feb 2025 + # + # See also what every_pathogen_default_by_name() does. + # -trs, 28 Mar 2025 + configured_default = PathogenVersion(f""{name}@{configured_default}"") + else: + configured_default = None + + if configured_default: + default = configured_default + elif default := default_version_of(name, implicit = True): + default = PathogenVersion(f""{name}@{default}"") + else: + default = None + + return default, configured_default + + +def default_version_of(name: str, implicit: bool = True, versions: List[str] = None) -> Optional[str]: + """""" + Returns the default version string for the pathogen *name*. + + If the user config contains an explicit default, that value is returned. + + >>> default_version_of(""from-config"") + 'v1' + + Otherwise, if *implicit* is ``True`` (the default), then the filesystem is + scanned for available versions of *name* and if there's only one setup, its + version is returned. + + >>> default_version_of(""with-implicit-default"") + '1.2.3' + >>> default_version_of(""with-implicit-default"", implicit = False) + >>> + >>> default_version_of(""with-no-implicit-default"") + >>> + + To avoid a filesystem scan for consistency (and performance in the limit) + when it's been scanned already, a list of string *versions* may be passed. + This is only used when no default is configured and *implicit* is ``True``. + + >>> default_version_of(""with-cached-versions"", versions = [""one""]) + 'one' + + >>> default_version_of(""with-cached-versions"", versions = [""one"", ""two""]) + >>> + + >>> default_version_of(""from-config"", versions = [""one"", ""two""]) + 'v1' + + If no default version can be determined, ``None`` is returned. + + >>> default_version_of(""not-in-config"") + >>> + >>> default_version_of(""bogus"") + >>> + """""" + assert name + default = config.get(f""pathogen {name}"", ""default_version"") + + # The ""implicit default"" behaviour below makes the code (in + # pathogen_defaults() above and in nextstrain/cli/setup.py) considerably + # more complicated. It's tempting to ditch the behaviour to ditch the + # additional complexity. But I think the implicit default also makes the + # `nextstrain setup` and `nextstrain run` user interfaces more humane. If + # someone has only one version of a pathogen installed (as will be very + # common), why should they have to remember to specify --set-default at + # setup-time or the full version at run-time? It would be annoying for the + # computer to tell them, ""hey, what version of 'measles' did you mean?"" + # when they only have one version of 'measles' installed! + # + # I dithered on this for a while, but I think it's worth taking on the + # behind-the-scenes complexity in order to make the user interface more + # compatible with human common sense. + # -trs, 10 Jan 2025 + # + # See also our long discussion of this (mostly captured) on a PR review + # thread: + # -trs, 7 April 2025 + if not default and implicit: + if versions is None: + versions = versions_of(name) + + if len(versions) == 1: + default = versions[0] + + return default or None + + +def versions_of(name: str) -> List[str]: + """""" + Scans the filesystem for setup versions of pathogen *name* and returns a + list of version strings. + + Sorted as PEP-440-compliant versions (newest → oldest) then other textual + versions (A → Z and 0 → 9, by parts). + + >>> versions_of(""with-implicit-default"") + ['1.2.3'] + + >>> versions_of(""with-no-implicit-default"") + ['4.5.6', '1.2.3'] + + >>> versions_of(""bogus"") + [] + """""" + return versions_within(PATHOGENS / name) + + +def versions_within(pathogen_dir: Path) -> List[str]: + """""" + Scans the filesystem for setup versions within *pathogen_dir* and returns a + list of version strings. + + Sorted as PEP-440-compliant versions (newest → oldest) then other textual + versions (A → Z and 0 → 9, by parts). + """""" + if not pathogen_dir.exists(): + return [] + + return sorted_versions( + PathogenVersion.decode_version_dir(d.name) + for d in pathogen_dir.iterdir() + if d.is_dir() ) + + +def sorted_versions(vs: Iterable[str]) -> List[str]: + """""" + Sort newest → oldest for normal versions (e.g. 4.5.6, 1.2.3) and A → Z + for non-compliant versions (e.g. branch names, commit ids, arbitrary + strings, etc.), with the latter always after the former. + + The versions given should be strings. The returned list of versions will + be the same strings in sorted order. Versions are parsed by + :func:`parse_lax_version`. + """""" + versions = [*map(parse_version_lax, vs)] + + compliant = sorted(v for v in versions if v.compliant) + non_compliant = sorted(v for v in versions if not v.compliant) + + return [v.original for v in [*reversed(compliant), *non_compliant]] + + +def read_pathogen_registration(path: Path) -> Optional[Dict]: + """""" + Reads a ``nextstrain-pathogen.yaml`` file at *path* and returns a dict of + its deserialized contents. + + Returns ``None`` if the path does not exist. + + Raises :exc:`RegistrationError` if there are issues with the registration. + """""" + # Read file + try: + with path.open(""r"", encoding = ""utf-8"") as f: + registration = yaml.safe_load(f) + + except FileNotFoundError as err: + debug(f""failed to read pathogen registration at {str(path)!r}:"", err) + return None + + # File exists and we read it. + # + # If it's an empty file (or contains only comments) as is common when the + # file is used solely as a marker, then we'll get None. Treat that as an + # empty dict instead. + if registration is None: + registration = {} + + if not isinstance(registration, dict): + raise RegistrationError(f""top-level not a dict (got a {type(registration).__name__})"") + + # Locate schema for file, if any + if not (schema_id := registration.get(""$schema"")): + debug(f""skipping validation of pathogen registration {str(path)!r}: no $schema declared"") + return registration + + # Known schemas we can validate against + schemas = { + ""https://nextstrain.org/schemas/pathogen/v0"": ""schema-pathogen-v0.json"" } + + # Skip validation if schema is unknown + if not (schema_path := schemas.get(schema_id)): + debug(f""skipping validation of pathogen registration {str(path)!r}: unknown $schema: {schema_id!r}"") + return registration + + # Validate + debug(f""validating pathogen registration against {schema_id!r} ({schema_path!r})"") + + with resources.open_text(schema_path) as f: + schema = json.load(f) + + assert schema.get(""$id"") == schema_id + + try: + jsonschema.validate(registration, schema) + except jsonschema.ValidationError as err: + raise RegistrationError(f""Schema validation failed: {err.message}"") from err + + return registration + + +class RegistrationError(InternalError): + pass + + +# We query a nextstrain.org API instead of querying GitHub's API directly for a +# few reasons. +# +# 1. It gives us greater flexibility to move away from Git/GitHub-based +# versioning and distribution in the future. +# 2. It gives us insight into usage. +# 3. It starts us down the road of a real Nextstrain pathogen registry. +# +# -trs, 22 April 2025 +def nextstrain_repo_latest_version(name: str) -> Optional[str]: + """""" + Queries a Nextstrain pathogen repo *name* to return the latest version, + i.e. the name of the highest version tag, if any, otherwise the name of the + default branch. + """""" + versions_url = URL(f""/pathogen-repos/{urlquote(name)}/versions"", NEXTSTRAIN_DOT_ORG) + + with requests.Session() as http: + response = http.get(str(versions_url), headers = {""Accept"": ""application/json""}) + + if response.status_code == 404: + return None + else: + response.raise_for_status() + + versions = sorted_versions(response.json().get(""versions"", [])) + + return versions[0] if versions else None + + +def nextstrain_repo_zip_url(name: str, version: str) -> URL: + """""" + Queries a Nextstrain pathogen repo *name* to resolve *version* (i.e. + currently any commit-ish) to a specific revision (i.e. commit id, SHA) if + possible and returns a URL to a ZIP file of the repo contents at that + revision. + """""" + # Quoting `version` _without_ the default `safe='/'` so that it gets + # properly formatted as a single route parameter. Required for supporting + # versions that are branch names with slashes. Note, I did not do the same + # for `name` since GitHub repo names cannot contain slashes. + # -Jover, 18 July 2025 + version_url = URL(f""/pathogen-repos/{urlquote(name)}/versions/{urlquote(version, safe='')}"", NEXTSTRAIN_DOT_ORG) + + with requests.Session() as http: + resolved_version = http.get(str(version_url), headers = {""Accept"": ""application/json""}) + resolved_version.raise_for_status() + + if revision := resolved_version.json().get(""revision""): + return URL(urlquote(revision), version_url) + else: + return version_url +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/util.py",".py","30617","903","import os +import platform +import re +import site +import subprocess +import sys +from functools import partial +from importlib.metadata import distribution as distribution_info, PackageNotFoundError +from typing import Any, Callable, Iterable, Literal, Mapping, NamedTuple, List, Optional, Sequence, Tuple, TypeVar, Union, overload +from packaging.version import Version, InvalidVersion, parse as parse_version_strict +from pathlib import Path, PurePath +from shlex import quote as shquote +from shutil import which +from textwrap import dedent, indent +from wcmatch.glob import globmatch, GLOBSTAR, EXTGLOB, BRACE, MATCHBASE, NEGATE, NEGATEALL, REALPATH +from . import requests +from .__version__ import __version__ +from .debug import debug +from .types import RunnerModule, SetupTestResults, SetupTestResultStatus, UpdateStatus +from .url import NEXTSTRAIN_DOT_ORG, URL + + +NO_COLOR = bool( + # + os.environ.get(""NO_COLOR"") + + or + + # XXX TODO: This assumes our return value is being printed to stdout. + # That's true for all callers currently but may not always be. Rather than + # fix it properly, move away from our colored() function to the rich + # library instead. + # -trs, 4 March 2025 + not sys.stdout.isatty()) + + +def warn(*args): + print(*args, file = sys.stderr) + + +def colored(color, text): + """""" + Returns a string of text suitable for colored output on a terminal. + """""" + if NO_COLOR: + return text + + # These magic numbers are standard ANSI terminal escape codes for + # formatting text. + colors = { + ""red"": ""\033[0;31m"", + ""green"": ""\033[0;32m"", + ""blue"": ""\033[0;1;34m"", + ""yellow"": ""\033[0;33m"", + ""gray"": ""\033[0;90m"", + ""bold"": ""\033[1m"", + ""reset"": ""\033[0m"", + } + + return ""{start}{text}{end}"".format( + start = colors.get(color, """"), + end = colors[""reset""], + text = text, + ) + + +def remove_prefix(prefix, string): + return re.sub('^' + re.escape(prefix), '', string) + +def remove_suffix(suffix, string): + return re.sub(re.escape(suffix) + '$', '', string) + + +class NewVersionCheckResult(NamedTuple): + newer_version: Optional[str] + status_message: Optional[str] + update_instructions: Optional[str] + update_command: Optional[str] + + def __bool__(self): + return self.newer_version is not None + + def update(self) -> UpdateStatus: + print(self.status_message) + + if not self.newer_version: + return True + + if not self.update_command: + if self.update_instructions: + print(self.update_instructions) + return None + + # Pick the shell to use ourselves since subprocess.run()'s ""shell"" + # kwarg doesn't let us. + system = platform.system() + + if system in {""Linux"", ""Darwin""}: + shell = ""bash"" + elif system == ""Windows"": + shell = ""pwsh"" + else: + raise RuntimeError(f""unknown system {system!r}"") + + print(f""Running `{self.update_command}` via {shell}"") + + # Instead of checking the result and returning False ourselves, use + # check = True to raise an exception on error that will percolate + # upwards and be handled nicely in nextstrain/cli/command/update.py. + subprocess.run([shell, ""-c"", self.update_command], check = True) + + return True + + +def check_for_new_version() -> NewVersionCheckResult: + newer_version = new_version_available() + status_message = None + update_instructions = None + update_command = None + + installed_into_user_site = \ + site.ENABLE_USER_SITE \ + and site.USER_SITE is not None \ + and (__file__ or """").startswith(site.USER_SITE) + + # Find our Python executable/command. + if sys.executable: + exe_name = Path(sys.executable).name + + if which(exe_name) == sys.executable: + python = exe_name + else: + python = sys.executable + else: + # We don't know our own executable, which is a bit unusual, so first + # see if either python3 or python is available on PATH and use the + # first one that is. If neither is on PATH, use python3 and hope the + # user can figure it out. + python = next(filter(which, [""python3"", ""python""]), ""python3"") + + # Find our installer (e.g. pip, conda). + installer = distribution_installer() + + # Find our Conda details, if applicable. + if installer == ""conda"": + # Prefer mamba over conda, if available on PATH. + # + # If we can't find either mamba or conda on the current PATH but we're + # positively installed via a Conda package, then we have to assume that + # a) one of them is available _somehow_ and b) that the user knows (or + # will figure out) how to run one of them. We could default to either + # conda or mamba, but since our official install instructions use mamba + # and conda sometimes has dep-solving memory issues, I figured that + # mamba was the best thing to use in this edge case. + # + # There's several reasons why neither command may be available on PATH + # when we go looking with `which`, e.g. the commands could be off PATH + # but available via shell alias or shell function wrappers or they + # could be behind a modules system like Environment Modules and need + # enabling with e.g. `module load …`. + # -trs, 28 July 2022 + conda = next(filter(which, [""mamba"", ""conda""]), ""mamba"") + + # Search upwards for first parent directory which contains a + # ""conda-meta"" dir. This is the env prefix. + parent_dirs = Path(__file__).resolve(strict = True).parents + conda_prefix = next((str(d) for d in parent_dirs if (d / ""conda-meta"").is_dir()), None) + else: + conda, conda_prefix = None, None + + # Put it all together into an update command! + if newer_version: + pkgreq = shquote(f""nextstrain-cli=={newer_version}"") + + status_message = dedent(f""""""\ + A new version of Nextstrain CLI, {newer_version}, is available! You're running {__version__}. + + See what's new in the changelog: + + https://docs.nextstrain.org/projects/cli/en/{newer_version}/changes/ + """""") + + if standalone_installation(): + update_command = standalone_installer(newer_version) + + update_instructions = dedent(f""""""\ + Update your standalone installation of Nextstrain CLI automatically by running: + + nextstrain update cli + + or manually by running: + + {update_command} + + or by downloading a new archive from: + + {standalone_installation_archive_url(newer_version)} + """""") + + elif installer == ""pip"": + if installed_into_user_site: + update_command = f""{python} -m pip install --user {pkgreq}"" + else: + update_command = f""{python} -m pip install {pkgreq}"" + + update_instructions = dedent(f""""""\ + Update your Pip-based installation of Nextstrain CLI automatically by running: + + nextstrain update cli + + or manually by running: + + {update_command} + """""") + + elif installer == ""pipx"": + update_command = f""pipx install -f {pkgreq}"" + + update_instructions = dedent(f""""""\ + Update your pipx-based installation of Nextstrain CLI automatically by running: + + nextstrain update cli + + or manually by running: + + {update_command} + """""") + + elif installer == ""conda"": + if conda_prefix: + update_command = f""{conda} install -p {shquote(conda_prefix)} {pkgreq}"" + else: + update_command = f""{conda} install {pkgreq} # add -n NAME or -p PATH if necessary"" + + update_instructions = dedent(f""""""\ + Update your Conda-based installation of Nextstrain CLI automatically by running: + + nextstrain update cli + + or manually by running: + + {update_command} + """""") + + else: + update_instructions = dedent(f""""""\ + Automated updating of Nextstrain CLI is unsupported due to unknown installation + method ({installer!r}). + """""") + + else: + status_message = ""Nextstrain CLI is up to date!\n"" + + return NewVersionCheckResult(newer_version, status_message, update_instructions, update_command) + + +def distribution_installer() -> Optional[str]: + """""" + Report the program which installed us (i.e. our distribution), if known. + + Common examples are ``pip``, ``pipx``, ``conda``, ``uv``, and + ``standalone``. + """""" + if standalone_installation(): + return ""standalone"" + + try: + distribution = distribution_info(""nextstrain-cli"") + except PackageNotFoundError: + installer = None + else: + installer = (distribution.read_text(""INSTALLER"") or '').strip() or None + + # Determine if we're pipx or not. + if installer == ""pip"" and ""/pipx/venvs/nextstrain-cli/"" in (sys.executable or """"): + installer = ""pipx"" + + return installer + + +def standalone_installation(): + """""" + Return True if this is a standalone installation, i.e. a self-contained + executable built with PyOxidizer. + + Relies on a compiled-in -X flag set at build time by our PyOxidizer config. + """""" + # sys._xoptions is documented for use but specific to CPython. Our + # standalone executables are built upon CPython, so this works in that + # context, but this code may also run on other interpreters (e.g. PyPy) in + # other contexts. + # + # I think using an explicit, compiled-in flag is best, but we could + # alternatively choose to inspect something like: + # + # nextstrain.cli.__loader__.__module__ == ""oxidized_importer"" + # + # if necessary in the future. + # -trs, 7 July 2022 + return ""nextstrain-cli-is-standalone"" in getattr(sys, ""_xoptions"", {}) + + +def standalone_installation_path() -> Optional[Path]: + """""" + Return the path of this standalone installation, if applicable. + """""" + if not standalone_installation(): + return None + + if not sys.executable: + return None + + return Path(sys.executable).resolve(strict = True).parent + + +def standalone_installer(version: str) -> str: + system = platform.system() + destination = str(standalone_installation_path() or """") + + if system == ""Linux"": + return f""curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/linux | DESTINATION={shquote(destination)} bash -s {shquote(version)}"" + + elif system == ""Darwin"": + return f""curl -fsSL --proto '=https' https://nextstrain.org/cli/installer/mac | DESTINATION={shquote(destination)} bash -s {shquote(version)}"" + + elif system == ""Windows"": + return '$env:DESTINATION=%s; Invoke-Expression ""& { $(Invoke-RestMethod https://nextstrain.org/cli/installer/windows) } %s""' % (shquote(destination), shquote(version)) + + else: + raise RuntimeError(f""unknown system {system!r}"") + + +def standalone_installation_archive_url(version: str) -> str: + machine = platform.machine() + system = platform.system() + + if system == ""Linux"": + vendor, os, archive_format = ""unknown"", ""linux-gnu"", ""tar.gz"" + elif system == ""Darwin"": + vendor, os, archive_format = ""apple"", ""darwin"", ""tar.gz"" + elif system == ""Windows"": + vendor, os, archive_format = ""pc"", ""windows-msvc"", ""zip"" + else: + raise RuntimeError(f""unknown system {system!r}"") + + target_triple = f""{machine}-{vendor}-{os}"" + + return f""https://nextstrain.org/cli/download/{version}/standalone-{target_triple}.{archive_format}"" + + +def new_version_available(): + """""" + Return the latest version of nextstrain-cli on PyPI if it's newer than the + currently running version. Otherwise return None. + + .. envvar:: NEXTSTRAIN_CLI_LATEST_VERSION + + If set, the value will be used as the latest released version of + nextstrain-cli and the query to PyPI will be skipped. Primarily + intended for development and testing but can also be used to disable + the update check by setting the value to 0. + """""" + this_version = parse_version_strict(__version__) + latest_version = parse_version_strict(os.environ.get(""NEXTSTRAIN_CLI_LATEST_VERSION"") or fetch_latest_version()) + + return str(latest_version) if latest_version > this_version else None + + +def fetch_latest_version(): + """""" + Return the latest version of ourselves from nextstrain.org. + """""" + return requests.get(str(URL(""/cli"", NEXTSTRAIN_DOT_ORG)), headers = {""Accept"": ""application/json""}).json().get(""latest_version"", """") + + +def capture_output(argv, extra_env: Mapping = {}): + """""" + Run the command specified by the argument list and return a list of output + lines. + + If an *extra_env* mapping is passed, the provided keys and values are + overlayed onto the current environment. Keys with a value of ``None`` are + removed from the current environment (i.e. like ``del os.environ[key]``). + """""" + debug(f""capture_output({argv!r}, {extra_env!r})"") + + env = os.environ.copy() + + if extra_env: + for k, v in extra_env.items(): + if v is None: + env.pop(k, None) + else: + env[k] = v + + result = subprocess.run( + argv, + env = env, + stdout = subprocess.PIPE, + check = True) + + return result.stdout.decode(""utf-8"").splitlines() + + +def exec_or_return(argv: List[str], extra_env: Mapping = {}) -> int: + """""" + exec(3) into the desired program, or return 1 on failure. Never returns if + successful. + + The return value makes this suitable for chaining through to sys.exit(). + + On Windows (or other non-POSIX OSs), where os.execvp() is not properly + supported¹, this forks another process, waits for it to finish, and then + exits with the same return code. A proper POSIX exec(3) is still more + desirable when available as it properly handles file descriptors and + signals. + + If an *extra_env* mapping is passed, the provided keys and values are + overlayed onto the current environment. Keys with a value of ``None`` are + removed from the current environment (i.e. like ``del os.environ[key]``). + + ¹ https://bugs.python.org/issue9148 + """""" + debug(f""exec_or_return({argv!r}, {extra_env!r})"") + + env = os.environ.copy() + + if extra_env: + for k, v in extra_env.items(): + if v is None: + env.pop(k, None) + else: + env[k] = v + + # Use a POSIX exec(3) for file descriptor and signal handling… + if os.name == ""posix"": + try: + os.execvpe(argv[0], argv, env) + except OSError as error: + warn(""Error executing into %s: %s"" % (argv, error)) + return 1 + + # …or naively emulate one when not available. + else: + try: + process = subprocess.run(argv, env = env) + except OSError as error: + warn(""Error running %s: %s"" % (argv, error)) + return 1 + else: + sys.exit(process.returncode) + + +def runner_name(runner: RunnerModule) -> str: + """""" + Return a friendly name suitable for display for the given runner module. + """""" + return module_basename(runner).replace(""_"", ""-"") + + +def runner_module(name: str) -> RunnerModule: + """""" + Converts a string *name* into a :py:cls:`RunnerModule`. + + *name* is case-insensitive and underscores, hyphens, or spaces may be used + to separate words. Internally, they're normalized to hyphens and the whole + string is lowercased. + + ``native`` is accepted as an alias for ``ambient``. + + Raises a :py:exc:`ValueError` if *name* is unknown. + + >>> runner_module(""docker"") # doctest: +ELLIPSIS + + + >>> runner_module(""AWS-Batch"") # doctest: +ELLIPSIS + + + >>> runner_module(""AWS Batch"") # doctest: +ELLIPSIS + + + >>> runner_module(""native"") # doctest: +ELLIPSIS + + + >>> runner_module(""invalid"") + Traceback (most recent call last): + ... + ValueError: invalid runtime name: 'invalid'; valid names are: 'docker', 'conda', 'singularity', 'ambient', 'aws-batch' + + >>> runner_module(""Invalid Name"") + Traceback (most recent call last): + ... + ValueError: invalid runtime name: 'Invalid Name' (normalized to 'invalid-name'); valid names are: 'docker', 'conda', 'singularity', 'ambient', 'aws-batch' + """""" + # Import here to avoid circular import + from .runner import all_runners_by_name + + normalized_name = re.sub(r'(_|\s+)', '-', name).lower() + + # Accept ""native"" as an alias for ""ambient"" for backwards compatibility + if normalized_name == ""native"": + normalized_name = ""ambient"" + + try: + return all_runners_by_name[normalized_name] + except KeyError as err: + valid_names = "", "".join(map(repr, all_runners_by_name)) + + if name != normalized_name: + raise ValueError(f""invalid runtime name: {name!r} (normalized to {normalized_name!r}); valid names are: {valid_names}"") from err + else: + raise ValueError(f""invalid runtime name: {name!r}; valid names are: {valid_names}"") from err + + +def runner_help(runner: RunnerModule) -> str: + """""" + Return a brief description of a runner module, suitable for help strings. + """""" + if runner.__doc__: + return runner.__doc__.strip().splitlines()[0] + else: + return ""(undocumented)"" + + +def module_basename(module: Any) -> str: + """""" + Return the final portion of the given module's name, akin to a file's basename. + """""" + return module.__name__.split(""."")[-1] + + +def format_usage(doc: str) -> str: + """""" + Reformat a multi-line description of command-line usage to play nice with + argparse's usage printing. + + Strips trailing and leading newlines, removes indentation shared by all + lines (common in docstrings), and then pads all but the first line to match + the ""usage: "" prefix argparse prints for the first line. + """""" + padding = "" "" * len(""usage: "") + return indent(dedent(doc.strip(""\n"")), padding).lstrip() + + +def byte_quantity(quantity: str) -> int: + """""" + Parses a string *quantity* consisting of a number, optional whitespace, and + a unit of bytes. + + Returns the number of bytes in *quantity*, as an integer. + + Supported units: + + * ``b`` (bytes) + * ``kb`` (kilobytes) + * ``mb`` (megabytes) + * ``gb`` (gigabytes) + * ``kib`` (kibibytes) + * ``mib`` (mebibytes) + * ``gib`` (gibibytes) + + Units are not case sensitive. If no unit is given, bytes is assumed. + + Raises a :py:class:`ValueError` if *quantity* is not parseable. + + >>> byte_quantity(""2Kb"") + 2000 + >>> byte_quantity(""2 kib"") + 2048 + >>> byte_quantity(""1.5GB"") + 1500000000 + >>> byte_quantity(""1024"") + 1024 + >>> byte_quantity(""hello mb"") + Traceback (most recent call last): + ... + ValueError: Unparseable byte quantity value: 'hello' + """""" + match = re.search(r"""""" + ^ + # The numeric value. We rely on float() to parse this, so don't + # restrict it here. + (\S+?) + + \s* + + # The optional unit. + ( [kmg]b + | [kmg]ib + | b + )? + $ + """""", quantity.strip(), re.VERBOSE | re.IGNORECASE) + + if not match: + raise ValueError(""Unrecognized byte quantity: %s"" % repr(quantity)) + + value_str, units = match.groups() + + try: + value = float(value_str) + except ValueError: + raise ValueError(""Unparseable byte quantity value: %s"" % repr(value_str)) from None + + if not units: + units = ""b"" + + unit_factor = { + 'b': 1, + 'kb': 1000, + 'mb': 1000**2, + 'gb': 1000**3, + 'kib': 1024, + 'mib': 1024**2, + 'gib': 1024**3, + } + + return int(value * unit_factor[units.lower()]) + + +@overload +def split_image_name(name: str, implicit_latest: Literal[True] = True) -> Tuple[str, str]: + ... + +@overload +def split_image_name(name: str, implicit_latest: Literal[False]) -> Tuple[str, Optional[str]]: + ... + +def split_image_name(name: str, implicit_latest: bool = True) -> Tuple[str, Optional[str]]: + """""" + Split the Docker image *name* into a (repository, tag) tuple. + + >>> split_image_name(""nextstrain/base:build-20200424T101900Z"") + ('nextstrain/base', 'build-20200424T101900Z') + + >>> split_image_name(""nextstrain/base"") + ('nextstrain/base', 'latest') + + >>> split_image_name(""nextstrain/base"", implicit_latest = False) + ('nextstrain/base', None) + + >>> split_image_name(""nextstrain/base:latest"", implicit_latest = False) + ('nextstrain/base', 'latest') + """""" + if "":"" in name: + repository, tag = name.split("":"", maxsplit = 2) + else: + repository, tag = name, ""latest"" if implicit_latest else None + + return (repository, tag) + + +def glob_matcher(patterns: Sequence[str], *, root: Path = None) -> Callable[[Union[str, Path, PurePath]], bool]: + """""" + Generate a function which matches a string or path-like object against the + list of Bash-like glob *patterns*. + + If a *root* path is provided, paths will be matched against *patterns* as + real filesystem paths relative to the given *root* directory. + + See :func:`glob_match` for supported pattern features. + """""" + def matcher(path: Union[str, Path, PurePath]) -> bool: + return glob_match(path, patterns, root = root) + + return matcher + + +def glob_match(path: Union[str, Path, PurePath], patterns: Union[str, Sequence[str]], *, root: Path = None) -> bool: + """""" + Test if *path* matches any of the glob *patterns*. + + Besides basic glob features like single-part wildcards (``*``), character + classes (``[…]``), and brace expansion (``{…, …}``), several advanced + globbing features are also supported: multi-part wildcards (``**``), + extended globbing (``@(…)``, ``+(…)``, etc.), basename matching for + patterns containing only a single path part, and negation (``!…``). + Passing only negated patterns is explicitly supported and will match + anything that doesn't match the given patterns. + + If a *root* path is provided, *path* will be matched against *patterns* as + real filesystem paths relative to the given *root* directory. + + Implemented with with :func:`wcmatch.glob.globmatch`. + """""" + if root: + path = Path(path).resolve(strict = True).relative_to(root) + return globmatch(path, patterns, flags = GLOBSTAR | BRACE | EXTGLOB | MATCHBASE | NEGATE | NEGATEALL | (REALPATH if root else 0), root_dir = root) + + +def setup_tests_ok(tests: SetupTestResults) -> bool: + """""" + Returns True iff none of a runner's or pathogen's ``test_setup()`` results failed. + """""" + return False not in [result for test, result in tests] + + +def print_and_check_setup_tests(tests: SetupTestResults) -> bool: + """""" + Iterates through and prints a runner's or pathogen's setup test results. + Returns True if there are no failures. + """""" + success = partial(colored, ""green"") + failure = partial(colored, ""red"") + warning = partial(colored, ""yellow"") + unknown = partial(colored, ""gray"") + + # XXX TODO: Now that there are special values other than True/False, these + # should probably become an enum or custom algebraic type or something + # similar. That will cause a cascade into the test_setup() producers + # though, which I'm going to punt on for now. + # -trs, 4 Oct 2018 + status = { + True: success(""✔ yes""), + False: failure(""✘ no""), + None: warning(""⚑ warning""), + ...: unknown(""? unknown""), + } + + results = [] + + for description, result in tests: + # Indent subsequent lines of any multi-line descriptions so it + # lines up under the status marker. + formatted_description = \ + remove_prefix("" "", indent(description, "" "")) + + results.append((description, result)) + + print(status.get(result, str(result)) + "":"", formatted_description) + + return setup_tests_ok(results) + + +def test_rosetta_enabled(msg: str = ""Rosetta 2 is enabled"") -> SetupTestResults: + """""" + Check if Rosetta 2 is enabled (installed and active) on macOS aarch64 + systems. + """""" + if (platform.system(), platform.machine()) != (""Darwin"", ""arm64""): + return + + status: SetupTestResultStatus = ... # unknown + + try: + subprocess.run( + [""pgrep"", ""-qU"", ""_oahd""], + stdin = subprocess.DEVNULL, + stdout = subprocess.DEVNULL, + stderr = subprocess.DEVNULL, + check = True) + + except OSError: + status = ... # unknown; something's maybe wrong with our check + + except subprocess.CalledProcessError as err: + if err.returncode > 0: + status = False + msg += dedent("""""" + + To enable Rosetta, please run: + + softwareupdate --install-rosetta + + and then try your setup or check-setup command again.\ + """""") + else: + status = None # warning; something's weird about the system + msg += "" (unable to check!)"" + else: + status = True + + yield (msg, status) + + +# Copied without modification from lib/id3c/api/utils/__init__.py in the ID3C +# project¹, which is licensed under the MIT license. See the LICENSE.id3c file +# distributed alongside this project's own LICENSE file. +# +# ¹ +def prose_list(iterable: Iterable[str], conjunction: str = ""or"") -> str: + """""" + Construct a nice natural language list of items from the *iterable*. The + default *conjunction* is ""or"". + """""" + values = list(iterable) + + if len(values) > 2: + return "", "".join([*values[:-1], f""{conjunction} "" + values[-1]]) + else: + return f"" {conjunction} "".join(values) + + +def request_list(response: requests.Response, initial_indent = "" "", redirect_indent = "" ⮡ "") -> str: + """""" + Formats the requested URLs (including redirects) that led to *response* as + a multi-line text-snippet. + + Intended for use in user-facing messages. + """""" + return ""\n"".join( + initial_indent + (redirect_indent * i) + r.url + for i, r in enumerate([*response.history, response]) ) + + +def parse_version_lax(version: str) -> 'LaxVersion': + """""" + Parse *version* into a PEP-440-compliant :cls:`Version` object, by hook or + by crook. Dubbed ""lax"" because a non-compliant *version* will not raise an + exception (in contrast to :func:`parse_version_strict`) but will produce a + :cls:`Version` object with reasonably useful comparison behaviour. + + If *version* isn't already PEP-440 compliant, then it is parsed as a + PEP-440 local version label after replacing with ``.`` any characters not + matching ``a-z``, ``A-Z``, ``0-9``, ``.``, ``_``, or ``-``. The comparison + semantics for local version labels amount to a string- and integer-based + comparison by parts (""segments""), which is super good enough for our + purposes here. The full local version identifier produced for versions + parsed in this way always contains a public version identifier component of + ``0.dev0`` so it compares lowest against other public version identifiers. + + >>> parse_version_lax(""1.2.3"") + + >>> parse_version_lax(""1.2.3-nope"") + + >>> parse_version_lax(""20221019T172207Z"") + + >>> parse_version_lax(""@invalid+@"") + + >>> parse_version_lax(""not@@ok"") + + >>> parse_version_lax(""20221019T172207Z"") < parse_version_lax(""20230525T143814Z"") + True + """""" + try: + return LaxVersion(version, compliant = True) + except InvalidVersion: + # Per PEP-440 + # + # > …local version labels MUST be limited to the following set of + # > permitted characters: + # > + # > ASCII letters ([a-zA-Z]) + # > ASCII digits ([0-9]) + # > periods (.) + # > + # > Local version labels MUST start and end with an ASCII letter or + # > digit. + # + # and + # + # > With a local version, in addition to the use of . as a separator of + # > segments, the use of - and _ is also acceptable. The normal form is + # > using the . character. + # + # and empty segments (x..z) aren't allowed either. + # + # c.f. + # + remove_invalid_start_end_chars = partial(re.sub, r'^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$', '') + replace_invalid_with_separators = partial(re.sub, r'[^a-zA-Z0-9._-]+', '.') + + as_local_segment = lambda v: replace_invalid_with_separators(remove_invalid_start_end_chars(v)) + + return LaxVersion(f""0.dev0+{as_local_segment(version)}"", compliant = False, original = version) + + +class LaxVersion(Version): + """""" + A :cls:`Version` object produced by :func:`parse_version_lax`, with some + additional attributes to preserve parse-time information. + """""" + + compliant: bool + """""" + Whether :func:`parse_version_lax` found the version string + PEP-440-compliant or not (i.e. whether it had to munge it or not). + """""" + + original: str + """""" + The original version string that was parsed by :func:`parse_version_lax`. + + Useful even for :attr:`.compliant` versions, as stringification will return + a normalized representation that may not string compare identically. + """""" + + def __init__(self, version: str, *, compliant: bool, original: str = None): + super().__init__(version) + self.compliant = compliant + self.original = original if original is not None else version + + +T = TypeVar(""T"") + +def uniq(xs: Iterable[T]) -> Iterable[T]: + """""" + Filter an iterable *xs* to its unique elements, preserving order. + + Elements must be hashable. + """""" + return dict.fromkeys(xs).keys() +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/__version__.py",".py","27","2","__version__ = '10.4.2+git' +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/config.py",".py","3797","153",""""""" +Configuration file handling. +"""""" + +import stat +from configparser import ConfigParser +from contextlib import contextmanager +from fasteners import InterProcessReaderWriterLock +from pathlib import Path +from typing import Optional +from .paths import CONFIG, SECRETS, LOCK + + +# Permissions to use for the secrets file if we have to create it. +SECRETS_PERMS = \ + ( stat.S_IRUSR # u+r + | stat.S_IWUSR # u+w + ) # u=rw,go= + + +def load(path: Path = CONFIG) -> ConfigParser: + """""" + Load the config file at *path* and return a ConfigParser object. + + If *path* does not exist, no error is raised, but an empty ConfigParser + object is returned. This is the default behaviour of ConfigParser and + intended so that a missing config file isn't fatal. + """""" + config = ConfigParser() + config.read(str(path), encoding = ""utf-8"") + return config + + +def save(config, path: Path = CONFIG): + """""" + Write the *config* object to *path*. + + If the immediate parent directory of the file named by *path* is + ``.nextstrain``, then that directory will be created if it does not already + exist. + """""" + secrets = path is SECRETS + + path = path.resolve(strict = False) + + if path.parent.name == "".nextstrain"": + path.parent.mkdir(exist_ok = True) + + if secrets: + if path.exists(): + path.chmod(SECRETS_PERMS) + else: + path.touch(SECRETS_PERMS) + + with path.open(mode = ""w"", encoding = ""utf-8"") as file: + config.write(file) + + +def get(section: str, field: str, fallback: str = None, path: Path = CONFIG) -> Optional[str]: + """""" + Return *field* from *section* in the config file at the given *path*. + + If *section* or *field* does not exist, returns *fallback* (which defaults + to None). + """""" + with read_lock(): + config = load(path) + + if section in config: + return config[section].get(field, fallback) + else: + return fallback + + +def set(section: str, field: str, value: str, path: Path = CONFIG): + """""" + Set *field* in *section* to *value* in the config file at the given *path*. + + If *section* does not exist, it is automatically created. + """""" + with write_lock(): + config = load(path) + + if section not in config: + config.add_section(section) + + config[section][field] = value + + save(config, path) + + +def setdefault(section: str, field: str, value: str, path: Path = CONFIG): + """""" + Set *field* in *section* to *value* in the config file at the given *path*, + if *field* doesn't already exist. + + If *section* does not exist, it is automatically created. + """""" + with write_lock(): + config = load(path) + + if section not in config: + config.add_section(section) + + config[section].setdefault(field, value) + + save(config, path) + + +def remove(section: str, path: Path) -> bool: + """""" + Remove the *section* in the config file at the given *path*. + + Returns ``True`` when *section* is removed. Returns ``False`` if *section* + or *path* does not exist. + """""" + if not path.exists(): + return False + + with write_lock(): + config = load(path) + + if section not in config: + return False + + del config[section] + + save(config, path) + + return True + + +@contextmanager +def read_lock(): + """""" + Lock for reading across processes (but not within). + + Uses a global advisory/cooperative lock. + """""" + with InterProcessReaderWriterLock(LOCK).read_lock(): + yield + + +@contextmanager +def write_lock(): + """""" + Lock for writing across processes (but not within). + + Uses a global advisory/cooperative lock. + """""" + with InterProcessReaderWriterLock(LOCK).write_lock(): + yield +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/paths.py",".py","1510","52",""""""" +Filesystem paths. + +Documented manually in :file:`doc/config/paths.rst` because the autodoc +directives make it too difficult to produce reasonable output for this module. +(Granted, it's a bit of an off-label use.) +"""""" +import os +from pathlib import Path +from typing import Union + + +def from_env(name: str, default: Union[str, Path]) -> Path: + """""" + Wrap a :py:cls:`Path` around the value of the environment variable *name*, + if any, otherwise *default*. + + Environment variables which are set but empty will be treated as unset + (i.e. *default* will be used). + """""" + return Path(os.environ.get(name) or default) + + +# Not finding a homedir is unlikely, but possible. Fallback to the current +# directory. +try: + HOME = Path.home() +except: + HOME = Path(""."") + + +# Path to our config/app data dir +NEXTSTRAIN_HOME = from_env(""NEXTSTRAIN_HOME"", HOME / "".nextstrain/"") + +# Path to runtime data dirs +RUNTIMES = from_env(""NEXTSTRAIN_RUNTIMES"", NEXTSTRAIN_HOME / ""runtimes/"") + +# Path to pathogen workflow data dirs +PATHOGENS = from_env(""NEXTSTRAIN_PATHOGENS"", NEXTSTRAIN_HOME / ""pathogens/"") + +# Path to our config file +CONFIG = from_env(""NEXTSTRAIN_CONFIG"", NEXTSTRAIN_HOME / ""config"") + +# Path to our secrets file +SECRETS = from_env(""NEXTSTRAIN_SECRETS"", NEXTSTRAIN_HOME / ""secrets"") + +# Path to our global lock file +LOCK = from_env(""NEXTSTRAIN_LOCK"", NEXTSTRAIN_HOME / ""lock"") + +# Path to our shell history file +SHELL_HISTORY = from_env(""NEXTSTRAIN_SHELL_HISTORY"", NEXTSTRAIN_HOME / ""shell-history"") +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/__main__.py",".py","1418","44",""""""" +Stub function and module used as a setuptools entry point. +"""""" + +import sys +from io import TextIOWrapper +from sys import argv, exit +from nextstrain import cli + +# Entry point for setuptools-installed script. +def main(): + # Explicitly configure our stdio output streams to be as assumed in the + # rest of the codebase. Avoids needing to instruct folks to set + # PYTHONIOENCODING=UTF-8 or use Python's UTF-8 mode (-X utf8 or + # PYTHONUTF8=1). + reconfigure_stdio(sys.stdout) # pyright: ignore[reportArgumentType] + reconfigure_stdio(sys.stderr) # pyright: ignore[reportArgumentType] + + return cli.run( argv[1:] ) + + +def reconfigure_stdio(stdio: TextIOWrapper): + """""" + Reconfigure *stdio* to match the assumptions of this codebase. + + Suitable only for output streams (e.g. stdout, stderr), as reconfiguring an + input stream is more complicated. + """""" + + # Configure new text stream on the same underlying buffered byte stream. + stdio.reconfigure( + # Always use UTF-8 and be more lenient on stderr so even mangled error + # messages make it out. + encoding = ""UTF-8"", + errors = ""backslashreplace"" if stdio is sys.stderr else ""strict"", + + # Explicitly enable universal newlines mode so we do the right thing. + newline = None) + + +# Run when called as `python -m nextstrain.cli`, here for good measure. +if __name__ == ""__main__"": + exit( main() ) +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/hostenv.py",".py","1451","54",""""""" +Translation of local host environment to the runtime environments. +"""""" + +import os +from typing import List, Tuple + + +# Host environment variables to pass through (forward) into the Nextstrain +# build/runner environments (e.g. the Docker container or AWS Batch job). This +# is intended to be a central, authoritative list. + +# XXX TODO: Remove build-specific variables below (which don't belong in this +# generic CLI tool) in favor of another mechanism for consistently passing +# environment variables into the containers. +# -trs, 13 Dec 2019 + +forwarded_names = [ + # Augur + ""AUGUR_RECURSION_LIMIT"", + ""AUGUR_MINIFY_JSON"", + + # AWS + ""AWS_ACCESS_KEY_ID"", + ""AWS_SECRET_ACCESS_KEY"", + ""AWS_SESSION_TOKEN"", + + # ID3C + ""ID3C_URL"", + ""ID3C_USERNAME"", + ""ID3C_PASSWORD"", + + # RethinkDB credentials + ""RETHINK_HOST"", + ""RETHINK_AUTH_KEY"", +] + + +def forwarded_values() -> List[Tuple[str, str]]: + """""" + Return a list of (name, value) tuples for the ``hostenv.forwarded_names`` + defined in the current ``os.environ``. + + Values may be sensitive credentials, so if at all possible, values returned + from this should generally be omitted from command-line invocations and + similar widely-visible contexts. + """""" + + return [ + (name, os.environ.get(name, """")) + for name in forwarded_names + if name in os.environ + ] +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/types.py",".py","3329","113",""""""" +Type definitions for internal use. +"""""" + +import argparse +import builtins +import sys +from pathlib import Path +from typing import Any, Callable, Iterable, List, Mapping, Optional, Protocol, Tuple, Union, TYPE_CHECKING, runtime_checkable +# TODO: Use typing.TypeAlias once Python 3.10 is the minimum supported version. +from typing_extensions import TypeAlias + +# Import concrete types from our other modules only during type checking to +# avoid import cycles during runtime. +if TYPE_CHECKING: + from .authn import User + from .volume import NamedVolume + from .url import URL, Origin + +# Re-export EllipsisType so we can paper over its absence from older Pythons +if sys.version_info >= (3, 10): + from types import EllipsisType +else: + EllipsisType: TypeAlias = 'builtins.ellipsis' + +"""""" +An immutable mapping of (*name*, *value*) pairs representing a set of +additional environment variables to overlay on the current environment (e.g. +when executing a subprocess). + +Each (*name*, *value*) pair represents a single environment variable. + +A *value* of ``None`` indicates the positive absence of *name* (e.g. it is to +be removed if present). +"""""" +Env = Mapping['EnvName', 'EnvValue'] +EnvItem = Tuple['EnvName', 'EnvValue'] +EnvName = str +EnvValue = Union[str, None] + +Options = argparse.Namespace + +SetupStatus = Optional[bool] + +SetupTestResults = Iterable['SetupTestResult'] +SetupTestResult = Tuple[str, 'SetupTestResultStatus'] +SetupTestResultStatus: TypeAlias = Union[bool, None, EllipsisType] + +UpdateStatus = Optional[bool] + +# Re-export boto3 S3 resource types we use for convenience. +if TYPE_CHECKING: + from types_boto3_s3.service_resource import Bucket as S3Bucket, Object as S3Object # noqa: F401 (for re-export) +else: + S3Bucket = Any + S3Object = Any + + +@runtime_checkable +class RunnerModule(Protocol): + @staticmethod + def register_arguments(parser: argparse.ArgumentParser) -> None: ... + + @staticmethod + def run(opts: Options, + argv: List[str], + working_volume: Optional['NamedVolume'], + extra_env: Env, + cpus: Optional[int], + memory: Optional[int]) -> int: + ... + + @staticmethod + def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: ... + + @staticmethod + def test_setup() -> SetupTestResults: ... + + @staticmethod + def set_default_config() -> None: ... + + @staticmethod + def update() -> UpdateStatus: ... + + @staticmethod + def versions() -> Iterable[str]: ... + + +class RemoteModule(Protocol): + @staticmethod + def upload(url: 'URL', local_files: List[Path], dry_run: bool = False) -> Iterable[Tuple[Path, str]]: ... + + @staticmethod + def download(url: 'URL', local_path: Path, recursively: bool = False, dry_run: bool = False) -> Iterable[Tuple[str, Path]]: ... + + @staticmethod + def ls(url: 'URL') -> Iterable[str]: ... + + @staticmethod + def delete(url: 'URL', recursively: bool = False, dry_run: bool = False) -> Iterable[str]: ... + + @staticmethod + def current_user(origin: 'Origin') -> Optional['User']: ... + + @staticmethod + def login(origin: 'Origin', credentials: Optional[Callable[[], Tuple[str, str]]] = None) -> 'User': ... + + @staticmethod + def renew(origin: 'Origin') -> Optional['User']: ... + + @staticmethod + def logout(origin: 'Origin'): ... +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/browser.py",".py","2261","70",""""""" +Web browser interaction. + +.. envvar:: BROWSER + + A ``PATH``-like list of web browsers to try in preference order, before + falling back to a set of default browsers. May be program names, e.g. + ``firefox``, or absolute paths to specific executables, e.g. + ``/usr/bin/firefox``. + +.. envvar:: NOBROWSER + + If set to a truthy value (e.g. 1) then no web browser will be considered + available. This can be useful to prevent opening of a browser when there + are not other means of doing so. +"""""" +import webbrowser +from threading import Thread, ThreadError +from os import environ +from typing import Union +from .url import URL +from .util import warn + + +if environ.get(""NOBROWSER""): + BROWSER = None +else: + # Avoid text-mode browsers + TERM = environ.pop(""TERM"", None) + try: + BROWSER = webbrowser.get() + except: + BROWSER = None + finally: + if TERM is not None: + environ[""TERM""] = TERM + + +def open_browser(url: Union[str, URL], new_thread: bool = True): + """""" + Opens *url* in a web browser. + + Opens in a new tab, if possible, and raises the window to the top, if + possible. + + Launches the browser from a separate thread by default so waiting on the + browser child process doesn't block the main (or calling) thread. Set + *new_thread* to False to launch from the same thread as the caller (e.g. if + you've already spawned a dedicated thread or process for the browser). + Note that some registered browsers launch in the background themselves, but + not all do, so this feature makes launch behaviour consistent across + browsers. + + Prints a warning to stderr if a browser can't be found or can't be + launched, as automatically opening a browser is considered a + nice-but-not-necessary feature. + """""" + if not BROWSER: + warn(f""Couldn't open <{url}> in browser: no browser found"") + return + + try: + if new_thread: + Thread(target = open_browser, args = (str(url), False), daemon = True).start() + else: + # new = 2 means new tab, if possible + BROWSER.open(str(url), new = 2, autoraise = True) + except (ThreadError, webbrowser.Error) as err: + warn(f""Couldn't open <{url}> in browser: {err!r}"") +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/__init__.py",".py","11332","280","import argparse +import os +from argparse import ArgumentParser, ArgumentTypeError +from typing import List, Union +# TODO: Use typing.TypeAlias once Python 3.10 is the minimum supported version. +from typing_extensions import TypeAlias +from . import docker, conda, singularity, ambient, aws_batch +from .. import config, env, hostenv +from ..argparse import DirectoryPath, SKIP_AUTO_DEFAULT_IN_HELP +from ..errors import UserError +from ..types import EllipsisType, Env, Options, RunnerModule +from ..util import prose_list, runner_name, runner_module, runner_help, warn +from ..volume import store_volume, NamedVolume + + +all_runners: List[RunnerModule] = [ + docker, + conda, + singularity, + ambient, + aws_batch, +] + +all_runners_by_name = dict((runner_name(r), r) for r in all_runners) + +def runner_defaults(): + default_runner = docker + configured_runner = None + + if configured := config.get(""core"", ""runner""): + try: + configured_runner = runner_module(configured) + except ValueError: + warn(""WARNING: Default runner from config file (%s) is invalid. Using %s.\n"" + % (configured, runner_name(default_runner))) + else: + default_runner = configured_runner + + return default_runner, configured_runner + +default_runner, configured_runner = runner_defaults() + + +RunnerExec: TypeAlias = List[Union[str, EllipsisType]] + + +def register_runners(parser: ArgumentParser, + exec: RunnerExec, + runners: List[RunnerModule] = all_runners, + default: RunnerModule = default_runner) -> None: + """""" + Register runner selection flags and runner-specific arguments on the given + ArgumentParser instance. + """""" + # Not all commands may support the default runner. + if default not in runners: + default = runners[0] + + register_flags(parser, runners, default) + register_arguments(parser, runners, exec = exec) + + +def register_flags(parser: ArgumentParser, runners: List[RunnerModule], default: RunnerModule) -> None: + """""" + Register runner selection flags on the given ArgumentParser instance. + """""" + runner_selection = parser.add_argument_group( + ""runtime selection options"", + ""Select the Nextstrain runtime to use, if the\n"" + ""default is not suitable."") + + # We use a different flag for each runner for a simpler UX, but only one + # runner may be selected from the group. + flags = runner_selection.add_mutually_exclusive_group() + + # The selected runner is stored in __runner__ (a la __command__). The + # run() function below calls __runner__. + flags.set_defaults( __runner__ = default ) + + # Add a flag for each runner based on its name. + # + # The standard display of option defaults (via ArgumentDefaultsHelpFormatter) + # is suppressed so we can provide better custom handling that doesn't + # expose full runner module names. + for runner in runners: + if runner is default: + default_indicator = "" (default)"" + else: + default_indicator = """" + + flags.add_argument( + ""--%s"" % runner_name(runner), + help = runner_help(runner) + default_indicator, + action = ""store_const"", + const = runner, + dest = ""__runner__"", + default = argparse.SUPPRESS) + + if runner is ambient: + # Alias --ambient as --native for backwards compatibility but hide + # it from --help output. + flags.add_argument( + ""--native"", + help = argparse.SUPPRESS, + action = ""store_const"", + const = ambient, + dest = ""__runner__"") + + +def register_arguments(parser: ArgumentParser, runners: List[RunnerModule], exec: RunnerExec) -> None: + """""" + Register arguments shared by all runners as well as runner-specific + arguments on the given ArgumentParser instance. + """""" + + # Unpack exec parameter into the command and everything else + (exec_cmd, *exec_args) = exec + + # Arguments for all runners + runtime = parser.add_argument_group( + ""runtime options"", + ""Options shared by all runtimes."") + + runtime.add_argument( + ""--env"", + metavar = ""[=]"", + help = ""Set the environment variable ```` to the value in the current environment (i.e. pass it thru) or to the given ````. "" + ""May be specified more than once. "" + ""Overrides any variables of the same name set via :option:`--envdir`. "" + ""When this option or :option:`--envdir` is given, the default behaviour of automatically passing thru several \""well-known\"" variables is disabled. "" + f""The \""well-known\"" variables are {prose_list([f'``{x}``' for x in hostenv.forwarded_names], 'and')}. "" + ""Pass those variables explicitly via :option:`--env` or :option:`--envdir` if you need them in combination with other variables. "" + f""{SKIP_AUTO_DEFAULT_IN_HELP}"", + action = ""append"", + default = []) + + runtime.add_argument( + ""--envdir"", + metavar = """", + help = ""Set environment variables from the envdir at ````. "" + ""May be specified more than once. "" + ""An envdir is a directory containing files describing environment variables. "" + ""Each filename is used as the variable name. "" + ""The first line of the contents of each file is used as the variable value. "" + ""When this option or :option:`--env` is given, the default behaviour of automatically passing thru several \""well-known\"" variables is disabled. "" + f""Envdirs may also be specified by setting ``NEXTSTRAIN_RUNTIME_ENVDIRS`` in the environment to a ``{os.pathsep}``-separated list of paths. "" + ""See the description of :option:`--env` for more details. "" + f""{SKIP_AUTO_DEFAULT_IN_HELP}"", + type = DirectoryPath, + action = ""append"", + default = []) + + # Development arguments for all runners + development = parser.add_argument_group( + ""development options"", + ""These should generally be unnecessary unless you're developing Nextstrain."") + + # Image to use; shared by Docker, AWS Batch, and Singularity runners + development.add_argument( + ""--image"", + help = ""Container image name to use for the Nextstrain runtime "" + f""(default: %(default)s for Docker and AWS Batch, {singularity.DEFAULT_IMAGE} for Singularity)"", + metavar = """", + default = docker.DEFAULT_IMAGE) + + development.set_defaults(volumes = []) + + for name in docker.COMPONENTS: + development.add_argument( + ""--"" + name, + help = ""Replace the image's copy of %s with a local copy"" % name, + metavar = """", + action = store_volume(name)) + + # Program to execute + # + # XXX TODO: We could make this nargs = ""*"" to accept more than one arg and + # thus provide a way to override default_exec_args. This would resolve + # some weirdness below re: the interplay of default exec args, the + # Ellipsis, and extra_exec_args. However, it would require --exec's last + # value is followed by either another option or ""--"" to separate the --exec + # values from other positional arguments like the build workdir. + # -trs, 21 May 2020 + development.add_argument( + ""--exec"", + help = ""Program to run inside the runtime"", + metavar = """", + default = exec_cmd) + + # Static exec arguments; never modified directly by the user invocation, + # but they won't be used if --exec is changed. + parser.set_defaults(default_exec_cmd = exec_cmd) + parser.set_defaults(default_exec_args = exec_args) + + # Optional exec arguments, if the calling command indicates they're allowed + parser.set_defaults(extra_exec_args = []) + + if ... in exec_args: + parser.add_argument( + ""extra_exec_args"", + help = ""Additional arguments to pass to the executed program"", + metavar = ""..."", + nargs = argparse.REMAINDER) + + # Register additional arguments for each runner + for runner in runners: + runner.register_arguments(parser) + + +def run(opts: Options, working_volume: NamedVolume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + """""" + Inspect the given options object and call the selected runner's run() + function with appropriate arguments. + """""" + + # Construct the appropriate argv list so each runner doesn't have to. This + # keeps together the definition of these options, above, and their + # handling, below. + argv = [ + opts.exec, + *replace_ellipsis( + opts.default_exec_args if opts.default_exec_cmd == opts.exec else [...], + opts.extra_exec_args + ) + ] + + if (opts.image is not docker.DEFAULT_IMAGE + and opts.__runner__ in {conda, ambient}): + why_runner = ""the configured default"" if default_runner in {conda, ambient} else f""selected by --{runner_name(opts.__runner__)}"" + raise UserError(f"""""" + The --image option is incompatible with the {runner_name(opts.__runner__)} runtime ({why_runner}). + + If you need to use the {runner_name(opts.__runner__)} runtime, please omit the --image option. + + If you need the --image option, please select another runtime (e.g. + with the --docker option) that supports it. Currently --image is + supported by the Docker (--docker), AWS Batch (--aws-batch), and + Singularity (--singularity) runtimes. You can check if your setup + supports these runtimes with `nextstrain check-setup`. + """""") + + # Account for potentially different defaults for --image depending on the + # selected runner. + if opts.__runner__ is singularity and opts.image is docker.DEFAULT_IMAGE: + opts.image = singularity.DEFAULT_IMAGE + + if envdirs := os.environ.get(""NEXTSTRAIN_RUNTIME_ENVDIRS""): + try: + opts.envdir = [ + *[DirectoryPath(d) for d in envdirs.split(os.pathsep) if d], + *opts.envdir ] + except ArgumentTypeError as err: + raise UserError(f""{err} (in NEXTSTRAIN_RUNTIME_ENVDIRS)"") + + # Add env from automatically forwarded vars xor from --envdir and --env + # without overriding values explicitly set by our commands' own internals + # (i.e. the callers of this function). + if opts.envdir or opts.env: + extra_env = { + **dict(env.from_dirs(opts.envdir)), + **dict(env.from_vars(opts.env)), + **extra_env } + else: + extra_env = { + **dict(hostenv.forwarded_values()), + **extra_env } + + return opts.__runner__.run(opts, argv, working_volume = working_volume, extra_env = extra_env, cpus = cpus, memory = memory) + + +def replace_ellipsis(items, elided_items): + """""" + Replaces any Ellipsis items (...) in a list, if any, with the items of a + second list. + """""" + return [ + y for x in items + for y in (elided_items if x is ... else [x]) + ] +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/singularity.py",".py","20826","598",""""""" +Run commands inside a container image using Singularity. + +Singularity is a container system freely-available for Linux platforms. It is +commonly available on institutional HPC systems as an alternative to Docker, +which is often not supported on such systems. When you use Singularity with +the Nextstrain CLI, you don't need to install any other Nextstrain software +dependencies as validated versions are already bundled into a container image +by the Nextstrain team. + +The Singularity runtime uses the same images built for the Docker runtime by +automatically converting them to local Singularity images. Local images are +stored as files named +:file:`~/.nextstrain/runtimes/singularity/images/{repository}/{tag}.sif`. + +.. versionadded:: 6.1.0 + + +.. _singularity-setup: + +Setup +===== + +Run ``nextstrain setup singularity`` to get started. +Singularity version 3.0.0 or newer is required, but we recommend at least +version 3.10.0 or newer when possible. + +This will download image layers totaling about 750 MB in size which are +converted to a final on-disk image of about 650 MB. Transient disk usage +during this process peaks at about 2 GB. These numbers are current as of +August 2023, as observed on Linux. Numbers will vary over time, with a +tendency to slowly increase, and vary slightly by OS. + +Note that the Singularity project forked into two separate projects in late +2021: `SingularityCE`_ under `Sylabs`_ and `Apptainer`_ under the `Linux +Foundation`_. Either fork should work with Nextstrain CLI, as both projects +still provide very similar interfaces and functionality via the ``singularity`` +command. You can read `Sylab's announcement`_ and `Apptainer's announcement`_ +for more information on the fork. + +.. _SingularityCE: https://sylabs.io/singularity/ +.. _Sylabs: https://sylabs.io/ +.. _Apptainer: https://apptainer.org +.. _Linux Foundation: https://www.linuxfoundation.org/ +.. _Sylab's announcement: https://sylabs.io/2022/06/singularityce-is-singularity/ +.. _Apptainer's announcement: https://apptainer.org/news/community-announcement-20211130 + + +.. _singularity-config: + +Config file variables +===================== + +Defaults for the corresponding command line options, specified in the +:doc:`config file `. + +.. glossary:: + + :index:`singularity.image ` + Default for ``--image`` when using the Singularity runtime, e.g. + ``docker://nextstrain/base:build-20230525T143814Z``. + + Typically set initially by ``nextstrain setup`` and subsequently by + ``nextstrain update``. + + +.. _singularity-env: + +Environment variables +===================== + +.. warning:: + For development only. You don't need to set these during normal operation. + +Defaults for the corresponding command line options, potentially overriding +defaults set by `config file variables`_. + +.. envvar:: NEXTSTRAIN_SINGULARITY_IMAGE + + Default for ``--image`` when using the Singularity runtime. +"""""" + +import itertools +import os +import re +import shutil +import subprocess +import sys +from functools import lru_cache +from packaging.version import Version, InvalidVersion +from pathlib import Path +from typing import Iterable, List, Optional, cast +from urllib.parse import urlsplit +from .. import config +from ..errors import UserError +from ..paths import RUNTIMES +from ..types import Env, RunnerModule, SetupStatus, SetupTestResults, UpdateStatus +from ..util import capture_output, colored, exec_or_return, runner_name, split_image_name, warn +from . import docker + +flatten = itertools.chain.from_iterable + + +RUNTIME_ROOT = RUNTIMES / ""singularity/"" + +IMAGES = RUNTIME_ROOT / ""images/"" + +CACHE = RUNTIME_ROOT / ""cache/"" + + +# The default intentionally omits an explicit ""latest"" tag so that on the first +# `nextstrain update` it gets pinned in the config file to the most recent +# ""build-*"" tag. Users can set an explicit ""latest"" tag in config to always +# use the most recent image and not pin to ""build-*"" tags. +# (copied from ./docker.py on 5 Jan 2022) +DEFAULT_IMAGE = os.environ.get(""NEXTSTRAIN_SINGULARITY_IMAGE"") \ + or config.get(""singularity"", ""image"") \ + or ""docker://nextstrain/base"" + + +SINGULARITY_MINIMUM_VERSION = ""3.0.0"" + +APPTAINER_MINIMUM_VERSION = ""1.0.0"" # forked from Singularity 3.9.5 + +SINGULARITY_CONFIG_ENV = { + # Store image caches in our runtime root instead of ~/.singularity/… + ""SINGULARITY_CACHEDIR"": str(CACHE), + + # PROMPT_COMMAND is used by Singularity 3.5.3 onwards to forcibly set PS1 + # to ""Singularity> "" on the first evaluation.¹ This happens *after* our + # bashrc is evaluated, so our Nextstrain prompt is overwritten. + # Singularity appends to any existing PROMPT_COMMAND value, so use a + # well-placed comment char (#) to avoid evaluating what it appends. + # Additionally unset PROMPT_COMMAND the first time it's evaluated so this + # silly workaround doesn't happen on every prompt. + # + # We set this via the special-cased environment passthru instead of setting + # it via an --env arg because --env is only first available in 3.6.0. + # + # ¹ + # + # + ""SINGULARITYENV_PROMPT_COMMAND"": ""unset PROMPT_COMMAND; #"", +} + +SINGULARITY_EXEC_ARGS = lambda: [ + # Increase isolation. + # + # In the future, we may find we want to use additional related flags to + # further increase isolation.¹ Note, however, that we'll want to think + # about the minimum Singularity version we want to support, as many flags + # in this area are not available on older versions. + # + # --compat (available since 3.9.0; a bundle option) + # --containall (available since 2.2; a bundle option) + # --contain + # --cleanenv + # --ipc + # --pid + # --writable-tmpfs (3.0.0) + # --no-init (3.0.0) + # --no-umask (3.7.0) + # --no-eval (3.10.0, Apptainer 1.1.0) + # + # We opt not to use the --compat bundle option itself mainly for broader + # version compatibility but also because what it includes will likely + # change over time with newer Singularity releases. We'd rather a stable, + # predictable set of behaviour of our choosing that maximizes + # compatibility. + # + # The options we use here are compatible with Singularity 2.6.0 and newer. + # + # XXX TODO: Once Singularity 4.0 is released and widely available, we *may* + # consider switching from --compat to --oci² for a) stronger Docker-like + # isolation and b) no longer having to convert our Docker (OCI) images to + # Singularity (SIF) images. Alternatively, we may want to keep this + # runtime as a ""middle ground"" between the relatively strict isolation of + # our Docker runtime and the much looser isolation of the Conda runtime. + # Not sure! + # -trs, 23 May 2023 + # + # ¹ + # ² + ""--contain"", + + # Don't mount anything at all at the container's value of HOME. This is + # necesary because --compat includes --containall which includes --contain + # which makes HOME in the container an empty temporary directory. + # --no-home is available since 2.6.0. + ""--no-home"", + + # Singularity really wants to default HOME inside the container to the + # value from outside the container, thus ignoring the value set by the + # upstream Docker image which is only used as a default by the Singularity + # image. Singularity forbids using --env to directly override HOME, so + # instead we use --home : with two empty values. doesn't + # apply because we use --no-home, and setting to an empty value + # allows the container's default to apply (thus avoiding hardcoding it + # here). + ""--home"", "":"", + + # Allow writes to the image filesystem, discarded at container exit, à la + # Docker. Snakemake, for example, needs to be able to write to HOME + # (/nextstrain). + ""--writable-tmpfs"", + + # Don't copy entire host environment. We forward our own hostenv. + ""--cleanenv"", + + # Don't evaluate the entrypoint command line (e.g. arguments passed via + # `nextstrain build`) before exec-ing the entrypoint. It leads to unwanted + # substitutions that happen too early. + *([""--no-eval""] if singularity_version_at_least(""3.10.0"", apptainer=""1.1.0"") else []), + + # Since we use --no-home above, avoid warnings about not being able to cd + # to $HOME (the default behaviour). run() will override this by specifying + # --pwd again. + ""--pwd"", ""/"", +] + + +def register_arguments(parser) -> None: + """""" + No-op. No arguments necessary. + """""" + pass + + +def run(opts, argv, working_volume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + docker.assert_volumes_exist(opts.volumes) + + # We require docker:// qualified image names in this runtime internally, + # but the external --image option is common to a few runtimes and takes + # unqualified names. + # + # XXX TODO: We could probably support other schemes Singularity supports… + # but it's likely not worth it until we have a need (if ever). + # -trs, 5 Jan 2023 + image = f""docker://{opts.image}"" if not opts.image.startswith(""docker://"") else opts.image + + if not image_exists(image): + if not download_image(image): + raise UserError(f""Unable to create local Singularity image for {image!r}."") + + # XXX TODO: In the future we might want to set rlimits based on cpus and + # memory, at least on POSIX systems. + # -trs, 21 May 2020 (copied from ./native.py on 30 Aug 2022) + + extra_env = { + **SINGULARITY_CONFIG_ENV, + + # Pass environment into the container via Singularity's bespoke + # prefixing with SINGULARITYENV_….¹ + # + # ¹ + **{f""SINGULARITYENV_{k}"": v + for k, v in extra_env.items() + if v is not None }, + } + + return exec_or_return([ + ""singularity"", ""run"", *SINGULARITY_EXEC_ARGS(), + + # Map directories to bind mount into the container. + *flatten((""--bind"", ""%s:%s:%s"" % (v.src.resolve(strict = True), docker.mount_point(v), ""rw"" if v.writable else ""ro"")) + for v in opts.volumes + if v.src is not None), + + # Change the default working directory if requested + *((""--pwd"", str(docker.mount_point(working_volume))) if working_volume else ()), + + str(image_path(image)), + *argv, + ], extra_env) + + +def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: + if not setup_image(dry_run, force): + return False + + return True + + +def setup_image(dry_run: bool = False, force: bool = False) -> bool: + """""" + Create Singularity image if it's not already available locally. + + Though not strictly required, by doing this during setup we avoid the + initial download and creation on first use instead. + """""" + image = DEFAULT_IMAGE + path = image_path(image) + exists = path.exists() + + if not force and exists: + print(f""Using existing local copy of Singularity image {image}."") + print(f"" Hint: if you want to ignore this existing local copy, re-run `nextstrain setup` with --force."") + return True + + if exists: + print(f""Removing existing local copy of Singularity image {image}…"") + if not dry_run: + path.unlink() + + update_ok = _update(dry_run) + + if not update_ok: + return False + + return True + + +def test_setup() -> SetupTestResults: + def test_run(): + try: + capture_output([ + ""singularity"", ""exec"", *SINGULARITY_EXEC_ARGS(), + + # XXX TODO: We should test --bind, as that's maybe most likely + # to be adminstratively disabled, but it's a bit more ceremony + # to arrange for a reliable dir to bind into the container. + # Putting it off for now… + # -trs, 5 Jan 2023 + + # Use the official Busybox image, which is tiny, because + # the hello-world image doesn't have /bin/sh, which + # Singularity requires. + ""docker://busybox"", + + ""/bin/true"" + ], extra_env = SINGULARITY_CONFIG_ENV) + except: + return False + else: + return True + + yield (""singularity is installed"", + shutil.which(""singularity"") is not None) + + yield (f""singularity version {singularity_version()} ≥ {SINGULARITY_MINIMUM_VERSION} ({APPTAINER_MINIMUM_VERSION} for Apptainer)"", + singularity_version_at_least(SINGULARITY_MINIMUM_VERSION, apptainer=APPTAINER_MINIMUM_VERSION)) + + yield (""singularity works"", + test_run()) + + +def set_default_config() -> None: + """""" + Sets ``core.runner`` to this runner's name (``singularity``). + + Sets ``singularity.image``, if it isn't already set, to the latest + ``build-*`` image. + """""" + config.set(""core"", ""runner"", runner_name(cast(RunnerModule, sys.modules[__name__]))) + config.setdefault(""singularity"", ""image"", latest_build_image(DEFAULT_IMAGE)) + + +def update() -> UpdateStatus: + """""" + Download and convert the latest Docker runtime image into a local + Singularity image. + + Prunes old local Singularity image versions. + """""" + return _update() + + +def _update(dry_run: bool = False) -> UpdateStatus: + current_image = DEFAULT_IMAGE + latest_image = latest_build_image(current_image) + + if latest_image == current_image: + print(colored(""bold"", ""Updating Singularity image %s…"" % current_image)) + else: + print(colored(""bold"", ""Updating Singularity image from %s to %s…"" % (current_image, latest_image))) + print() + + # Pull the latest image down + if not dry_run: + if not download_image(latest_image): + return False + + # Update the config file to point to the new image so we use it by + # default going forward. + config.set(""singularity"", ""image"", latest_image) + + # Clean up unnecessary caches + print() + print(colored(""bold"", ""Cleaning up…"")) + print() + + if not dry_run: + argv = (""singularity"", ""cache"", ""clean"", ""--type=all"", ""--force"") + env = { + **os.environ.copy(), + **SINGULARITY_CONFIG_ENV, + } + + try: + subprocess.run(argv, env = env, check = True) + except (OSError, subprocess.CalledProcessError) as err: + warn(f""Error running {argv!r}: {err}"") + warn(f""Continuing anyway."") + + # Prune any old images to avoid leaving lots of hidden disk use around. + print() + print(colored(""bold"", ""Pruning old images…"")) + print() + + if not dry_run: + try: + for old_image in old_build_images(latest_image): + print(f""Deleting {old_image}"") + old_image.unlink() + except OSError as error: + warn() + warn(""Update succeeded, but an error occurred pruning old image versions:"") + warn("" "", error) + warn() + warn(""Not to worry, we'll try again the next time you run `nextstrain update`."") + warn() + + return True + + +def download_image(image: str = DEFAULT_IMAGE) -> bool: + """""" + Download and convert a remote Singularity ``docker://` *image* into a local + Singularity image using ``singularity build``. + """""" + # We can avoid downloading/conversion for build-* tags (which are static) + # if the image already exists locally. + _, tag = split_image_name(docker_image_name(image)) + + if docker.is_build_tag(tag) and image_exists(image): + print(f""Singularity image {image} exists and is up-to-date."") + return True + + # …but otherwise we must create it fresh. + path = image_path(image) + path.parent.mkdir(exist_ok = True, parents = True) + + env = { + **os.environ.copy(), + **SINGULARITY_CONFIG_ENV, + } + + try: + subprocess.run( + [""singularity"", ""build"", path, image], + env = env, + check = True) + except (OSError, subprocess.CalledProcessError): + return False + + return True + + +def old_build_images(image: str) -> List[Path]: + """""" + Return a list of local Singularity image paths which were derived from an + older version of *image* tagged with ""build-*"". + + If *image* isn't tagged ""build-*"", nothing is returned out of an abundance + of caution. Our ""build-*"" timestamps use an ISO-8601 timestamp, so oldness + is determined by sorting lexically. + """""" + repository, tag = split_image_name(docker_image_name(image)) + + if not docker.is_build_tag(tag): + return [] + + # List all local images from the same respository, e.g. nextstrain/base. + images = (IMAGES / repository).glob(""*.sif"") + + # Return the paths of images with build tags that come before our current + # build tag, as well as the image with the ""latest"" tag. The latter is + # useful to include because it will likely be out of date when the current + # tag is a build tag (guaranteed above). + return [ + path + for path in images + if (docker.is_build_tag(path.stem) and path.stem < tag) + or path.stem == ""latest"" + ] + + +def image_exists(image: str = DEFAULT_IMAGE) -> bool: + """""" + Check if a Singularity ``docker://`` *image* exists locally, returning True + or False. + """""" + return image_path(image).exists() + + +def image_path(image: str = DEFAULT_IMAGE) -> Path: + """""" + Return a local path to use for a Singularity ``docker://`` *image*. + """""" + repository, tag = split_image_name(docker_image_name(image)) + return IMAGES / repository / f""{tag}.sif"" + + +def latest_build_image(image: str = DEFAULT_IMAGE) -> str: + return ""docker://"" + docker.latest_build_image(docker_image_name(image)) + + +def docker_image_name(image: str = DEFAULT_IMAGE) -> str: + """""" + Convert a Singularity ``docker://`` *image* into a Docker image name. + + >>> docker_image_name(""docker://nextstrain/base:latest"") + 'nextstrain/base:latest' + + >>> docker_image_name(""nextstrain/base"") + Traceback (most recent call last): + ... + cli.errors.UserError: Error: Singularity runtime currently only supports docker:// images but got: 'nextstrain/base' + """""" + url = urlsplit(image) + + if url.scheme != ""docker"": + raise UserError(f""Singularity runtime currently only supports docker:// images but got: {image!r}"") + + return url.netloc + url.path + + +def versions() -> Iterable[str]: + if not image_exists(): + yield f""{DEFAULT_IMAGE} (not present)"" + return + + yield f""{DEFAULT_IMAGE} ({image_path()})"" + + try: + yield from run_bash(docker.report_component_versions()) + except (OSError, subprocess.CalledProcessError): + pass + + +def run_bash(script: str, image: str = DEFAULT_IMAGE) -> List[str]: + """""" + Run a Bash *script* inside of the container *image*. + + Returns the output of the script as a list of strings. + """""" + return capture_output([ + ""singularity"", ""run"", *SINGULARITY_EXEC_ARGS(), image_path(image), + ""bash"", ""-c"", script + ]) + + +@lru_cache(maxsize = None) +def singularity_version_at_least(min_version: str, *, apptainer: str) -> bool: + version = singularity_version() + + if not version: + return False + + if singularity_is_apptainer(): + min_version = apptainer + + return version >= Version(min_version) + + +@lru_cache(maxsize = None) +def singularity_version() -> Optional[Version]: + try: + raw_version = capture_output([""singularity"", ""version""])[0] + except (OSError, subprocess.CalledProcessError): + return None + + try: + return Version(raw_version) + except InvalidVersion: + # Singularity sometimes reports a version like 3.11.1-bionic with a + # (for Python) non-standard suffix (""-bionic""), so try stripping it. + try: + return Version(re.sub(r'-.+$', '', raw_version)) + except InvalidVersion: + return None + + +@lru_cache(maxsize = None) +def singularity_is_apptainer() -> Optional[bool]: + singularity = shutil.which(""singularity"") + + if not singularity: + return None + + if not Path(singularity).is_symlink(): + return False + + try: + return Path(os.readlink(singularity)).name == ""apptainer"" + except OSError: + return None +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/conda.py",".py","26622","761",""""""" +Run commands with access to a fully-managed Conda environment. + +`Conda `__ is a very popular +packaging system freely-available for all platforms. When you use Nextstrain +CLI's built-in Conda support, you don't need to install any other Nextstrain +software dependencies yourself as validated versions are already bundled into a +package (`nextstrain-base`_) by the Nextstrain team and automatically managed +in an isolated location (isolated even from other Conda environments you may +manage yourself). + +.. _nextstrain-base: https://github.com/nextstrain/conda-base + + +.. versionadded:: 5.0.0 + + +.. _conda-setup: + +Setup +===== + +On macOS and Linux, run ``nextstrain setup conda`` to get started. + +This will download compressed packages totaling about 450 MB in size which +expand to a final on-disk size of about 2 GB. Transient disk usage during this +process peaks at about 3 GB. These numbers are current as of August 2023, as +observed on Linux. Numbers will vary over time, with a tendency to slowly +increase, and vary slightly by OS. + +This runtime is not directly supported on Windows, but you can use `WSL2 +`__ to ""switch"" to +Linux and run the above setup command. + + +.. _conda-env: + +Environment variables +===================== + +.. envvar:: NEXTSTRAIN_CONDA_CHANNEL_ALIAS + + The base URL to prepend to channel names. Equivalent to the |channel_alias + Conda config setting|_. + + Useful if you want to use a Conda package mirror that's not the default + (i.e. not Anaconda's). + + Defaults to the Conda ecosystem's default of + ``__. + +.. |channel_alias Conda config setting| replace:: ``channel_alias`` Conda config setting +.. _channel_alias Conda config setting: https://docs.conda.io/projects/conda/en/latest/user-guide/configuration/settings.html#set-ch-alias + + +.. warning:: + The remaining variables are for development only. You don't need to set + these during normal operation. + +.. envvar:: NEXTSTRAIN_CONDA_CHANNEL + + Conda channel name (or URL) to use for Nextstrain packages not otherwise + available via Bioconda (e.g. ``nextstrain-base``). + + Defaults to ``nextstrain``. + +.. envvar:: NEXTSTRAIN_CONDA_BASE_PACKAGE + + Conda meta-package name to use for the Nextstrain base runtime dependencies. + + May be a two- or three-part `Conda package match spec`_ instead of just a + package name. Note that a ``conda install``-style package spec, with a + single ``=`` or without spaces, is not supported. + + Defaults to ``nextstrain-base``. + + .. _Conda package match spec: https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/pkg-specs.html#package-match-specifications + +.. envvar:: NEXTSTRAIN_CONDA_MICROMAMBA_URL + + URL of a Micromamba release tarball (e.g. Conda package) to use for setup + and updates. + + May be a full URL or a relative URL to be joined with + :envvar:`NEXTSTRAIN_CONDA_CHANNEL_ALIAS`. Any occurrence of ``{subdir}`` + will be replaced with the current platform's Conda subdir value. + + Replaces the previously-supported development environment variable + ``NEXTSTRAIN_CONDA_MICROMAMBA_VERSION``. + + Defaults to ``conda-forge/{subdir}/micromamba-1.5.8-0.tar.bz2``. + +.. envvar:: NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR + + Conda subdir to use for both Micromamba and the runtime environment. + + If set, overrides the default behaviour of detecting the best subdir that's + usable for the platform. +"""""" + +import json +import os +import platform +import shutil +import subprocess +import sys +import tarfile +import traceback +from pathlib import Path, PurePosixPath +from tempfile import TemporaryFile +from typing import IO, Iterable, List, NamedTuple, Optional, cast +from urllib.parse import urljoin +from .. import config +from .. import requests +from ..errors import InternalError, UserError +from ..paths import RUNTIMES +from ..types import Env, RunnerModule, SetupStatus, SetupTestResults, UpdateStatus +from ..util import capture_output, colored, exec_or_return, parse_version_lax, runner_name, setup_tests_ok, test_rosetta_enabled, uniq, warn + + +RUNTIME_ROOT = RUNTIMES / ""conda/"" + +PREFIX = RUNTIME_ROOT / ""env/"" +PREFIX_BIN = PREFIX / ""bin"" + +MICROMAMBA_ROOT = RUNTIME_ROOT / ""micromamba/"" +MICROMAMBA = MICROMAMBA_ROOT / ""bin/micromamba"" + +# If you update the version pin below, please update the docstring above too. +MICROMAMBA_URL = os.environ.get(""NEXTSTRAIN_CONDA_MICROMAMBA_URL"") \ + or ""conda-forge/{subdir}/micromamba-1.5.8-0.tar.bz2"" + +CHANNEL_ALIAS = os.environ.get(""NEXTSTRAIN_CONDA_CHANNEL_ALIAS"") \ + or ""https://conda.anaconda.org"" + +NEXTSTRAIN_CHANNEL = os.environ.get(""NEXTSTRAIN_CONDA_CHANNEL"") \ + or ""nextstrain"" + +NEXTSTRAIN_BASE = os.environ.get(""NEXTSTRAIN_CONDA_BASE_PACKAGE"") \ + or ""nextstrain-base"" + +OVERRIDE_SUBDIR = os.environ.get(""NEXTSTRAIN_CONDA_OVERRIDE_SUBDIR"") + +PYTHONUSERBASE = RUNTIME_ROOT / ""python-user-base"" + +# Construct a PATH with our runtime prefix which provides some, but not total, +# isolation from the rest of the system. +PATH = os.pathsep.join(map(str, [ + # Programs installed by this runtime. + PREFIX_BIN, + + # Python's idea of a default path for the system, which currently under + # CPython is either ""/bin:/usr/bin"" on POSIX systems or "".;C:\\bin"" on + # Windows. This will ensure basic system commands like `ls` are + # available, although it will also ""leak"" any user-installed programs + # there. + os.defpath, +])) + +EXEC_ENV = { + ""PATH"": PATH, + + # Avoid letting user-set custom Python installs and module search paths + # from outside the runtime leak inside. + ""PYTHONHOME"": None, + ""PYTHONPATH"": None, + + # Avoid letting the user site directory leak into the runtime, c.f. + # and + # . + ""PYTHONUSERBASE"": str(PYTHONUSERBASE), + ""PYTHONNOUSERSITE"": ""1"", +} + + +def register_arguments(parser) -> None: + """""" + No-op. No arguments necessary. + """""" + pass + + +def run(opts, argv, working_volume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + if working_volume: + os.chdir(str(working_volume.src)) + + # XXX TODO: In the future we might want to set rlimits based on cpus and + # memory, at least on POSIX systems. + # -trs, 21 May 2020 (copied from ./native.py on 30 Aug 2022) + + # XXX TODO: If we need to support Conda activation scripts (e.g. + # …/env/etc/conda/activate.d/) in the future, we could probably switch to + # exec chaining thru `micromamba run` here (with carefully constructed + # options and environ akin to what we do in micromamba() below). + # + # Currently our env has a couple activation scripts, but they're not + # necessary due to 1) our particular usage of the related packages and 2) + # that this runtime, for reasons of package availability, can't support + # Windows at this time (where activation is more crucial than Unix due to + # DLL searching). + # -trs, 13 Jan 2023 + + return exec_or_return(argv, {**extra_env, **EXEC_ENV}) + + +def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: + return _setup(dry_run, force) + + +def _setup(dry_run: bool = False, force: bool = False, install_dist: 'PackageDistribution' = None) -> SetupStatus: + if not setup_micromamba(dry_run, force): + return False + + if not setup_prefix(dry_run, force, install_dist): + return False + + return True + + +def setup_micromamba(dry_run: bool = False, force: bool = False) -> bool: + """""" + Install Micromamba into our ``MICROMAMBA_ROOT``. + """""" + if not force and MICROMAMBA.exists(): + print(f""Using existing Micromamba installation at {MICROMAMBA_ROOT}."") + print(f"" Hint: if you want to ignore this existing installation, re-run `nextstrain setup` with --force."") + return True + + if MICROMAMBA_ROOT.exists(): + print(f""Removing existing directory {MICROMAMBA_ROOT} to start fresh…"") + if not dry_run: + shutil.rmtree(str(MICROMAMBA_ROOT)) + + try: + subdir = OVERRIDE_SUBDIR or platform_subdir() + except InternalError as err: + warn(err) + return False + + url = urljoin(CHANNEL_ALIAS, MICROMAMBA_URL.replace('{subdir}', subdir)) + + print(f""Requesting Micromamba from {url}…"") + + if not dry_run: + response = requests.get(url, stream = True) + response.raise_for_status() + content_type = response.headers[""Content-Type""] + + try: + with tarfile.open(fileobj = response.raw, mode = ""r|*"") as tar: + # Ignore archive members starting with ""/"" and or including "".."" parts, + # as these can be used (maliciously or accidentally) to overwrite + # unintended files (e.g. files outside of MICROMAMBA_ROOT). + safe_members = ( + member + for member in tar + if not member.name.startswith(""/"") + and "".."" not in PurePosixPath(member.name).parts) + + print(f""Downloading and extracting Micromamba to {MICROMAMBA_ROOT}…"") + tar.extractall(path = str(MICROMAMBA_ROOT), members = safe_members) + + except tarfile.TarError as err: + raise UserError(f"""""" + Failed to extract {url} (Content-Type: {content_type}) as tar archive: {err} + """""") + else: + print(f""Downloading and extracting Micromamba to {MICROMAMBA_ROOT}…"") + + return True + + +def setup_prefix(dry_run: bool = False, force: bool = False, install_dist: 'PackageDistribution' = None) -> bool: + """""" + Install Conda packages with Micromamba into our ``PREFIX``. + """""" + if not force and (PREFIX_BIN / ""augur"").exists(): + print(f""Using existing Conda packages in {PREFIX}."") + print(f"" Hint: if you want to ignore this existing installation, re-run `nextstrain setup` with --force."") + return True + + if PREFIX.exists(): + print(f""Removing existing directory {PREFIX} to start fresh…"") + if not dry_run: + shutil.rmtree(str(PREFIX)) + + if not install_dist: + if OVERRIDE_SUBDIR: + subdirs = [OVERRIDE_SUBDIR] + else: + subdirs = [platform_subdir(), *alternate_platform_subdirs()] + + for subdir in subdirs: + if install_dist := package_distribution(NEXTSTRAIN_CHANNEL, NEXTSTRAIN_BASE, subdir): + break + else: + raise UserError(f""Unable to find latest version of {NEXTSTRAIN_BASE} package in {NEXTSTRAIN_CHANNEL}"") + + install_spec = f""{install_dist.name} =={install_dist.version}"" + + # Create environment + print(f""Installing Conda packages into {PREFIX}…"") + print(f"" - {install_spec} ({install_dist.subdir})"") + + if not dry_run: + try: + micromamba(""create"", install_spec, ""--platform"", install_dist.subdir) + except InternalError as err: + warn(err) + traceback.print_exc() + return False + + # Clean up unnecessary caches + print(""Cleaning up…"") + + if not dry_run: + try: + micromamba(""clean"", ""--all"", add_prefix = False) + except InternalError as err: + warn(err) + warn(f""Continuing anyway."") + + return True + + +def micromamba(*args, stdout: IO[bytes] = None, add_prefix: bool = True) -> None: + """""" + Runs our installed Micromamba with appropriate global options and options + for prefix and channel selection. + + Invokes :py:func:`subprocess.run` and checks the exit status. Raises a + :py:exc:`InternalError` on failure, chained from the original + :py:exc:`OSError` or :py:exc:`subprocess.CalledProcessError`. + + For convenience, all arguments are converted to strings before being passed + to :py:func:`subprocess.run`. + + Set the keyword-only argument *stdout* to a binary file-like object (with a + file descriptor) to redirect the process's stdout. + + Set the keyword-only argument *add_prefix* to false to omit the + ``--prefix`` option and channel-related options which are otherwise + automatically added. + """""" + argv = tuple(map(str, ( + MICROMAMBA, + + # Always use our custom root + ""--root-prefix"", MICROMAMBA_ROOT, + + # Ignore any config the user may have set + ""--no-rc"", + ""--no-env"", + + # Never prompt + ""--yes"", + + *args, + ))) + + if add_prefix: + argv += ( + # Path-based env + ""--prefix"", str(PREFIX), + + # BioConda config per , plus our + # own channel. + ""--override-channels"", + ""--strict-channel-priority"", + ""--channel"", urljoin(CHANNEL_ALIAS, NEXTSTRAIN_CHANNEL), + ""--channel"", urljoin(CHANNEL_ALIAS, ""conda-forge""), + ""--channel"", urljoin(CHANNEL_ALIAS, ""bioconda""), + + # Don't automatically pin Python so nextstrain-base deps can change + # it on upgrade. + ""--no-py-pin"", + + # Allow uninstalls and downgrades of existing installed packages so + # nextstrain-base deps can change on upgrade. Uninstalls are + # currently allowed by default (unlike downgrades), but make it + # explicit here. + ""--allow-uninstall"", + ""--allow-downgrade"", + + # Honor same method of CA certificate overriding as requests, + # except without support for cert directories (only files). + *([""--cacert-path"", requests.CA_BUNDLE] + if not Path(requests.CA_BUNDLE).is_dir() else []), + ) + + env = { + # Filter out all CONDA_* and MAMBA_* host env vars so micromamba's + # behaviour isn't affected by running inside an externally-activated + # Conda environment (CONDA_*) or user-set configuration vars (MAMBA_*). + # + # When first drafting this runner, I'd thought we might have to do this + # env filtering, but everything seemed to work fine in practice without + # it, so I didn't on the premise of not including code you don't need. + # Joke's on me! Now that I've been burned by CONDA_PROMPT_MODIFIER + # triggering an infinite loop in the right conditions¹, let's be + # proactively defensive and filter them all out. + # + # We bother with MAMBA_* vars even though we're using --no-env above + # because it turns out that Micromamba may sometimes indirectly invoke + # itself (e.g. the generated wrapper script for package post-link + # scripts calls `micromamba activate`). We can't apply command-line + # options to those instances, so use env vars. + # -trs, 7 Oct 2022 + # + # ¹ + **{ k: v + for k, v in os.environ.copy().items() + if not any(k.startswith(p) for p in {""CONDA_"", ""MAMBA_""}) }, + + # Set env vars to match options above for subprocesses that micromamba + # itself launches. We can't include MAMBA_NO_ENV because that would + # make these two vars moot, but we do filter out all other CONDA_* and + # MAMBA_* vars above. + ""MAMBA_ROOT_PREFIX"": str(MICROMAMBA_ROOT), + ""MAMBA_NO_RC"": ""true"", + + # Override HOME so that micromamba's hardcoded paths under ~/.mamba/ + # don't get used. This could lead to issues with a shared package + # cache at ~/.mamba/pkgs/ for example. + ""HOME"": str(RUNTIME_ROOT), + } + + try: + subprocess.run(argv, env = env, stdout = stdout, check = True) + except (OSError, subprocess.CalledProcessError) as err: + raise InternalError(f""Error running {argv!r}"") from err + + +def test_setup() -> SetupTestResults: + def which_finds_our(cmd) -> bool: + # which() checks executability and also handles PATHEXT, e.g. the + # "".exe"" extension on Windows, which is why we don't just naively test + # for existence ourselves. File extensions are also why we don't test + # equality below instead check containment in PREFIX_BIN. + found = shutil.which(cmd, path = PATH) + + if not found: + return False + + # Path.is_relative_to() was added in Python 3.9, so implement it + # ourselves around .relative_to(). + try: + Path(found).relative_to(PREFIX_BIN) + except ValueError: + return False + else: + return True + + + def runnable(*argv) -> bool: + try: + capture_output(argv, extra_env = EXEC_ENV) + return True + except (OSError, subprocess.CalledProcessError): + return False + + + support = list(test_support()) + + yield from support + + if not setup_tests_ok(support): + return + + elif not PREFIX_BIN.exists(): + yield (""runtime appears set up\n\n"" + ""The Conda runtime appears supported but not yet set up.\n"" + ""Try running `nextstrain setup conda` first."", False) + + else: + yield (""runtime appears set up"", True) + + yield ('snakemake is installed and runnable', + which_finds_our(""snakemake"") and runnable(""snakemake"", ""--version"")) + + yield ('augur is installed and runnable', + which_finds_our(""augur"") and runnable(""augur"", ""--version"")) + + yield ('auspice is installed and runnable', + which_finds_our(""auspice"") and runnable(""auspice"", ""--version"")) + + +def test_support() -> SetupTestResults: + def supported_os() -> bool: + machine = platform.machine() + system = platform.system() + + if system == ""Linux"": + return machine == ""x86_64"" + + elif system == ""Darwin"": + return machine in {""x86_64"", ""arm64""} + + # Conda supports Windows, but we can't because several programs we need + # are not available for Windows. + else: + return False + + yield ('operating system is supported', + supported_os()) + + yield (""runtime data dir doesn't have spaces"", + "" "" not in str(RUNTIME_ROOT)) + + +def set_default_config() -> None: + """""" + Sets ``core.runner`` to this runner's name (``conda``). + """""" + config.set(""core"", ""runner"", runner_name(cast(RunnerModule, sys.modules[__name__]))) + + +def update() -> UpdateStatus: + """""" + Update all installed packages with Micromamba. + """""" + # In the comparisons and logic below, we handle selecting the version to + # update to but still let Micromamba select the specific package _build_ to + # use. While our package creation automation currently doesn't support + # multiple builds of a version, it's worth noting that 1) Conda's data + # model allows for it, and 2) we may start producing multiple builds in the + # future (e.g. for varying x86_64-microarch-level dependencies¹ or other + # platform compatibility reasons). If we do, the code below should still + # work fine. However, if we start making ""fixup"" builds of existing + # versions (e.g. build 1 of version X after build 0 of version X), the ""do + # we need to update?"" logic below would not deal with them properly. + # -trs, 9 April 2025 & 13 May 2025 + # + # ¹ + + nextstrain_base = PackageSpec.parse(NEXTSTRAIN_BASE) + + current_meta = package_meta(NEXTSTRAIN_BASE) or {} + current_version = current_meta.get(""version"") + current_subdir = current_meta.get(""subdir"") or OVERRIDE_SUBDIR or platform_subdir() + + assert current_meta.get(""name"") in {nextstrain_base.name, None} + + # Prefer the platform subdir if possible (e.g. to migrate from osx-64 → + # osx-arm64). Otherwise, use the prefix's current subdir or alternate + # platform subdirs (e.g. to allow ""downgrade"" from osx-arm64 → osx-64). + if OVERRIDE_SUBDIR: + subdirs = [OVERRIDE_SUBDIR] + else: + subdirs = uniq([platform_subdir(), current_subdir, *alternate_platform_subdirs()]) + + for subdir in subdirs: + if latest_dist := package_distribution(NEXTSTRAIN_CHANNEL, NEXTSTRAIN_BASE, subdir): + assert latest_dist.name == nextstrain_base.name + break + else: + raise UserError(f""Unable to find latest version of {NEXTSTRAIN_BASE} package in {NEXTSTRAIN_CHANNEL}"") + + latest_version = latest_dist.version + latest_subdir = latest_dist.subdir + + if latest_version == current_version: + print(f""Conda package {nextstrain_base.name} {current_version} already at latest version"") + else: + print(colored(""bold"", f""Updating Conda package {nextstrain_base.name} from {current_version} to {latest_version}…"")) + + # Do we need to force a new setup? + if current_subdir != latest_subdir: + print(f""Updating platform from {current_subdir} → {latest_subdir} by setting up from scratch again…"") + return _setup(install_dist = latest_dist, dry_run = False, force = True) + + # Anything to do? + if latest_version == current_version: + return True + + update_spec = f""{latest_dist.name} =={latest_version}"" + + print() + print(f""Updating Conda packages in {PREFIX}…"") + print(f"" - {update_spec} ({latest_dist.subdir})"") + + try: + micromamba(""update"", update_spec, ""--platform"", latest_dist.subdir) + except InternalError as err: + warn(err) + traceback.print_exc() + return False + + # Clean up unnecessary caches + print(""Cleaning up…"") + try: + micromamba(""clean"", ""--all"", add_prefix = False) + except InternalError as err: + warn(err) + warn(f""Continuing anyway."") + + return True + + +def versions() -> Iterable[str]: + try: + yield package_version(NEXTSTRAIN_BASE) + except OSError: + pass + + try: + yield capture_output([str(PREFIX_BIN / ""augur""), ""--version""])[0] + except (OSError, subprocess.CalledProcessError): + pass + + try: + yield ""auspice "" + capture_output([str(PREFIX_BIN / ""auspice""), ""--version""])[0] + except (OSError, subprocess.CalledProcessError): + pass + + +def package_version(spec: str) -> str: + name = package_name(spec) + meta = package_meta(spec) + + if not meta: + return f""{name} unknown"" + + version = meta.get(""version"", ""unknown"") + build = meta.get(""build"", ""unknown"") + channel = meta.get(""channel"", ""unknown"") # full URL; includes subdir + + return f""{name} {version} ({build}, {channel})"" + + +def package_meta(spec: str) -> Optional[dict]: + name = package_name(spec) + metafile = next((PREFIX / ""conda-meta"").glob(f""{name}-*.json""), None) + + if not metafile: + return None + + return json.loads(metafile.read_bytes()) + + +def package_distribution(channel: str, spec: str, subdir: str) -> Optional['PackageDistribution']: + with TemporaryFile() as tmp: + micromamba( + ""repoquery"", ""search"", spec, + + # Channel (repo) to search + ""--override-channels"", + ""--strict-channel-priority"", + ""--channel"", urljoin(CHANNEL_ALIAS, channel), + ""--platform"", subdir, + + # Always check that we have latest package index + ""--repodata-ttl"", 0, + + # Emit JSON so we can process it + ""--json"", + + # Honor same method of CA certificate overriding as requests, + # except without support for cert directories (only files). + *([""--cacert-path"", requests.CA_BUNDLE] + if not Path(requests.CA_BUNDLE).is_dir() else []), + + add_prefix = False, + stdout = tmp) + + tmp.seek(0) + + result = json.load(tmp).get(""result"", {}) + + assert (status := result.get(""status"")) == ""OK"", \ + f""repoquery {status=}, not OK"" + + dists = result.get(""pkgs"", []) + + # Default '0-dev' should be the lowest version according to PEP440.¹ + # + # We're intentionally ignoring build number as we let Micromamba sort out + # the best build variant for a given version of our nextstrain-base + # package. We currently do not produce multiple builds per version, but we + # may in the future. See also the comment at the top of update(). + # + # ¹ + dist = max(dists, default = None, key = lambda d: parse_version_lax(d.get(""version"", ""0-dev""))) + + if not dist: + return None + + return PackageDistribution(dist[""name""], dist[""version""], dist[""subdir""]) + + +class PackageDistribution(NamedTuple): + name: str + version: str + subdir: str + + +def package_name(spec: str) -> str: + return PackageSpec.parse(spec).name + + +class PackageSpec(NamedTuple): + name: str + version_spec: Optional[str] = None + build_id: Optional[str] = None + + @staticmethod + def parse(spec): + """""" + Splits a `Conda package match spec`_ into a tuple of (name, version_spec, build_id). + + Returns a :cls:`PackageSpec`. + + .. _Conda package match spec: https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/pkg-specs.html#package-match-specifications + """""" + parts = spec.split(maxsplit = 2) + + try: + return PackageSpec(parts[0], parts[1], parts[2]) + except IndexError: + try: + return PackageSpec(parts[0], parts[1], None) + except IndexError: + return PackageSpec(parts[0], None, None) + + +def platform_subdir() -> str: + """""" + Conda subdir to use for the :mod:`platform` on which we're running. + + One of ``linux-64``, ``osx-64``, or ``osx-arm64``. + + Raises an :exc:`InternalError` if the platform is currently unsupported. + """""" + system = platform.system() + machine = platform.machine() + + if (system, machine) == (""Linux"", ""x86_64""): + subdir = ""linux-64"" + elif (system, machine) == (""Darwin"", ""x86_64""): + subdir = ""osx-64"" + elif (system, machine) == (""Darwin"", ""arm64""): + subdir = ""osx-arm64"" + else: + raise InternalError(f""Unsupported system/machine: {system}/{machine}"") + + return subdir + + +def alternate_platform_subdirs() -> List[str]: + """""" + Alternative Conda subdirs that this :mod:`platform` can use. + """""" + system = platform.system() + machine = platform.machine() + + if (system, machine) == (""Darwin"", ""arm64""): + if setup_tests_ok(test_rosetta_enabled()): + return [""osx-64""] + + return [] +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/ambient.py",".py","3354","114",""""""" +Run commands in the ambient environment, outside of any container image or managed environment. + +The ""ambient"" runtime allows you to use the Nextstrain CLI with your own ambient +setup, for when you cannot or do not want to have Nextstrain CLI manage its own +runtime. + +.. versionadded:: 1.5.0 +.. versionchanged:: 5.0.0 + Renamed from ""native"" to ""ambient"". + + +.. _ambient-setup: + +Setup +===== + +You will need to make sure all of the Nextstrain software dependencies +are available locally or ""ambiently"" on your computer. + +A common way to do this is by manually using `Conda +`__ to manage your own +environment that includes the required software, however you're responsible for +making sure the correct software is installed and kept up-to-date. Our +:doc:`general Nextstrain installation page ` describes more +comprehensively how to do this. + +It is also possible to install the required Nextstrain software `Augur +`__ and `Auspice +`__ and their dependencies manually, +although this is not recommended. + +Once you've installed dependencies, proceed with ``nextstrain setup ambient``. +"""""" + +import os +import shutil +import sys +from subprocess import CalledProcessError +from typing import Iterable, cast +from .. import config +from ..types import Env, RunnerModule, SetupStatus, SetupTestResults, UpdateStatus +from ..util import capture_output, exec_or_return, runner_name + + +def register_arguments(parser) -> None: + """""" + No-op. No arguments necessary. + """""" + pass + + +def run(opts, argv, working_volume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + if working_volume: + os.chdir(str(working_volume.src)) + + # XXX TODO: In the future we might want to set rlimits based on cpus and + # memory, at least on POSIX systems. + # -trs, 21 May 2020 + + return exec_or_return(argv, extra_env) + + +def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: + """""" + Not supported. + """""" + return None + + +def test_setup() -> SetupTestResults: + def runnable(*argv) -> bool: + try: + capture_output(argv) + return True + except (OSError, CalledProcessError): + return False + + + yield ('snakemake is installed and runnable', + shutil.which(""snakemake"") is not None and runnable(""snakemake"", ""--version"")) + + yield ('augur is installed and runnable', + shutil.which(""augur"") is not None and runnable(""augur"", ""--version"")) + + yield ('auspice is installed and runnable', + shutil.which(""auspice"") is not None and runnable(""auspice"", ""--version"")) + + +def set_default_config() -> None: + """""" + Sets ``core.runner`` to this runner's name (``ambient``). + """""" + config.set(""core"", ""runner"", runner_name(cast(RunnerModule, sys.modules[__name__]))) + + +def update() -> UpdateStatus: + """""" + Not supported. Updating the ambient environment isn't reasonably possible. + """""" + return None + + +def versions() -> Iterable[str]: + try: + yield capture_output([""augur"", ""--version""])[0] + except (OSError, CalledProcessError): + pass + + try: + yield ""auspice "" + capture_output([""auspice"", ""--version""])[0] + except (OSError, CalledProcessError): + pass +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/docker.py",".py","24564","696",""""""" +Run commands inside a container image using Docker. + +`Docker `__ is a very popular container system +freely-available for all platforms. When you use Docker with the Nextstrain +CLI, you don't need to install any other Nextstrain software dependencies as +validated versions are already bundled into a container image +(`nextstrain/base`_) by the Nextstrain team. + + +.. _nextstrain/base: https://github.com/nextstrain/docker-base + + +.. _docker-setup: + +Setup +===== + +.. hint:: + This is a reference page with brief pointers for set up. For a more + comprehensive installation guide, please see `our general Nextstrain + installation page `__. + +On macOS, download and install `Docker Desktop`_, also known previously as +""Docker for Mac"". + +On Linux, install Docker with the standard package manager. For example, on +Ubuntu, you can install Docker with ``sudo apt install docker.io``. + +On Windows, install `Docker Desktop`_ with its support for a WSL2 backend. + +Once you've installed Docker, proceed with ``nextstrain setup docker``. + +This will download compressed image layers totaling about 750 MB in size which +expand to a final on-disk size of about 2 GB. Transient disk usage during this +process peaks at about 3 GB. These numbers are current as of August 2023, as +observed on Linux. Numbers will vary over time, with a tendency to slowly +increase, and vary slightly by OS. + +.. _Docker Desktop: https://www.docker.com/products/docker-desktop + + +.. _docker-config: + +Config file variables +===================== + +Defaults for the corresponding command line options, specified in the +:doc:`config file `. + +.. glossary:: + + :index:`docker.image ` + Default for ``--image`` when using the Docker runtime, e.g. + ``nextstrain/base:build-20230623T174208Z``. + + Typically set initially by ``nextstrain setup`` and subsequently by + ``nextstrain update``. + + +.. _docker-env: + +Environment variables +===================== + +.. warning:: + For development only. You don't need to set these during normal operation. + +Defaults for the corresponding command line options, potentially overriding +defaults set by `config file variables`_. + +.. envvar:: NEXTSTRAIN_DOCKER_IMAGE + + Default for ``--image`` when using the Docker runtime. +"""""" + +import os +import json +import shutil +import subprocess +import sys +from enum import Enum +from pathlib import Path, PurePosixPath +from tempfile import TemporaryDirectory +from textwrap import dedent +from typing import Iterable, List, cast +from .. import config, env, requests +from ..errors import UserError +from ..types import Env, RunnerModule, SetupStatus, SetupTestResults, SetupTestResultStatus, UpdateStatus +from ..util import warn, colored, capture_output, exec_or_return, runner_name, split_image_name, test_rosetta_enabled +from ..volume import NamedVolume +from ..__version__ import __version__ + + +# The default intentionally omits an explicit ""latest"" tag so that on the first +# `nextstrain update` it gets pinned in the config file to the most recent +# ""build-*"" tag. Users can set an explicit ""latest"" tag in config to always +# use the most recent image and not pin to ""build-*"" tags. +DEFAULT_IMAGE = os.environ.get(""NEXTSTRAIN_DOCKER_IMAGE"") \ + or config.get(""docker"", ""image"") \ + or ""nextstrain/base"" + +COMPONENTS = [""augur"", ""auspice"", ""fauna""] + + +class IMAGE_FEATURE(Enum): + # Auspice ≥1.35.2 necessitated tightly-coupled changes to the image (first + # present in this tag) and `nextstrain view` (see commit 2754026, first + # present in the 1.8.0 release). + compatible_auspice = ""build-20190119T045444Z"" + + # /nextstrain/env.d support first present. + envd = ""build-20230613T204512Z"" + + # AWS Batch: support for volume overlays (i.e. ../ in archive members and + # file overwriting) in ZIP extraction. + aws_batch_overlays = ""build-20250321T184358Z"" + + +def register_arguments(parser) -> None: + # Docker development options + development = parser.add_argument_group( + ""development options for --docker"") + + development.set_defaults(docker_args = []) + development.add_argument( + ""--docker-arg"", + help = ""Additional arguments to pass to `docker run`"", + metavar = ""..."", + dest = ""docker_args"", + action = ""append"") + + +def run(opts, argv, working_volume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + assert_volumes_exist(opts.volumes) + + # Check if all our stdio fds (stdin = 0, stdout = 1, stderr = 2) are TTYs. + # This uses fds explicitly as that's what we (and `docker run`) ultimately + # care about; not whatever the Python sys.stdin/stdout/stderr filehandles + # point to. (They're probably unchanged, but ya never know.) + stdio_isatty = all(os.isatty(fd) for fd in [0, 1, 2]) + + # If the image supports /nextstrain/env.d, then pass any env vars using it + # so values aren't visible in the container's config (e.g. visible via + # `docker inspect`). + if extra_env and image_supports(IMAGE_FEATURE.envd, opts.image): + # Most of the time this TemporaryDirectory's destructor won't run + # because we exec into another program. That's desireable since + # ultimately the container, shortly after startup, needs to read the + # files in envd. The container is configured to delete them when its + # done, thus leaving an empty directory. We rely on the OS to + # periodically clean out TMP (e.g. at boot) to remove the empty + # directories. However, if the exec fails, then the destructor *will* + # run, and we'll clean up the whole thing. + envd = TemporaryDirectory(prefix = ""nextstrain-"", suffix = ""-env.d"") + opts.volumes.append(NamedVolume(""env.d"", Path(envd.name))) + + # Write out all env to the dir… + env.to_dir(Path(envd.name), extra_env) + + # …then clear it from what we pass via the container config and replace + # it with a flag to delete the contents of the env.d after use. + extra_env = {""NEXTSTRAIN_DELETE_ENVD"": ""1""} + + return exec_or_return([ + ""docker"", ""run"", + ""--rm"", # Remove the ephemeral container after exiting + ""--interactive"", # Pass through control signals (^C, etc.) + + # Colors, etc. As documented in `man docker-run`: + # + # The -t option is incompatible with a redirection of the docker + # client standard input. + # + # so only set it when (at least) our stdin is a TTY. + # + # Additionally, we go a step further and condition on _all_ our stdio + # being a TTY. Reason being is that under --tty Docker/containerd/runc + # will read from the container's TTY and send it to `docker run`'s + # stdout, thus combining the container's stdout + stderr into ""our"" + # stdout. If someone is redirecting our stdout and/or stderr (i.e. + # it's not a TTY), then they necessarily want separate streams and + # using --tty will foil that. More details on this complex issue are + # in . + *([""--tty""] + if stdio_isatty else []), + + # On Unix (POSIX) systems, run the process in the container with the same + # UID/GID so that file ownership is correct in the bind mount directories. + # The getuid()/getgid() functions are documented to be only available on + # Unix systems, not, for example, Windows. + *([""--user=%d:%d"" % (os.getuid(), os.getgid())] if os.name == ""posix"" else []), + + # Map directories to bind mount into the container. + *[""--volume=%s:%s:%s"" % (v.src.resolve(strict = True), mount_point(v), ""rw"" if v.writable else ""ro"") + for v in opts.volumes + if v.src is not None], + + # Change the default working directory if requested + *([""--workdir=%s"" % mount_point(working_volume)] if working_volume else []), + + # Pass thru any extra environment variables provided by us (not via an env.d) + *[""--env=%s"" % name for name, value in extra_env.items() if value is not None], + + # Set resource limits if any + *([""--cpus=%d"" % cpus] + if cpus is not None else []), + + *([""--memory=%db"" % memory] + if memory is not None else []), + + *opts.docker_args, + opts.image, + *argv, + ], extra_env) + + +def assert_volumes_exist(volumes: Iterable[NamedVolume]): + # Ensure all volume source paths exist. Docker will auto-create missing + # directories in the path, which, while desirable under some circumstances, + # doesn't match up well with our use case. We're aiming to not surprise or + # confuse the user. + # + missing_volumes = [ + vol for vol in volumes + if (vol.dir and not vol.src.is_dir()) + or not vol.src.exists() ] + + if missing_volumes: + raise UserError("""""" + Error: The path(s) given for the following components do not exist + or are not directories: + + {missing} + """""", missing = ""\n"".join(f"" • {vol.name}: {vol.src}"" for vol in missing_volumes)) + + +def mount_point(volume: NamedVolume) -> PurePosixPath: + """""" + Determine the mount point of *volume* in the container. + """""" + if volume.name == ""bashrc"": + return PurePosixPath(""/etc/bash.bashrc"") + + return PurePosixPath(""/nextstrain"", volume.name) + + +def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: + if not setup_image(dry_run, force): + return False + + return True + + +def setup_image(dry_run: bool = False, force: bool = False) -> bool: + """""" + Download the image if it's not already available locally. + + Though not strictly required, by doing this during setup we avoid the + initial download on first use instead. + """""" + image = DEFAULT_IMAGE + + if not force and image_exists(image): + print(f""Using existing local copy of Docker image {image}."") + print(f"" Hint: if you want to ignore this existing local copy, re-run `nextstrain setup` with --force."") + return True + + update_ok = _update(dry_run) + + if not update_ok: + return False + + return True + + +def test_setup() -> SetupTestResults: + def test_run(): + try: + status = subprocess.run( + [""docker"", ""run"", ""--rm"", ""hello-world""], + check = True, + stdout = subprocess.DEVNULL) + except: + return False + else: + return status.returncode == 0 + + def test_memory_limit(): + GiB = 1024**3 + desired = 2 * GiB + + msg = 'containers have access to >%.0f GiB of memory' % (desired / GiB) + status: SetupTestResultStatus = ... + + if image_exists(): + def int_or_none(x): + try: + return int(float(x)) + except ValueError: + return None + + report_memory = """""" + awk '/^MemTotal:/ { print $2 * 1024 }' /proc/meminfo + (cat /sys/fs/cgroup/memory.max || cat /sys/fs/cgroup/memory/memory.limit_in_bytes) 2>/dev/null + """""" + + try: + limits = list(filter(None, map(int_or_none, run_bash(report_memory)))) + except (OSError, subprocess.CalledProcessError): + pass + else: + if limits: + limit = min(limits) + + if limit <= desired: + msg += dedent("""""" + + Containers appear to be limited to %0.1f GiB of memory. This + may not be enough for some Nextstrain builds. On Windows or + a Mac, you can increase the memory available to containers + in the Docker preferences.\ + """""" % (limit / GiB)) + status = None + else: + msg += "" (limit is %.1f GiB)"" % (limit / GiB) + status = True + + yield (msg, status) + + def test_image_version(): + minimum_tag = IMAGE_FEATURE.compatible_auspice.value + + msg = 'image is new enough for this CLI version' + status: SetupTestResultStatus = ... + + repository, tag = split_image_name(DEFAULT_IMAGE) + + # If we're using a build tag, regardless of if the image exists + # locally or not yet, we can say for sure if we're all good or not. + if is_build_tag(tag): + status = tag >= minimum_tag + + if not status: + msg += dedent("""""" + + Your copy of the Nextstrain Docker image, %s, + is too old for this version of the CLI (%s). At least + version %s of the image is required. + + Please run `nextstrain update docker` to download a newer + image. Afterwards, run `nextstrain check-setup docker` + again and this version check shoud pass. + """""" % (tag, __version__, minimum_tag)) + + # If we're using the ""latest"" tag and the image doesn't yet exist + # locally, then the most recent image will be pulled down the first + # time its needed. Presumably this will be new enough for the CLI. + elif tag == ""latest"" and not image_exists(DEFAULT_IMAGE): + status = True + + yield (msg, status) + + yield ('docker is installed', + shutil.which(""docker"") is not None) + + yield ('docker run works', + test_run()) + + yield from test_memory_limit() + + yield from test_image_version() + + # Rosetta 2 is optional, so convert False (fail) → None (warning) + yield from ((msg, None if status is False else status) + for msg, status + in test_rosetta_enabled(""Rosetta 2 is enabled for faster execution (optional)"")) + + +def set_default_config() -> None: + """""" + Sets ``core.runner`` to this runner's name (``docker``). + + Sets ``docker.image``, if it isn't already set, to the latest ``build-*`` + image. + """""" + config.set(""core"", ""runner"", runner_name(cast(RunnerModule, sys.modules[__name__]))) + config.setdefault(""docker"", ""image"", latest_build_image(DEFAULT_IMAGE)) + + +def update() -> UpdateStatus: + """""" + Pull down the latest Docker image build and prune old image versions. + """""" + return _update() + + +def _update(dry_run: bool = False) -> UpdateStatus: + current_image = DEFAULT_IMAGE + latest_image = latest_build_image(current_image) + + if latest_image == current_image: + print(colored(""bold"", ""Updating Docker image %s…"" % current_image)) + else: + print(colored(""bold"", ""Updating Docker image from %s to %s…"" % (current_image, latest_image))) + print() + + # Pull the latest image down + if not dry_run: + try: + subprocess.run( + [""docker"", ""image"", ""pull"", latest_image], + check = True) + except (OSError, subprocess.CalledProcessError): + return False + + # Update the config file to point to the new image so we use it by default + # going forward. + config.set(""docker"", ""image"", latest_image) + + # Prune any old images which are now dangling to avoid leaving lots of + # hidden disk use around. We don't use `docker image prune` because we + # want to just remove _our_ dangling images, not all. We very much don't + # want to automatically prune unrelated images. + print() + print(colored(""bold"", ""Pruning old images…"")) + print() + + if not dry_run: + try: + images = dangling_images(latest_image) \ + + old_build_images(latest_image) + + if images: + subprocess.run( + [""docker"", ""image"", ""rm"", *images], + check = True) + except (OSError, subprocess.CalledProcessError) as error: + warn() + warn(""Update succeeded, but an error occurred pruning old image versions:"") + warn("" "", error) + warn() + warn(""This can occur, for example, if you have a `nextstrain build`,"") + warn(""`nextstrain view`, or `nextstrain shell` command still running."") + warn() + warn(""Not to worry, we'll try again the next time you run `nextstrain update`."") + warn() + + return True + + +def image_supports(feature: IMAGE_FEATURE, image: str = DEFAULT_IMAGE) -> bool: + """""" + Test if the given *image* supports a *feature*, i.e. by tag comparison + against the feature's first release. + + If *image* is tagged ``latest``, either explicitly or implicity, it is + assumed to have support for all features. + """""" + repository, tag = split_image_name(image) + + return tag == ""latest"" \ + or (is_build_tag(tag) and tag >= feature.value) + + +def is_build_tag(tag: str) -> bool: + """""" + Test if the given *tag* looks like one of our build tags. + """""" + return tag.startswith(""build-"") + + +def latest_build_image(image_name: str) -> str: + """""" + Query the Docker registry for the latest image tagged ""build-*"" in the + given *image_name*'s repository. + + Our ""latest"" tag always has a ""build-*"" counterpart. Using a ""build-*"" tag + is better than using the ""latest"" tag since the former is more descriptive + and points to a static snapshot instead of a mutable snapshot. + + If the given *image_name* has a tag but it isn't a ""build-*"" tag, then the + given *image_name* is returned as-is under the presumption that it points + to some other mutable snapshot that should be pulled in-place to update. + This means, for example, that users can opt into tracking the ""latest"" tag + by explicitly configuring it as the image to use (versus omitting the + ""latest"" tag). + + Examples + -------- + + When a newer ""build-*"" tag exists, it's returned. + + >>> old = ""nextstrain/base:build-20220215T000459Z"" + >>> new = latest_build_image(old) + >>> _, old_tag = split_image_name(old) + >>> _, new_tag = split_image_name(new) + >>> old_tag + 'build-...' + >>> new_tag + 'build-...' + >>> new_tag > old_tag + True + + When a non-build tag is present, it's simply passed through. + + >>> latest_build_image(""nextstrain/base:latest"") + 'nextstrain/base:latest' + + >>> latest_build_image(""nextstrain/base:example"") + 'nextstrain/base:example' + + When no tag is present (i.e. implicitly ""latest""), a ""build-*"" tag is + returned. + + >>> latest_build_image(""nextstrain/base"") + 'nextstrain/base:build-...' + """""" + def GET(url, **kwargs): + response = requests.get(url, **kwargs) + response.raise_for_status() + return response + + def auth_token(repository: str) -> str: + url, params = ""https://auth.docker.io/token"", { + ""scope"": ""repository:%s:pull"" % repository, + ""service"": ""registry.docker.io"", + } + return GET(url, params = params).json().get(""token"") + + def tags(respository: str) -> List[str]: + url, headers = ""https://registry.hub.docker.com/v2/%s/tags/list"" % repository, { + ""Accept"": ""application/vnd.docker.distribution.manifest.v2+json"", + ""Authorization"": ""Bearer %s"" % auth_token(repository), + } + return GET(url, headers = headers).json().get(""tags"", []) + + repository, tag = split_image_name(image_name, implicit_latest = False) + + if not tag or is_build_tag(tag): + build_tags = sorted(filter(is_build_tag, tags(repository))) + + if build_tags: + return repository + "":"" + build_tags[-1] + + return image_name + + +def old_build_images(name: str) -> List[str]: + """""" + Return a list of local Docker image IDs which are tagged with ""build-*"" and + older than the given image *name*. + + If *name* isn't tagged ""build-*"", nothing is returned out of an abundance + of caution. Our ""build-*"" timestamps use an ISO-8601 timestamp, so oldness + is determined by sorting lexically. + """""" + repository, tag = split_image_name(name) + + if not is_build_tag(tag): + return [] + + # List all local images from the respository, e.g. nextstrain/base. + build_images = map(json.loads, capture_output([ + ""docker"", ""image"", ""ls"", + ""--no-trunc"", + ""--format={{json .}}"", + repository + ])) + + # Return the fully-qualified names of images with build tags that come + # before our current build tag, as well as the image with the ""latest"" tag. + # The latter is useful to include because it will likely be out of date + # when the current tag is a build tag (guaranteed above). + # + # Names are used instead of IDs because they won't cause conflicts when an + # image ID is tagged multiple times: rm-ing the first name will remove only + # that tag, rm-ing the final name will remove the actual image layers. + return [ + image[""Repository""] + "":"" + image[""Tag""] + for image in build_images + if (is_build_tag(image[""Tag""]) and image[""Tag""] < tag) + or image[""Tag""] == ""latest"" + ] + + +def dangling_images(name: str) -> List[str]: + """""" + Return a list of local Docker image IDs which are untagged (""dangling"") and + thus likely no longer in use. + + Since dangling images are untagged, this finds images by name using our + custom org.nextstrain.image.name label. + """""" + name_sans_tag = name.split("":"")[0] + + return capture_output([ + ""docker"", ""image"", ""ls"", + ""--no-trunc"", + ""--format={{.ID}}"", + ""--filter=dangling=true"", + ""--filter=label=org.nextstrain.image.name=%s"" % name_sans_tag + ]) + + +def versions() -> Iterable[str]: + try: + yield image_version() + except (OSError, subprocess.CalledProcessError): + pass + + try: + if image_exists(): + yield from component_versions() + except (OSError, subprocess.CalledProcessError): + pass + + +def image_version() -> str: + """""" + Print the Docker image name and version. + """""" + + # Qualify the name with the ""latest"" tag if necessary so we only get a + # single id back. + qualified_image = DEFAULT_IMAGE + + if "":"" not in DEFAULT_IMAGE: + qualified_image += "":latest"" + + image_ids = capture_output([ + ""docker"", ""image"", ""ls"", + ""--format=({{.ID}}, {{.CreatedAt}})"", qualified_image]) + + assert len(image_ids) <= 1 + + # Print the default image name as-is, without the implicit :latest + # qualification (if any). The :latest tag is often confusing, as it + # doesn't mean you have the latest version. Thus we avoid it. + # + # This function (via the version command), may be run before the image is + # downloaded, so we handle finding no image ids. + return ""%s %s"" % (DEFAULT_IMAGE, image_ids[0] if image_ids else ""not present"") + + +def component_versions() -> Iterable[str]: + """""" + Print the git ids of the Nextstrain components in the image. + """""" + yield from run_bash(report_component_versions()) + + +def report_component_versions() -> str: + # It is much faster to spin up a single ephemeral container and read all + # the versions with a little bash than to do it one-by-one. It also lets + # us more easily do fine-grained reporting of presence/absence. + return """""" + for component in %s; do + if [[ -e /nextstrain/$component/.GIT_ID ]]; then + echo $component $( List[str]: + """""" + Run a Bash *script* inside of the container *image*. + + Returns the output of the script as a list of strings. + """""" + return capture_output([ + ""docker"", ""run"", ""--rm"", image, + ""bash"", ""-c"", script + ]) + + +def image_exists(image: str = DEFAULT_IMAGE) -> bool: + """""" + Check if a Docker *image* exists locally, returning True or False. + """""" + try: + subprocess.run( + [""docker"", ""image"", ""inspect"", image], + check = True, + stdout = subprocess.DEVNULL, + stderr = subprocess.DEVNULL) + except: + return False + else: + return True +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/aws_batch/s3.py",".py","11530","319",""""""" +S3 handling for AWS Batch jobs. +"""""" + +import binascii +import fsspec +import os.path +from calendar import timegm +from os import utime +from pathlib import Path, PurePath +from time import struct_time +from typing import Callable, Generator, Iterable, List, Optional, Any, Union +from urllib.parse import urlparse +from zipfile import ZipFile, ZipInfo +from ... import env +from ...aws.s3 import S3BucketWithPrefix, split_url +from ...debug import DEBUGGING +from ...types import Env, S3Object +from ...url import URL +from ...util import glob_matcher +from ...volume import NamedVolume + + +PathMatcher = Callable[[Union[Path, PurePath]], bool] + + +def object_url(object: S3Object) -> str: + return ""s3://{object.bucket_name}/{object.key}"".format_map(locals()) + + +def object_from_url(s3url: str) -> S3Object: + url = urlparse(s3url) + key = url.path.lstrip(""/"") + + assert url.scheme == ""s3"", \ + ""Object URL %s has scheme %s://, not s3://"" % (s3url, url.scheme) + assert url.netloc, ""Object URL %s is missing a bucket name"" % s3url + assert key, ""Object URL %s is missing an object path/key"" % s3url + + return bucket(url.netloc).Object(key) + + +def upload_workdir(workdir: Path, bucket: S3BucketWithPrefix, run_id: str, patterns: List[str] = None, volumes: List[NamedVolume] = []) -> S3Object: + """""" + Upload a ZIP archive of the local *workdir* (and optional *volumes*) to the + remote S3 *bucket* for the given *run_id*. + + An optional list of *patterns* (shell-style advanced globs) can be passed + to selectively exclude part of the local *workdir* from being uploaded. + + Returns the S3.Object instance of the uploaded archive. + """""" + + remote_workdir = bucket.Object(run_id + "".zip"") + + always_excluded = path_matcher([ + # Jobs don't use .git, so save the bandwidth/space/time. It may also + # contain information in history that shouldn't be uploaded. + "".git/"", + + # Don't let the local Snakemake's state interfere with the remote job or + # vice versa. + "".snakemake/"", + + # Sensitive data is often stored in environment.sh files + ""environment*"", + + # Ignore Python bytecode + ""*.pyc"", + ""__pycache__/"", + ]) + + if patterns: + deselected = glob_matcher(patterns, root = workdir) + else: + deselected = lambda path: False + + excluded = lambda path: always_excluded(path) or deselected(path) + + # Stream writes directly to the remote ZIP file + remote_file: Any + with fsspec.open(object_url(remote_workdir), ""wb"", auto_mkdir = False) as remote_file: + with ZipFile(remote_file, ""w"") as zipfile: + for path in walk(workdir, excluded): + dst = path.relative_to(workdir) + print(f""zipping: {path}"" + (f"" (as {dst})"" if DEBUGGING else """")) + zipfile.write(str(path), dst) + + for volume in volumes: + # XXX TODO: Use the ""walk_up"" argument to Path.relative_to() + # once we require Python 3.12. + # -trs, 10 Feb 2025 + try: + prefix = PurePath(volume.name).relative_to(""build"") + except ValueError: + prefix = PurePath("".."", volume.name) + + for path in walk(volume.src, always_excluded): + dst = prefix / path.relative_to(volume.src) + print(f""zipping: {path}"" + (f"" (as {dst})"" if DEBUGGING else """")) + zipfile.write(str(path), dst) + + return remote_workdir + + +def download_workdir(remote_workdir: S3Object, workdir: Path, patterns: List[str] = None) -> None: + """""" + Download the *remote_workdir* archive into the local *workdir*. + + The remote workdir's files **overwrite** local files! + + An optional list of *patterns* (shell-style advanced globs) can be passed + to selectively download only part of the remote workdir. + """""" + + # XXX TODO: Consider extending excluded patterns with the globs from any + # --exclude-from-upload options given, so that files excluded from upload + # are by default also excluded from download. That behaviour would seems + # sometimes useful but other times confusing. See also my discussion with + # Trevor and James about this.¹ + # -trs, 23 May 2024 + # + # ¹ + + excluded = path_matcher([ + # Jobs don't use .git and it may also contain information that + # shouldn't be uploaded. + "".git/"", + + # We don't want the remote Snakemake state to interfere locally… + "".snakemake/"", + + # Ignore Python bytecode + ""*.pyc"", + ""__pycache__/"", + ]) + + included = path_matcher([ + # But we do want the Snakemake logs to come over… + "".snakemake/log/"", + + # …and the input/output metadata Snakemake tracks (akin to mtimes, + # which we also preserve)… + "".snakemake/metadata/"", + + # …and the remote files downloaded via Snakemake's storage support. + # Note this is the default path used by Snakemake, but the storage path + # is configurable via `--local-storage-prefix`.¹ So if someone configures + # the storage path to a custom path within `.snakemake`, e.g. `.snakemake/foo`, + # then it would not be available in their downloaded workdir. + # I'm not even sure it's possible to configure the path in entrypoint-aws-batch + # for the docker-base image, so I've added a warning against using the + # Snakemake option when using aws-batch runtimes. + # -Jover, 18 July 2025 + # + # ¹ + "".snakemake/storage/"", + ]) + + if patterns: + selected = glob_matcher(patterns) + else: + selected = lambda path: True + + # Open a seekable handle to the remote ZIP file… + remote_file: Any + with fsspec.open(object_url(remote_workdir)) as remote_file: + + # …and extract its contents to the workdir. + with ZipFile(remote_file) as zipfile: + # Completely ignore archive members with unsafe paths (absolute or + # upwards-traversing) instead of relying on zipfile.extract()'s + # default of munging them to be ""safe"". Munging seems more + # confusing than skipping, and skipping is essential in the case of + # additional volumes being uploaded in the workdir initially. + safe_members = [ + (filename, member) + for filename, member + in ((PurePath(m.filename), m) for m in zipfile.infolist()) + if not filename.is_absolute() + and os.path.pardir not in filename.parts ] + + for path, member in safe_members: + # Inclusions negate exclusions but aren't an exhaustive + # list of what is included. + if selected(path) and (included(path) or not excluded(path)): + + # Only extract files which are different, replacing the + # local file with the zipped file. Note that this means + # that empty directories present in the archive but not + # locally are never created. + if member.CRC != crc32(workdir / path): + print(""unzipping:"", workdir / path) + + extracted = zipfile.extract(member, str(workdir)) + + # Update atime and mtime from the zip member; it's a + # bit boggling that .extract() doesn't handle this, + # even optionally. + mtime = zipinfo_mtime(member) + utime(extracted, (mtime, mtime)) + + # XXX TODO: Preserve/restore Unix mode (e.g. executable + # bit). Currently not handled by this routine, though + # we could if need be; see nextstrain/cli/pathogens.py + # for an example. It doesn't seem necessary for + # pathogen builds, however, as 1) we've gone this long + # without it and 2) pathogen workflows aren't producing + # executables as their primary output. + # -trs, 10 Feb 2025 + + +def walk(path: Path, excluded: PathMatcher = lambda x: False) -> Generator[Path, None, None]: + """""" + Iterate over a directory tree (depth-first) starting from *path*, excluding + any paths matched by *excluded*. + """""" + if not excluded(path): + yield path + + if path.is_dir(): + for child in path.iterdir(): + yield from walk(child, excluded) + + +def path_matcher(patterns: Iterable[str]) -> PathMatcher: + """""" + Generate a function which matches a Path object against the list of glob + *patterns*. + """""" + def matches(path: Union[Path, PurePath]) -> bool: + return any(map(path.match, patterns)) + + return matches + + +def crc32(path) -> Optional[int]: + """""" + Compute the CRC-32 checksum of the given *path*, consistent with + checksums stored in a ZIP file. + + Returns None if *path* does not exist. + """""" + if path.exists(): + crc = 0 + + # Directories always return 0, matching the behaviour of the CRC + # attribute of ZipInfo members. + if not path.is_dir(): + with path.open(""rb"") as data: + for chunk in iter(lambda: data.read(1024), b""""): + crc = binascii.crc32(chunk, crc) + + return crc + else: + return None + + +def zipinfo_mtime(member: ZipInfo) -> float: + """""" + Return the mtime, in seconds since the Unix epoch, of the given + :class:`zipfile.ZipInfo` *member*. + + Assumes the zip file was created using GMT/UTC! + """""" + # The argument to struct_time() is a 9-tuple, the first 6 values of which + # we can get from the zip member. The rest, filled with bogus -1 + # placeholders, are tm_wday (day of week), tm_yday (day of year), and + # tm_isdst (DST flag). + return timegm(struct_time((*member.date_time, -1, -1, -1))) + + +def upload_envd(extra_env: Env, bucket: S3BucketWithPrefix, run_id: str) -> S3Object: + """""" + Upload a ZIP archive of *extra_env* as an envdir to the remote S3 *bucket* + for the given *run_id*. + + Returns the S3.Object instance of the uploaded archive. + """""" + + remote_zip = bucket.Object(run_id + ""-env.d.zip"") + + remote_file: Any + with fsspec.open(object_url(remote_zip), ""wb"", auto_mkdir = False) as remote_file: + with ZipFile(remote_file, ""w"") as zipfile: + for name, contents in env.to_dir_items(extra_env): + zipfile.writestr(name, contents) + + return remote_zip + + +def bucket(name: str) -> S3BucketWithPrefix: + """""" + Load an **existing** bucket from S3 by *name*. + + *name* may include an optional fixed prefix for object keys delimited from + the bucket name by a slash (``/``). The prefix will be preprended to the + key of any objects returned by the :meth:`.Object` method of the returned + bucket object. + """""" + url = URL(name) + + if not url.scheme: + url = URL(""s3://"" + name) + + return split_url(url) + + +def bucket_exists(name: str) -> bool: + """""" + Test if an S3 bucket exists. + """""" + try: + bucket(name) + except: + return False + else: + return True +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/aws_batch/__init__.py",".py","20795","605",""""""" +Run commands remotely on AWS Batch inside the Nextstrain container image. + +`AWS Batch `__ is an advanced computing +platform which allows you to launch and monitor Nextstrain builds in the +cloud from the comfort of your own computer. The same image used by the local +Docker runtime is used by AWS Batch, making your builds more reproducible, and +builds have access to computers with very large CPU and memory allocations if +necessary. + +.. versionadded:: 1.7.0 + + +.. _aws-batch-setup: + +Setup +===== + +The initial setup is quite a bit more involved than most runtimes, but +:doc:`detailed instructions ` are available. + +Once you've set up AWS, proceed with ``nextstrain setup aws-batch``. + + +.. _aws-batch-config: + +Config file variables +===================== + +Defaults for the corresponding command line options, specified in the +:doc:`config file `. + +.. glossary:: + + :index:`aws-batch.job ` + Default for ``--aws-batch-job``. + + :index:`aws-batch.queue ` + Default for ``--aws-batch-queue``. + + :index:`aws-batch.s3-bucket ` + Default for ``--aws-batch-bucket``. + + :index:`aws-batch.cpus ` + Default for ``--aws-batch-cpus``. + + :index:`aws-batch.memory ` + Default for ``--aws-batch-memory``. + + +.. _aws-batch-env: + +Environment variables +===================== + +Defaults for the corresponding command line options, potentially overriding +defaults set by `config file variables`_. + +.. envvar:: NEXTSTRAIN_AWS_BATCH_JOB + + Default for ``--aws-batch-job``. + +.. envvar:: NEXTSTRAIN_AWS_BATCH_QUEUE + + Default for ``--aws-batch-queue``. + +.. envvar:: NEXTSTRAIN_AWS_BATCH_S3_BUCKET + + Default for ``--aws-batch-bucket``. + +.. envvar:: NEXTSTRAIN_AWS_BATCH_CPUS + + Default for ``--aws-batch-cpus``. + +.. envvar:: NEXTSTRAIN_AWS_BATCH_MEMORY + + Default for ``--aws-batch-memory``. +"""""" + +import botocore.exceptions +import os +import shlex +import sys +from datetime import datetime +from pathlib import Path +from signal import signal, Signals, SIGINT +from sys import exit, stdin +from textwrap import dedent +from time import sleep, time +from typing import Iterable, Optional, cast +from uuid import uuid4 +from ...types import Env, RunnerModule, SetupStatus, SetupTestResults, UpdateStatus +from ...util import colored, prose_list, runner_name, warn +from ... import config +from .. import docker +from . import jobs, s3 + + +DEFAULT_JOB = os.environ.get(""NEXTSTRAIN_AWS_BATCH_JOB"") \ + or config.get(""aws-batch"", ""job"") \ + or ""nextstrain-job"" + +DEFAULT_QUEUE = os.environ.get(""NEXTSTRAIN_AWS_BATCH_QUEUE"") \ + or config.get(""aws-batch"", ""queue"") \ + or ""nextstrain-job-queue"" + +DEFAULT_S3_BUCKET = os.environ.get(""NEXTSTRAIN_AWS_BATCH_S3_BUCKET"") \ + or config.get(""aws-batch"", ""s3-bucket"") \ + or ""nextstrain-jobs"" + +# defaults to None if enviroment or config is not set +DEFAULT_CPUS = os.environ.get(""NEXTSTRAIN_AWS_BATCH_CPUS"") \ + or config.get(""aws-batch"", ""cpus"") + +# defaults to None if enviroment or config is not set +DEFAULT_MEMORY = os.environ.get(""NEXTSTRAIN_AWS_BATCH_MEMORY"") \ + or config.get(""aws-batch"", ""memory"") + + +CTRL_C_CONFIRMATION_TIMEOUT = 10 # seconds + + +def register_arguments(parser) -> None: + # AWS Batch development options + development = parser.add_argument_group( + ""development options for --aws-batch"", + ""See \nfor more information."") + + development.add_argument( + ""--aws-batch-job"", + dest = ""job_definition"", + help = ""Name of the AWS Batch job definition to use"", + metavar = """", + default = DEFAULT_JOB) + + development.add_argument( + ""--aws-batch-queue"", + dest = ""job_queue"", + help = ""Name of the AWS Batch job queue to use"", + metavar = """", + default = DEFAULT_QUEUE) + + development.add_argument( + ""--aws-batch-s3-bucket"", + dest = ""s3_bucket"", + help = ""Name (or URL) of the AWS S3 bucket to use as shared storage, with optional prefix for keys"", + metavar = ""[s3://][/]"", + default = DEFAULT_S3_BUCKET) + + development.add_argument( + ""--aws-batch-cpus"", + dest = ""aws_batch_cpus"", + help = ""Number of vCPUs to request for job"", + metavar = """", + type = int, + default = DEFAULT_CPUS) + + development.add_argument( + ""--aws-batch-memory"", + dest = ""aws_batch_memory"", + help = ""Amount of memory in MiB to request for job"", + metavar = """", + type = int, + default = DEFAULT_MEMORY) + + +def run(opts, argv, working_volume = None, extra_env: Env = {}, cpus: int = None, memory: int = None) -> int: + docker.assert_volumes_exist(opts.volumes) + + # ""build"" is a special-cased volume for AWS Batch, as /nextstrain/build is + # the fixed initial working directory and what we'll populate by extracting + # a ZIP file. + build_volume = next((v for v in opts.volumes if v and v.name == ""build""), None) + + opts.volumes = [v for v in opts.volumes if v is not build_volume] + + # Unlike other runners, the AWS Batch runner currently *requires* a working + # dir in most usages. This is ok as we only provide the AWS Batch runner + # for commands which also require a working dir (e.g. build), whereas other + # runners also work with commands that don't. + # -trs, 28 Feb 2022 (updated 24 August 2023) + assert (working_volume is not None and build_volume is not None) or (opts.attach and (not opts.download or opts.cancel)) + + # Note that ""workdir"" here always refers to our image's default WORKDIR, + # /nextstrain/build, since AWS Batch provides no way to override the + # initial working directory of a container, i.e. an equivalent to the + # --workdir option of `docker run`. Instead, to change the initial working + # directory, we arrange to exec-chain thru `env --chdir`. + # -trs, 29 Jan 2024 + local_workdir = build_volume.src.resolve(strict = True) if build_volume else None + + if opts.attach: + print_stage(""Attaching to Nextstrain AWS Batch Job ID:"", opts.attach) + job = jobs.lookup(opts.attach) + + # Read remote workdir from the job description + remote_workdir = job.workdir + + if not remote_workdir: + warn(dedent("""""" + Error determining remote workdir of job. + + This is probably a bug. Please open an issue on GitHub + or send an + email to for help. + """""")) + return 1 + + print_stage(""Job is %s"" % job.status) + else: + assert local_workdir is not None + assert working_volume is not None + + # Generate our own unique run id since we can't know the AWS Batch job id + # until we submit it. This run id is used for workdir and run results + # storage on S3, in a bucket accessible to both Batch jobs and CLI users. + run_id = generate_run_id() + + print_stage(""Nextstrain Run ID:"", run_id) + + # Upload workdir to S3 so it can be fetched at the start of the Batch job. + print_stage(""Uploading %s to S3"" % local_workdir) + + for volume in opts.volumes: + print("" and %s as %s"" % (volume.src.resolve(strict = True), volume.name)) + + bucket = s3.bucket(opts.s3_bucket) + remote_workdir = s3.upload_workdir(local_workdir, bucket, run_id, opts.exclude_from_upload, opts.volumes) + + print(""uploaded:"", s3.object_url(remote_workdir)) + + # If the image supports /nextstrain/env.d, then pass any env vars using + # it so values aren't visible in the job's config (i.e. visible via + # `aws batch describe-jobs` and the web console). + if extra_env and docker.image_supports(docker.IMAGE_FEATURE.envd, opts.image): + # Write out all env directly to a ZIP archive on S3… + envd = s3.upload_envd(extra_env, bucket, run_id) + + print(""uploaded:"", s3.object_url(envd)) + + # …then clear the env we pass via the job config and replace it + # with the URL of the ZIP archive and a flag to delete the + # /nextstrain/env.d contents and ZIP archive after use. + extra_env = { + ""NEXTSTRAIN_ENVD_URL"": s3.object_url(envd), + ""NEXTSTRAIN_DELETE_ENVD"": ""1"" } + + # Submit job. + print_stage(""Submitting job"") + + # Our own --aws-batch-cpus and --aws-batch-memory options take + # precedence over whatever was passed from the command (e.g. the build + # command's --cpus and --memory options). + if opts.aws_batch_cpus: + cpus = opts.aws_batch_cpus + + if opts.aws_batch_memory: + memory = opts.aws_batch_memory + elif memory: + # Memory from our caller is in bytes, but AWS expects MiB. + memory //= 1024**2 + + # Change working directory in the container before running our command. + # Note that this happens _after_ the build context we uploaded + # (remote_workdir) is downloaded and extracted to the default working + # directory (/nextstrain/build). + exec = [ + ""env"", ""--chdir"", str(docker.mount_point(working_volume)), ""--"", + *argv ] + + try: + job = jobs.submit( + name = run_id, + image = opts.image, + queue = opts.job_queue, + definition = opts.job_definition, + cpus = cpus, + memory = memory, + workdir = remote_workdir, + exec = exec, + env = { k: v for k, v in extra_env.items() if v is not None }) + except Exception as error: + warn(error) + warn(""Job submission failed!"") + return 1 + + print_stage(""AWS Batch Job ID:"", job.id) + + # Optionally detach and return early. + if opts.detach: + return detach(job, local_workdir) + + + if opts.cancel: + interrupt(job, confirm = False) + + + # Don't setup signal handlers for jobs that are already complete or we're + # stopping (cancelling). + if not job.is_complete and not job.stop_sent: + # Set up signal handler for SIGTSTP (""stop typed at terminal"", e.g. + # Ctrl-Z) and SIGHUP (""hangup detected on controlling terminal, or + # death of controlling process""). Only Unix systems support these, + # so we guard this non-essential feature. + # + # We leave SIGSTOP (non-TTY-generated stop signal) alone so standard + # Unix process control with SIGSTOP and SIGCONT still works as usual. + # Besides, SIGSTOP is not catchable! + # + # If modifying these, consider (re-)reading signal(7) first for + # context. + # -trs, 29 August 2023 + SIGTSTP = getattr(Signals, ""SIGTSTP"", None) + SIGHUP = getattr(Signals, ""SIGHUP"", None) + + def detach_signaled(sig, frame): + exit(detach(job, local_workdir)) + + if SIGTSTP: + signal(SIGTSTP, detach_signaled) + if SIGHUP: + signal(SIGHUP, detach_signaled) + + + # Set up signal handler for SIGINT (""interrupt from keyboard"", e.g. + # Ctrl-C). + # + # We leave SIGTERM alone to allow `kill`'s default signal and other + # standard Unix process control to work as usual. + # -trs, 29 August 2023 + if opts.detach_on_interrupt: + signal(SIGINT, detach_signaled) + else: + def interrupt_signaled(sig, frame): + if interrupt(job): + exit(128 + SIGINT) + + signal(SIGINT, interrupt_signaled) + + + print_stage(""Watching job status"") + + if stdin.isatty(): + if opts.detach_on_interrupt: + if SIGTSTP: + control_hints = """""" + Press Control-C or Control-Z to detach from this job. + """""" + elif SIGHUP: + control_hints = """""" + Press Control-C or send SIGHUP to detach from this job. + """""" + else: + control_hints = """""" + Press Control-C to detach from this job. + """""" + else: + if SIGTSTP: + control_hints = """""" + Press Control-C twice within %d seconds to cancel this job, + Control-Z to detach from it. + """""" % (CTRL_C_CONFIRMATION_TIMEOUT,) + elif SIGHUP: + control_hints = """""" + Press Control-C twice within %d seconds to cancel this job. + Send SIGHUP to detach from it. + """""" % (CTRL_C_CONFIRMATION_TIMEOUT,) + else: + control_hints = """""" + Press Control-C twice within %d seconds to cancel this job. + """""" % (CTRL_C_CONFIRMATION_TIMEOUT,) + else: + if opts.detach_on_interrupt: + sigs = prose_list(sig.name for sig in [SIGINT, SIGHUP, SIGTSTP] if sig) + control_hints = f"""""" + Send {sigs} to detach from this job. + """""" + else: + if SIGHUP or SIGTSTP: + sigs = prose_list(sig.name for sig in [SIGHUP, SIGTSTP] if sig) + control_hints = f"""""" + Send SIGINT to cancel this job, + {sigs} to detach from it. + """""" + else: + control_hints = """""" + Send SIGINT to cancel this job. + """""" + + print(dedent(control_hints)) + + + # Watch job status and tail logs. + log_watcher = None + + while True: + job.update() + + # Inform the user of intermediate status changes. Final status changes + # are messaged separately below. + if job.status_changed and not job.is_complete: + print_stage(""Job now %s"" % job.status) + + if job.is_running and not log_watcher: + # Transitioned from waiting → running, so kick off the log watcher. + if opts.logs: + log_watcher = job.log_watcher(consumer = print_job_log) + log_watcher.start() + + elif job.is_complete: + if log_watcher: + if log_watcher.is_alive(): + log_watcher.stop() + log_watcher.join() + else: + # The watcher never started, so we probably missed the + # transition to running. Display the whole log now! + if opts.logs: + try: + for entry in job.log_entries(): + print_job_log(entry) + except botocore.exceptions.ClientError as error: + warn(f""Unable to fetch job logs: {error}"") + + print_stage( + ""Job %s after %0.1f minutes"" % (job.status, job.elapsed_time / 60), + ""(%s)"" % job.status_reason) + break + + # Only check status every 6s (10 times per minute). + sleep(6) + + + # Download results if we didn't stop the job early. + if opts.download and not job.stop_sent and not job.stopped: + assert local_workdir is not None + + patterns = opts.download if isinstance(opts.download, list) else None + + if patterns: + print_stage(""Downloading select files modified by job to %s"" % local_workdir) + for pattern in patterns: + print("" - %s"" % pattern) + else: + print_stage(""Downloading all files modified by job to %s"" % local_workdir) + + s3.download_workdir(remote_workdir, local_workdir, patterns) + + + # Exit with the job's exit code if available or 1 if another failure, + # otherwise success. + return ( + job.exit_code if job.exit_code is not None else + 1 if job.is_failed else + 0 + ) + + +interrupt_called = 0 + +def interrupt(job: jobs.JobState, confirm: bool = stdin.isatty()) -> bool: + """""" + Request interruption (cancellation) of the specified *job* and wait for it + to exit. + + Prints status messages about what's going on. + + If *confirm* is ``True``, by default when a TTY is attached to stdin, then + this function must be invoked at least twice within the + ``CTRL_C_CONFIRMATION_TIMEOUT`` to actually cancel the job. + + Returns ``True`` if the process should exit immediately, i.e. not wait for + the job to exit first. Otherwise, returns ``False``. + """""" + global interrupt_called + + print() + + # Exit immediately the job is already complete or has already been stopped + # (e.g. by a previous double Ctrl-C). + if job.is_complete or job.stop_sent: + return True + + now = int(time()) + + if confirm and now - interrupt_called > CTRL_C_CONFIRMATION_TIMEOUT: + interrupt_called = now + + if stdin.isatty(): + print_stage(""Press Control-C again within %d seconds to cancel this job."" % (CTRL_C_CONFIRMATION_TIMEOUT,)) + else: + print_stage(""Send SIGINT again within %d seconds to cancel this job."" % (CTRL_C_CONFIRMATION_TIMEOUT,)) + else: + print_stage(""Canceling job…"") + job.stop() + + print_stage(""Waiting for job to stop…"") + if stdin.isatty(): + print(f""(Press Control-C {'one more time ' if confirm else ''}if you don't want to wait.)"") + else: + print(f""(Send SIGINT {'one more time ' if confirm else ''}if you don't want to wait.)"") + + return False + + +def detach(job: jobs.JobState, local_workdir: Optional[Path]) -> int: + """""" + Detach from the specified *job* and print a message about how to re-attach + (using the *local_workdir*). + """""" + print("""") + print_stage(""Detaching from job, as requested"") + + reattach_cmd = "" "".join([ + ""nextstrain"", + ""build"", + ""--aws-batch"", + ""--attach"", shlex.quote(job.id), + + # Preserve the local workdir, which has been resolved to an absolute path + shlex.quote(str(local_workdir) if local_workdir else ""."") + ]) + + print(dedent("""""" + Run the following command to re-attach to this job later to see output + and download results: + + %s"""""") % (reattach_cmd,)) + + return 0 + + +def print_stage(stage, *args): + """""" + Print the current running stage, nicely formatted. + """""" + return print(colored(""bold"", stage), *args) + + +def print_job_log(entry): + """""" + Print an AWS Batch job log entry. + """""" + msg = entry.get(""message"", """") + ts = entry.get(""timestamp"", entry.get(""ingestionTime"")) # milliseconds since epoch + + if ts is not None: + ts = datetime.fromtimestamp(round(ts / 1000)).astimezone().isoformat() + print(f""[batch] [{ts}] {msg}"") + else: + print(f""[batch] {msg}"") + + +def generate_run_id() -> str: + """""" + Return a globally unique ID string identifying a run. + + Currently this is just a version 4 UUID (GUID). + """""" + return str(uuid4()) + + +def setup(dry_run: bool = False, force: bool = False) -> SetupStatus: + """""" + Not supported. + """""" + return None + + +def test_setup() -> SetupTestResults: + """""" + Check that necessary AWS resources exist. + """""" + yield ('job description ""%s"" exists' % DEFAULT_JOB, + jobs.definition_exists(DEFAULT_JOB)) + + yield ('job queue ""%s"" exists' % DEFAULT_QUEUE, + jobs.queue_exists(DEFAULT_QUEUE)) + + yield ('S3 bucket ""%s"" exists' % DEFAULT_S3_BUCKET, + s3.bucket_exists(DEFAULT_S3_BUCKET)) + + +def set_default_config() -> None: + """""" + Sets ``core.runner`` to this runner's name (``aws-batch``). + """""" + config.set(""core"", ""runner"", runner_name(cast(RunnerModule, sys.modules[__name__]))) + + +def update() -> UpdateStatus: + """""" + Not supported. Updating the AWS Batch runtime isn't meaningful. + """""" + return None + + +def versions() -> Iterable[str]: + """""" + No-op. Since batch jobs are non-interactive, there's no good way to + extract meaningful versions from them. Perhaps the job definition + revision would be useful, but maybe not? + """""" + return [] +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/aws_batch/jobs.py",".py","10746","335",""""""" +Job handling for AWS Batch. +"""""" + +import re +from copy import deepcopy +from operator import itemgetter +from time import time +from typing import Callable, Generator, Iterable, Mapping, Optional +from ... import aws +from ...errors import UserError +from ...util import split_image_name +from . import logs, s3 + + +class JobState: + """""" + Query and present AWS Batch job state. + + Abstracts away some of the AWS Batch job details into a simpler state + object. Call update() to fetch the initial state and again to subsequently + refresh it. + """""" + + INITIAL_STATUS = { 'SUBMITTED', 'PENDING', 'RUNNABLE', 'STARTING' } + RUNNING_STATUS = { 'RUNNING' } + TERMINAL_STATUS = { 'SUCCEEDED', 'FAILED' } + + STOP_REASON = ""stopped by user"" + + def __init__(self, job_id): + self.id = job_id + self.state = {} + self.previous_status = None + self.stop_sent = False + self._client = aws.client_with_default_region(""batch"") + + def update(self) -> None: + """""" + Fetch the latest state for this job, replacing the previously cached + state. + """""" + self.previous_status = self.status + + jobs = self._client.describe_jobs(jobs = [ self.id ])[""jobs""] + + try: + self.state = jobs[0] + except IndexError: + raise ValueError(""Invalid or unknown job id %s"" % self.id) from None + + @property + def status(self) -> str: + return self.state.get(""status"", ""UNKNOWN"") + + @property + def status_changed(self) -> bool: + return self.status != self.previous_status + + @property + def status_reason(self) -> Optional[str]: + reason = self.state.get(""statusReason"") + container_reason = self.state.get(""container"", {}).get(""reason"") + + # Make the default/normal reason more informative + if reason == ""Essential container in task exited"": + if self.exit_code is not None: + reason = ""exited %d"" % self.exit_code + else: + reason = ""exited"" + + if reason and container_reason: + return ""%s, %s"" % (container_reason, reason) + else: + return reason or container_reason + + @property + def is_waiting(self) -> bool: + return self.status in self.INITIAL_STATUS + + @property + def is_running(self) -> bool: + return self.status in self.RUNNING_STATUS + + @property + def is_complete(self) -> bool: + return self.status in self.TERMINAL_STATUS + + @property + def is_failed(self) -> bool: + return self.status == ""FAILED"" + + @property + def elapsed_time(self) -> float: + # Timestamps from the job state are in milliseconds + created = self.state.get(""createdAt"", float(""NaN"")) / 1000 + stopped = self.state.get(""stoppedAt"", time() * 1000) / 1000 + return stopped - created + + @property + def log_stream(self) -> Optional[str]: + return self.state.get(""container"", {}).get(""logStreamName"") + + @property + def exit_code(self) -> Optional[int]: + return self.state.get(""container"", {}).get(""exitCode"") + + @property + def workdir(self) -> Optional[s3.S3Object]: + env = { + var[""name""]: var[""value""] + for var in self.state.get(""container"", {}).get(""environment"", []) } + + url = env.get(""NEXTSTRAIN_AWS_BATCH_WORKDIR_URL"") + + return s3.object_from_url(url) if url else None + + def log_entries(self) -> Generator[dict, None, None]: + """""" + Fetch all the CloudWatch log entries for this job. + + Returns a generator which yields dict objects. + """""" + if self.log_stream: + yield from logs.fetch_stream(self.log_stream) + else: + yield from [] + + def log_watcher(self, consumer: Callable[[dict], None]) -> logs.LogWatcher: + """""" + Monitor the CloudWatch log stream for this job and call the supplied + *consumer* function with each log entry. + + Returns a LogWatcher thread object, which the caller must start(). + """""" + assert self.log_stream, ""No log stream for job"" + + return logs.LogWatcher(self.log_stream, consumer) + + def stop(self) -> None: + """""" + Stop the job, regardless of if it has started yet or not. + """""" + self._client.terminate_job(jobId = self.id, reason = self.STOP_REASON) + self.stop_sent = True + + @property + def stopped(self) -> bool: + return self.status_reason == self.STOP_REASON + + +def submit(name: str, + image: str, + queue: str, + definition: str, + cpus: Optional[int], + memory: Optional[int], + workdir: s3.S3Object, + exec: Iterable[str], + env: Mapping = {}) -> JobState: + """""" + Submit a job to AWS Batch. + + Returns a JobState object. + """""" + batch = aws.client_with_default_region(""batch"") + + submission = batch.submit_job( + jobName = name, + jobQueue = queue, + jobDefinition = override_definition(definition, image), + containerOverrides = { + ""environment"": [ + { + ""name"": ""NEXTSTRAIN_AWS_BATCH_WORKDIR_URL"", + ""value"": s3.object_url(workdir), + }, + *[{""name"": name, ""value"": value} for name, value in env.items()] + ], + ""resourceRequirements"": [ + *([{ ""type"": ""VCPU"", ""value"": str(cpus) }] if cpus else []), + *([{ ""type"": ""MEMORY"", ""value"": str(memory) }] if memory else []), + ], + ""command"": [ + ""/sbin/entrypoint-aws-batch"", + *exec + ] + } + ) + + job_id = submission[""jobId""] + + return JobState(job_id) + + +def lookup(job_id: str) -> JobState: + """""" + Lookup an AWS Batch job by its id. + + Returns a JobState object. + """""" + job = JobState(job_id) + job.update() + return job + + +def override_definition(base_definition_name: str, image: str) -> str: + """""" + Find or create a job definition based on *base_definition_name* but which + uses *image*. + + *base_definition_name* must already exist. If it uses *image* itself, it + will be returned as-is. Otherwise, a new derived job definition will be + created to override *image*. + + This function only exists because the ``containerOverrides`` data structure + used in job submission doesn't support overriding the image. + + Returns a job definition name. + """""" + # XXX TODO: We only create derived job definitions from an existing base + # definition, which is minimally modified. This is a conservative choice + # that avoids hardcoding a default definition. In the future, we might + # consider relaxing this to auto-create a default base definition. The + # advantage there is one less piece of initial AWS setup. The challenge is + # choosing defaults that work for everyone's taste for resources/spending, + # as well as using the right job roles and other details. + # -trs, 22 May 2020 + batch = aws.client_with_default_region(""batch"") + + base_definition = lookup_definition(base_definition_name) + + if not base_definition: + raise UserError(""AWS Batch job definition «%s» does not exist"" % base_definition_name) + + # The base definition might already use this image, in which case we avoid + # creating anything. This lets admins not grant job definition creation to + # users if they want; users will instead have to specify matching + # --aws-batch-job and --image values. + # + # Split the image name in order to normalize the implicit :latest tag. + base_image = base_definition[""containerProperties""][""image""] + + if split_image_name(base_image) == split_image_name(image): + return base_definition_name + + # The revision of the base definition is included in the derived image name + # so that changes to the base definition cause derived definitions to be + # re-created. Unfortunately, we can't explicitly set the revision of new + # definitions. + derived_definition_name = sanitize_name( + ""_"".join(( + base_definition_name, + str(base_definition[""revision""]), + *split_image_name(image)))) + + derived_definition = lookup_definition(derived_definition_name) + + if not derived_definition: + derived_definition = deepcopy(base_definition) + derived_definition[""jobDefinitionName""] = derived_definition_name + derived_definition[""containerProperties""][""image""] = image + + # Remove AWS-assigned keys returned by describe_job_definitions() which + # aren't supported as keyword arguments by register_job_definition(). + register_inputs = batch.meta.service_model.operation_model(""RegisterJobDefinition"").input_shape.members + + for key in set(derived_definition) - set(register_inputs): + del derived_definition[key] + + batch.register_job_definition(**derived_definition) + else: + derived_image = derived_definition[""containerProperties""][""image""] + + assert split_image_name(derived_image) == split_image_name(image), ( + ""Expected job definition «%s», derived from «%s», to use image «%s», "" + ""but it uses «%s» instead"" + % (derived_definition_name, base_definition_name, image, derived_image)) + + return derived_definition_name + + +def lookup_definition(name: str) -> Optional[dict]: + """""" + Lookup an AWS Batch job definition by its *name*. + + Always returns the latest active revision. + + Returns a dict if found, ``None`` if not. + """""" + batch = aws.client_with_default_region(""batch"") + + active = batch.describe_job_definitions(jobDefinitionName = name, status = 'ACTIVE') + + revisions = sorted( + active[""jobDefinitions""], + key = itemgetter(""revision""), + reverse = True) + + return revisions[0] if revisions else None + + +def sanitize_name(name: str) -> str: + """""" + Mangles *name* to fit within a job or job definition name. + + * Replaces any invalid character with a hyphen ``-`` + * Truncates to 128 characters in length + """""" + return re.sub(r""[^A-Za-z0-9_-]"", ""-"", name)[0:128] + + +def definition_exists(name: str) -> bool: + """""" + Test if an AWS Batch job definition exists. + """""" + try: + return bool(lookup_definition(name)) + except: + return False + + +def queue_exists(name: str) -> bool: + """""" + Test if an AWS Batch job queue exists. + """""" + try: + batch = aws.client_with_default_region(""batch"") + + return bool( + batch.describe_job_queues(jobQueues = [name]) \ + .get(""jobQueues"")) + except: + return False +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/runner/aws_batch/logs.py",".py","3542","104",""""""" +Log handling for AWS Batch jobs. +"""""" + +import threading +from botocore.exceptions import ClientError, ConnectionError as BotocoreConnectionError +from typing import Any, Callable, Dict, Generator, MutableSet # noqa: F401 (it's wrong; we use it in a type comment) +from ... import aws + + +LOG_GROUP = ""/aws/batch/job"" +MAX_FAILURES = 10 + + +def fetch_stream(stream: str, start_time: int = None) -> Generator[dict, None, None]: + """""" + Fetch all log entries from the named AWS Batch job *stream*. Returns a + generator. + + If the *start_time* argument is given, only entries with timestamps on or + after the given value are fetched. + """""" + + client = aws.client_with_default_region(""logs"") + + log_events = client.get_paginator(""filter_log_events"") + + query: Dict[str, Any] = { + ""logGroupName"": LOG_GROUP, + ""logStreamNames"": [ stream ], + } + + if start_time: + query[""startTime""] = start_time + + for page in log_events.paginate(**query): + yield from page.get(""events"", []) + + +class LogWatcher(threading.Thread): + """""" + Monitor an AWS Batch job log stream and call a supplied function (the + *consumer*) with each log entry. + + This is a Thread. Call start() to begin monitoring the log stream and + stop() (and then join()) to stop. + """""" + + def __init__(self, stream: str, consumer: Callable[[dict], None]) -> None: + super().__init__(name = ""log-watcher"", daemon = True) + self.stream = stream + self.consumer = consumer + self.stopped = threading.Event() + + def stop(self) -> None: + """""" + Tell the log watcher to cease watching for new logs. + + This method merely signals to the thread that it should stop, so you + must call the thread's join() method afterwards to wait for the thread + to exit. It is an error to call stop() on a thread which isn't alive + (running). + """""" + assert self.is_alive(), ""Thread not alive"" + self.stopped.set() + + def run(self) -> None: + """""" + Watch for new logs and pass each log entry to the ""consumer"" function. + """""" + + # Track the last timestamp we see. When we fetch_stream() again on the + # next iteration, we'll start from that timestamp onwards to avoid + # fetching every single page again. The last event or two will be + # still be in the response, but our de-duping will ignore those. + last_timestamp = None + + # Keep track of what log entries we've consumed so that we suppress + # duplicates. Duplicates will arise in our stream due to the way we + # watch for new entries. + consumed = set() # type: MutableSet + + # How many successful vs failed fetch_stream calls. If we consistently see + # failures but we never see a successful attempt, we should raise an exception + # and stop. + success_count = 0 + failure_count = 0 + + while not self.stopped.wait(0.2): + try: + for entry in fetch_stream(self.stream, start_time = last_timestamp): + if entry[""eventId""] not in consumed: + consumed.add(entry[""eventId""]) + + last_timestamp = entry[""timestamp""] + + self.consumer(entry) + except (ClientError, BotocoreConnectionError): + failure_count += 1 + if failure_count > MAX_FAILURES and not success_count: + raise + else: + success_count += 1 +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/authn/errors.py",".py","887","41",""""""" +Authentication errors. +"""""" +from ..aws.cognito.srp import NewPasswordRequiredError # noqa: F401 (NewPasswordRequiredError is for re-export) + +class IdPError(Exception): + """"""Error from IdP during authentication."""""" + pass + +class NotAuthorizedError(IdPError): + """"""Not Authorized response during authentication."""""" + pass + +class TokenError(Exception): + """"""Error when verifying tokens."""""" + pass + +class MissingTokenError(TokenError): + """""" + No token provided but one is required. + + Context is the kind of token (""use"") that was missing. + """""" + pass + +class ExpiredTokenError(TokenError): + """""" + Token is expired. + + Context is the kind of token (""use"") that was missing. + """""" + pass + +class InvalidUseError(TokenError): + """""" + The ""use"" of the token does not match the expected value. + + May indicate an accidental token swap. + """""" + pass +","Python" +"Pathogens","nextstrain/cli","nextstrain/cli/authn/session.py",".py","30417","758",""""""" +Authentication sessions. +"""""" +import boto3 +import jwt +import jwt.exceptions +import secrets + +from base64 import b64encode +from errno import EADDRINUSE +from hashlib import sha256 +from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler +from inspect import cleandoc +from textwrap import fill +from threading import Thread +from typing import Any, Dict, Mapping, Optional, Set + +from .. import requests +from ..aws.cognito.srp import CognitoSRP +from ..browser import BROWSER, open_browser +from ..debug import debug +from ..errors import UserError +from ..net import is_loopback +from ..url import URL, Origin, query +from .configuration import openid_configuration, client_configuration +from .errors import NotAuthorizedError, TokenError, MissingTokenError, ExpiredTokenError, InvalidUseError + + +class Session: + origin: Origin + can_authenticate_with_browser: bool = False + can_authenticate_with_password: bool = False + + def __new__(cls, origin: Origin) -> 'Session': + assert origin + if cls is Session: + if client_configuration(origin).get(""aws_cognito_user_pool_id""): + cls = CognitoSession + else: + cls = OpenIDSession + return super().__new__(cls) # pyright: ignore[reportArgumentType] + + def authenticate_with_password(self, username: str, password: str) -> None: + raise NotImplementedError + + def authenticate_with_browser(self) -> None: + raise NotImplementedError + + def renew_tokens(self, *, refresh_token: Optional[str]) -> None: + raise NotImplementedError + + def verify_tokens(self, *, id_token: Optional[str], access_token: Optional[str], refresh_token: Optional[str]) -> None: + raise NotImplementedError + + @property + def id_token(self) -> Optional[str]: + raise NotImplementedError + + @property + def access_token(self) -> Optional[str]: + raise NotImplementedError + + @property + def refresh_token(self) -> Optional[str]: + raise NotImplementedError + + @property + def id_claims(self) -> Optional[Mapping[str, Any]]: + raise NotImplementedError + + +class OpenIDSession(Session): + """""" + Authentication session interface for OpenID. + + The interface of this class aims to be hard or impossible to accidentally + use insecurely. + """""" + def __init__(self, origin: Origin): + assert origin + self.origin = origin + + self.openid_configuration = openid_configuration(origin) + self.client_configuration = client_configuration(origin) + + self.jwks = jwt.PyJWKClient(self.openid_configuration[""jwks_uri""]) + + self.can_authenticate_with_browser = ""code"" in self.client_configuration.get(""response_types"", []) + self.can_authenticate_with_password = False + + self._tokens: Dict[str, Optional[str]] = {} + self._claims: Dict[str, Dict[str, Any]] = {} + + @property + def id_token(self): + """""" + The id token for this session, set by calling + :meth:`.authenticate_with_password`, + :meth:`.authenticate_with_browser`, or :meth:`.verify_tokens`. + + Useful for persisting in external storage, but should be treated as an + opaque value. The claims embedded in this token are accessible in + :attr:`.id_claims`. + """""" + return self._tokens.get(""id"") + + @property + def access_token(self): + """""" + The access token for this session, set by calling + :meth:`.authenticate_with_password`, + :meth:`.authenticate_with_browser`, or :meth:`.verify_tokens`. + + Useful for persisting in external storage, but should be treated as an + opaque value. + """""" + return self._tokens.get(""access"") + + @property + def refresh_token(self): + """""" + The refresh token for this session, set by calling + :meth:`.authenticate_with_password`, + :meth:`.authenticate_with_browser`, or :meth:`.verify_tokens`. + + Useful for persisting in external storage, but should be treated as an + opaque value. + """""" + return self._tokens.get(""refresh"") + + @property + def id_claims(self): + """""" + Dictionary of verified claims from the :attr:`.id_token`. + """""" + return self._claims.get(""id"") + + + def authenticate_with_password(self, username: str, password: str) -> None: + """""" + Authenticates the given *username* and *password* with the IdP. + + If successful, returns nothing, but several instance attributes will be + set: + + * :attr:`.id_token` + * :attr:`.access_token` + * :attr:`.refresh_token` + * :attr:`.id_claims` + + If unsuccessful, raises an :exc:`IdPError` or :exc:`TokenError` (or + one of their subclasses). + """""" + # This could implement OAuth2's ""password"" grant type¹, but Cognito + # doesn't support it² and we don't need to support it for other IdPs. + # -trs, 17 Nov 2023 + # + # ¹ + # ² Cognito supports password auth via its own API instead; see + # CognitoSession below. + raise NotImplementedError + + + def authenticate_with_browser(self) -> None: + """""" + Authenticates with the IdP via the user's web browser. + + If successful, returns nothing, but several instance attributes will be + set: + + * :attr:`.id_token` + * :attr:`.access_token` + * :attr:`.refresh_token` + * :attr:`.id_claims` + + If unsuccessful, raises an :exc:`IdPError` or :exc:`TokenError` (or + one of their subclasses). + """""" + # What follows is a basic implementation of the OpenID Connect (OIDC)¹ + # and OAuth 2.0² authorization code flow additionally secured with + # Proof Key for Code Exchange (PKCE)³ and informed by the best current + # practices for OAuth 2.0 native apps.⁴ Variable names and such + # intentionally stick to the terms used in the specs to ease + # understanding. A survey of OIDC/OAuth2 libraries found nothing + # suitable for our uses here. + # -trs, 17 Nov 2023 + # + # ¹ + # ² + # ³ + # ⁴ + assert self.can_authenticate_with_browser + + + # XXX TODO: This giant function should likely be broken up into + # smaller, more digestable parts. But I am out of time and cannot do + # that now. It works as-is and since it's only about internal + # organization, I think fine to ship like this and fix it up later. Of + # course, fine for someone else to clean it up too! + # -trs, 21 Nov 2023 + + + # Set up a minimal HTTP server to receive the authorization response, + # which contains query parameters we need to complete authentication. + class AuthorizationResponseHandler(BaseHTTPRequestHandler): + def do_GET(self): + assert isinstance(self.server, AuthorizationResponseServer) + + url = URL(self.path) + + if url.path.lstrip(""/"") == self.server.redirect_uri.path.lstrip(""/""): + # Capture the HTTP request URL so we can parse the + # authorization response details (code, state, etc) later. + self.server.response_url = url + self.respond(200, ""You may now close this page and return to the terminal."") + else: + self.respond(400, ""(Redirect path does not match expectation.)"") + + # Accept only one request; close this request's connection and + # stop the server. + # + # Shutting down the server from within a request handler only + # works because we're using a ThreadingHTTPServer so we're + # requesting shutdown from a different thread than the server. + # With a non-threading HTTPServer, we'd deadlock here. + self.close_connection = True + self.server.shutdown() + + def respond(self, status: int, details: str): + self.send_response(status) + self.send_header(""Content-Type"", ""text/html; charset=utf-8"") + self.end_headers() + css = """""" + body { + margin-top: 2rem; + text-align: center; + font-family: monospace; + font-size: 1.5rem; + } + h1 { + font-size: 2rem; + font-weight: normal; + background: black; + color: white; + background: linear-gradient(to right, #4377cd, #5097ba, #63ac9a, #7cb879, #9abe5c, #b9bc4a, #d4b13f, #e49938, #e67030, #de3c26); + } + .success { color: green } + .failure { color: red } + aside { font-size: 1rem } + """""" + html = f"""""" + +

Nextstrain CLI

+

+ Authentication {'complete' if status == 200 else 'failed'}. +