Create records from data frames

R/Artifact.R

@@ -9,21 +9,16 @@ ArtifactRecord <- R6::R6Class( # nolint object_name_linter
   inherit = Record,
   public = list(
     #' @description
-    #' Load the artifact into memory. This currently only supports AnnData
-    #' artifacts.
+    #' Load the artifact into memory.
     #'
     #' @return The artifact
     load = function() {
-      artifact_accessor <- private$get_value("_accessor")
-
       file_path <- self$cache()
 
-      if (artifact_accessor == "AnnData") {
-        check_requires("Loading AnnData objects", "anndata")
-        anndata::read_h5ad(file_path)
-      } else {
-        cli_abort(paste0("Unsupported accessor: ", artifact_accessor))
-      }
+      suffix <- private$get_value("suffix")
+      file_loader <- get_file_loader(suffix)
+
+      file_loader(file_path)
     },
     #' @description
     #' Cache the artifact to the local filesystem. This currently only supports

R/Record.R

@@ -120,12 +120,28 @@ Record <- R6::R6Class( # nolint object_name_linter
         "key"
       )
 
-      record_fields <- private$.api$get_record(
-        module_name = private$.registry$module$name,
-        registry_name = private$.registry$name,
-        id_or_uid = private$.data[["uid"]],
-        include_foreign_keys = TRUE
-      )
+      expected_fields <- private$.registry$get_fields() |>
+        discard(~ is.null(.x$column_name)) |>
+        map_chr("column_name")
+
+      record_fields <- map(names(expected_fields), function(.field) {
+        value <- tryCatch(
+          self[[.field]],
+          error = function(err) {
+            if (!grepl("status code 404", conditionMessage(err))) {
+              cli::abort(conditionMessage(err))
+            }
+            NULL
+          }
+        )
+
+        if (inherits(value, "Record")) {
+          value <- value$id
+        }
+
+        value
+      }) |>
+        setNames(expected_fields)
 
       # Get the important fields that are in the record
       important_fields <- intersect(important_fields, names(record_fields))

R/Registry.R

@@ -138,6 +138,29 @@
         # Bind entries as rows
         list_rbind()
     },
+    from_df = function(dataframe, key = NULL, description = NULL, run = NULL) {
+      if (private$.registry_name != "artifact") {
+        cli::cli_abort(
+          "Creating records from data frames is only supported for the Artifact registry"
+        )
+      }
+
+      check_requires("Creating records from data frames", "reticulate")
+
+      py_lamin <- reticulate::import("lamindb")
+
+      instance_settings <- private$.instance$get_settings()
+      system2("lamin", "settings set auto-connect false")
+      py_lamin$connect(
+        paste0(instance_settings$owner, "/", instance_settings$name)
+      )
+
+      py_record <- py_lamin$Artifact$from_df(
+        dataframe, key = key, description = description, run = run
+      )
+
+      create_record_from_python(py_record, private$.instance)
+    },
     #' @description
     #' Get the fields in the registry.
     #'
@@ -346,3 +369,75 @@
     }
   )
 )
+
+create_record_from_python <- function(py_record, instance) {
+
+  py_classes <- class(py_record)
+
+  # Skip related fields for now
+  if ("django.db.models.manager.Manager" %in% py_classes) {
+    return(NULL)
+  }
+
+  class_split <- strsplit(py_classes[1], "\\.")[[1]]
+  module_name <- class_split[1]
+  if (module_name == "lnschema_core") {
+    module_name <- "core"
+  }
+  registry_name <- tolower(class_split[3])
+
+  registry <- instance$get_module(module_name)$get_registry(registry_name)
+  fields <- registry$get_field_names()
+
+  record_list <- map(fields, function(.field) {
+    value <- tryCatch(
+      py_record[[.field]],
+      error = function(err) {
+        NULL
+      }
+    )
+    if (inherits(value, "lnschema_core.models.Record")) {
+      value <- create_record_from_python(value, instance)
+    }
+    value
+  }) |>
+    setNames(fields)
+
+  record_class <- registry$get_record_class()
+  temp_record_class <- create_temporary_record_class(record_class)
+
+  suppressWarnings(temp_record_class$new(record_class, py_record, record_list))
+}
+
+create_temporary_record_class <- function(record_class) {
+  R6::R6Class(
+    paste0("Temporary", record_class$classname),
+    cloneable = FALSE,
+    inherit = record_class,
+    public = list(
+      initialize = function(record_class, py_record, data) {
+        private$.record_class <- record_class
+        private$.py_record <- py_record
+
+        super$initialize(data)
+      },
+      save = function() {
+        private$.py_record$save()
+        private$.registry$get(self$uid)
+      },
+      #' @description
+      #' Print a `TemporaryRecord`
+      #'
+      #' @param style Logical, whether the output is styled using ANSI codes
+      print = function(style = TRUE) {
+        cat("!!! TEMPORARY RECORD !!!")
+        cat("\n\n")
+        super$print()
+      }
+    ),
+    private = list(
+      .record_class = NULL,
+      .py_record = NULL
+    )
+  )
+}

R/file_handlers.R

@@ -0,0 +1,48 @@
+#' Get file loader
+#'
+#' Get the correct file loader function based on a file suffix
+#'
+#' @param suffix String giving a file suffix
+#'
+#' @return Function that can be used to load the file
+#' @noRd
+get_file_loader <- function(suffix) {
+  switch (suffix,
+    ".h5ad" = load_h5ad,
+    ".csv" = load_csv,
+    ".tsv" = load_tsv,
+    cli::cli_abort("Loading files with suffix {suffix} is not supported")
+  )
+}
+
+#' Load a H5AD file
+#'
+#' @param file Path to the file to load
+#'
+#' @return An `anndata::AnnDataR6` object
+#' @noRd
+load_h5ad <- function(file) {
+  check_requires("Loading AnnData objects", "anndata")
+
+  anndata::read_h5ad(file)
+}
+
+#' Load a CSV file
+#'
+#' @param file Path to the file to load
+#'
+#' @return A `data.frame`
+#' @noRd
+load_csv <- function(file) {
+  read.csv(file)
+}
+
+#' Load a TSV file
+#'
+#' @param file Path to the file to load
+#'
+#' @return A `data.frame`
+#' @noRd
+load_tsv <- function(file) {
+  read.delim(file)
+}