A Fine Slice Of SQL Server
Andrew Collier does some linting and styling:
In the previous post we looked at how to apply a linter and styler to a Python Project. Now we’re going to do the same for an R project. We’ll use the
{precommit}R package to make the setup a breeze.
Read on to see how the combination of precommit, lintr, and styler can track deviations from expected development style. H/T R-Bloggers.
Thomas Williams wants to take control:
It is possible – though not the default – set set keyboard focus on load to a control in an R Markdown web page rendered with Shiny.
Setting keyboard focus when an R Markdown page is loaded is beneficial to users, who can start interacting with the page without having to first click the control.
Click through to learn how. This is one of the biggest losses we have in the GUI era: that you have a mouse necessitates using the mouse for everything. But that’s a “get off my lawn” rant for another day.
Comments closedThomas Williams wants you to wait patiently:
Waits are inevitable, whether getting data from an API or database, or manipulating data in an interactive R Markdown document. Showing a “loading” or “updating” message is a beneficial incremental improvement to users’ experience.
The code at https://github.com/thomasswilliams/r-markdown-snippets/blob/main/loading-message-datatable.Rmd, when run from RStudio, demonstrates using CSS and pseudo-elements to display text in a DataTables (
DTpackage).
Read on to see an example of how to use this.
Comments closedJamie Owen begins a series on building APIs as R packages:
At Jumping Rivers we were recently tasked with taking a prototype application built in {shiny} to a public facing production environment for a public sector organisation. During the scoping exercise it was determined that a more appropriate solution to fit the requirements was to build the application with a {plumber} API providing the interface to the Bayesian network model and other application tools written in R.
When building applications in {shiny} we have for some time been using the “app as a package” approach which has been popularised by tools like {golem} and {leprechaun}, in large part due to the convenience that comes with leveraging the testing and dependency structure that our R developers are comfortable with in authoring packages, and the ease with which one can install and run an application in a new environment as a result. For this project we looked to take some of these ideas to a {plumber} application. This blog post discusses some of the thoughts and resultant structure that came as a result of that process.
Read on for the first post in the series, dealing with some of the prep work.
Comments closedHugo Gruson and Maelle Salmon show how to set a minimum version of R itself in a package:
There have been much talk and many blog posts about R package dependencies. Yet, one special dependency is more rarely mentioned, even though all packages include it: the dependency on R itself. The same way you can specify a dependency on a package, and optionally on a specific version, you can add a dependency to a minimum R version in the
DESCRIPTIONfile of your package. In this post we shall explain why and how.
Read on for that explanation, as well as a lot of depth on why you might choose a particular R version, popular R versions (at least by number of packages), and what some of the largest maintainers do.
Comments closedBenjamin Smith looks for delays:
Any Torontonian who has commuted regularly on the TTC has probably experienced their fair share of delays on the subway. Having experienced a few recently I was inspired to visualize the average delay times across all stops on the subway. What are the stations with the longest delays on average this past year? Could we make a nice visual with it?
Click through for the end result as well as the process to get there.
Comments closedTomaz Kastrun has a script for us:
Determining and checking who has access to a particular workspace in your organisation can be time consuming task. You can always retrieve the list of workspaces and access the list of all users with PowerShell cmdlet Get-PowerBIWorkspace.
The results of this cmdlet gives you a great way to get to valuable information easy and fast. And the following script can do just that.
Click through for the script, which also excludes personal workspaces. Tomaz then provides a bonus script creating a graph of how users and workspaces connect.
Comments closedParisa Gregg continues a series on RStudio Connect and Python:
FastAPI is a light web framework and as you can probably tell by the name, it’s fast. It provides a similar functionality to Flask in that it allows the building of web applications and APIs, however it is newer and uses the ASGI (Asynchronous Server Gateway Interface) framework. One of the nice features of FastAPI is it is built on OpenAPI and JSON Schema standards which means it has the ability to provide automatic interactive API documentation with SwaggerUI. You also get validation for most Python data types with Pydantic. FastAPI is therefore another popular choice for data scientists when creating APIs to interact with and visualize data.
In this blog post we will go through how to deploy a simple machine learning API to RStudio Connect.
I’ve taken pretty well to FastAPI for rapid API development. I haven’t had to worry about scaling it out too much, so I’m not sure how well that works in practice. Still, for single-user or few-user apps, FastAPI definitely works well.
Comments closedJoris Chau pivots, unpivots, and unnests data in R:
The previous post showcases the
rrapply()function in the minimalrrapply-package as a revised and extended version of baserapply()in the context of nested list recursion in R. For quick data exploration of a nested list it can make sense to keep the list in its original nested format to reduce the number of processing steps and minimize code complexity. As part of a more elaborate data analysis, if there is no specific reason to keep the nested data structure, it is often more practical to transform the nested list into a more convenient rectangular format and work with the unnested object (e.g. a data.frame) instead. In this follow-up post, we review the available (how) options inrrapply()to unnest or melt nested lists into a rectangular format in more detail and highlight the similarities and differences with respect to several common alternatives in R.
There’s a lot going on in this demo-packed post. H/T R-Bloggers.
Comments closedDavid Schoch has an R package for us:
During the last 5 years, I have accumulated various scripts with (personal) convenience functions for network analysis and I also implemented new methods from time to time which I could not find in any other package in R. The package
netUtilsgathers all these functions and makes them available for anyone who may also needs to apply “non-standard” network analytic tools. In this post, I will briefly highlight some of the most prominent functions of the package. All available functions are listed in the README on github.
Click through to see what’s available in the package. H/T R-Bloggers.
Comments closed