Adds py_require() function

NAMESPACE

@@ -74,6 +74,7 @@ S3method(print,python.builtin.list)
 S3method(print,python.builtin.module)
 S3method(print,python.builtin.object)
 S3method(print,python.builtin.tuple)
+S3method(print,python_requirements)
 S3method(py_str,default)
 S3method(py_str,python.builtin.bytearray)
 S3method(py_str,python.builtin.dict)
@@ -190,6 +191,7 @@ export(py_module_available)
 export(py_none)
 export(py_numpy_available)
 export(py_repr)
+export(py_require)
 export(py_run_file)
 export(py_run_string)
 export(py_save_object)

R/package.R

@@ -26,6 +26,16 @@
 .globals$suppress_warnings_handlers <- list()
 .globals$class_filters <- list()
 .globals$py_repl_active <- FALSE
+.globals$python_requirements <- structure(
+  list(
+    dependencies = character(),
+    python = NULL
+  ),
+  class = "python_requirements",
+  history = list()
+)
+
+
 
 is_python_initialized <- function() {
   !is.null(.globals$py_config)

R/py_require.R

@@ -0,0 +1,235 @@
+#' @export
+py_require <- function(packages = NULL,
+                       python_version = NULL,
+                       exclude_newer = NULL,
+                       action = c("add", "remove", "set")) {
+  action <- match.arg(action)
+
+  if (!is.null(exclude_newer) &&
+    action != "set" &&
+    !is.null(get_python_reqs("exclude_newer"))
+  ) {
+    stop(
+      "`exclude_newer` is already set to '",
+      get_python_reqs("exclude_newer"),
+      "', use `action` 'set' to override"
+    )
+  }
+
+  if (missing(packages) && missing(python_version) && missing(exclude_newer)) {
+    return(get_python_reqs())
+  }
+
+  req_packages <- get_python_reqs("packages")
+  if (!is.null(packages)) {
+    req_packages <- switch(action,
+      add = unique(c(req_packages, packages)),
+      remove = setdiff(req_packages, packages),
+      set = packages
+    )
+  }
+
+  req_python <- get_python_reqs("python_version")
+  if (!is.null(python_version)) {
+    req_python <- switch(action,
+      add = unique(c(python_version, req_python)),
+      remove = setdiff(req_python, python_version),
+      set = python_version
+    )
+  }
+
+  top_env <- topenv(parent.frame())
+
+  pr <- .globals$python_requirements
+  pr$packages <- req_packages
+  pr$python_version <- req_python
+  pr$exclude_newer <- pr$exclude_newer %||% exclude_newer
+  pr$history <- c(pr$history, list(list(
+    requested_from = environmentName(top_env),
+    requested_is_package = isNamespace(top_env),
+    packages = packages,
+    python_version = python_version,
+    exclude_newer = exclude_newer,
+    action = action
+  )))
+  .globals$python_requirements <- pr
+
+  invisible()
+}
+
+# Print ------------------------------------------------------------------------
+
+#' @export
+print.python_requirements <- function(x, ...) {
+  packages <- x$packages
+  if (is.null(packages)) {
+    packages <- "[No packages added yet]"
+  } else {
+    packages <- paste0(packages, collapse = ", ")
+  }
+  python_version <- x$python_version
+  if (is.null(python_version)) {
+    python_version <- "[No version of Python selected yet]"
+  } else {
+    python_version <- paste0(python_version, collapse = ", ")
+  }
+  cat("------------------ Python requirements ----------------------\n")
+  cat("Current requirements ----------------------------------------\n")
+  cat(" Packages:", packages, "\n")
+  cat(" Python:  ", python_version, "\n")
+  if (!is.null(x$exclude_newer)) {
+    cat(" Exclude: Updates after", x$exclude_newer, "\n")
+  }
+  cat("Non-user requirements ---------------------------------------\n")
+  reqs <- data.frame()
+  for (item in x$history) {
+    if (item$requested_from != "R_GlobalEnv") {
+      if (item$requested_is_package) {
+        req_label <- paste0("package:", item$requested_from)
+      } else {
+        req_label <- item$requested_from
+      }
+      row_x <- data.frame(
+        requestor = paste(req_label, "|"),
+        packages = paste(paste0(item$packages, collapse = ", "), "|"),
+        python = paste(paste0(item$python, collapse = ", "), "|")
+      )
+      reqs <- rbind(reqs, row_x)
+    }
+  }
+  if (!is.null(reqs)) {
+    print(reqs)
+  }
+  return(invisible())
+}
+
+# Get requirements ---------------------------------------------------------
+
+get_python_reqs <- function(x = NULL) {
+  pr <- .globals$python_requirements
+  if (is.null(pr)) {
+    pr <- structure(
+      .Data = list(
+        python_version = c(),
+        packages = c(),
+        exclude_newer = NULL,
+        history = list()
+      ),
+      class = "python_requirements"
+    )
+    pkg_prime <- "numpy"
+    pr$packages <- pkg_prime
+    pr$history <- list(list(
+      requested_from = "reticulate",
+      requested_is_package = TRUE,
+      action = "add",
+      packages = pkg_prime
+    ))
+    .globals$python_requirements <- pr
+  }
+  if (!is.null(x)) {
+    pr[[x]]
+  } else {
+    pr
+  }
+}
+
+# uv ---------------------------------------------------------------------------
+
+uv_binary <- function() {
+  uv <- Sys.getenv("RETICULATE_UV", NA)
+  if (!is.na(uv)) {
+    return(uv)
+  }
+
+  uv <- getOption("reticulate.uv_binary")
+  if (!is.null(uv)) {
+    return(uv)
+  }
+
+  uv <- as.character(Sys.which("uv"))
+  if (uv != "") {
+    return(uv)
+  }
+
+  uv <- path.expand("~/.local/bin/uv")
+  if (file.exists(uv)) {
+    return(uv)
+  }
+
+  uv <- file.path(rappdirs::user_cache_dir("r-reticulate", NULL), "bin", "uv")
+  if (file.exists(uv)) {
+    return(uv)
+  }
+
+  if (is_windows()) {
+
+  } else if (is_macos() || is_linux()) {
+    install_uv.sh <- tempfile("install-uv-", fileext = ".sh")
+    download.file("https://astral.sh/uv/install.sh", install_uv.sh, quiet = TRUE)
+    Sys.chmod(install_uv.sh, mode = "0755")
+
+    dir.create(dirname(uv), showWarnings = FALSE)
+    # https://github.com/astral-sh/uv/blob/main/docs/configuration/installer.md
+    system2(install_uv.sh, c("--quiet"), env = c(
+      "INSTALLER_NO_MODIFY_PATH=1", paste0("UV_INSTALL_DIR=", maybe_shQuote(dirname(uv)))
+    ))
+    return(uv)
+  }
+}
+
+# TODO: we should pass --cache-dir=file.path(rappdirs::user_cache_dir("r-reticulate"), "uv-cache")
+# if we are using a reticulate-managed uv installation.
+
+get_or_create_venv <- function(packages = get_python_reqs("packages"),
+                               python_version = get_python_reqs("python_version"),
+                               exclude_newer = get_python_reqs("exclude_newer")) {
+  if (length(packages))
+    packages <- as.vector(rbind("--with", maybe_shQuote(packages)))
+
+  if (length(python_version))
+    python_version <- c("--python", maybe_shQuote(paste0(python_version, collapse = ",")))
+
+  if (!is.null(exclude_newer)) {
+    # todo, accept a POSIXct/lt, format correctly
+    exclude_newer <- c("--exclude-newer", maybe_shQuote(exclude_newer))
+  }
+
+  input <- "import sys; print(sys.executable);"
+
+  result <- suppressWarnings(system2(
+    uv_binary(), c(
+      "run",
+      "--no-project",
+      "--python-preference=only-managed",
+      exclude_newer,
+      python_version,
+      packages,
+      "python",
+      "-c",
+      shQuote("import sys; print(sys.executable);")
+    ), env = c(
+      "UV_NO_CONFIG=1"
+    ),
+    stdout = TRUE,
+  ))
+  if (!is.null(attr(result, "status"))) {
+    msg <- c(
+      "Python requirements could not be satisfied.",
+      if (!is.null(python_version))
+        paste0("Python version: ", python_version[2]),
+      if (!is.null(packages))
+        # TODO: wrap+indent+un_shQuote python packages
+        paste0(c("Python dependencies: ", matrix(packages, nrow = 2)[2, ]),
+               collapse = " "),
+      if (!is.null(exclude_newer))
+        paste0("Exclude newer: ", exclude_newer[2]),
+      "Call `py_require()` to remove or replace conflicting requirements."
+    )
+    msg <- paste0(msg, collapse = "\n")
+    # TODO: check if `stop()` will truncate msg, fix-up hint if yes.
+    stop(msg)
+  }
+
+  result
+}

reticulate.Rproj

@@ -1,4 +1,5 @@
 Version: 1.0
+ProjectId: 8168e5bb-a24d-416d-b683-1736e171d777
 
 RestoreWorkspace: No
 SaveWorkspace: No

tests/testthat/_snaps/py_require.md

@@ -0,0 +1,98 @@
+# Error requesting conflicting package versions
+
+    Code
+      r_session(attach_namespace = TRUE, {
+        py_require("numpy<2")
+        py_require("numpy>=2")
+        get_or_create_venv()
+      })
+    Output
+      > py_require("numpy<2")
+      > py_require("numpy>=2")
+      > get_or_create_venv()
+        × No solution found when resolving `--with` dependencies:
+        ╰─▶ Because you require numpy<2 and numpy>=2, we can conclude that your
+            requirements are unsatisfiable.
+      Error in get_or_create_venv() : 
+        Python requirements could not be satisfied.
+      Python dependencies:  'numpy<2' 'numpy>=2'
+      Call `py_require()` to remove or replace conflicting requirements.
+      Execution halted
+      ------- session end -------
+      success: false
+      exit_code: 1
+
+# Error requesting newer package version against an older snapshot
+
+    Code
+      r_session(attach_namespace = TRUE, {
+        py_require("tensorflow==2.18.*")
+        py_require(exclude_newer = "2024-10-20")
+        get_or_create_venv()
+      })
+    Output
+      > py_require("tensorflow==2.18.*")
+      > py_require(exclude_newer = "2024-10-20")
+      > get_or_create_venv()
+        × No solution found when resolving `--with` dependencies:
+        ╰─▶ Because only tensorflow<2.18.dev0 is available and you require
+            tensorflow>=2.18.dev0, we can conclude that your requirements are
+            unsatisfiable.
+
+            hint: `tensorflow` was requested with a pre-release marker (e.g.,
+            tensorflow>=2.18.dev0), but pre-releases weren't enabled (try:
+            `--prerelease=allow`)
+      Error in get_or_create_venv() : 
+        Python requirements could not be satisfied.
+      Python dependencies:  'tensorflow==2.18.*'
+      Exclude newer: 2024-10-20
+      Call `py_require()` to remove or replace conflicting requirements.
+      Execution halted
+      ------- session end -------
+      success: false
+      exit_code: 1
+
+# Error requesting a package that does not exists
+
+    Code
+      r_session(attach_namespace = TRUE, {
+        py_require(c("pandas", "numpy", "notexists"))
+        get_or_create_venv()
+      })
+    Output
+      > py_require(c("pandas", "numpy", "notexists"))
+      > get_or_create_venv()
+        × No solution found when resolving `--with` dependencies:
+        ╰─▶ Because notexists was not found in the package registry and you require
+            notexists, we can conclude that your requirements are unsatisfiable.
+      Error in get_or_create_venv() : 
+        Python requirements could not be satisfied.
+      Python dependencies:  pandas numpy notexists
+      Call `py_require()` to remove or replace conflicting requirements.
+      Execution halted
+      ------- session end -------
+      success: false
+      exit_code: 1
+
+# Error requesting conflicting Python versions
+
+    Code
+      r_session(attach_namespace = TRUE, {
+        py_require(python_version = ">=3.10")
+        py_require(python_version = "<3.10")
+        get_or_create_venv()
+      })
+    Output
+      > py_require(python_version = ">=3.10")
+      > py_require(python_version = "<3.10")
+      > get_or_create_venv()
+      error: No interpreter found for Python <3.10, >=3.10 in virtual environments or managed installations
+      Error in get_or_create_venv() : 
+        Python requirements could not be satisfied.
+      Python version: '<3.10,>=3.10'
+      Call `py_require()` to remove or replace conflicting requirements.
+      Execution halted
+      ------- session end -------
+      success: false
+      exit_code: 1
+