Download plumber_hf.R from Symmetron/darth_API: direct link, hf CLI and curl.
- Browser
- Download file 7.03 kB
-
https://huggingface.co/spaces/Symmetron/darth_API/resolve/main/plumber_hf.R
- Command line
-
hf download hf://spaces/Symmetron/darth_API/plumber_hf.R
-
curl -L -o plumber_hf.R https://huggingface.co/spaces/Symmetron/darth_API/resolve/main/plumber_hf.R
7.03 kB
| library(dampack) | |
| library(readr) | |
| library(assertthat) | |
| library(jsonlite) | |
| library(httr) | |
| #* @apiTitle DARTH Health Economic Model API | |
| #* | |
| #* @apiDescription This API runs a health economic Markov model (Sick-Sicker) | |
| #* for probabilistic sensitivity analysis. Hosted on Hugging Face Spaces. | |
| #* Users send their own parameter CSV data from their local machine. | |
| #* Supports multiple CSV inputs (e.g., base parameters + clinical inputs) that get merged. | |
| #* Welcome page - API info | |
| #* @get / | |
| function() { | |
| list( | |
| name = "DARTH Health Economic Model API", | |
| version = "1.0", | |
| status = "running", | |
| endpoints = list( | |
| "GET /" = "This welcome page", | |
| "GET /health" = "Health check", | |
| "POST /runDARTHmodel" = "Run the DARTH model with your CSV data" | |
| ) | |
| ) | |
| } | |
| #* Health check endpoint | |
| #* @get /health | |
| function() { | |
| list(status = "healthy", timestamp = Sys.time()) | |
| } | |
| #* Run the DARTH model | |
| #* @serializer csv | |
| #* @param psa_inputs_json JSON string containing the base parameter distributions data from client's local CSV | |
| #* @param clinical_inputs_json JSON string containing clinical input parameters (optional, merged with psa_inputs) | |
| #* @param param_updates JSON string with optional parameter overrides (applied after merging all inputs) | |
| #* @post /runDARTHmodel | |
| function(psa_inputs_json = NULL, clinical_inputs_json = NULL, param_updates = NULL) { | |
| # Source the model functions from Hugging Face (local) or Private GitHub | |
| # Local path = inside Docker container on Hugging Face after deployment | |
| model_functions_path <- "/app/model/darth_funcs.R" | |
| # Private GitHub repo URL for model code | |
| # Repo: https://github.com/Veenalim/API_Site2.git | |
| # Path: model/darth_funcs.R | |
| github_raw_url <- "https://raw.githubusercontent.com/Veenalim/API_Site2/main/model/darth_funcs.R" | |
| model_loaded <- FALSE | |
| # Option 1: Try local file on Hugging Face first (fastest, most reliable) | |
| if (file.exists(model_functions_path)) { | |
| source(model_functions_path) | |
| model_loaded <- TRUE | |
| message("Model loaded from Hugging Face local file") | |
| } | |
| # Option 2: Try Private GitHub repo (uses token for authentication) | |
| if (!model_loaded) { | |
| tryCatch({ | |
| # Get GitHub token from environment variable (set in Hugging Face secrets) | |
| github_token <- Sys.getenv("GITHUB_TOKEN") | |
| if (github_token == "") { | |
| stop("GITHUB_TOKEN environment variable not set") | |
| } | |
| # Fetch file from private GitHub repo with authentication | |
| response <- httr::GET( | |
| github_raw_url, | |
| httr::add_headers( | |
| Authorization = paste("token", github_token), | |
| Accept = "application/vnd.github.v3.raw" | |
| ) | |
| ) | |
| # Check if request was successful | |
| if (httr::status_code(response) != 200) { | |
| stop(paste("GitHub returned status:", httr::status_code(response))) | |
| } | |
| # Save to temp file and source | |
| temp_file <- tempfile(fileext = ".R") | |
| writeLines(httr::content(response, "text", encoding = "UTF-8"), temp_file) | |
| source(temp_file) | |
| # Clean up temp file | |
| unlink(temp_file) | |
| model_loaded <- TRUE | |
| message("Model loaded from Private GitHub repo") | |
| }, error = function(e) { | |
| message("GitHub source failed: ", e$message) | |
| }) | |
| } | |
| # No fallback - fail if model cannot be loaded | |
| if (!model_loaded) { | |
| stop("ERROR: Could not load model. Check GITHUB_TOKEN is set and repo is accessible.") | |
| } | |
| # Helper function to parse and validate CSV JSON input | |
| parse_csv_json <- function(json_input, input_name) { | |
| if (is.null(json_input) || json_input == "") { | |
| return(NULL) | |
| } | |
| tryCatch({ | |
| df <- jsonlite::fromJSON(json_input) | |
| df <- as.data.frame(df) | |
| # Validate required columns exist | |
| required_cols <- c("parameter", "distribution", "v1", "v2") | |
| if (!all(required_cols %in% names(df))) { | |
| stop(paste("Error:", input_name, "must contain columns:", paste(required_cols, collapse = ", "))) | |
| } | |
| # Ensure v1 and v2 are numeric (handle NULL/NA values) | |
| df$v1 <- as.numeric(df$v1) | |
| df$v2 <- as.numeric(df$v2) | |
| # Replace NA with 0 for v2 (needed for 'fixed' distributions) | |
| df$v2[is.na(df$v2)] <- 0 | |
| return(df) | |
| }, error = function(e) { | |
| stop(paste("Error parsing", input_name, "JSON:", e$message)) | |
| }) | |
| } | |
| # Parse the base PSA inputs (required) | |
| if (is.null(psa_inputs_json) || psa_inputs_json == "") { | |
| stop("Error: psa_inputs_json is required. Please send your local CSV data.") | |
| } | |
| psa_inputs <- parse_csv_json(psa_inputs_json, "psa_inputs_json") | |
| # Parse clinical inputs if provided (optional, merged with psa_inputs) | |
| clinical_inputs <- parse_csv_json(clinical_inputs_json, "clinical_inputs_json") | |
| if (!is.null(clinical_inputs)) { | |
| # Merge clinical inputs with base inputs (clinical inputs are appended) | |
| # If duplicate parameters exist, clinical inputs take precedence | |
| existing_params <- psa_inputs$parameter | |
| new_params <- clinical_inputs$parameter | |
| # Remove any duplicate parameters from psa_inputs (clinical takes precedence) | |
| duplicates <- existing_params %in% new_params | |
| if (any(duplicates)) { | |
| psa_inputs <- psa_inputs[!duplicates, ] | |
| } | |
| # Combine the data frames | |
| psa_inputs <- rbind(psa_inputs, clinical_inputs) | |
| } | |
| # Parse param_updates if provided (for additional overrides) | |
| if (!is.null(param_updates) && param_updates != "") { | |
| # Handle both JSON string and data frame input | |
| if (is.character(param_updates)) { | |
| param_updates <- jsonlite::fromJSON(param_updates) | |
| } | |
| # Convert to data frame if needed | |
| if (!is.data.frame(param_updates)) { | |
| param_updates <- as.data.frame(param_updates) | |
| } | |
| # For each row of the data-frame containing the variables to be changed... | |
| for(n in 1:nrow(param_updates)) { | |
| # Update parameters from API input | |
| psa_inputs <- overwrite_parameter_value( | |
| existing_df = psa_inputs, | |
| parameter = param_updates[n, "parameter"], | |
| distribution = param_updates[n, "distribution"], | |
| v1 = param_updates[n, "v1"], | |
| v2 = param_updates[n, "v2"] | |
| ) | |
| } | |
| } | |
| # Run the model using the single run-model function | |
| results <- run_model(psa_inputs) | |
| # Check that the model results being returned are the correct dimensions | |
| assertthat::assert_that( | |
| all(dim(x = results) == c(1000, 6)), | |
| class(results) == "data.frame", | |
| msg = "Dimensions or type of data are incorrect, please check the model code." | |
| ) | |
| # Check that no sensitive data is included in the output | |
| assertthat::assert_that( | |
| all(psa_inputs[, 1] %in% as.character(unlist(x = results, recursive = TRUE)) == FALSE) | |
| ) | |
| return(results) | |
| } | |