mrroy's questions

Apesar de ler muitos tutoriais, ainda não está claro para mim o que está sendo passado de volta de uma reactiveexpressão/bloco de código, especialmente quando os blocos de código dentro dele reactivese tornam maiores. Fiz alguns testes básicos, assumindo que reactiveConsole(TRUE)é uma maneira adequada de testar essas coisas.

O resumo a seguir é preciso?

• sem uma declaração explícita return, reactivesempre retorna o valor produzido pela última declaração dentro de sua expressão, independentemente de esse valor ter sido atribuído a uma variável local (mas veja o comportamento "inesperado" nos exemplos abaixo)
• use returninstruções explícitas para evitar retornar o resultado da instrução final, por exemplo, para evitar retornar uma printinstrução de depuração no final da expressão, para criar uma lógica if/else sobre o que retornar, etc.

Se houver outras variações importantes ou exceções a esse comportamento que valham a pena mencionar, por favor, faça-o.

library(shiny)
reactiveConsole(TRUE)

#------single line-----
#direct assignment
x = reactive({5})
x() #-> 5

ans = x()
ans #-> 5

#assign value to local variable, return
x = reactive({tmp = 5
return(tmp)})
x() #-> 5

ans = x()
ans #-> 5

#assign value to local variable, don't return
x = reactive({tmp = 5})
x() #-> [no response]

ans = x()
ans #-> 5 [value unexpectedly returns]


#-----multi-line---
#direct assignment: final line is retained
x = reactive({5
  10})
x() #-> 10

ans = x()
ans #-> 10


#return requested local var, tmp
x = reactive({tmp = 5
tmp2 = 10
return(tmp)})
x() #-> 5

ans = x()
ans #-> 5

#return requested local var, tmp2
x = reactive({tmp = 5
tmp2=10
return(tmp2)})
x() #-> 10

ans = x()
ans #-> 10

#without return
x = reactive({tmp = 5
tmp2 = 10})
x() #-> [no response]

ans = x()
ans #-> 10 [value unexpectedly returns]

Quero exibir uma tabela onde o usuário pode filtrar dinamicamente a tabela com base em uma ou mais colunas, com os diferentes filtros "respeitando" uns aos outros. Isso é semelhante a algumas outras perguntas (por exemplo, aqui , aqui e aqui ).

A exibição inicial deve ser a tabela completa. As colunas que podem ser usadas para filtragem são categóricas, e vários valores são permitidos para cada coluna. As escolhas nos menus suspensos devem refletir os valores disponíveis no momento, portanto, devem ser atualizadas com base nas seleções feitas em outros menus. Não há hierarquia pai/filho inerente às colunas/menus/filtros: o usuário deve ser capaz de começar a filtrar de qualquer menu. Finalmente, se nada foi selecionado em um menu específico, esse filtro deve ser desconsiderado (em vez de filtrar tudo).

No final das contas, isso também precisa ser dimensionado para ~10 filtros, então tentando evitar soluções muito detalhadas. Com base em tudo isso e perguntas/respostas relacionadas, cheguei ao seguinte. Bits individuais parecem funcionar durante o teste, mas não quando colocados juntos:

library(shiny)

ui = fluidPage(
  fluidRow(selectizeInput("cyl_select", "Select cylinder:","",multiple = TRUE), #using `selectizeInput` because real data requires adjusting the `maxOptions` setting
           selectizeInput("gear_select","Select gear:", "",multiple = TRUE),
           selectizeInput("carb_select","Select carburator:", "",multiple = TRUE)),
  fluidRow(DTOutput("filtered_table")))

server <- function(input, output, session) {
  
  df_mtcars = reactive({mtcars})
  
  #filter based on user input
  df_mtcars_filt = reactive({df_mtcars() %>%
      {if (!is.null(input$cyl_select)) filter(.,cyl %in% input$cyl_select) else . } %>% #piped if/else: only filter if input$[selection_var] contains meaningful values, otherwise pass data unaltered
      {if (!is.null(input$gear_select)) filter(.,gear %in% input$gear_select) else . } %>%
      {if (!is.null(input$carb_select)) filter(.,carb %in% input$carb_select) else . }
    })
 
  #render
  output$filtered_table = renderDT( df_mtcars_filt())
  
  #update the choice list
  observe({updateSelectizeInput(session,"cyl_select",choices = sort(unique(df_mtcars_filt()$cyl)))})
  observe({updateSelectizeInput(session,"gear_select",choices = sort(unique(df_mtcars_filt()$gear)))})
  observe({updateSelectizeInput(session,"carb_select",choices = sort(unique(df_mtcars_filt()$carb)))})
                                 
}

# run the app
shinyApp(ui = ui,
         server = server, 
         options = list(launch.browser = TRUE))

Estou tentando configurar o seguinte no Shiny:

1. leia o arquivo de origem usando uma rotina de leitura personalizada
2. processar dataframe e renderizar
3. monitorar o arquivo de origem para alterações usando o verificador de alterações de arquivo personalizado: quando o arquivo de origem tiver sido alterado, repita 1 e 2

Como isso pode ser feito?

Com base em várias postagens, tenho tentado a sorte com reactivePoll, pois isso parece ser o mais direto conceitualmente. Mas, dependendo da tentativa exata, estou tendo vários problemas, como checkFuncnão ser encontrado ou seu argumento de entrada não ser reconhecido.

De forma mais geral, ainda estou lutando para compreender as muitas maneiras pelas quais as variáveis ​​podem ser tornadas reativas ( Vantagens de reativo vs. observe vs. observeEvent ) e como tudo isso se aplica à minha situação.

Abaixo, segue um código simplificado que esperamos que forneça a essência:

library(shiny)
library(tidyverse)

#---------create data-----------
#tibble
id=c('p1','p2','p3')
val=c(2,4,6)
my_data=tibble(id,val)

#csv
file_csv='test.csv'
write_csv(my_data,file_csv)


#my "checkFunc" routine (with input argument)
myFileCheck = function(input_path) {
  if (file.exists(input_path))
    file.info(input_path)$mtime[1]
  else
    ""}
#test
tmp_time = myFileCheck(file_csv)
print(tmp_time)


#my read routine (with input argument)
myReadRoutine = function(input_path){
  df = read_csv(input_path, id = 'my_source')
}
#test
tmp_df=myReadRoutine(file_csv)
print(tmp_df)

#----------shiny---------
#ui
ui = fluidPage(tableOutput('my_data'))

#server
server = function(input, output, session) {
  
  #-----this part works---
  #always read data upon launch
  df_shiny=myReadRoutine(file_csv)
  
  #some processing for display
  df_shiny_display = reactive({df_shiny %>%
      mutate(val2=val*10)})
  
  #render
  output$my_data = renderTable(df_shiny_display())
  
  #-----this part doesn't----
  #use custom file check function (with argument): if file has changed, use custom file reader
  df_shiny = reactivePoll(1000, session, checkFunc = myFileCheck(file_csv), myReadRoutine(file_csv))
}

shinyApp(ui = ui,
         server = server)