Package ‘pins’

December 15, 2021

Type Package
Title Pin, Discover and Share Resources
Version 1.0.1
Description Publish data sets, models, and other R objects, making it
easy to share them across projects and with your colleagues. You can
pin objects to a variety of ``boards'', including local folders (to
share on a networked drive or with 'DropBox'), 'RStudio' connect,
Amazon S3, and more.
License Apache License (>= 2)

URL https://pins.rstudio.com/, https://github.com/rstudio/pins

BugReports https://github.com/rstudio/pins/issues
Depends R (>= 3.3.0)
Imports arrow, cli, digest, ellipsis, filelock, fs, glue, httr,
jsonlite, lifecycle, magrittr, mime, openssl, rappdirs, rlang
(>= 0.4.10), tibble, whisker, withr, yaml, zip
Suggests AzureStor, data.table, datasets, gitcreds, knitr,
Microsoft365R, mockery, paws.storage, qs, R.utils, rmarkdown,
rsconnect, shiny, testthat (>= 3.0.0), xml2
VignetteBuilder knitr
Config/testthat/edition 3
Encoding UTF-8
RoxygenNote 7.1.2
NeedsCompilation no
Author Hadley Wickham [aut, cre] (<https://orcid.org/0000-0003-4757-117X>),
Javier Luraschi [aut],
RStudio [cph]
Maintainer Hadley Wickham <hadley@rstudio.com>
Repository CRAN
Date/Publication 2021-12-15 12:10:02 UTC

1
2 board_azure

R topics documented:
board_azure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
board_folder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
board_kaggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
board_ms365 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
board_rsconnect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
board_s3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
board_url . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
cache_browse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
legacy_azure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
legacy_datatxt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
legacy_dospace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
legacy_gcloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
legacy_github . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
legacy_kaggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
legacy_local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
legacy_s3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
pin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
pin_browse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
pin_delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
pin_download . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
pin_exists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
pin_find . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
pin_get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
pin_info . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
pin_list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
pin_meta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
pin_reactive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
pin_reactive_read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
pin_read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
pin_remove . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
pin_search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
pin_versions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Index 38

board_azure Use an Azure storage container as a board

Description

Pin data to a container in Azure storage using the AzureStor package.

board_azure 3

Usage
board_azure(
container,
path = "",
n_processes = 10,
versioned = TRUE,
cache = NULL
)

Arguments
container An azure storage container created by AzureStor::blob_container() or sim-
ilar.
path Path to the directory in the container to store pins. Will be created if it doesn’t
already exist. The equivalent of a prefix for AWS S3 storage.
n_processes Maximum number of processes used for parallel uploads/downloads.
versioned Should this board be registered with support for versions?
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.

Details
You can create a board in any of the services that AzureStor supports: blob storage, file storage and
Azure Data Lake Storage Gen2 (ADLSgen2).
Blob storage is the classic storage service that is most familiar to people, but is relatively old and
inefficient. ADLSgen2 is a modern replacement API for working with blobs that is much faster
when working with directories. You should consider using this rather than the classic blob API
where possible; see the examples below.

Examples
if (requireNamespace("AzureStor")) {
# Public access board
url <- "https://pins.blob.core.windows.net/public-data"
container <- AzureStor::blob_container(url)
board <- board_azure(container)
board %>% pin_read("mtcars")
}

## Not run:
# To create a board that you can write to, you'll need to supply one
# of `key`, `token`, or `sas` to AzureStor::blob_container()
# First, we create a board using the classic Azure blob API
url <- "https://myaccount.blob.core.windows.net/mycontainer"
container <- AzureStor::blob_container(url, sas = "my-sas")
board <- board_azure(container, "path/to/board")
board %>% pin_write(iris)
4 board_folder

# ADLSgen2 is a modern, efficient way to access blobs

# - Use 'dfs' instead of 'blob' in the account URL to use the ADLSgen2 API
# - Use the 'storage_container' generic instead of the service-specific
# 'blob_container'
# - We reuse the board created via the blob API above
adls_url <- "https://myaccount.dfs.core.windows.net/mycontainer"
container <- AzureStor::storage_container(adls_url, sas = "my-sas")
board <- board_azure(container, "path/to/board")
board %>% pin_list()
board %>% pin_read("iris")

## End(Not run)

board_folder Use a local folder as board

Description
• board_folder() creates a board inside a folder. You can use this to share files by using a
folder on a shared network drive or inside a DropBox.
• board_local() creates a board in a system data directory. It’s useful if you want to share
pins between R sessions on your computer, and you don’t care where the data lives.
• board_temp() creates a temporary board that lives in a session specific temporary directory.
It will be automatically deleted once the current R session ends. It’s useful for examples and
tests.

Usage
board_folder(path, versioned = FALSE)

board_local(versioned = FALSE)

board_temp(versioned = FALSE)

Arguments
path Path to directory to store pins. Will be created if it doesn’t already exist.
versioned Should this board be registered with support for versions?

See Also
Other boards: board_rsconnect(), board_url()

Examples
# session-specific local board
board <- board_temp()
board_kaggle 5

board_kaggle Use kaggle datasets/competitions as a board

Description
board_kaggle_competition() allows you to treat a Kaggle competition like a read-only board,
making it easy get the data on to your computer. board_kaggle_dataset() lets you upload and
download files to and from a kaggle dataset. Data is only re-downloaded when it changes.
These boards work best with pin_download() and pin_upload() since pin_read() and pin_write()
are not a good fit to the kaggle model.

Usage
board_kaggle_competitions(username = NULL, key = NULL, cache = NULL)

## S3 method for class 'pins_board_kaggle_competition'

pin_search(
board,
search = NULL,
sort_by = c("grouped", "prize", "earliestDeadline", "latestDeadline",
"numberOfTeams", "recentlyCreated"),
page = 1,
user = NULL,
...
)

board_kaggle_dataset(username = NULL, key = NULL, cache = NULL)

## S3 method for class 'pins_board_kaggle_dataset'

pin_search(
board,
search = NULL,
sort_by = c("hottest", "votes", "updated", "active"),
page = 1,
user = NULL,
...
)

## S3 method for class 'pins_board_kaggle_dataset'

pin_store(
board,
name,
paths,
metadata,
versioned = NULL,
...,
6 board_kaggle

private = TRUE,
license = "CC0-1.0"
)

Arguments
username, key Typically you’ll authenticate using the "~/.kaggle/kaggle.json" file down-
loaded from your account page (by clicking "Create New API Token". However,
if necessary you can supply the username and key arguments here; this can be
useful for testing.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
board The name of the board to register.
search A string to search for in pin name and title. Use NULL to return all pins.
sort_by How to sort the results.
page Which page of results to retrieve.
user If non-NULL filter to specified user.
... Additional parameters required to initialize a particular board.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
paths A character vector of file paths to upload to board.
metadata A list containing additional metadata to store with the pin. When retrieving
the pin, this will be stored in the user key, to avoid potential clashes with the
metadata that pins itself uses.
versioned Should this board be registered with support for versions?
private Should the dataset be private (TRUE, the default) or public (FALSE)?
license How should the data be licensed?

Examples
## Not run:
board <- board_kaggle_competitions()
board

board %>% pin_meta("titanic")

paths <- board %>% pin_download("titanic")
paths
head(read.csv(paths[[1]]))
head(read.csv(paths[[2]]))

## End(Not run)
## Not run:
board <- board_kaggle_dataset()

board %>% pin_search("cats")

board_ms365 7

board %>% pin_exists("rturley/pet-breed-characteristics")

board %>% pin_meta("rturley/pet-breed-characteristics")
board %>% pin_versions("rturley/pet-breed-characteristics")

board %>% pin_versions("imsparsh/animal-breed-cats-and-dogs")

## End(Not run)

board_ms365 Use a OneDrive or Sharepoint document library as a board

Description
Pin data to a folder in Onedrive or a SharePoint Online document library using the Microsoft365R
package.

Usage
board_ms365(
drive,
path,
versioned = TRUE,
cache = NULL,
delete_by_item = FALSE
)

Arguments
drive A OneDrive or SharePoint document library object, of class Microsoft365R::ms_drive.
path Path to directory to store pins. This can be either a string containing the path-
name like "path/to/board", or a Microsoft365R::ms_drive_item object
pointing to the board path.
versioned Should this board be registered with support for versions?
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
delete_by_item Whether to handle folder deletions on an item-by-item basis, rather than deleting
the entire folder at once. You may need to set this to TRUE for a board in Share-
Point Online or OneDrive for Business, due to document protection policies that
prohibit deleting non-empty folders.

Details
Sharing a board in OneDrive (personal or business) is a bit complicated, as OneDrive normally
allows only the person who owns the drive to access files and folders. First, the drive owner
has to set the board folder as shared with other users, using either the OneDrive web interface
or Microsoft365R’s ms_drive_item$create_share_link() method. The other users then call
8 board_rsconnect

board_ms365 with a drive item object in the path argument, pointing to the shared folder. See the
examples below.
Sharing a board in SharePoint Online is much more straightforward, assuming all users have access
to the document library: in this case, everyone can use the same call board_ms365(doclib,"path/to/board").
If you want to share a board with users outside your team, follow the same steps for sharing a board
in OneDrive.

Examples
## Not run:
# A board in your personal OneDrive
od <- Microsoft365R::get_personal_onedrive()
board <- board_ms365(od, "myboard")
board %>% pin_write(iris)

# A board in OneDrive for Business

odb <- Microsoft365R::get_business_onedrive(tenant = "mytenant")
board <- board_ms365(odb, "myproject/board")

# A board in a SharePoint Online document library

sp <- Microsoft365R::get_sharepoint_site("my site", tenant = "mytenant")
doclib <- sp$get_drive()
board <- board_ms365(doclib, "general/project1/board")

## Sharing a board in OneDrive:

# First, create the board on the drive owner's side
board <- board_ms365(od, "myboard")

# Next, let other users write to the folder

# - set the expiry to NULL if you want the folder to be permanently available
od$get_item("myboard")$create_share_link("edit", expiry="30 days")

# On the recipient's side: find the shared folder item, then pass it to board_ms365
shared_items <- od$list_shared_items()
board_folder <- shared_items$remoteItem[[which(shared_items$name == "myboard")]]
board <- board_ms365(od, board_folder)

## End(Not run)

board_rsconnect Use RStudio Connect as board

Description
To use a RStudio Connect board, you need to first authenticate. The easiest way to do so is by
launching Tools - Global Options - Publishing - Connect, and follow the instructions.
You can share pins with others in RStudio Connect by changing the viewers of the document to
specific users or groups. This is accomplished by opening the new published pin and then changing
board_rsconnect 9

access under the settings tab. After you’ve shared the pin, it will be automatically available to
others.

Usage
board_rsconnect(
auth = c("auto", "manual", "envvar", "rsconnect"),
server = NULL,
account = NULL,
key = NULL,
output_files = FALSE,
cache = NULL,
name = "rsconnect",
versioned = TRUE,
use_cache_on_failure = is_interactive(),
versions = deprecated()
)

Arguments
auth There are three ways to authenticate:
• auth = "manual" uses arguments server and key.
• auth = "envvar" uses environment variables CONNECT_API_KEY and CONNECT_SERVER.
• auth = "rsconnect" uses servers registered with the rsconnect package
(filtered by server and account, if provided)
The default, auth = "auto", automatically picks between the three options, us-
ing "manual" if server and key are provided, "envvar" if both environment
variables are set, and "rsconnect" otherwise.
server For auth = "manual" or auth = 'envvar', the full url to the server, like http://server.rstudio.com/rsc
or https://connect.rstudio.com/. For auth = 'rsconnect' a host name used to
disambiguate RSC accounts, like server.rstudio.com or connect.rstudio.com.
account A user name used to disambiguate multiple RSC accounts.
key The RStudio Connect API key.
output_files [Deprecated] No longer supported.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
versioned Should this board be registered with support for versions?
use_cache_on_failure
If the pin fails to download, is it ok to use the last cached version? Defaults
to is_interactive() so you’ll be robust to poor internet connectivity when
exploring interactively, but you’ll get clear errors when the code is deployed.
versions Should this board be registered with support for versions?
10 board_s3

Public pins
If your RSC instance allows it, you can share a pin publicly by setting the access type to all:

board %>% pin_write(my_df, access_type = "all")

(You can also do this in RSC by setting "Access" to "Anyone - no login required")
Now anyone can read your pin through board_url():

board <- board_url(c(

my_df = "https://connect.rstudioservices.com/content/3004/"
))
board %>% pin_read("my_df")

You can find the URL of a pin with pin_browse().

See Also
Other boards: board_folder(), board_url()

Examples
## Not run:
board <- board_rsconnect()
# Share the mtcars with your team
board %>% pin_write(mtcars, "mtcars")

# Download a shared dataset

board %>% pin_read("timothy/mtcars")

## End(Not run)

board_s3 Use an S3 bucket as a board

Description
Pin data to a bucket on Amazon’s S3 service, using the paws.storage package.

Usage
board_s3(
bucket,
prefix = NULL,
versioned = TRUE,
access_key = NULL,
secret_access_key = NULL,
session_token = NULL,
credential_expiration = NULL,
board_s3 11

profile = NULL,
region = NULL,
endpoint = NULL,
cache = NULL
)

Arguments
bucket Bucket name.
prefix Prefix within this bucket that this board will occupy. You can use this to maintain
multiple independent pin boards within a single S3 bucket. Will typically end
with / to take advantage of S3’s directory-like handling.
versioned Should this board be registered with support for versions?
access_key, secret_access_key, session_token, credential_expiration
Manually control authentication. See documentation below for details.
profile Role to use from AWS shared credentials/config file.
region AWS region. If not specified, will be read from AWS_REGION, or AWS config
file.
endpoint AWS endpoint to use; usually generated automatically from region.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.

Authentication
board_s3() is powered by the paws package which provides a wide range of authentication options,
as documented at https://github.com/paws-r/paws/blob/main/docs/credentials.md. In
brief, there are four main options that are tried in order:

• The access_key and secret_access_key arguments to this function. If you have a tempo-
rary session token, you’ll also need to supply session_token and credential_expiration.
(Not recommended since your secret_access_key will be recorded in .Rhistory)
• The AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY env vars. (And AWS_SESSION_TOKEN
and AWS_CREDENTIAL_EXPIRATION env vars if you have a temporary session token)
• The AWS shared credential file, ~/.aws/credentials:
[profile-name]
aws_access_key_id=your AWS access key
aws_secret_access_key=your AWS secret key
The "default" profile will be used if you don’t supply the access key and secret access key as
described above. Otherwise you can use the profile argument to use a profile of your choice.
• Automatic authentication from EC2 instance or container IAM role.

See the paws documentation for more unusual options including getting credentials from a com-
mand line process, picking a role when running inside an EC2 instance, using a role from another
profile, and using multifactor authentication.
12 board_url

Caveats
• If you point at a bucket that’s not created by pins, some functions like pins_list() will work,
but won’t return useful output.

Examples
## Not run:
board <- board_s3("pins-test-hadley", region = "us-east-2")
board %>% pin_write(mtcars)
board %>% pin_read("mtcars")

# A prefix allows you to have multiple independent boards in the same pin.
board_sales <- board_s3("company-pins", prefix = "sales/")
board_marketing <- board_s3("company-pins", prefix = "marketing/")
# You can make the hierarchy arbitrarily deep.

## End(Not run)

board_url Use a vector of URLs as a board

Description
board_url() lets you build up a board from individual urls. This is useful because pin_download()
and pin_get() will be cached - they’ll only re-download the data if it’s changed from the last time
you downloaded it (using the tools of HTTP caching). You’ll also be protected from the vagaries of
the internet; if a fresh download fails, you’ll get the previously cached result with a warning.
board_url() is read only and does not currently support versions.

Usage
board_url(urls, cache = NULL, use_cache_on_failure = is_interactive())

Arguments
urls A named character vector of URLs If the URL ends in a /, board_url will look
for a data.txt that provides metadata. The easiest way to generate this file is
to upload a pin directory created by board_folder().
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
use_cache_on_failure
If the pin fails to download, is it ok to use the last cached version? Defaults
to is_interactive() so you’ll be robust to poor internet connectivity when
exploring interactively, but you’ll get clear errors when the code is deployed.
cache_browse 13

See Also
Other boards: board_folder(), board_rsconnect()

Examples
github_raw <- "https://raw.githubusercontent.com/"
board <- board_url(c(
files = paste0(github_raw, "rstudio/pins/master/tests/testthat/pin-files/"),
rds = paste0(github_raw, "rstudio/pins/master/tests/testthat/pin-rds/"),
raw = paste0(github_raw, "rstudio/pins/master/tests/testthat/pin-files/first.txt")
))

board %>% pin_read("rds")

board %>% pin_browse("rds", local = TRUE)

board %>% pin_download("files")

board %>% pin_download("raw")

cache_browse Cache management

Description
Most boards maintain a local cache so that if you’re reading a pin that hasn’t changed since the last
time you read it, it can be rapidly retrieved from a local cache. These functions help you manage
that cache.
• cache_browse(): open the cache directory for interactive exploration.
• cache_info(): report how much disk space each board’s cache uses.
• cache_prune(): delete pin versions that you haven’t used for days (you’ll be asked to confirm
before the deletion happens).
In general, there’s no real harm to deleting the cached pins, as they’ll be re-downloaded as needed.
The one exception is legacy_local() which mistakenly stored its pinned data in the cache direc-
tory; do not touch this directory.

Usage
cache_browse()

cache_info()

cache_prune(days = 30)

Arguments
days Number of days to preserve cached data; any pin versions older than days will
be removed.
14 legacy_azure

legacy_azure Azure board (legacy API)

Description
To use Microsoft Azure Storage as a board, you’ll need an Azure Storage account, an Azure Storage
container, and an Azure Storage key. You can sign-up and create those at portal.azure.com.

Usage
legacy_azure(
container = Sys.getenv("AZURE_STORAGE_CONTAINER"),
account = Sys.getenv("AZURE_STORAGE_ACCOUNT"),
key = Sys.getenv("AZURE_STORAGE_KEY"),
cache = NULL,
name = "azure",
...
)

board_register_azure(
name = "azure",
container = Sys.getenv("AZURE_STORAGE_CONTAINER"),
account = Sys.getenv("AZURE_STORAGE_ACCOUNT"),
key = Sys.getenv("AZURE_STORAGE_KEY"),
cache = NULL,
path = NULL,
...
)

Arguments
container The name of the Azure Storage container.
account The name of the Azure Storage account.
key The access key for the Azure Storage container. You can find this under "Access
keys" in your storage account settings.
The key is equivalent to a password, so generally should not be stored in your
script. The easiest alternative is to store it in the AZURE_STORAGE_KEY environ-
ment variable, which legacy_azure() will use by default.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.
path Subdirectory within url
legacy_datatxt 15

Examples
## Not run:
# the following example requires an Azure Storage key
board_register_azure(
container = "pinscontainer",
account = "pinsstorage",
key = "abcabcabcabcabcabcabcabcabcab=="
)

## End(Not run)

legacy_datatxt Remote "data.txt" board (legacy API)

Description
Use board that for a website that uses the data.txt specification. A data.txt file is a YAML that
provides some basic metadata about a directory of files.

Usage
legacy_datatxt(
url,
headers = NULL,
cache = NULL,
needs_index = TRUE,
browse_url = url,
index_updated = NULL,
index_randomize = FALSE,
path = NULL,
versions = FALSE,
name = NULL,
...
)

board_register_datatxt(url, name = NULL, headers = NULL, cache = NULL, ...)

Arguments
url Path to the data.txt file or directory containing it.
headers Optional list of headers to include or a function to generate them.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
needs_index Does this board have an index file?
browse_url Not currently used
16 legacy_dospace

index_updated Callback function used to update index

index_randomize
When retrieving data.txt at a parameter with random query string to defeat
caching?
path Subdirectory within url
versions Should this board be registered with support for versions?
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.

Examples

# register website board using datatxt file

board_register_datatxt(
url = "https://datatxt.org/data.txt",
name = "txtexample",
cache = tempfile()
)

# find pins
pin_find(board = "txtexample")

legacy_dospace DigitalOcean board (legacy API)

Description
To use DigitalOcean Spaces as a board, you first need an DigitalOcean space and a storage key. You
can sign-up and create those at digitalocean.com.

Usage
legacy_dospace(
space = Sys.getenv("DO_SPACE"),
key = Sys.getenv("DO_ACCESS_KEY_ID"),
secret = Sys.getenv("DO_SECRET_ACCESS_KEY"),
datacenter = Sys.getenv("DO_DATACENTER"),
cache = NULL,
host = "digitaloceanspaces.com",
name = "dospace",
...
)

board_register_dospace(
name = "dospace",
legacy_gcloud 17

space = Sys.getenv("DO_SPACE"),
key = Sys.getenv("DO_ACCESS_KEY_ID"),
secret = Sys.getenv("DO_SECRET_ACCESS_KEY"),
datacenter = Sys.getenv("DO_DATACENTER"),
cache = NULL,
host = "digitaloceanspaces.com",
path = NULL,
...
)

Arguments
space The name of the DigitalOcean space.
key, secret The key and secret for your space. You can create a key and secret in the "Spaces
access keys" in your API settings.
The secret is equivalent to a password, so generally should not be stored in
your script. The easiest alternative is to store it in the DO_SECRET_ACCESS_KEY
environment variable, which legacy_dospace() will use by default.
datacenter The datacenter name.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
host The host to use for storage, defaults to "digitaloceanspaces.com".
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.
path Subdirectory within url

Examples
## Not run:
# the following example requires a DigitalOcean Spaces API key
board <- legacy_dospace(bucket = "s3bucket")

## End(Not run)

legacy_gcloud Google Cloud board (legacy API)

Description
To use a Google Cloud Storage board, you first need a Google Cloud Storage account, a Google
Storage bucket, and an access token or the Google Cloud SDK properly installed and configured.
You can sign-up and create these from https://console.cloud.google.com
18 legacy_gcloud

Usage

legacy_gcloud(
bucket = Sys.getenv("GCLOUD_STORAGE_BUCKET"),
token = NULL,
cache = NULL,
name = "gcloud",
...
)

board_register_gcloud(
name = "gcloud",
bucket = Sys.getenv("GCLOUD_STORAGE_BUCKET"),
token = NULL,
cache = NULL,
path = NULL,
...
)

Arguments

bucket The name of the Google Cloud Storage bucket. Defaults to the GCLOUD_STORAGE_BUCKET
environment variable.
token The access token of the Google Cloud Storage container. Generally, it’s best
to leave this as NULL, and rely on the installed Google Cloud SDK to handle
authentication.
If you do want to use an access token, you can retrieve it from https://developers.
google.com/oauthplayground. You will need to authorize the "Google Stor-
age API v1" scope.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.
path Subdirectory within url

Examples
## Not run:
# the following example requires the Google Cloud SDK to be configured
board <- legacy_gcloud(container = "gcloudcontainer")

## End(Not run)
legacy_github 19

legacy_github GitHub board (legacy API)

Description
To use a GitHub board, you’ll need to set up authentication, following the instructions at https:
//happygitwithr.com/https-pat.html#https-pat.

Usage
legacy_github(
repo,
branch = NULL,
token = NULL,
path = "",
host = "https://api.github.com",
name = "github",
cache = NULL,
...
)

board_register_github(
name = "github",
repo = NULL,
branch = NULL,
token = NULL,
path = "",
host = "https://api.github.com",
cache = NULL,
...
)

Arguments
repo The GitHub repository formatted as ’owner/repo’.
branch The branch to use to commit pins. Default, NULL, will use main or master if
present.
token GitHub personal access token. Uses gitcreds if not set.
path The subdirectory in the repo where the pins will be stored.
host The URL of the GitHub API. You’ll need to customise this to use GitHub enter-
prise, e.g. "https://yourhostname/api/v3".
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
20 legacy_kaggle

... Additional parameters required to initialize a particular board.

Large Files
A GitHub repo only supports files under 25MB in size (100MB in theory but there is additional
overhead when using the GitHub API). To store large files, GitHub recommends storing them using
GitHub Releases which support up to 2GB files, which is what pins uses. You don’t need to do
anything extra as this will happen behind the scenes, but don’t be surprised if pins creates releases
in your repo.

Examples
## Not run:
# the following example requires a GitHub API key
board <- legacy_github("owner/repo")

## End(Not run)

legacy_kaggle Kaggle board (legacy API)

Description
To use a Kaggle board, you need to first download a token file from your account.

Usage
legacy_kaggle(token = NULL, name = "kaggle", ...)

board_register_kaggle(name = "kaggle", token = NULL, cache = NULL, ...)

Arguments
token The Kaggle token as a path to the kaggle.json file, can be NULL if the ~/.kag-
gle/kaggle.json file already exists.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.

Sharing
When working in teams, you might want to share your pins with others. For You can do by adding
users or making the dataset public on Kaggle’s website.
Once you share with specific users, they can follow the same steps to register a Kaggle board which
allows them to download and upload pins
legacy_local 21

Examples
## Not run:
# the following example requires a Kaggle API token
board <- legacy_kaggle(token = "path/to/kaggle.json")

pin_find("crowdflower", board = board)

# names starting with c/ are competitions

pin_get("c/crowdflower-weather-twitter", board = board)

## End(Not run)

legacy_local Local board (legacy API)

Description

legacy_local() powers board_register_local(), which allows you to access local pins cre-
ated in earlier versions of the pins package. For new pins, we recommend that you transition to
board_local() which supports the new pins API.
legacy_temp() creates a legacy board in a temporary location, for use in tests and examples.

Usage

legacy_local(path = NULL, name = "local", versions = FALSE)

board_register_local(name = "local", cache = NULL, ...)

legacy_temp(name = "temp", ...)

Arguments

path Path where pins will be stored. If not supplied, defaults to a system cache
directory, which may be deleted by the operating system if you run out of disk
space.
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
versions Should this board be registered with support for versions?
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
... Additional parameters required to initialize a particular board.
22 legacy_s3

Examples
# Old api
pin(data.frame(x = 1:3), "test")
pin_get("test")

# New api
board <- board_local()
board %>% pin_write(data.frame(x = 1:3), "test")
board %>% pin_read("test")

legacy_s3 S3 board (legacy API)

Description

To use an Amazon S3 Storage board, you need an Amazon S3 bucket and a user with enough
permissions to access the S3 bucket. You can sign-up and create those at https://aws.amazon.
com/. Note that it can take a few minutes after you’ve created it before a bucket is usable.
See board_s3() for a modern version of this legacy board.

Usage

legacy_s3(
bucket = Sys.getenv("AWS_BUCKET"),
key = Sys.getenv("AWS_ACCESS_KEY_ID"),
secret = Sys.getenv("AWS_SECRET_ACCESS_KEY"),
cache = NULL,
region = NULL,
host = "s3.amazonaws.com",
name = "s3",
...
)

board_register_s3(
name = "s3",
bucket = Sys.getenv("AWS_BUCKET"),
key = Sys.getenv("AWS_ACCESS_KEY_ID"),
secret = Sys.getenv("AWS_SECRET_ACCESS_KEY"),
cache = NULL,
host = "s3.amazonaws.com",
region = NULL,
path = NULL,
...
)
pin 23

Arguments
bucket The name of the Amazon S3 bucket.
key, secret The key and secret for your space. You can create a key and secret in the "Spaces
access keys" in your API settings.
The secret is equivalent to a password, so generally should not be stored in
your script. The easiest alternative is to store it in the AWS_SECRET_ACCESS_KEY
environment variable, which board_s3() will use by default.
cache Cache path. Every board requires a local cache to avoid downloading files mul-
tiple times. The default stores in a standard cache location for your operating
system, but you can override if needed.
region The region to use, required in some AWS regions and to enable V4 signatures.
host The host to use for storage, defaults to "s3.amazonaws.com".
name An optional name used identify the board. This is no longer generally needed
since you should be passing around an explicit board object.
... Additional parameters required to initialize a particular board.
path Subdirectory within url

Examples
## Not run:
# the following example requires an Amazon S3 API key
board <- legacy_s3(bucket = "s3bucket")

## End(Not run)

pin Pin a resource (legacy API)

Description
Pins the given resource locally or to the given board.

Usage
pin(x, name = NULL, description = NULL, board = NULL, ...)

Arguments
x An object, local file or remote URL to pin.
name The name for the dataset or object.
description Optional description for this pin.
board The board where this pin will be placed.
... Additional parameters.
24 pin_browse

Details
pin() allows you to cache remote resources and intermediate results with ease. When caching
remote resources, usually URLs, it will check for HTTP caching headers to avoid re-downloading
when the remote result has not changed.
This makes it ideal to support reproducible research by requiring manual instruction to download
resources before running your R script.
In addition, pin() still works when working offline or when the remote resource becomes unavail-
able; when this happens, a warning will be triggered but your code will continue to work.
pin() stores data frames in two files, an R native file (RDS) and a ’CSV’ file. To force saving a pin
in R’s native format only, you can use pin(I(data)). This can improve performance and size at
the cost of making the pin unreadable from other tools and programming languages.

Examples
# old API
board_register_local(cache = tempfile())
pin(mtcars)
pin_get("mtcars")

# new api
board <- board_local()
board %>% pin_write(mtcars)
board %>% pin_read("mtcars")

pin_browse Browse source of a pin

Description
pin_browse() navigates you to the home of a pin, either on the internet or on your local file system.

Usage
pin_browse(board, name, version = NULL, local = FALSE)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
name Pin name.
version Retrieve a specific version of a pin. Use pin_versions() to find out which
versions are available and when they were created.
local If TRUE, will open the local copy of the pin; otherwise will show you the home
of the pin on the internet.
pin_delete 25

Examples

board <- board_temp(versioned = TRUE)

board %>% pin_write(1:10, "x")
board %>% pin_write(1:11, "x")
board %>% pin_write(1:12, "x")

board %>% pin_browse("x", local = TRUE)

pin_delete Delete a pin

Description

Delete a pin (or pins), removing it from the board

Usage

pin_delete(board, names, ...)

Arguments

board A pin board, created by board_folder(), board_rsconnect(), board_url()

or another board_ function.
names The names of one or more pins to delete
... Additional arguments passed on to methods for a specific board.

Examples

board <- board_temp()

board %>% pin_write(1:5, "x")
board %>% pin_write(mtcars)
board %>% pin_write(runif(1e6), "y")
board %>% pin_list()

board %>% pin_delete(c("x", "y"))

board %>% pin_list()
26 pin_download

pin_download Upload and download files to and from a board

Description
This is a lower-level interface than pin_read() and pin_write() that you can use to pin any file,
as opposed to any R object. The path returned by pin_download() is a read-only path to a cached
file: you should never attempt to modify this file.

Usage
pin_download(board, name, version = NULL, hash = NULL, ...)

pin_upload(
board,
paths,
name = NULL,
title = NULL,
description = NULL,
metadata = NULL,
...
)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
name Pin name.
version Retrieve a specific version of a pin. Use pin_versions() to find out which
versions are available and when they were created.
hash Specify a hash to verify that you get exactly the dataset that you expect. You
can find the hash of an existing pin by looking for pin_hash in pin_meta().
... Additional arguments passed on to methods for a specific board.
paths A character vector of file paths to upload to board.
title A title for the pin; most important for shared boards so that others can understand
what the pin contains. If omitted, a brief description of the contents will be
automatically generated.
description A detailed description of the pin contents.
metadata A list containing additional metadata to store with the pin. When retrieving
the pin, this will be stored in the user key, to avoid potential clashes with the
metadata that pins itself uses.

Value
pin_download() returns a character vector of file paths; pin_upload() returns the fully qualified
name of the new pin, invisibly.
pin_exists 27

Examples
board <- board_temp()

board %>% pin_upload(system.file("CITATION"))

path <- board %>% pin_download("CITATION")
path
readLines(path)[1:5]

pin_exists Determine if a pin exists

Description
Determine if a pin exists

Usage
pin_exists(board, name, ...)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
name Pin name.
... Additional arguments passed on to methods for a specific board.

pin_find Search for pins (legacy API)

Description
Search for pins in legacy boards.

Usage
pin_find(
text = NULL,
board = NULL,
name = NULL,
extended = FALSE,
metadata = FALSE,
...
)
28 pin_get

Arguments
text The text to find in the pin description or name.
board The board name used to find the pin.
name The exact name of the pin to match when searching.
extended Should additional board-specific columns be shown?
metadata Include pin metadata in results?
... Additional parameters.

Examples
pin_find("cars")
# ->
board <- board_local()
board %>% pin_search("cars")

pin_get Retrieve a pin (legacy API)

Description
Retrieves a pin by name from the local or given board.

Usage
pin_get(
name,
board = NULL,
cache = TRUE,
extract = NULL,
version = NULL,
files = FALSE,
signature = NULL,
...
)

Arguments
name The name of the pin.
board The board where this pin will be retrieved from.
cache Should the pin cache be used? Defaults to TRUE.
extract Should compressed files be extracted? Each board defines the default behavior.
version The version of the dataset to retrieve, defaults to latest one.
files Should only the file names be returned?
signature Optional signature to validate this pin, use pin_info() to compute signature.
... Additional parameters.
pin_info 29

Details

pin_get() retrieves a pin by name and, by default, from the local board. You can use the board
parameter to specify which board to retrieve a pin from. If a board is not specified, it will use
pin_find() to find the pin across all boards and retrieve the one that matches by name.

Examples
# define temporary board
board <- legacy_temp()
pin(mtcars, board = board)

# retrieve the mtcars pin

pin_get("mtcars", board = board)

pin_info Retrieve pin metadata (legacy API)

Description

Retrieve metadata for pins in legacy boards.

Usage

pin_info(
name,
board = NULL,
extended = TRUE,
metadata = TRUE,
signature = FALSE,
...
)

Arguments

name The exact name of the pin to match when searching.

board The board name used to find the pin.
extended Should additional board-specific information be shown?
metadata Should additional pin-specific information be shown?
signature Should a signature to identify this pin be shown?
... Additional parameters.
30 pin_list

Examples
# old API
board_register_local(cache = tempfile())
pin(mtcars)
pin_info("mtcars", "local")

# new API
board <- board_temp()
board %>% pin_write(mtcars)
board %>% pin_meta("mtcars")

pin_list List all pins

Description

List names of all pins in a board. This is a low-level function; use pin_search() to get more data
about each pin in a convenient form.

Usage

pin_list(board, ...)

Arguments

board A pin board, created by board_folder(), board_rsconnect(), board_url()

or another board_ function.
... Other arguments passed on to methods

Value

A character vector

Examples
board <- board_temp()

board %>% pin_write(1:5, "x")

board %>% pin_write(letters, "y")
board %>% pin_write(runif(20), "z")

board %>% pin_list()

pin_meta 31

pin_meta Retrieve metadata for a pin

Description

Pin metadata comes from three sources:

• Standard metadata added by pin_upload()/pin_write(). This includes:

– $name - the pin’s name.
– $file - names of files stored in the pin.
– $file_size - size of each file.
– $pin_hash - hash of pin contents.
– $type - type of pin, "rds", "csv", etc
– $title - pin title
– $description - pin description
– $created - date this (version of the pin) was created
– $api_version - API version used by pin
• Metadata supplied by the user, stored in $user. This is untouched from what is supplied in
pin_write()/pin_upload() except for being converted to and from to YAML.
• Local metadata generated when caching the pin, stored in $local. This includes information
like the version of the pin, and the path its local cache.

Usage

pin_meta(board, name, version = NULL, ...)

Arguments

board A pin board, created by board_folder(), board_rsconnect(), board_url()

or another board_ function.
name Pin name.
version Retrieve a specific version of a pin. Use pin_versions() to find out which
versions are available and when they were created.
... Additional arguments passed on to methods for a specific board.

Value

A list.
32 pin_reactive_read

Examples
b <- board_temp()
b %>% pin_write(head(mtcars), "mtcars", metadata = list("Hadley" = TRUE))

# Get the pin

b %>% pin_read("mtcars")
# Get its metadata
b %>% pin_meta("mtcars")
# Get path to underlying data
b %>% pin_download("mtcars")

pin_reactive Reactive Pin (legacy API)

Description
Creates a pin that reacts to changes in the given board by polling pin_get(), useful when used
from the shiny package.

Usage
pin_reactive(name, board, interval = 5000, session = NULL, extract = NULL)

Arguments
name The name of the pin.
board The board where this pin will be retrieved from.
interval Approximate number of milliseconds to wait to retrieve updated pin. This can
be a numeric value, or a function that returns a numeric value.
session The user session to associate this file reader with, or NULL if none. If non-null,
the reader will automatically stop when the session ends.
extract Should compressed files be extracted? Each board defines the deefault behavior.

pin_reactive_read Wrap a pin in a reactive expression

Description
pin_reactive_read() and pin_reactive_download() wrap the results of pin_read() and pin_download()
into a Shiny reactive. This allows you to use pinned data within your app, and have the results au-
tomatically recompute when the pin is modified.
pin_read 33

Usage
pin_reactive_read(board, name, interval = 5000)

pin_reactive_download(board, name, interval = 5000)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
name Pin name.
interval Approximate number of milliseconds to wait between re-downloading the pin
metadata to check if anything has changed.

Examples
if (FALSE) {
library(shiny)
ui <- fluidPage(
tableOutput("table")
)

server <- function(input, output, session) {

board <- board_local()
data <- pin_reactive_read(board, "shiny", interval = 1000)
output$table <- renderTable(data())
}
shinyApp(ui, server)
}

pin_read Read and write objects to and from a board

Description
Use pin_write() to pin an object to board, and pin_read() to retrieve it.

Usage
pin_read(board, name, version = NULL, hash = NULL, ...)

pin_write(
board,
x,
name = NULL,
type = NULL,
title = NULL,
description = NULL,
34 pin_read

metadata = NULL,
versioned = NULL,
...
)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
name Pin name.
version Retrieve a specific version of a pin. Use pin_versions() to find out which
versions are available and when they were created.
hash Specify a hash to verify that you get exactly the dataset that you expect. You
can find the hash of an existing pin by looking for pin_hash in pin_meta().
... Additional arguments passed on to methods for a specific board.
x An object (typically a data frame) to pin.
type File type used to save x to disk. Must be one of "csv", "rds", "json", "arrow", or
"qs". If not supplied will use json for bare lists and rds for everything else.
title A title for the pin; most important for shared boards so that others can understand
what the pin contains. If omitted, a brief description of the contents will be
automatically generated.
description A detailed description of the pin contents.
metadata A list containing additional metadata to store with the pin. When retrieving
the pin, this will be stored in the user key, to avoid potential clashes with the
metadata that pins itself uses.
versioned Should the pin be versioned? The default, NULL, will use the default for board

Details
pin_write() takes care of the details of serialising an R object to disk, controlled by the type
argument. See pin_download()/pin_upload() if you want to perform the serialisation yourself
and work just with files.

Value
pin_read() returns an R object read from the pin; pin_write() returns the fully qualified name
of the new pin, invisibly.

Examples
b <- board_temp(versioned = TRUE)

b %>% pin_write(1:10, "x", description = "10 numbers")

b

b %>% pin_meta("x")
b %>% pin_read("x")
pin_remove 35

# Add a new version

b %>% pin_write(2:11, "x")
b %>% pin_read("x")

# Retrieve an older version

b %>% pin_versions("x")
b %>% pin_read("x", version = .Last.value$version[[1]])
# (Normally you'd specify the version with a string, but since the
# version includes the date-time I can't do that in an example)

pin_remove Delete a pin (legacy API)

Description

Deletes pins from a legacy board.

Usage

pin_remove(name, board = NULL)

Arguments

name The name for the pin.

board The board from where this pin will be removed.

Examples

# old API
board_register_local(cache = tempfile())
pin(mtcars)
pin_remove("mtcars")

# new API
board <- board_local()
board %>% pin_write(mtcars)
board %>% pin_delete("mtcars")
36 pin_versions

pin_search Search for pins

Description
The underlying search method depends on the board, but most will search for text in the pin name
and title.

Usage
pin_search(board, search = NULL, ...)

Arguments
board A pin board, created by board_folder(), board_rsconnect(), board_url()
or another board_ function.
search A string to search for in pin name and title. Use NULL to return all pins.
... Additional arguments passed on to methods.

Value
A data frame that summarises the metadata for each pin. Key attributes (name, type, description,
created, and file_size) are pulled out into columns; everything else can be found in the meta
list-column.

Examples
board <- board_temp()

board %>% pin_write(1:5, "x", title = "Some numbers")

board %>% pin_write(letters[c(1, 5, 10, 15, 21)], "y", title = "My favourite letters")
board %>% pin_write(runif(20), "z", title = "Random numbers")

board %>% pin_search()

board %>% pin_search("number")
board %>% pin_search("letters")

pin_versions List, delete, and prune pin versions

Description
• pin_versions() lists available versions a pin.
• pin_versions_prune() deletes old versions.
• pin_version_delete() deletes a single version.
pin_versions 37

Usage
pin_versions(board, name, ..., full = deprecated())

pin_version_delete(board, name, version, ...)

pin_versions_prune(board, name, n = NULL, days = NULL, ...)

Arguments
board, name A pair of board and pin name. For modern boards, use board %>% pin_versions(name).
For backward compatibility with the legacy API, you can also use pin_versions(name)
or pin_version(name,board).
... Additional arguments passed on to methods for a specific board.
full [Deprecated]
version Version identifier.
n, days Pick one of n or days to choose how many versions to keep. n = 3 will keep the
last three versions, days = 14 will keep all the versions in the 14 days. Regard-
less of what values you set, pin_versions_prune() will never delete the most
recent version.

Value
A data frame with at least a version column. Some boards may provided additional data.

Examples
board <- board_temp(versioned = TRUE)

board %>% pin_write(data.frame(x = 1:5), name = "df")

board %>% pin_write(data.frame(x = 2:6), name = "df")
board %>% pin_write(data.frame(x = 3:7), name = "df")

# pin_read() returns the latest version by default

board %>% pin_read("df")

# but you can return earlier versions if needed

board %>% pin_versions("df")

ver <- pin_versions(board, "df")$version[[1]]

board %>% pin_read("df", version = ver)

# delete all versions created more than 30 days ago

board %>% pin_versions_prune("df", days = 30)
Index

∗ boards cache_prune (cache_browse), 13

board_folder, 4
board_rsconnect, 8 legacy_azure, 14
board_url, 12 legacy_datatxt, 15
legacy_dospace, 16
AzureStor::blob_container(), 3 legacy_gcloud, 17
legacy_github, 19
board_azure, 2 legacy_kaggle, 20
board_folder, 4, 10, 13 legacy_local, 21
board_folder(), 12, 24–27, 30, 31, 33, 34, 36 legacy_local(), 13
board_kaggle, 5 legacy_s3, 22
board_kaggle_competitions legacy_temp (legacy_local), 21
(board_kaggle), 5
board_kaggle_dataset (board_kaggle), 5
Microsoft365R::ms_drive, 7
board_local (board_folder), 4
Microsoft365R::ms_drive_item, 7
board_local(), 21
board_ms365, 7
board_register_azure (legacy_azure), 14 pin, 23
board_register_datatxt pin_browse, 24
(legacy_datatxt), 15 pin_browse(), 10
board_register_dospace pin_delete, 25
(legacy_dospace), 16 pin_download, 26
board_register_gcloud (legacy_gcloud), pin_download(), 12, 32, 34
17 pin_exists, 27
board_register_github (legacy_github), pin_find, 27
19 pin_get, 28
board_register_kaggle (legacy_kaggle), pin_get(), 12
20 pin_info, 29
board_register_local (legacy_local), 21 pin_list, 30
board_register_s3 (legacy_s3), 22 pin_meta, 31
board_rsconnect, 4, 8, 13 pin_meta(), 26, 34
board_rsconnect(), 24–27, 30, 31, 33, 34, 36 pin_reactive, 32
board_s3, 10 pin_reactive_download
board_s3(), 22 (pin_reactive_read), 32
board_temp (board_folder), 4 pin_reactive_read, 32
board_url, 4, 10, 12 pin_read, 33
board_url(), 10, 24–27, 30, 31, 33, 34, 36 pin_read(), 32
pin_remove, 35
cache_browse, 13 pin_search, 36
cache_info (cache_browse), 13 pin_search(), 30

38
INDEX 39

pin_search.pins_board_kaggle_competition
(board_kaggle), 5
pin_search.pins_board_kaggle_dataset
(board_kaggle), 5
pin_store.pins_board_kaggle_dataset
(board_kaggle), 5
pin_upload (pin_download), 26
pin_upload(), 31, 34
pin_version_delete (pin_versions), 36
pin_versions, 36
pin_versions(), 24, 26, 31, 34
pin_versions_prune (pin_versions), 36
pin_write (pin_read), 33
pin_write(), 31