CA: check the parameters a cacheAs file was created with
Until now, a cacheAs file was used whenever it existed. Changing a
parameter and forgetting to delete the file therefore silently returned
an analysis computed with the old parameters. Inferring the parameters
from the cached data frame would not help much: of the 23 parameters
that affect the result, only node, vc, leftContextSize and
rightContextSize are recoverable from it, which leaves out exactly the
ones that are typically tuned between runs, such as minOccur,
topCollocatesLimit, searchHitsSampleLimit, exactFrequencies, stopwords
and threshold.
The parameters are therefore recorded when the file is written, and
compared on the next call. They are collected from the call frame rather
than listed explicitly, so that parameters added later are covered
without having to remember to register them. Also recorded is the API
URL, since reusing one cache file for two KorAP instances is a mistake
worth catching, and, for reference only, the index revision: corpus
updates should not invalidate an analysis that was deliberately kept.
If parameters differ, the analysis is recomputed and the file
overwritten, with a warning naming the differing parameters. That is
preferred over an error: it never returns results that disagree with the
requested parameters, and never breaks a long pipeline. Users who want
to keep an old analysis can pass a different cacheAs file name.
The parameters are stored in an attribute, so the file stays a plain
data frame for anyone reading it with readRDS(), and the attribute is
stripped when loading, so the returned value is the same whether it came
from the cache or not. Cache files written by 1.3.0 carry no attribute
and are used as they are.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Change-Id: Ib21aa93fa3c2bf1cd42dd07dbfcbd2970841a412
diff --git a/R/collocationAnalysis.R b/R/collocationAnalysis.R
index d185a0c..2d68636 100644
--- a/R/collocationAnalysis.R
+++ b/R/collocationAnalysis.R
@@ -1,6 +1,62 @@
#' @include logging.R
setGeneric("collocationAnalysis", function(kco, ...) standardGeneric("collocationAnalysis"))
+#' Name of the attribute under which cache files record their analysis parameters
+#' @noRd
+collocationCacheAttribute <- "RKorAPClient.collocationAnalysis"
+
+#' Parameters that a cached collocation analysis was computed with
+#'
+#' Collected from the calling `collocationAnalysis()` frame, so that parameters
+#' added in the future are taken into account automatically. `kco` and `cacheAs`
+#' are excluded: the former is not a parameter of the analysis, the latter only
+#' says where to store it.
+#'
+#' @param frame environment of the `collocationAnalysis()` call
+#' @param dots arguments passed on to [collocationScoreQuery()]
+#' @param kco [KorAPConnection()] object
+#' @return list of parameters to store with, and compare against, a cache file
+#' @noRd
+collocationCacheParameters <- function(frame, dots, kco) {
+ parameterNames <- setdiff(
+ names(formals(sys.function(sys.parent()))),
+ c("kco", "cacheAs", "...")
+ )
+ list(
+ parameters = mget(parameterNames, envir = frame),
+ dots = dots,
+ # reusing one cache file for two KorAP instances is a mistake worth catching
+ apiUrl = kco@apiUrl,
+ # recorded for reference only, deliberately not compared: corpus updates
+ # should not invalidate a deliberately kept analysis
+ indexRevision = kco@indexRevision
+ )
+}
+
+#' Parameters in which a cached collocation analysis differs from the current call
+#'
+#' @param stored parameters recorded in the cache file
+#' @param current parameters of the current call
+#' @return names of the differing parameters, empty if the cache is still valid
+#' @noRd
+differingCollocationCacheParameters <- function(stored, current) {
+ differing <- character(0)
+
+ for (name in union(names(stored$parameters), names(current$parameters))) {
+ if (!identical(stored$parameters[[name]], current$parameters[[name]])) {
+ differing <- c(differing, name)
+ }
+ }
+ if (!identical(stored$dots, current$dots)) {
+ differing <- c(differing, "...")
+ }
+ if (!identical(stored$apiUrl, current$apiUrl)) {
+ differing <- c(differing, "KorAP instance")
+ }
+
+ differing
+}
+
#' Collocation analysis
#'
#' @family collocation analysis functions
@@ -46,6 +102,13 @@
#' @param missingScoreQuantile lower quantile (evaluated per association measure over the pooled result set) that anchors the adaptive floor used for imputing missing scores between virtual corpora; a robust spread is subtracted from this anchor so the imputed values stay at or below the weakest observed scores. Imputed cells are marked in the `imputed*` columns; see the section on interpreting multi-VC comparisons below
#' @param vcLabel optional label override for the current virtual corpus (used internally when named VC collections are expanded)
#' @param cacheAs path to an RDS file for caching the result. If the file already exists, the cached result is loaded and returned immediately without contacting the server. Otherwise the analysis is run normally and the result is saved to the file before returning. Defaults to \code{NULL} (no caching).
+#'
+#' The analysis parameters are stored alongside the result. If they differ from
+#' those of the current call, the cached result would not be the one that was
+#' asked for, so it is recomputed and the file overwritten, with a warning
+#' naming the parameters that differ. Pass a different \code{cacheAs} file name
+#' to keep an existing analysis. Cache files written by RKorAPClient 1.3.0 do
+#' not contain the parameters yet and are used as they are.
#' @param ... more arguments will be passed to [collocationScoreQuery()]
#' @inheritParams collocationScoreQuery,KorAPConnection-method
#' @return
@@ -163,13 +226,43 @@
...) {
word <- frequency <- O <- NULL
- if (!is.null(cacheAs) && !grepl("\\.rds$", cacheAs, ignore.case = TRUE)) {
- cacheAs <- paste0(cacheAs, ".rds")
+ cacheParameters <- NULL
+ if (!is.null(cacheAs)) {
+ if (!grepl("\\.rds$", cacheAs, ignore.case = TRUE)) {
+ cacheAs <- paste0(cacheAs, ".rds")
+ }
+ cacheParameters <- collocationCacheParameters(environment(), list(...), kco)
}
if (!is.null(cacheAs) && file.exists(cacheAs)) {
- log_info(kco@verbose, sprintf("Loading collocation analysis from cache: %s\n", cacheAs))
- return(readRDS(cacheAs))
+ cached <- readRDS(cacheAs)
+ storedParameters <- attr(cached, collocationCacheAttribute)
+ attr(cached, collocationCacheAttribute) <- NULL
+
+ if (is.null(storedParameters)) {
+ # written before parameter checking existed, so there is nothing to check
+ log_info(kco@verbose, sprintf(
+ "Loading collocation analysis from cache (written without parameters): %s\n", cacheAs
+ ))
+ return(cached)
+ }
+
+ differing <- differingCollocationCacheParameters(storedParameters, cacheParameters)
+ if (length(differing) == 0) {
+ log_info(kco@verbose, sprintf("Loading collocation analysis from cache: %s\n", cacheAs))
+ return(cached)
+ }
+
+ warning(
+ sprintf(
+ paste0(
+ "Cache file '%s' was created with different parameters (%s) and is recomputed and overwritten.\n",
+ "Pass a different cacheAs file name to keep the cached analysis."
+ ),
+ cacheAs, paste(differing, collapse = ", ")
+ ),
+ call. = FALSE
+ )
}
if (!exactFrequencies && (!is.na(withinSpan) && !is.null(withinSpan) && nzchar(withinSpan))) {
@@ -417,7 +510,11 @@
if (!is.null(cacheAs)) {
log_info(kco@verbose, sprintf("Saving collocation analysis to cache: %s\n", cacheAs))
- saveRDS(result, cacheAs)
+ # only the stored copy carries the parameters, so that the returned value
+ # is the same whether it was cached or not
+ cachedResult <- result
+ attr(cachedResult, collocationCacheAttribute) <- cacheParameters
+ saveRDS(cachedResult, cacheAs)
}
result