Shiny app downloads CRAN

The options argument in renderDataTable can take a list literally an R list of options, and pass them to DataTables when the table is initialized. For the iris data, we pass the options aLengthMenu and iDisplayLength to customize the drop down menu, which has items [10, 25, 50, ] by default; now the menu has three items [5, 30, 50] , and 5 is selected as the default value. The More Widgets application demonstrates the help text and submit button widgets as well as the use of embedded HTML elements to customize formatting.

In this example we update the Shiny Text application with some additional controls and formatting, specifically:. All of the changes from the original Shiny Text application were to the user-interface, the server script remains the same:. Shiny makes it easy to offer your users file uploads straight from the browser, which you can then access from your server logic. File upload controls are created by using the fileInput function in your ui.

R file. The fileInput function takes a multiple parameter that can be set to TRUE to allow the user to select multiple files, and an accept parameter can be used to give the user clues as to what kind of files the application expects.

This example receives a file and attempts to read it as comma-separated values using read. As the comment in server. In this case, fileInput did not have the multiple parameter so we can assume there is only one row. The file contents can be accessed by reading the file named by the datapath column. See the? The examples so far have demonstrated outputs that appear directly in the page, such as plots, tables, and text boxes.

Shiny also has the ability to offer file downloads that are calculated on the fly, which makes it easy to build data exporting features. You define a download using the downloadHandler function on the server side, and either downloadButton or downloadLink in the UI:. As you can see, downloadHandler takes a filename argument, which tells the web browser what filename to default to when saving.

This argument can either be a simple string, or it can be a function that returns a string as is the case here. The content argument must be a function that takes a single argument, the file name of a non-existent temp file.

The content function is responsible for writing the contents of the file download into that temp file. Provide your own content type string e. Shiny apps are often more than just a fixed set of controls that affect a fixed set of outputs. Inputs may need to be shown or hidden depending on the state of another input, or input controls may need to be created on-the-fly in response to user input. Shiny currently has three different approaches you can use to make your interfaces more dynamic.

From easiest to most difficult, they are:. In this example, the select control for smoothMethod will appear only when the smooth checkbox is checked. Its condition is "input. The condition can also use output values; they work in the same way output. If you have a situation where you wish you could use an R expression as your condition argument, you can create a reactive expression in server. R and assign it to a new output, then refer to that output in your condition expression.

For example:. However, since this technique requires server-side calculation which could take a long time, depending on what other reactive expressions are executing we recommend that you avoid using output in your conditions unless absolutely necessary. Note: This feature should be considered experimental.

Let us know whether you find it useful. These tags can include inputs and outputs. In ui. R , use a uiOutput to tell Shiny where these controls should be rendered. General instructions for doing so are outside the scope of this tutorial, except to mention an important additional requirement. Our current recommendation is:. R script. The previous examples in this tutorial used a ui. R file to build their user-interfaces. While this is a fast and convenient way to build user-interfaces, some appliations will inevitably require more flexiblity.

For this type of application, you can define your user-interface directly in HTML. In this case there is no ui. R file and the directory structure looks like this:. Here is the source code for the new user-interface definition:. There are few things to point out regarding how Shiny binds HTML elements back to inputs and outputs:. All of the changes from the original Tabsets application were to the user-interface, the server script remains the same:. Where you define objects will determine where the objects are visible.

Some objects are visible within the server. R code of each user session; other objects are visible in the server. R code across all sessions multiple users could use a shared variable ; and yet others are visible in the server.

R and the ui. R code across all user sessions. In server. R , when you call shinyServer , you pass it a function func which takes two arguments, input and output :. The function that you pass to shinyServer is called once for each session. In other words, func is called each time a web browser is pointed to the Shiny application.

Everything within this function is instantiated separately for each session. This includes the input and output objects that are passed to it: each session has its own input and output objects, visible within this function. Other objects inside the function, such as variables and functions, are also instantiated for each session. In this example, each session will have its own variable named startTime , which records the start time for the session:.

You might want some objects to be visible across all sessions. R , but outside of the call to shinyServer. You could put bigDataSet and utilityFunction inside of the function passed to shinyServer , but doing so will be less efficient, because they will be created each time a user connects. If the objects change, then the changed objects will be visible in every user session. Things work this way because server. R is sourced when you start your Shiny app.

Everything in the script is run immediately, including the call to shinyServer —but the function which is passed to shinyServer is called only when a web browser connects and a new session is started. Objects defined in global. R are similar to those defined in server. R outside shinyServer , with one important difference: they are also visible to the code in ui. This is because they are loaded into the global environment of the R session; all R code in a Shiny app is run in the global environment or a child of it.

R and ui. The code in ui. R is run once, when the Shiny app is started and it generates an HTML file which is cached and sent to each web browser that connects. This may be useful for setting some shared configuration options. You can think of this as putting the code in-line, so the code from the sourced files will receive the same scope as if you copied and pasted the text right there.

This example server. R file shows how sourced files will be scoped:. On the server side, Shiny applications use the input object to receive user input from the client web browser. The values in input are set by UI objects on the client web page. For example, a plot output object will report its height, width, and hidden status. Here is the view from the client, with all the clientData values:.

When you want to have R generate a plot and send it to the client browser, the renderPlot function will in most cases do the job. But when you need finer control over the process, you might need to use the renderImage function instead. In other words, any plot-generating code that would normally go between png and dev. If the following code works from the console, then it should work in renderPlot :. The solution in these cases is the renderImage function.

Image files can be sent using renderImage. The expression that you pass to renderImage must return a list containing an element named src , which is the path to the file. Here is a very basic example of a Shiny app with an output that generates a plot and sends it with renderImage :. Each time this output object is re-executed, it creates a new PNG file, saves a plot to it, then returns a list containing the filename along with some other values. Because the deleteFile argument is TRUE , Shiny will delete the file specified by the src element after it sends the data.

In this particular case, the image file is created with the png function. But it just as well could have been created with writePNG from the png package, or by any other method. If you have the filename of the image, you can send it with renderImage. The effect is similar to having an image tag with the following:. For browsers that support the data URI scheme , the src and contentType from the returned list are put together to create a special URL that embeds the data, so the result would be similar to something like this:.

If your Shiny app has pre-rendered images saved in a subdirectory, you can send them using renderImage. In the first example above, the plot size was fixed at by pixels. The width and height values passed to png specify the pixel dimensions of the saved image. These can differ from the width and height values in the returned list: those values are the pixel dimensions to used display the image. In Shiny, there are three kinds of objects in reactive programming: reactive sources, reactive conductors, and reactive endpoints, which are represented with these symbols:.

In a Shiny application, the source typically is user input through a browser interface. For example, when the selects an item, types input, or clicks on a button, these actions will set values that are reactive sources. In a simple Shiny application, reactive sources are accessible through the input object, and reactive endpoints are accessible through the output object. The server. R code for that example looks something like this:.

In traditional program with an interactive user interface, this might involve setting up event handlers and writing code to read values and transfer data. Shiny does all these things for you behind the scenes, so that you can simply write code that looks like regular R code.

A reactive source can be connected to multiple endpoints, and vice versa. Here is a slightly more complex Shiny application:. In a Shiny application, most endpoint functions have their results automatically wrapped up and sent to the web browser. In short, we will be creating a reactiveValues object that contains all of our visualizations, models, and data that we want to be in the PDF that a user downloads. We can store anything reactive and non-reactive in this object, as it functions exactly like a named list.

Below is another example of storing something we want to pass to the markdown in the reactiveValues object. Below is how I used it for this example app. The R community is known for continuously adding user-generated packages for specific areas of study, which makes it applicable to many fields.

Installation may take a while. Installation has successfully completed when we see the following lines near the end of the output and are returned to the R prompt:. The built-in web server randomly chooses a port each time it is started unless we initiate it with a specific value. If you followed our prerequisite tutorials, only SSH is allowed, as indicated in the following output:.

You may have other rules in place or no firewall rules at all. Shiny includes eleven built-in examples that demonstrate how it works. We installed Shiny to illustrate using devtools to install directly from a GitHub repository. Then we ran the example Shiny application without elevated privileges to verify that all users have access to the package. This allows me to separate access to the app from access to the data only if you have the relevant credentials you can get the data file - the.

It also means an upload of a much slimmer set of information to the shinyapps. It all works fine within R-studio as the download operation sticks the. It fails predictably once the app is deployed to shinyapps. Ideally there should be a "open" action which opens the. I really couldn't find it. This is the code that works within R-Studio I cannot obviously share the precise details of the Sharepoint site , any help figuring out the correct workflow strategy so it could work on shinyapps.

The actual problem is not the management of the file itself the comment below should address that. It's the autentication on Sharepoint within Shinyapps. This barebone app fails as well while working as expected on R-studio. This won't work when your code is on a remote server, like shinyapps. Instead you have to register your app with Azure, and use the resulting app ID when authenticating.

Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow.