flip/sdk
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/sdk.git synced 2026-02-06 10:46:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

R shroomDK Package

Browse Source 
Pending: 
 - README
 - devtools::install_github() test
This commit is contained in:
charlieflipside 2022-07-20 11:18:25 -04:00 committed by GitHub
parent 5d39e32e94
commit 519bc43239
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 1379 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
r/shroomDK/DESCRIPTION Normal file
View File

@ -0,0 +1,12 @@
Package: shroomDK
Type: Package
Title: What the Package Does (Title Case)
Version: 0.1.0
Author: Who wrote it
Maintainer: The package maintainer <yourself@somewhere.net>
Description: More about what it does (maybe more than one line)
Use four spaces when indenting paragraphs within the Description.
License: What license is it under?
Encoding: UTF-8
LazyData: true
RoxygenNote: 7.2.0

1
r/shroomDK/NAMESPACE Normal file
View File

@ -0,0 +1 @@
exportPattern("^[[:alpha:]]+")

73
r/shroomDK/R/clean_query.R Normal file
View File

@ -0,0 +1,73 @@
#' Clean Query
#'
#' @param request The request output from get_query_from_token()
#' @param try_simplify because requests can return JSON and may not have the same length
#' across values, they may not be data frame compliant (all columns having the same number of rows).
#' A key example would be TX_JSON in EVM FACT_TRANSACTION tables which include 50+
#' extra details from transaction logs. But other examples like NULLs TO_ADDRESS can have similar
#' issues. Default TRUE.
#'
#' @return A data frame. If `try_simplify` is FALSE OR if `try_simplify` TRUE fails:
#' the data frame is comprised of lists, where each column must be coerced
#' to a desired class (e.g., with `as.numeric()`).
#'
#' @export
#'
#' @examples {
#' query = create_query_token("SELECT * FROM ETHEREUM.CORE.FACT_TRANSACTIONS LIMIT 10000", api_key)
#' request = get_query_from_token(query$token, api_key, 1, 10000)
#' clean_query(request, try_simplify = FALSE)
#' }
clean_query <- function(request, try_simplify = TRUE){
# Functions NOT exported
fill_null <- function(columnlist){
# NULL values must be replaced with NA to avoid getting dropped in list coercions
null_index <- which(unlist(lapply(columnlist, is.null)))
columnlist[null_index] <- NA
return(columnlist)
}
error <- function(request){
warning("Attempts to simplify result in different number of rows per column. Likely
due to the request including JSON. Returned is a data frame of lists, coerce them
to numeric/character/date one by one. See: request$columnTypes")
clean_query(request, try_simplify = FALSE)
}
# start data reformat
# this is a matrix/array
data <- t(list2DF(request$results))
colnames(data) <- request$columnLabels
rownames(data) <- NULL
# Protects NULL values
for(i in 1:ncol(data)){
data[, i] <- fill_null(data[, i])
}
# data frame of Lists
data <- as.data.frame(data)
if(try_simplify == FALSE){
# user must manually coerce each column as needed, e.g., as.numeric(data$BLOCK_NUMBER)
return(data)
} else {
# check if all columns of lists are same length
test_lengths <- unlist(lapply(data, function(x){length(unlist(x))}))
# if NOT return data frame of lists for user coercion w/ error
if( min(test_lengths) != max(test_lengths) ){
error(request)
} else { # if YES coerce data frame
return( as.data.frame(lapply(data, unlist)) )
}
}
}

60
r/shroomDK/R/create_query_token.R Normal file
View File

@ -0,0 +1,60 @@
library(jsonlite)
library(httr)
#' Create Query Token
#'
#' Uses Flipside ShroomDK to create a Query Token to access Flipside Crypto
#' data. The query token is cached up to ttl minutes
#' allowing for pagination and multiple requests before expending more daily request uses.
#'
#' @param query Flipside Crypto Snowflake SQL compatible query as a string.
#' @param api_key Flipside Crypto ShroomDK API Key
#' @param ttl time (in minutes) to keep query in cache.
#' @param cache Use cached results; set as FALSE to re-execute.
#' @return list of `token` and `cached` use `token` in `get_query_from_token()`
#' @import jsonlite, httr
#' @export
#'
#' @examples
#' \dontrun{
#' create_query_token(
#' query = "SELECT * FROM ethereum.core.fact_transactions LIMIT 1",
#' api_key = readLines("api_key.txt"),
#' ttl = 15,
#' cache = TRUE)
#'}
create_query_token <- function(query, api_key, ttl = 10, cache = TRUE){
headers = c(
"Accept" = 'application/json',
"Content-Type" = 'application/json',
"x-api-key" = api_key
)
# Small default query to validate connection & api key
if(is.null(query)){
query = 'SELECT * FROM ethereum.core.fact_transactions LIMIT 1'
}
# warn if no order by
if( !grepl("ORDER BY", query, ignore.case = TRUE) ){
warning("No ORDER BY found in query. Unordered queries may return different
results over time and not be reproducible. They may also be harder to paginate.")
}
# must use auto_unbox to ensure toJSON does not wrap string in an array
res <- httr::POST(
"https://node-api.flipsidecrypto.com/queries",
config = httr::add_headers(.headers = headers),
body = jsonlite::toJSON(
list("sql" = query,
"ttlMinutes" = ttl,
cache = cache),
auto_unbox = TRUE)
)
token <- content(res)
return(token)
}

67
r/shroomDK/R/get_query_from_token.R Normal file
View File

@ -0,0 +1,67 @@
library(jsonlite)
library(httr)
#' Get Query From Token
#'
#' Uses Flipside ShroomDK to access a Query Token. Query tokens are cached up to `ttl` minutes
#' for each `query`. This function is for pagination and multiple requests
#' while . Note: To reduce payload it returns
#' a list of outputs (separating column names from rows).
#'
#' @param query_token token from `create_query_token()`
#' @param api_key Flipside Crypto ShroomDK API Key
#' @param page_number Query tokens are cached and 100k rows max. Get up to 1M rows by going through pages.
#' @param page_size Default 100,000. Paginate via page_number.
#' @return returns a request of length 8: `results`, `columnLabels`,
#' `columnTypes`, `startedAt`, `endedAt`, `pageNumber`, `pageSize`, `status`
#' @import jsonlite, httr
#' @export
#'
#' @examples
#' \dontrun{
#' query = create_query_token("SELECT * FROM ETHEREUM.CORE.FACT_TRANSACTIONS LIMIT 10000", api_key)
#' get_query_from_token(query$token, api_key, 1, 10000)
#' }
get_query_from_token <- function(query_token, api_key, page_number = 1, page_size = 100000){
headers = c(
"Accept" = 'application/json',
"Content-Type" = 'application/json',
"x-api-key" = api_key
)
url = paste0(
"https://node-api.flipsidecrypto.com/queries/",
query_token,"?",
"pageNumber=", page_number, "&",
"pageSize=", format(page_size, scientific = FALSE) # just in case user's R settings force 100,000 -> 1e+05 which breaks API.
)
req <- httr::GET(
url = url,
config = httr::add_headers(.headers = headers)
)
request <- content(req, as = 'parsed')
# if running give it a few seconds
# this won't count as a re-request as long as cache intact
if(request$status == 'running'){
Sys.sleep(5)
warning("Query is still running! Trying again shortly")
return(
get_query_from_token(query_token, api_key, page_number, page_size)
)
} else if(request$status == 'finished') {
return(request)
} else {
return(
paste0("Request not running nor finished, see status code: ",
request$status))
}
return(request)
}

32
r/shroomDK/man/clean_query.Rd Normal file
View File

@ -0,0 +1,32 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/clean_query.R
\name{clean_query}
\alias{clean_query}
\title{Clean Query}
\usage{
clean_query(request, try_simplify = TRUE)
}
\arguments{
\item{request}{The request output from get_query_from_token()}
\item{try_simplify}{because requests can return JSON and may not have the same length
across values, they may not be data frame compliant (all columns having the same number of rows).
A key example would be TX_JSON in EVM FACT_TRANSACTION tables which include 50+
extra details from transaction logs. But other examples like NULLs TO_ADDRESS can have similar
issues. Default TRUE.}
}
\value{
A data frame. If `try_simplify` is FALSE OR if `try_simplify` TRUE fails:
the data frame is comprised of lists, where each column must be coerced
to a desired class (e.g., with `as.numeric()`).
}
\description{
Clean Query
}
\examples{
{
query = create_query_token("SELECT * FROM ETHEREUM.CORE.FACT_TRANSACTIONS LIMIT 10000", api_key)
request = get_query_from_token(query$token, api_key, 1, 10000)
clean_query(request, try_simplify = FALSE)
}
}

34
r/shroomDK/man/create_query_token.Rd Normal file
View File

@ -0,0 +1,34 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/create_query_token.R
\name{create_query_token}
\alias{create_query_token}
\title{Create Query Token}
\usage{
create_query_token(query, api_key, ttl = 10, cache = TRUE)
}
\arguments{
\item{query}{Flipside Crypto Snowflake SQL compatible query as a string.}
\item{api_key}{Flipside Crypto ShroomDK API Key}
\item{ttl}{time (in minutes) to keep query in cache.}
\item{cache}{Use cached results; set as FALSE to re-execute.}
}
\value{
list of`token` and `cached` use `token` in `get_query_from_token()`
}
\description{
Uses Flipside ShroomDK to create a Query Token to access Flipside Crypto
data. The query token is cached up to ttl minutes
allowing for pagination and multiple requests before expending more daily request uses.
}
\examples{
\dontrun{
create_query_token(
query = "SELECT * FROM ethereum.core.fact_transactions LIMIT 1",
api_key = readLines("api_key.txt"),
ttl = 15,
cache = TRUE)
}
}

33
r/shroomDK/man/get_query_from_token.Rd Normal file
View File

@ -0,0 +1,33 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/get_query_from_token.R
\name{get_query_from_token}
\alias{get_query_from_token}
\title{Get Query From Token}
\usage{
get_query_from_token(query_token, api_key, page_number = 1, page_size = 1e+05)
}
\arguments{
\item{query_token}{token from `create_query_token()`}
\item{api_key}{Flipside Crypto ShroomDK API Key}
\item{page_number}{Query tokens are cached and 100k rows max. Get up to 1M rows by going through pages.}
\item{page_size}{Default 100,000. Paginate via page_number.}
}
\value{
returns a request of length 8: `results`, `columnLabels`,
`columnTypes`, `startedAt`, `endedAt`, `pageNumber`, `pageSize`, `status`
}
\description{
Uses Flipside ShroomDK to access a Query Token. Query tokens are cached up to `ttl` minutes
for each `query`. This function is for pagination and multiple requests
while . Note: To reduce payload it returns
a list of outputs (separating column names from rows).
}
\examples{
\dontrun{
query = create_query_token("SELECT * FROM ETHEREUM.CORE.FACT_TRANSACTIONS LIMIT 10000", api_key)
get_query_from_token(query$token, api_key, 1, 10000)
}
}

95
r/shroomDK/renv.lock Normal file
View File

@ -0,0 +1,95 @@
{
"R": {
"Version": "4.2.1",
"Repositories": [
{
"Name": "CRAN",
"URL": "https://cran.rstudio.com"
}
]
},
"Packages": {
"R6": {
"Package": "R6",
"Version": "2.5.1",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "470851b6d5d0ac559e9d01bb352b4021",
"Requirements": []
},
"askpass": {
"Package": "askpass",
"Version": "1.1",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "e8a22846fff485f0be3770c2da758713",
"Requirements": [
"sys"
]
},
"curl": {
"Package": "curl",
"Version": "4.3.2",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "022c42d49c28e95d69ca60446dbabf88",
"Requirements": []
},
"httr": {
"Package": "httr",
"Version": "1.4.3",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "88d1b310583777edf01ccd1216fb0b2b",
"Requirements": [
"R6",
"curl",
"jsonlite",
"mime",
"openssl"
]
},
"jsonlite": {
"Package": "jsonlite",
"Version": "1.8.0",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "d07e729b27b372429d42d24d503613a0",
"Requirements": []
},
"mime": {
"Package": "mime",
"Version": "0.12",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "18e9c28c1d3ca1560ce30658b22ce104",
"Requirements": []
},
"openssl": {
"Package": "openssl",
"Version": "2.0.2",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "6d3bef2e305f55c705c674653c7d7d3d",
"Requirements": [
"askpass"
]
},
"renv": {
"Package": "renv",
"Version": "0.15.5",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "6a38294e7d12f5d8e656b08c5bd8ae34",
"Requirements": []
},
"sys": {
"Package": "sys",
"Version": "3.4",
"Source": "Repository",
"Repository": "CRAN",
"Hash": "b227d13e29222b4574486cfcbde077fa",
"Requirements": []
}
}
}

942
r/shroomDK/renv/activate.R Normal file
View File

@ -0,0 +1,942 @@
local({
# the requested version of renv
version <- "0.15.5"
# the project directory
project <- getwd()
# figure out whether the autoloader is enabled
enabled <- local({
# first, check config option
override <- getOption("renv.config.autoloader.enabled")
if (!is.null(override))
return(override)
# next, check environment variables
# TODO: prefer using the configuration one in the future
envvars <- c(
"RENV_CONFIG_AUTOLOADER_ENABLED",
"RENV_AUTOLOADER_ENABLED",
"RENV_ACTIVATE_PROJECT"
)
for (envvar in envvars) {
envval <- Sys.getenv(envvar, unset = NA)
if (!is.na(envval))
return(tolower(envval) %in% c("true", "t", "1"))
}
# enable by default
TRUE
})
if (!enabled)
return(FALSE)
# avoid recursion
if (identical(getOption("renv.autoloader.running"), TRUE)) {
warning("ignoring recursive attempt to run renv autoloader")
return(invisible(TRUE))
}
# signal that we're loading renv during R startup
options(renv.autoloader.running = TRUE)
on.exit(options(renv.autoloader.running = NULL), add = TRUE)
# signal that we've consented to use renv
options(renv.consent = TRUE)
# load the 'utils' package eagerly -- this ensures that renv shims, which
# mask 'utils' packages, will come first on the search path
library(utils, lib.loc = .Library)
# unload renv if it's already been loaded
if ("renv" %in% loadedNamespaces())
unloadNamespace("renv")
# load bootstrap tools
`%||%` <- function(x, y) {
if (is.environment(x) || length(x)) x else y
}
bootstrap <- function(version, library) {
# attempt to download renv
tarball <- tryCatch(renv_bootstrap_download(version), error = identity)
if (inherits(tarball, "error"))
stop("failed to download renv ", version)
# now attempt to install
status <- tryCatch(renv_bootstrap_install(version, tarball, library), error = identity)
if (inherits(status, "error"))
stop("failed to install renv ", version)
}
renv_bootstrap_tests_running <- function() {
getOption("renv.tests.running", default = FALSE)
}
renv_bootstrap_repos <- function() {
# check for repos override
repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA)
if (!is.na(repos))
return(repos)
# check for lockfile repositories
repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity)
if (!inherits(repos, "error") && length(repos))
return(repos)
# if we're testing, re-use the test repositories
if (renv_bootstrap_tests_running())
return(getOption("renv.tests.repos"))
# retrieve current repos
repos <- getOption("repos")
# ensure @CRAN@ entries are resolved
repos[repos == "@CRAN@"] <- getOption(
"renv.repos.cran",
"https://cloud.r-project.org"
)
# add in renv.bootstrap.repos if set
default <- c(FALLBACK = "https://cloud.r-project.org")
extra <- getOption("renv.bootstrap.repos", default = default)
repos <- c(repos, extra)
# remove duplicates that might've snuck in
dupes <- duplicated(repos) | duplicated(names(repos))
repos[!dupes]
}
renv_bootstrap_repos_lockfile <- function() {
lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock")
if (!file.exists(lockpath))
return(NULL)
lockfile <- tryCatch(renv_json_read(lockpath), error = identity)
if (inherits(lockfile, "error")) {
warning(lockfile)
return(NULL)
}
repos <- lockfile$R$Repositories
if (length(repos) == 0)
return(NULL)
keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1))
vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1))
names(vals) <- keys
return(vals)
}
renv_bootstrap_download <- function(version) {
# if the renv version number has 4 components, assume it must
# be retrieved via github
nv <- numeric_version(version)
components <- unclass(nv)[[1]]
# if this appears to be a development version of 'renv', we'll
# try to restore from github
dev <- length(components) == 4L
# begin collecting different methods for finding renv
methods <- c(
renv_bootstrap_download_tarball,
if (dev)
renv_bootstrap_download_github
else c(
renv_bootstrap_download_cran_latest,
renv_bootstrap_download_cran_archive
)
)
for (method in methods) {
path <- tryCatch(method(version), error = identity)
if (is.character(path) && file.exists(path))
return(path)
}
stop("failed to download renv ", version)
}
renv_bootstrap_download_impl <- function(url, destfile) {
mode <- "wb"
# https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715
fixup <-
Sys.info()[["sysname"]] == "Windows" &&
substring(url, 1L, 5L) == "file:"
if (fixup)
mode <- "w+b"
utils::download.file(
url = url,
destfile = destfile,
mode = mode,
quiet = TRUE
)
}
renv_bootstrap_download_cran_latest <- function(version) {
spec <- renv_bootstrap_download_cran_latest_find(version)
message("* Downloading renv ", version, " ... ", appendLF = FALSE)
type <- spec$type
repos <- spec$repos
info <- tryCatch(
utils::download.packages(
pkgs = "renv",
destdir = tempdir(),
repos = repos,
type = type,
quiet = TRUE
),
condition = identity
)
if (inherits(info, "condition")) {
message("FAILED")
return(FALSE)
}
# report success and return
message("OK (downloaded ", type, ")")
info[1, 2]
}
renv_bootstrap_download_cran_latest_find <- function(version) {
# check whether binaries are supported on this system
binary <-
getOption("renv.bootstrap.binary", default = TRUE) &&
!identical(.Platform$pkgType, "source") &&
!identical(getOption("pkgType"), "source") &&
Sys.info()[["sysname"]] %in% c("Darwin", "Windows")
types <- c(if (binary) "binary", "source")
# iterate over types + repositories
for (type in types) {
for (repos in renv_bootstrap_repos()) {
# retrieve package database
db <- tryCatch(
as.data.frame(
utils::available.packages(type = type, repos = repos),
stringsAsFactors = FALSE
),
error = identity
)
if (inherits(db, "error"))
next
# check for compatible entry
entry <- db[db$Package %in% "renv" & db$Version %in% version, ]
if (nrow(entry) == 0)
next
# found it; return spec to caller
spec <- list(entry = entry, type = type, repos = repos)
return(spec)
}
}
# if we got here, we failed to find renv
fmt <- "renv %s is not available from your declared package repositories"
stop(sprintf(fmt, version))
}
renv_bootstrap_download_cran_archive <- function(version) {
name <- sprintf("renv_%s.tar.gz", version)
repos <- renv_bootstrap_repos()
urls <- file.path(repos, "src/contrib/Archive/renv", name)
destfile <- file.path(tempdir(), name)
message("* Downloading renv ", version, " ... ", appendLF = FALSE)
for (url in urls) {
status <- tryCatch(
renv_bootstrap_download_impl(url, destfile),
condition = identity
)
if (identical(status, 0L)) {
message("OK")
return(destfile)
}
}
message("FAILED")
return(FALSE)
}
renv_bootstrap_download_tarball <- function(version) {
# if the user has provided the path to a tarball via
# an environment variable, then use it
tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA)
if (is.na(tarball))
return()
# allow directories
info <- file.info(tarball, extra_cols = FALSE)
if (identical(info$isdir, TRUE)) {
name <- sprintf("renv_%s.tar.gz", version)
tarball <- file.path(tarball, name)
}
# bail if it doesn't exist
if (!file.exists(tarball)) {
# let the user know we weren't able to honour their request
fmt <- "* RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist."
msg <- sprintf(fmt, tarball)
warning(msg)
# bail
return()
}
fmt <- "* Bootstrapping with tarball at path '%s'."
msg <- sprintf(fmt, tarball)
message(msg)
tarball
}
renv_bootstrap_download_github <- function(version) {
enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE")
if (!identical(enabled, "TRUE"))
return(FALSE)
# prepare download options
pat <- Sys.getenv("GITHUB_PAT")
if (nzchar(Sys.which("curl")) && nzchar(pat)) {
fmt <- "--location --fail --header \"Authorization: token %s\""
extra <- sprintf(fmt, pat)
saved <- options("download.file.method", "download.file.extra")
options(download.file.method = "curl", download.file.extra = extra)
on.exit(do.call(base::options, saved), add = TRUE)
} else if (nzchar(Sys.which("wget")) && nzchar(pat)) {
fmt <- "--header=\"Authorization: token %s\""
extra <- sprintf(fmt, pat)
saved <- options("download.file.method", "download.file.extra")
options(download.file.method = "wget", download.file.extra = extra)
on.exit(do.call(base::options, saved), add = TRUE)
}
message("* Downloading renv ", version, " from GitHub ... ", appendLF = FALSE)
url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version)
name <- sprintf("renv_%s.tar.gz", version)
destfile <- file.path(tempdir(), name)
status <- tryCatch(
renv_bootstrap_download_impl(url, destfile),
condition = identity
)
if (!identical(status, 0L)) {
message("FAILED")
return(FALSE)
}
message("OK")
return(destfile)
}
renv_bootstrap_install <- function(version, tarball, library) {
# attempt to install it into project library
message("* Installing renv ", version, " ... ", appendLF = FALSE)
dir.create(library, showWarnings = FALSE, recursive = TRUE)
# invoke using system2 so we can capture and report output
bin <- R.home("bin")
exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R"
r <- file.path(bin, exe)
args <- c(
"--vanilla", "CMD", "INSTALL", "--no-multiarch",
"-l", shQuote(path.expand(library)),
shQuote(path.expand(tarball))
)
output <- system2(r, args, stdout = TRUE, stderr = TRUE)
message("Done!")
# check for successful install
status <- attr(output, "status")
if (is.numeric(status) && !identical(status, 0L)) {
header <- "Error installing renv:"
lines <- paste(rep.int("=", nchar(header)), collapse = "")
text <- c(header, lines, output)
writeLines(text, con = stderr())
}
status
}
renv_bootstrap_platform_prefix <- function() {
# construct version prefix
version <- paste(R.version$major, R.version$minor, sep = ".")
prefix <- paste("R", numeric_version(version)[1, 1:2], sep = "-")
# include SVN revision for development versions of R
# (to avoid sharing platform-specific artefacts with released versions of R)
devel <-
identical(R.version[["status"]], "Under development (unstable)") ||
identical(R.version[["nickname"]], "Unsuffered Consequences")
if (devel)
prefix <- paste(prefix, R.version[["svn rev"]], sep = "-r")
# build list of path components
components <- c(prefix, R.version$platform)
# include prefix if provided by user
prefix <- renv_bootstrap_platform_prefix_impl()
if (!is.na(prefix) && nzchar(prefix))
components <- c(prefix, components)
# build prefix
paste(components, collapse = "/")
}
renv_bootstrap_platform_prefix_impl <- function() {
# if an explicit prefix has been supplied, use it
prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA)
if (!is.na(prefix))
return(prefix)
# if the user has requested an automatic prefix, generate it
auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA)
if (auto %in% c("TRUE", "True", "true", "1"))
return(renv_bootstrap_platform_prefix_auto())
# empty string on failure
""
}
renv_bootstrap_platform_prefix_auto <- function() {
prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity)
if (inherits(prefix, "error") || prefix %in% "unknown") {
msg <- paste(
"failed to infer current operating system",
"please file a bug report at https://github.com/rstudio/renv/issues",
sep = "; "
)
warning(msg)
}
prefix
}
renv_bootstrap_platform_os <- function() {
sysinfo <- Sys.info()
sysname <- sysinfo[["sysname"]]
# handle Windows + macOS up front
if (sysname == "Windows")
return("windows")
else if (sysname == "Darwin")
return("macos")
# check for os-release files
for (file in c("/etc/os-release", "/usr/lib/os-release"))
if (file.exists(file))
return(renv_bootstrap_platform_os_via_os_release(file, sysinfo))
# check for redhat-release files
if (file.exists("/etc/redhat-release"))
return(renv_bootstrap_platform_os_via_redhat_release())
"unknown"
}
renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) {
# read /etc/os-release
release <- utils::read.table(
file = file,
sep = "=",
quote = c("\"", "'"),
col.names = c("Key", "Value"),
comment.char = "#",
stringsAsFactors = FALSE
)
vars <- as.list(release$Value)
names(vars) <- release$Key
# get os name
os <- tolower(sysinfo[["sysname"]])
# read id
id <- "unknown"
for (field in c("ID", "ID_LIKE")) {
if (field %in% names(vars) && nzchar(vars[[field]])) {
id <- vars[[field]]
break
}
}
# read version
version <- "unknown"
for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) {
if (field %in% names(vars) && nzchar(vars[[field]])) {
version <- vars[[field]]
break
}
}
# join together
paste(c(os, id, version), collapse = "-")
}
renv_bootstrap_platform_os_via_redhat_release <- function() {
# read /etc/redhat-release
contents <- readLines("/etc/redhat-release", warn = FALSE)
# infer id
id <- if (grepl("centos", contents, ignore.case = TRUE))
"centos"
else if (grepl("redhat", contents, ignore.case = TRUE))
"redhat"
else
"unknown"
# try to find a version component (very hacky)
version <- "unknown"
parts <- strsplit(contents, "[[:space:]]")[[1L]]
for (part in parts) {
nv <- tryCatch(numeric_version(part), error = identity)
if (inherits(nv, "error"))
next
version <- nv[1, 1]
break
}
paste(c("linux", id, version), collapse = "-")
}
renv_bootstrap_library_root_name <- function(project) {
# use project name as-is if requested
asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE")
if (asis)
return(basename(project))
# otherwise, disambiguate based on project's path
id <- substring(renv_bootstrap_hash_text(project), 1L, 8L)
paste(basename(project), id, sep = "-")
}
renv_bootstrap_library_root <- function(project) {
prefix <- renv_bootstrap_profile_prefix()
path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA)
if (!is.na(path))
return(paste(c(path, prefix), collapse = "/"))
path <- renv_bootstrap_library_root_impl(project)
if (!is.null(path)) {
name <- renv_bootstrap_library_root_name(project)
return(paste(c(path, prefix, name), collapse = "/"))
}
renv_bootstrap_paths_renv("library", project = project)
}
renv_bootstrap_library_root_impl <- function(project) {
root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA)
if (!is.na(root))
return(root)
type <- renv_bootstrap_project_type(project)
if (identical(type, "package")) {
userdir <- renv_bootstrap_user_dir()
return(file.path(userdir, "library"))
}
}
renv_bootstrap_validate_version <- function(version) {
loadedversion <- utils::packageDescription("renv", fields = "Version")
if (version == loadedversion)
return(TRUE)
# assume four-component versions are from GitHub; three-component
# versions are from CRAN
components <- strsplit(loadedversion, "[.-]")[[1]]
remote <- if (length(components) == 4L)
paste("rstudio/renv", loadedversion, sep = "@")
else
paste("renv", loadedversion, sep = "@")
fmt <- paste(
"renv %1$s was loaded from project library, but this project is configured to use renv %2$s.",
"Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile.",
"Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library.",
sep = "\n"
)
msg <- sprintf(fmt, loadedversion, version, remote)
warning(msg, call. = FALSE)
FALSE
}
renv_bootstrap_hash_text <- function(text) {
hashfile <- tempfile("renv-hash-")
on.exit(unlink(hashfile), add = TRUE)
writeLines(text, con = hashfile)
tools::md5sum(hashfile)
}
renv_bootstrap_load <- function(project, libpath, version) {
# try to load renv from the project library
if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE))
return(FALSE)
# warn if the version of renv loaded does not match
renv_bootstrap_validate_version(version)
# load the project
renv::load(project)
TRUE
}
renv_bootstrap_profile_load <- function(project) {
# if RENV_PROFILE is already set, just use that
profile <- Sys.getenv("RENV_PROFILE", unset = NA)
if (!is.na(profile) && nzchar(profile))
return(profile)
# check for a profile file (nothing to do if it doesn't exist)
path <- renv_bootstrap_paths_renv("profile", profile = FALSE)
if (!file.exists(path))
return(NULL)
# read the profile, and set it if it exists
contents <- readLines(path, warn = FALSE)
if (length(contents) == 0L)
return(NULL)
# set RENV_PROFILE
profile <- contents[[1L]]
if (!profile %in% c("", "default"))
Sys.setenv(RENV_PROFILE = profile)
profile
}
renv_bootstrap_profile_prefix <- function() {
profile <- renv_bootstrap_profile_get()
if (!is.null(profile))
return(file.path("profiles", profile, "renv"))
}
renv_bootstrap_profile_get <- function() {
profile <- Sys.getenv("RENV_PROFILE", unset = "")
renv_bootstrap_profile_normalize(profile)
}
renv_bootstrap_profile_set <- function(profile) {
profile <- renv_bootstrap_profile_normalize(profile)
if (is.null(profile))
Sys.unsetenv("RENV_PROFILE")
else
Sys.setenv(RENV_PROFILE = profile)
}
renv_bootstrap_profile_normalize <- function(profile) {
if (is.null(profile) || profile %in% c("", "default"))
return(NULL)
profile
}
renv_bootstrap_path_absolute <- function(path) {
substr(path, 1L, 1L) %in% c("~", "/", "\\") || (
substr(path, 1L, 1L) %in% c(letters, LETTERS) &&
substr(path, 2L, 3L) %in% c(":/", ":\\")
)
}
renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) {
renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv")
root <- if (renv_bootstrap_path_absolute(renv)) NULL else project
prefix <- if (profile) renv_bootstrap_profile_prefix()
components <- c(root, renv, prefix, ...)
paste(components, collapse = "/")
}
renv_bootstrap_project_type <- function(path) {
descpath <- file.path(path, "DESCRIPTION")
if (!file.exists(descpath))
return("unknown")
desc <- tryCatch(
read.dcf(descpath, all = TRUE),
error = identity
)
if (inherits(desc, "error"))
return("unknown")
type <- desc$Type
if (!is.null(type))
return(tolower(type))
package <- desc$Package
if (!is.null(package))
return("package")
"unknown"
}
renv_bootstrap_user_dir <- function() {
dir <- renv_bootstrap_user_dir_impl()
path.expand(chartr("\\", "/", dir))
}
renv_bootstrap_user_dir_impl <- function() {
# use local override if set
override <- getOption("renv.userdir.override")
if (!is.null(override))
return(override)
# use R_user_dir if available
tools <- asNamespace("tools")
if (is.function(tools$R_user_dir))
return(tools$R_user_dir("renv", "cache"))
# try using our own backfill for older versions of R
envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME")
for (envvar in envvars) {
root <- Sys.getenv(envvar, unset = NA)
if (!is.na(root))
return(file.path(root, "R/renv"))
}
# use platform-specific default fallbacks
if (Sys.info()[["sysname"]] == "Windows")
file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv")
else if (Sys.info()[["sysname"]] == "Darwin")
"~/Library/Caches/org.R-project.R/R/renv"
else
"~/.cache/R/renv"
}
renv_json_read <- function(file = NULL, text = NULL) {
text <- paste(text %||% read(file), collapse = "\n")
# find strings in the JSON
pattern <- '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
locs <- gregexpr(pattern, text, perl = TRUE)[[1]]
# if any are found, replace them with placeholders
replaced <- text
strings <- character()
replacements <- character()
if (!identical(c(locs), -1L)) {
# get the string values
starts <- locs
ends <- locs + attr(locs, "match.length") - 1L
strings <- substring(text, starts, ends)
# only keep those requiring escaping
strings <- grep("[[\\]{}:]", strings, perl = TRUE, value = TRUE)
# compute replacements
replacements <- sprintf('"\032%i\032"', seq_along(strings))
# replace the strings
mapply(function(string, replacement) {
replaced <<- sub(string, replacement, replaced, fixed = TRUE)
}, strings, replacements)
}
# transform the JSON into something the R parser understands
transformed <- replaced
transformed <- gsub("[[{]", "list(", transformed)
transformed <- gsub("[]}]", ")", transformed)
transformed <- gsub(":", "=", transformed, fixed = TRUE)
text <- paste(transformed, collapse = "\n")
# parse it
json <- parse(text = text, keep.source = FALSE, srcfile = NULL)[[1L]]
# construct map between source strings, replaced strings
map <- as.character(parse(text = strings))
names(map) <- as.character(parse(text = replacements))
# convert to list
map <- as.list(map)
# remap strings in object
remapped <- renv_json_remap(json, map)
# evaluate
eval(remapped, envir = baseenv())
}
renv_json_remap <- function(json, map) {
# fix names
if (!is.null(names(json))) {
lhs <- match(names(json), names(map), nomatch = 0L)
rhs <- match(names(map), names(json), nomatch = 0L)
names(json)[rhs] <- map[lhs]
}
# fix values
if (is.character(json))
return(map[[json]] %||% json)
# handle true, false, null
if (is.name(json)) {
text <- as.character(json)
if (text == "true")
return(TRUE)
else if (text == "false")
return(FALSE)
else if (text == "null")
return(NULL)
}
# recurse
if (is.recursive(json)) {
for (i in seq_along(json)) {
json[i] <- list(renv_json_remap(json[[i]], map))
}
}
json
}
# load the renv profile, if any
renv_bootstrap_profile_load(project)
# construct path to library root
root <- renv_bootstrap_library_root(project)
# construct library prefix for platform
prefix <- renv_bootstrap_platform_prefix()
# construct full libpath
libpath <- file.path(root, prefix)
# attempt to load
if (renv_bootstrap_load(project, libpath, version))
return(TRUE)
# load failed; inform user we're about to bootstrap
prefix <- paste("# Bootstrapping renv", version)
postfix <- paste(rep.int("-", 77L - nchar(prefix)), collapse = "")
header <- paste(prefix, postfix)
message(header)
# perform bootstrap
bootstrap(version, libpath)
# exit early if we're just testing bootstrap
if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA)))
return(TRUE)
# try again to load
if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) {
message("* Successfully installed and loaded renv ", version, ".")
return(renv::load())
}
# failed to download or load renv; warn the user
msg <- c(
"Failed to find an renv installation: the project will not be loaded.",
"Use `renv::activate()` to re-initialize the project."
)
warning(paste(msg, collapse = "\n"), call. = FALSE)
})

10
r/shroomDK/renv/settings.dcf Normal file
View File

@ -0,0 +1,10 @@
bioconductor.version:
external.libraries:
ignored.packages:
package.dependency.fields: Imports, Depends, LinkingTo
r.version:
snapshot.type: implicit
use.cache: TRUE
vcs.ignore.cellar: TRUE
vcs.ignore.library: TRUE
vcs.ignore.local: TRUE

20
r/shroomDK/shroomDK.Rproj Normal file
View File

@ -0,0 +1,20 @@
Version: 1.0
RestoreWorkspace: Default
SaveWorkspace: Default
AlwaysSaveHistory: Default
EnableCodeIndexing: Yes
UseSpacesForTab: Yes
NumSpacesForTab: 2
Encoding: UTF-8
RnwWeave: Sweave
LaTeX: pdfLaTeX
AutoAppendNewline: Yes
StripTrailingWhitespace: Yes
BuildType: Package
PackageUseDevtools: Yes
PackageInstallArgs: --no-multiarch --with-keep.source