Variable description

• name: The birth name
• year: The year of their social security number creation.
• State Name Columns: Each column for the 50 states and DC.
• Total: The total over all the states.

Variable summary

# https://www.ssa.gov/oact/babynames/limits.html
# Download and unzip to same folder as this script
# AK,F,1911,Ruth,7
# %%
import polars as pl
from pins import board_connect
from dotenv import load_dotenv, find_dotenv
# from posit import connect

load_dotenv("../../../.env")
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')


# %%
dat = pl.read_csv(
  'namesbystate/*.TXT',
  has_header=False,
  new_columns = ['state', 'gender', 'year', 'name', 'count'])\
  .group_by('state', 'name', 'year')\
  .agg(pl.sum('count').alias('count'))\
  .sort('state')

dat_total = dat.group_by('name', 'year').agg(pl.sum('count').alias('Total'))
# %%
# Now pivot
out_dat = dat.pivot('state', index=['name', 'year'], values='count')\
  .fill_null(0)\
  .join(dat_total, on=['name', 'year'])\
  .sort('name', 'year')


# %%
# Publish the data to the server with Bro. Hathaway as the owner.
pin_name = "names_year"
board = board_connect(server_url=SERVER, api_key=API_KEY)
board.pin_write(out_dat.to_pandas(), "hathawayj/" + pin_name, type="parquet")

# %%
meta = board.pin_meta("hathawayj/" + pin_name)
# https://docs.posit.co/connect/user/python-pins/
# https://rstudio.github.io/pins-python/
meta.local.get("content_id")



#%% Need to set the vanity url
# Do by hand https://posit.byui.edu/connect/#/apps/c0c197d3-f6bc-4129-9df4-4683c1f25e61/access
# Soon there will be code.
# https://github.com/posit-dev/posit-sdk-py/issues/175
# https://posit-dev.github.io/posit-sdk-py/quickstart.html

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/names_year_csv/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("names_year_csv")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/names_year_csv")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/names_year_csv")

Variable description

• entity: Country name
• code: 3-letter code for each country
• year: Year
• Share of the population using safely managed drinking water services: (Percent)
• Share of the population using only basic drinking water services: (Percent)
• Share of the population using limited drinking water services: (Percent)
• Share of the population using unimproved drinking water services: (Percent)
• Share of the population using surface water as a primary source of drinking water: (Percent)

Variable summary

pacman::p_load(tidyverse, pins, connectapi, owidR)

# owid() function downloads current data directly from Our World in Data.
# Use owid_search() to search for other OWID datasets.
# For more information, see the package documentation here: https://github.com/piersyork/owidR/blob/main/README.md
access_drinking_water_stacked <- owid('access-drinking-water-stacked')

# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, access_drinking_water_stacked, type = "parquet", access_type = "all")

pin_name <- "access_drinking_water_stacked"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/access_drinking_water_stacked/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("access_drinking_water_stacked")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/access_drinking_water_stacked")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/access_drinking_water_stacked")

Variable description

• Entity: Country name
• Code: 3-letter code for each country
• Year: Year
• antarctic_sea_ice_september: Amount of sea ice in Antarctica in September (millions of square kilometers)
• antarctic_sea_ice_february: Amount of sea ice in Antarctica in February (millions of square kilometers)

Variable summary

pacman::p_load(tidyverse, pins, connectapi, owidR, googledrive)

# owid() doesn't work for this dataset right now because the source site is down 5/8/2024

# owid() function downloads current data directly from Our World in Data.
# Use owid_search() to search for other OWID datasets.
# For more information, see the package documentation here: https://github.com/piersyork/owidR/blob/main/README.md
# climate_change_antarctica <- owid('climate-change-antarctica')


# Until that issue is resolved, the data can be found in the google drive
# Download the file from google drive
sdrive <- shared_drive_find("byuids_data") # This will ask for authentication.
google_file <- drive_ls(sdrive) |>
  filter(stringr::str_detect(name, "climate-change-antarctica"))
tempf <- tempfile()
drive_download(google_file, tempf)
climate_change_antarctica <- read_csv(tempf)

# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, climate_change_antarctica, type = "parquet", access_type = "all")

pin_name <- "climate_change_antarctica"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/climate_change_antarctica/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("climate_change_antarctica")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/climate_change_antarctica")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/climate_change_antarctica")

Variable description

• Entity: Country name
• Code: 3-letter code for each country
• Year: Year
• 700m_ocean_heat_content_iap: Ocean heat content found by the Chinese Academy of Sciences’ institute of Atmospheric Physics (IAP) in 10²² joules
• 700m_ocean_heat_content_noaa: Ocean heat content found by the U.S. National Oceanic and Atmospheric Administration (NOAA) in 10²² joules
• 700m_ocean_heat_content_csiro: Ocean heat content found by the Australia’s Commonwealth Scientific and Industrial Research Organisation (CSIRO) in 10²² joules
• 700m_ocean_heat_content_mrijma: Ocean heat content found by the Japan Meteorological Agency’s Meteorological Research Institute (MRI/JMA) in 10²² joules

Variable summary

pacman::p_load(tidyverse, pins, connectapi, googledrive, owidR)

# pwid() doesn't work for this dataset right now because the source site is down 5/8/2024

# # owid() function downloads current data directly from Our World in Data.
# # Use owid_search() to search for other OWID datasets.
# # For more information, see the package documentation here: https://github.com/piersyork/owidR/blob/main/README.md
# climate_change_ocean <- owid('climate-change-ocean')

# Until that issue is resolved, the data can be found in the google drive
# Download the file from google drive
sdrive <- shared_drive_find("byuids_data") # This will ask for authentication.
google_file <- drive_ls(sdrive) |>
  filter(stringr::str_detect(name, "climate-change-ocean"))
tempf <- tempfile()
drive_download(google_file, tempf)
climate_change_ocean <- read_csv(tempf)

# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, climate_change_ocean, type = "parquet", access_type = "all")

pin_name <- "climate_change_ocean"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/climate_change_ocean/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("climate_change_ocean")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/climate_change_ocean")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/climate_change_ocean")

Variable description

• contestant_gender Gender of contestant (Female, Male)
• contestant_age_group Age group (< 30, 30 to 39, 40 to 49, 50 to 59, 60 Plus)
• contestant_age Age (years)
• initial_weight_at_start_show Initial weight at start of show (lbs)
• weight_after_1_week Weight after one week (lbs)
• height Height (in)
• season Season of show (1 to 17)
• trainer Trainer first name
• prop_initial_weight_lost Unknown (appears to be a quantity of weight in lbs)
• prop_initial_weight_lost_week1 Unknown (Presumes to be weight lost, but numbers are NOT the difference between the initial weight and weight after one week)
• winner Whether contestant won or lost (lost, won)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

biggest_loser <- read_csv('https://github.com/byuistats/data/raw/master/biggest_loser/biggest_loser.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, biggest_loser, type = "parquet", access_type = "all")

pin_name <- "biggest_loser"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/biggest_loser/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("biggest_loser")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/biggest_loser")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/biggest_loser")

Variable description

• Health: SF-36 score (0-100). Lower scores on the SF-36 indicate a poorer quality of health.

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

cardiac_arrest_health <- read_csv('https://github.com/byuistats/data/raw/master/CardiacArrestHealth/CardiacArrestHealth.csv') %>% 
  rename(Health = x) # Rename column to match documentation


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, cardiac_arrest_health, type = "parquet", access_type = "all")

pin_name <- "cardiac_arrest_health"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/cardiac_arrest_health/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("cardiac_arrest_health")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/cardiac_arrest_health")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/cardiac_arrest_health")

Variable description

• censusid: Unique ID for each county
• state: State that county is in
• county: County name
• totalpop: Total population of county
• men: Total population of men
• women: Total population of women
• hispanic: Percent of population that is marked as Hispanic
• white: Percent of population that is marked as White
• black: Percent of population that is marked as Black
• native: Percent of population that is marked as Native
• asian: Percent of population that is marked as Asian
• pacific: Percent of population that is marked as Pacific
• citizen: Unknown, could refer to total population of citizens
• income: Unknown, appears to be a summary statistic of some kind involving income
• incomeerr: Unknown
• incomepercap: Unknown, appears to relate to income per capita
• incomepercaperr: Unknown
• poverty: Unknown, possibly a percent of people in poverty
• childpoverty: Unknown, possibly a percent of children in poverty
• professional: Percent of people working in the category “professional”
• service: Percent of people working in the category “service”
• office: Percent of people working in the category “office”
• construction: Percent of people working in the category “construction”
• production: Percent of people working in the category “production”
• drive: Percent of people who fit into the category “drive”
• carpool: Percent of people who fit into the category “carpool”
• transit: Percent of people who fit into the category “transit”
• walk: Percent of people who fit into the category “walk”
• othertransp: Percent of people who fit into the category “other transport”
• workathome: Percent of people who fit into the category “work at home”
• meancommute: Most likely the mean duration of commutes (min)
• employed: Total people employed
• privatework: Percent of people who fit into the category “private work”
• publicwork: Percent of people who fit into the category “public work”
• selfemployed: Percent of people who fit into the category “self employed”
• familywork: Percent of people who fit into the category “family work”
• unemployment: Unemployment percentage (not part of the percentages in the previous 4 columns)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

census_2015 <- read_csv('https://github.com/byuistats/data/raw/master/census2015/census2015.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, census_2015, type = "parquet", access_type = "all")

pin_name <- "census_2015"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/census_2015/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("census_2015")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/census_2015")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/census_2015")

Variable description

• Community: Difference in ESWT score over course of study for participants in community-based rehab.
• Hospital: Difference in ESWT score over course of study for participants in hospital-based rehab. Note: Higher scores indicate improvement, and negative scores indicate deterioration.

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

copd_rehab <- read_csv('https://github.com/byuistats/data/raw/master/COPD-Rehab/COPD-Rehab.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, copd_rehab, type = "parquet", access_type = "all")

pin_name <- "copd_rehab"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/copd_rehab/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("copd_rehab")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/copd_rehab")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/copd_rehab")

Variable description

• title Movie title
• year Release Year
• length Movie length (min)
• budget Budget (dollars)
• rating Rating
• votes Unkown
• r1 Unkown
• r2 Unkown
• r3 Unkown
• r4 Unkown
• r5 Unkown
• r6 Unkown
• r7 Unkown
• r8 Unkown
• r9 Unkown
• r10 Unkown
• mpaa Motion Picture Association of America rating (NC-17, PG, PG-13, R)
• Action Whether film pertains to action genre or not (0, 1)
• Animation Whether film pertains to animation genre or not (0, 1)
• Comedy Whether film pertains to comedy genre or not (0, 1)
• Drama Whether film pertains to drama genre or not (0, 1)
• Documentary Whether film pertains to documentary genre or not (0, 1)
• Romance Whether film pertains to romance genre or not (0, 1)
• Short Whether film pertains to short genre or not (0, 1)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

movies <- read_csv('https://github.com/byuistats/data/raw/master/movies/movies.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, movies, type = "parquet", access_type = "all")

pin_name <- "movies"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/movies/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("movies")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/movies")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/movies")

Variable description

• Soprano Singer height (inches)
• Alto Singer height (inches)
• Tenor Singer height (inches)
• Bass Singer height (inches)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

singer_heights <- read_csv('https://github.com/byuistats/data/raw/master/SingerHeights/SingerHeights.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, singer_heights, type = "parquet", access_type = "all")

pin_name <- "singer_heights"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/singer_heights/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("singer_heights")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/singer_heights")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/singer_heights")

Variable description

• Footwear: A unique ID for each footwear (A, B, C, D, E, Socks)
• Accuracy: Distance from the center of the target (centimeters)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

soccer_shoes <- read_csv('https://github.com/byuistats/data/raw/master/SoccerShoes/SoccerShoes.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, soccer_shoes, type = "parquet", access_type = "all")

pin_name <- "soccer_shoes"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/soccer_shoes/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("soccer_shoes")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/soccer_shoes")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/soccer_shoes")

Variable description

• Date: Date (MM/DD/YYYY)
• Location: Submarine involved in accident, Location of accident
• TypeofAccident: Type of accident
• Deaths: Count of deaths associated with each accident

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

soviet_accidents <- read_csv('https://github.com/byuistats/data/raw/master/SovietAccidents/SovietAccidents.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, soviet_accidents, type = "parquet", access_type = "all")

pin_name <- "soviet_accidents"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/soviet_accidents/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("soviet_accidents")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/soviet_accidents")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/soviet_accidents")

Variable description

• SpeedOfLight: Speed of light (millions of meters per second)
• Temp: Temperature (F)
• Day: Day of the month
• TimeOfDay: (AM/PM)
• Set: Identification number of dataset (1 to 24)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

speed_of_light_by_michelson_1879 <- read_csv('https://github.com/byuistats/data/raw/master/SpeedOfLightByMichelson1879/SpeedOfLightByMichelson1879.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, speed_of_light_by_michelson_1879, type = "parquet", access_type = "all")

pin_name <- "speed_of_light_by_michelson_1879"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/speed_of_light_by_michelson_1879/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("speed_of_light_by_michelson_1879")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/speed_of_light_by_michelson_1879")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/speed_of_light_by_michelson_1879")

Variable description

• SpeedOfLight: Speed of light (millions of meters per second)

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

speed_of_light_by_michelson_1882 <- read_csv('https://github.com/byuistats/data/raw/master/SpeedOfLightByMichelson1882/SpeedOfLightByMichelson1882.csv') %>% 
  rename(SpeedOfLight = x)


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, speed_of_light_by_michelson_1882, type = "parquet", access_type = "all")

pin_name <- "speed_of_light_by_michelson_1882"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/speed_of_light_by_michelson_1882/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("speed_of_light_by_michelson_1882")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/speed_of_light_by_michelson_1882")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/speed_of_light_by_michelson_1882")

Variable description

• Year: Release Year
• AdvertisedinSuperBowl: Whether movie was advertised in Superbowl or not (No, Yes)
• Title: Movie title
• GrossRevenueMillion: Gross Revenue (millions of dollars)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

super_bowl_movies <- read_csv('https://github.com/byuistats/data/raw/master/SuperBowlMovies/SuperBowlMovies.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, super_bowl_movies, type = "parquet", access_type = "all")

pin_name <- "super_bowl_movies"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/super_bowl_movies/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("super_bowl_movies")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/super_bowl_movies")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/super_bowl_movies")

Variable description

• Twin: ID for each pair of twins
• Age: Age at time of diagnosis (years)
• Gender: Gender of twins (M, F)
• NonDiabeticHeight: Height of non-diabetic twin (cm)
• DiabeticHeight: Height of diabetic twin (cm)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

twins_diabetes <- read_csv('https://github.com/byuistats/data/raw/master/TwinsDiabetes/TwinsDiabetes.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, twins_diabetes, type = "parquet", access_type = "all")

pin_name <- "twins_diabetes"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/twins_diabetes/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("twins_diabetes")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/twins_diabetes")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/twins_diabetes")

Variable description

• VertebralHeight: Height of the T4 vertebra of the subject (centimeters)

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

vertebral_heights <- read_csv('https://github.com/byuistats/data/raw/master/VertebralHeights/VertebralHeights.csv') %>% 
  rename(VertebralHeight = x) # Rename column to match documentation


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, vertebral_heights, type = "parquet", access_type = "all")

pin_name <- "vertebral_heights"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/vertebral_heights/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("vertebral_heights")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/vertebral_heights")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/vertebral_heights")

Variable description

• Date: Date (Monthname day, YYYY)
• HeartAttacks: Count of heart attacks
• TimePeriod: Time period group (Control, World Cup)

Variable summary

library(tidyverse)
library(pins)
library(connectapi)

world_cup_heart_attacks <- read_csv('https://github.com/byuistats/data/raw/master/WorldCupHeartAttacks/WorldCupHeartAttacks.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, world_cup_heart_attacks, type = "parquet", access_type = "all")

pin_name <- "world_cup_heart_attacks"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/world_cup_heart_attacks/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("world_cup_heart_attacks")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/world_cup_heart_attacks")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/world_cup_heart_attacks")

Variable description

• Wrong.Site: Costs incurred by hospital from wrong site errors (dollars)
• Wrong.Patient: Costs incurred by hospital from wrong patient errors (dollars)

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

wrong_site_wrong_patient <- read_csv('https://github.com/byuistats/data/raw/master/WrongSiteWrongPatient/WrongSiteWrongPatient.csv')


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, wrong_site_wrong_patient, type = "parquet", access_type = "all")

pin_name <- "wrong_site_wrong_patient"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/wrong_site_wrong_patient/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("wrong_site_wrong_patient")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/wrong_site_wrong_patient")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/wrong_site_wrong_patient")

Variable description

• Duration.of.Symptoms..Zinc. Days for which subject reported symptoms (zinc lozenge group)
• Duration.of.Symptoms..Placebo. Days for which subject reported symptoms (placebo lozenge group)

Variable summary

NULL

library(tidyverse)
library(pins)
library(connectapi)

zinc_for_colds <- read_csv('https://github.com/byuistats/data/raw/master/ZincForColds/ZincForColds.csv') %>% 
  select(!Souce) # Delete description column


# Publish the data to the server with Bro. Hathaway as the owner.
board <- board_connect()
pin_write(board, zinc_for_colds, type = "parquet", access_type = "all")

pin_name <- "zinc_for_colds"
meta <- pin_meta(board, paste0("hathawayj/", pin_name))
client <- connect()
my_app <- content_item(client, meta$local$content_id)
set_vanity_url(my_app, paste0("data/", pin_name))

R and Python Download:

library(pins)
url_data <- "https://posit.byui.edu/data/zinc_for_colds/"
board_url <- board_connect_url(c("dat" = url_data))
dat <- pin_read(board_url, "dat")

import pandas as pd
import requests
from io import BytesIO

def read_url_pin(name):
  url = "https://posit.byui.edu/data/" + name + "/" + name + ".parquet"
  response = requests.get(url)
  if response.status_code == 200:
    parquet_content = BytesIO(response.content)
    pandas_dataframe = pd.read_parquet(parquet_content)
    return pandas_dataframe
  else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")
    return None

# Example usage:
pandas_df = read_url_pin("zinc_for_colds")

Authenticated Connection:

Our connect server is https://posit.byui.edu which you assign to your CONNECT_SERVER environment variable. You must create an API key and store it in your environment under CONNECT_API_KEY.

Read more about environment variables and the pins package to understand how these environment variables are stored and accessed in R and Python with pins.

library(pins)
board <- board_connect(auth = "auto")
dat <- pin_read(board, "hathawayj/zinc_for_colds")

import os
from pins import board_rsconnect
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('CONNECT_API_KEY')
SERVER = os.getenv('CONNECT_SERVER')

board = board_rsconnect(server_url=SERVER, api_key=API_KEY)
dat = board.pin_read("hathawayj/zinc_for_colds")