| |
|
|
| |
| args <- commandArgs(trailingOnly = TRUE) |
| arg_value <- function(name, default = '') { |
| prefix <- paste0('--', name, '=') |
| hit <- args[startsWith(args, prefix)] |
| if (!length(hit)) { |
| env_name <- toupper(gsub('-', '_', name)) |
| env_prefixed <- paste0('NHL_DB_', env_name) |
| value <- Sys.getenv(env_prefixed, unset = NA_character_) |
| if (is.na(value) || !nzchar(value)) { |
| value <- Sys.getenv(env_name, unset = NA_character_) |
| } |
| if (is.na(value)) { |
| return(default) |
| } |
| return(value) |
| } |
| sub(prefix, '', hit[[1]], fixed = TRUE) |
| } |
| OUTPUT_DIR <- arg_value('output-dir', 'output') |
| HF_SOURCE_REPO <- arg_value('hf-source-repo', 'RentoSaijo/NHL_DB') |
| SEASON_IDS <- arg_value('seasons', '') |
| UPDATE_DATE <- arg_value('update-date', '') |
| MAX_EVENTS <- arg_value('max-events', '') |
| OFFLINE_SOURCE <- arg_value('offline-source', 'false') |
| TIMEZONE <- arg_value('timezone', 'America/New_York') |
| DOWNLOAD_TIMEOUT <- arg_value('download-timeout', '3600') |
| DOWNLOAD_RETRIES <- arg_value('download-retries', '3') |
|
|
| |
| if (!nzchar(UPDATE_DATE)) { |
| UPDATE_DATE <- as.character(as.Date(format(Sys.time(), tz = TIMEZONE))) |
| } |
| UPDATE_DATE <- as.Date(UPDATE_DATE) |
| MAX_EVENTS <- suppressWarnings(as.integer(MAX_EVENTS)) |
| if (is.na(MAX_EVENTS) || MAX_EVENTS <= 0L) { |
| MAX_EVENTS <- Inf |
| } |
| OFFLINE_SOURCE <- tolower(OFFLINE_SOURCE) %in% c('true', '1', 'yes', 'y') |
| DOWNLOAD_TIMEOUT <- suppressWarnings(as.integer(DOWNLOAD_TIMEOUT)) |
| if (is.na(DOWNLOAD_TIMEOUT) || DOWNLOAD_TIMEOUT <= 0L) { |
| DOWNLOAD_TIMEOUT <- 3600L |
| } |
| DOWNLOAD_RETRIES <- suppressWarnings(as.integer(DOWNLOAD_RETRIES)) |
| if (is.na(DOWNLOAD_RETRIES) || DOWNLOAD_RETRIES <= 0L) { |
| DOWNLOAD_RETRIES <- 3L |
| } |
| options(timeout = max(getOption('timeout'), DOWNLOAD_TIMEOUT)) |
|
|
| |
|
|
| |
| format_elapsed_seconds <- function(start_time) { |
| sprintf('%.1fs', proc.time()[['elapsed']] - start_time) |
| } |
|
|
| |
| hf_url <- function(repo_id, path) { |
| paste0( |
| 'https://huggingface.co/datasets/', |
| repo_id, |
| '/resolve/main/', |
| path |
| ) |
| } |
|
|
| |
| get_remote_file_status <- function(url) { |
| response <- tryCatch( |
| httr2::request(url) |> |
| httr2::req_method('HEAD') |> |
| httr2::req_timeout(DOWNLOAD_TIMEOUT) |> |
| httr2::req_error(is_error = function(resp) FALSE) |> |
| httr2::req_perform(), |
| error = function(e) e |
| ) |
| if (inherits(response, 'error')) { |
| return('unknown') |
| } |
| status <- httr2::resp_status(response) |
| if (status == 404L) { |
| return('missing') |
| } |
| if (status >= 200L && status < 400L) { |
| return('exists') |
| } |
| 'unknown' |
| } |
|
|
| |
| read_hf_parquet <- function(path, repos = c(HF_SOURCE_REPO, 'RentoSaijo/NHL_DB')) { |
| local_path <- file.path(OUTPUT_DIR, path) |
| if (file.exists(local_path)) { |
| return(as.data.frame(arrow::read_parquet(local_path), stringsAsFactors = FALSE)) |
| } |
| if (isTRUE(OFFLINE_SOURCE)) { |
| return(NULL) |
| } |
| for (repo_id in unique(repos[nzchar(repos)])) { |
| url <- hf_url(repo_id, path) |
| status <- get_remote_file_status(url) |
| if (identical(status, 'missing')) { |
| next |
| } |
| last_error <- NULL |
| for (attempt in seq_len(DOWNLOAD_RETRIES)) { |
| tmp <- tempfile(fileext = '.parquet') |
| ok <- tryCatch( |
| utils::download.file(url, tmp, mode = 'wb', quiet = TRUE) == 0L, |
| error = function(e) { |
| last_error <<- conditionMessage(e) |
| FALSE |
| }, |
| warning = function(w) { |
| last_error <<- conditionMessage(w) |
| FALSE |
| } |
| ) |
| if (isTRUE(ok) && file.exists(tmp) && file.info(tmp)$size > 0L) { |
| out <- tryCatch( |
| as.data.frame(arrow::read_parquet(tmp), stringsAsFactors = FALSE), |
| error = function(e) { |
| last_error <<- conditionMessage(e) |
| NULL |
| } |
| ) |
| if (!is.null(out)) { |
| message(sprintf('Loaded existing parquet from %s/%s.', repo_id, path)) |
| return(out) |
| } |
| } |
| message(sprintf('Attempt %s/%s failed loading %s/%s.', attempt, DOWNLOAD_RETRIES, repo_id, path)) |
| } |
| if (!is.null(last_error) && grepl('404|Not Found', last_error, ignore.case = TRUE)) { |
| next |
| } |
| stop(sprintf( |
| 'Unable to load existing parquet from %s/%s; aborting to avoid treating remote data as missing. Last error: %s', |
| repo_id, |
| path, |
| ifelse(is.null(last_error), 'unknown', last_error) |
| )) |
| } |
| NULL |
| } |
|
|
| |
| write_output_parquet <- function(data, path) { |
| file_path <- file.path(OUTPUT_DIR, path) |
| dir.create(dirname(file_path), recursive = TRUE, showWarnings = FALSE) |
| arrow::write_parquet(data, file_path) |
| message(sprintf('Wrote %s row(s) to %s.', nrow(data), file_path)) |
| invisible(file_path) |
| } |
|
|
| |
| season_date <- function(x) { |
| as.Date(substr(as.character(x), 1L, 10L)) |
| } |
|
|
| |
| get_update_seasons <- function(update_date, season_ids = SEASON_IDS) { |
| if (nzchar(season_ids)) { |
| return(as.integer(strsplit(season_ids, ',', fixed = TRUE)[[1]])) |
| } |
| seasons <- nhlscraper::seasons() |
| start <- season_date(ifelse(is.na(seasons$preseasonStartdate), seasons$startDate, seasons$preseasonStartdate)) |
| end <- season_date(seasons$endDate) |
| seasons$seasonId[start <= update_date & end >= update_date] |
| } |
|
|
| |
| sort_replay_rows <- function(replays) { |
| if (is.null(replays) || !nrow(replays)) { |
| return(replays) |
| } |
| sort_columns <- intersect(c('gameId', 'eventId', 'timeInSeconds', 'timeInDeciseconds'), names(replays)) |
| if (!length(sort_columns)) { |
| return(replays) |
| } |
| replays[do.call(order, replays[sort_columns]), , drop = FALSE] |
| } |
|
|
| |
| bind_dynamic_rows <- function(rows) { |
| rows <- Filter(function(x) is.data.frame(x) && nrow(x), rows) |
| if (!length(rows)) { |
| return(data.frame()) |
| } |
| columns <- unique(unlist(lapply(rows, names), use.names = FALSE)) |
| rows <- lapply(rows, function(x) { |
| missing_columns <- setdiff(columns, names(x)) |
| for (column in missing_columns) { |
| x[[column]] <- NA |
| } |
| x[, columns, drop = FALSE] |
| }) |
| do.call(rbind, rows) |
| } |
|
|
| |
| empty_replay_index <- function() { |
| data.frame( |
| gameId = integer(), |
| eventId = integer(), |
| status = character(), |
| rowCount = integer(), |
| lastAttemptedAt = character(), |
| stringsAsFactors = FALSE |
| ) |
| } |
|
|
| |
| normalize_replay_index <- function(index) { |
| if (is.null(index) || !nrow(index)) { |
| return(empty_replay_index()) |
| } |
| for (column in names(empty_replay_index())) { |
| if (!column %in% names(index)) { |
| index[[column]] <- NA |
| } |
| } |
| index <- index[, names(empty_replay_index()), drop = FALSE] |
| index$gameId <- as.integer(index$gameId) |
| index$eventId <- as.integer(index$eventId) |
| index$status <- as.character(index$status) |
| index$rowCount <- as.integer(index$rowCount) |
| index$lastAttemptedAt <- as.character(index$lastAttemptedAt) |
| index$key <- paste(index$gameId, index$eventId, sep = '-') |
| index <- index[!duplicated(index$key, fromLast = TRUE), names(empty_replay_index()), drop = FALSE] |
| index[order(index$gameId, index$eventId), , drop = FALSE] |
| } |
|
|
| |
| build_replay_index_from_replays <- function(replays) { |
| if (is.null(replays) || !nrow(replays) || !all(c('gameId', 'eventId') %in% names(replays))) { |
| return(empty_replay_index()) |
| } |
| counts <- stats::aggregate( |
| x = list(rowCount = rep(1L, nrow(replays))), |
| by = list(gameId = as.integer(replays$gameId), eventId = as.integer(replays$eventId)), |
| FUN = sum |
| ) |
| counts$status <- 'success' |
| counts$lastAttemptedAt <- NA_character_ |
| normalize_replay_index(counts) |
| } |
|
|
| |
| merge_replay_index <- function(existing_index, new_index) { |
| existing_index <- normalize_replay_index(existing_index) |
| new_index <- normalize_replay_index(new_index) |
| if (!nrow(new_index)) { |
| return(existing_index) |
| } |
| existing_index$key <- paste(existing_index$gameId, existing_index$eventId, sep = '-') |
| new_index$key <- paste(new_index$gameId, new_index$eventId, sep = '-') |
| existing_index <- existing_index[!existing_index$key %in% new_index$key, names(empty_replay_index()), drop = FALSE] |
| normalize_replay_index(rbind(existing_index, new_index[, names(empty_replay_index()), drop = FALSE])) |
| } |
|
|
| |
| get_replay_index_skip_keys <- function(index) { |
| index <- normalize_replay_index(index) |
| index <- index[index$status %in% c('success', 'empty'), , drop = FALSE] |
| unique(paste(index$gameId, index$eventId, sep = '-')) |
| } |
|
|
| |
| get_goal_events <- function(pbps, season_id) { |
| event_type_column <- intersect(c('eventTypeDescKey', 'typeDescKey'), names(pbps)) |
| if (!length(event_type_column)) { |
| message(sprintf('GC play-by-play parquet for %s lacks goal-event columns; skipping replays.', season_id)) |
| return(NULL) |
| } |
| event_type_column <- event_type_column[[1]] |
| unique(pbps[pbps[[event_type_column]] == 'goal', c('gameId', 'eventId'), drop = FALSE]) |
| } |
|
|
| |
| aggregate_replays <- function(events, progress_label = 'Replays', progress_every = 100L) { |
| if (!nrow(events)) { |
| return(list(replays = data.frame(), index = empty_replay_index())) |
| } |
| results <- vector('list', nrow(events)) |
| attempts <- vector('list', nrow(events)) |
| success_count <- 0L |
| empty_count <- 0L |
| failed_count <- 0L |
| for (i in seq_len(nrow(events))) { |
| game_id <- events$gameId[[i]] |
| event_id <- events$eventId[[i]] |
| status <- 'error' |
| row_count <- 0L |
| attempted_at <- format(Sys.time(), '%Y-%m-%dT%H:%M:%SZ', tz = 'UTC') |
| results[[i]] <- tryCatch( |
| { |
| replay_df <- as.data.frame(nhlscraper::replay(game_id, event_id), stringsAsFactors = FALSE) |
| row_count <- nrow(replay_df) |
| if (!row_count) { |
| status <- 'empty' |
| data.frame() |
| } else { |
| status <- 'success' |
| replay_df$gameId <- as.integer(game_id) |
| replay_df$eventId <- as.integer(event_id) |
| replay_df[, c('gameId', 'eventId', setdiff(names(replay_df), c('gameId', 'eventId'))), drop = FALSE] |
| } |
| }, |
| error = function(e) { |
| message(sprintf('%s: failed game %s event %s: %s', progress_label, game_id, event_id, conditionMessage(e))) |
| data.frame() |
| } |
| ) |
| attempts[[i]] <- data.frame( |
| gameId = as.integer(game_id), |
| eventId = as.integer(event_id), |
| status = status, |
| rowCount = as.integer(row_count), |
| lastAttemptedAt = attempted_at, |
| stringsAsFactors = FALSE |
| ) |
| success_count <- success_count + as.integer(status == 'success') |
| empty_count <- empty_count + as.integer(status == 'empty') |
| failed_count <- failed_count + as.integer(status == 'error') |
| if (i %% progress_every == 0L || i == nrow(events)) { |
| message(sprintf( |
| '%s: %s/%s events complete (%s success, %s empty, %s failed).', |
| progress_label, |
| i, |
| nrow(events), |
| success_count, |
| empty_count, |
| failed_count |
| )) |
| } |
| } |
| list( |
| replays = bind_dynamic_rows(results), |
| index = normalize_replay_index(do.call(rbind, attempts)) |
| ) |
| } |
|
|
| |
| update_season_replays <- function(season_id) { |
| pbp_path <- sprintf('data/game/pbps/gc/NHL_PBPS_GC_%s.parquet', season_id) |
| replay_path <- sprintf('data/event/replays/NHL_REPLAYS_%s.parquet', season_id) |
| index_path <- sprintf('data/event/replays/index/NHL_REPLAYS_INDEX_%s.parquet', season_id) |
| pbps <- read_hf_parquet(pbp_path) |
| if (is.null(pbps) || !nrow(pbps)) { |
| message(sprintf('No GC play-by-play parquet found for %s; skipping replays.', season_id)) |
| return(invisible(NULL)) |
| } |
| if (!all(c('gameId', 'eventId') %in% names(pbps))) { |
| message(sprintf('GC play-by-play parquet for %s lacks event identity columns; skipping replays.', season_id)) |
| return(invisible(NULL)) |
| } |
| existing_replays <- NULL |
| replay_index <- read_hf_parquet(index_path) |
| if (is.null(replay_index)) { |
| existing_replays <- read_hf_parquet(replay_path) |
| replay_index <- build_replay_index_from_replays(existing_replays) |
| if (nrow(replay_index)) { |
| write_output_parquet(replay_index, index_path) |
| message(sprintf('Seeded replay index for %s from existing replay parquet.', season_id)) |
| } |
| } else { |
| replay_index <- normalize_replay_index(replay_index) |
| } |
| existing_keys <- get_replay_index_skip_keys(replay_index) |
| events <- get_goal_events(pbps, season_id) |
| if (is.null(events)) { |
| return(invisible(NULL)) |
| } |
| events$key <- paste(events$gameId, events$eventId, sep = '-') |
| events <- events[!events$key %in% existing_keys, c('gameId', 'eventId'), drop = FALSE] |
| if (is.finite(MAX_EVENTS)) { |
| events <- head(events, MAX_EVENTS) |
| } |
| message(sprintf( |
| 'Replays %s: %s existing goal events found, %s events remaining to scrape.', |
| season_id, |
| length(existing_keys), |
| nrow(events) |
| )) |
| if (!nrow(events)) { |
| message(sprintf('Replays %s: no new goal events found; leaving remote parquet unchanged.', season_id)) |
| return(invisible(replay_index)) |
| } |
| replay_update <- aggregate_replays(events, progress_label = sprintf('Replays %s', season_id)) |
| replay_index <- merge_replay_index(replay_index, replay_update$index) |
| write_output_parquet(replay_index, index_path) |
| if (!nrow(replay_update$replays)) { |
| message(sprintf('Replays %s: no new replay rows were returned; leaving remote parquet unchanged.', season_id)) |
| return(invisible(replay_index)) |
| } |
| if (is.null(existing_replays)) { |
| existing_replays <- read_hf_parquet(replay_path) |
| } |
| merged <- bind_dynamic_rows(list(existing_replays, replay_update$replays)) |
| merged <- sort_replay_rows(merged) |
| write_output_parquet(merged, replay_path) |
| invisible(merged) |
| } |
|
|
| |
|
|
| |
| season_ids <- get_update_seasons(UPDATE_DATE) |
| message(sprintf('Updating event datasets for season(s): %s.', paste(season_ids, collapse = ', '))) |
| for (season_id in season_ids) { |
| start_time <- proc.time()[['elapsed']] |
| update_season_replays(season_id) |
| message(sprintf('Finished replays %s in %s.', season_id, format_elapsed_seconds(start_time))) |
| } |
|
|
