Circular imports?

[dereckmezquita]

My understanding might be flawed or are ciruclar imports supposed to be possible?

I have a main.R that exports a and a module module.R that is called into main.R that exports b. Consequently module.R also imports c from main.R.

I tried this but I get file does not exists error for main.R.

I tried browser to check if the file exists and indeed fs::file_exists yeilds FALSE.

How can I accomplish this.

This is code I'm working on I decided to provide this example as my code does not work and demonstrates my goal. This is already a minimal example.

I'm trying to create a reactive timer in shiny that I can import across various modules of my shiny app and refresh them all in sync.

I hope someone more knowledgable can comment.

main.R

# https://community.rstudio.com/t/how-to-pause-edit-reactivetimer/176252/3
# This works but is not a module
box::use(shiny)

ui <- shiny$fluidPage(
  shiny$numericInput(
        "ms",
        "millisec",
        value = 300,
        min = 100,
        max = 2000,
        step = 100
    ),
    shiny$checkboxInput("chk", "on/off", value = TRUE),
    shiny$verbatimTextOutput("display")
)

options(digits.secs = 6)

box::use(./timer[ mytimer ])

#' @export
timer_opts <- list(
    ms = shiny$reactiveVal(NULL),
    chk = shiny$reactiveVal(NULL)
)

server <- function(input, output, session) {
    timer_opts$ms(shiny$req(input$ms))
    timer_opts$chk(shiny$req(input$chk))

    last_timer_value <- shiny$reactiveVal(NULL)

    shiny$observeEvent(mytimer(), {
        if(!identical(last_timer_value, mytimer())) {
            if(shiny$isTruthy(mytimer())) {
                last_timer_value(mytimer())
            }
        }
    })
    
    output$display <- shiny$renderText({
        capture.output(shiny$req(last_timer_value()))
    })
}

shiny$shinyApp(ui, server, options = list(port = 3003, launch.browser = FALSE))

timer.R

box::use(shiny)

timer_func <- function(timer_opts) {
    mytimer <- shiny$reactive({
        millis <- shiny$req(timer_opts$ms())
        shiny$invalidateLater(millis = millis)

        if (!shiny$isTruthy(timer_opts$chk())) {
            return(NULL)
        }

        return(Sys.time())
    })

    return(mytimer)
}

browser()

box::use(./main[ timer_opts ])

#' @export
mytimer <- timer_func(timer_opts)

Browse[1]> fs::file_exists("./main")
./main 
                                      FALSE 

[klmr]

Circular imports are supported, but several important limitations apply. In particular, while a module is being loaded, it only exists partially. So while other modules can import it, they will see a “placeholder” until loading has finished. That placeholder defines names but cannot yet be used.

However, I am not sure circularity is actually an issue here. In fact, when removing the circularity by inlining all code inside main.R (and removing the import of ./timer), the code still fails with a reactivity error. This error is therefore unrelated to circular modules:

Warning: Error in $: Can't access reactive value 'ms' outside of reactiv
 consumer.
ℹ Do you need to wrap inside reactive() or observe()?
  64: <Anonymous>
  63: signalCondition
  62: signal_abort
  61: rlang::abort
  60: $.reactivevalues
  50: server [main.R#54]
   4: runApp
   3: print.shiny.appobj
   1: source
Error in input$ms : 
  Can't access reactive value 'ms' outside of reactive consumer.
ℹ Do you need to wrap inside reactive() or observe()?

(And fs::file_exists("./main") will yield FALSE since the filename of the main module is main.R. So that’s also unrelated.)

[dereckmezquita]

Thank you @klmr, I tried to get this down to a minimal example so as to understand the concept and limitations. What am I doing wrong here?

main.R

#!/usr/bin/env Rscript
box::use(./module[ some_module ])

#' @export
something_from_main <- 1:10

print(some_module)

module.R

box::use(./main[ something_from_main ])

#' @export
some_module <- something_from_main * 2

(base) work@Derecks-MacBook-Air box-circular-imports % ./main.R
Loading .Rprofile.
Multi-threading for data.table using: 7 cores.
Error in box::use(./module[some_module]) : object 'some_module' not found
Calls: <Anonymous> ... tryCatchList -> tryCatchOne -> <Anonymous> -> rethrow
Execution halted
(base) work@Derecks-MacBook-Air box-circular-imports % 

[klmr]

Hi @dereckmezquita, yes, that’s one of the limitations of circular modules: you cannot use any imported name while the module is still in a partial loading state. The lines some_module <- something_from_main * 2 and print(some_module) are potentially problematic because they are attempting to use an imported name while the module the name is coming from is still being loaded.

The easiest way of dealing with circular imports is to break the circle. In your example you could do this by putting something_from_main into a third module, which you then import in both main and module.

However, you can use circular imports here, if you avoid that some_module is used during the (circular) import of main into some_module. In other words: print(some_module) should only be executed when main.R is executed directly, not when it is imported as a module. You can test this by checking whether box::name() is NULL inside main.R:

#!/usr/bin/env Rscript
box::use(./module[some_module])

#' @export
something_from_main <- 1:10

if (is.null(box::name())) {
  print(some_module)
}

Note that even though the line some_module <- something_from_main * 2 inside module.R is potentially problematic, it happens to work here after we made the change to main.R, because something_from_main is defined without dependency on module.R.

---

Please note that code that has a side-effect (such as print()) should never be executed directly at the module level. Currently this often works but in the future it will break (because future versions of ‘box’ will cache module contents, so box::use() won’t execute the code inside a module, it will just load exported names). Instead, such code should go into the .on_load() hook. In contrast to the above, the .on_load() hook is only executed when a module is loaded, not when the module is executed directly (e.g. via RScript main.R).

[klmr]

By the way, thanks for this excellent example of circular modules. I have to admit that I wasn’t sure myself what would happen here before trying it: circular imports are that tricky.

[dereckmezquita]

Thank you @klmr that makes total sense; thank you for pointing me to .on_load() that was my next question.