R/wrapper.R
custom_scaffold_py_function_wrapper.RdThis function can be used to generate R wrapper for a specified
Python function while allowing to inject custom code for critical parts of
the wrapper generation, such as process the any part of the obtained docs
and append additional roxygen fields. The result
from execution of python_function is assigned to a variable called
python_function_result that can also be processed by postprocess_fn
before writing the closing curly braces for the generated wrapper function.
custom_scaffold_py_function_wrapper( python_function, r_function = NULL, additional_roxygen_fields = NULL, process_docs_fn = function(docs) docs, process_param_fn = function(param, docs) param, process_param_doc_fn = function(param_doc, docs) param_doc, postprocess_fn = NULL, file_name = NULL )
| python_function | Fully qualified name of Python function or class
constructor (e.g. |
|---|---|
| r_function | Name of R function to generate (defaults to name of Python function if not specified) |
| additional_roxygen_fields | A list of additional roxygen fields to write
to the roxygen docs, e.g. |
| process_docs_fn | A function to process the obtained docs. |
| process_param_fn | A function to process each parameter needed for
|
| process_param_doc_fn | A function to process the roxygen docstring for each parameter. |
| postprocess_fn | A function to inject any custom code in the form of a string before writing the closing curly braces for the generated wrapper function. |
| file_name | The file name to write the generated wrapper function to. If
|
# \donttest{ library(tensorflow) library(stringr) # Example of a `process_param_fn` to cast parameters with default values # that contains "L" to integers process_int_param_fn <- function(param, docs) { # Extract the list of parameters that have integer values as default int_params <- gsub( " = [-]?[0-9]+L", "", str_extract_all(docs$signature, "[A-z]+ = [-]?[0-9]+L")[[1]]) # Explicitly cast parameter in the list obtained above to integer if (param %in% int_params) { param <- paste0("as.integer(", param, ")") } param } # Note that since the default value of parameter `k` is `1L`. It is wrapped # by `as.integer()` to ensure it's casted to integer before sending it to `tf$nn$top_k` # for execution. We then print out the python function result. custom_scaffold_py_function_wrapper( "tf$nn$top_k", r_function = "top_k", process_param_fn = process_int_param_fn, postprocess_fn = function() { "print(python_function_result)" })#> #' @title top_k #> #' #> #' @description Finds values and indices of the `k` largest entries for the last dimension. #> #' #> #' @details If the input is a vector (rank=1), finds the `k` largest entries in the vector #> #' and outputs their values and indices as vectors. Thus `values[j]` is the #> #' `j`-th largest entry in `input`, and its index is `indices[j]`. For matrices (resp. higher rank input), computes the top `k` entries in each #> #' row (resp. vector along the last dimension). Thus, values.shape = indices.shape = input.shape[:-1] + [k] If two elements are equal, the lower-index element appears first. #> #' #> #' @param input 1-D or higher `Tensor` with last dimension at least `k`. #> #' @param k 0-D `int32` `Tensor`. Number of top elements to look for along the last dimension (along each row for matrices). #> #' @param sorted If true the resulting `k` elements will be sorted by the values in descending order. #> #' @param name Optional name for the operation. #> #' #> #' @return values: The `k` largest elements along each last dimensional slice. indices: The indices of `values` within the last dimension of `input`. #> #' #> #' @export #> top_k <- function(input, k = 1L, sorted = TRUE, name = NULL) { #> #> python_function_result <- tf$nn$top_k( #> input = input, #> k = as.integer(k), #> sorted = sorted, #> name = name #> ) #> print(python_function_result) #> }# }