Crea una aplicación Shiny para buscar en Twitter con rtweet y R

¿Desea realizar un seguimiento de un hashtag de conferencia, o cualquier hashtag, en Twitter? Este tutorial adicional de Do More With R le muestra paso a paso cómo crear una aplicación web interactiva de Shiny para buscar, ordenar y filtrar tweets con un hashtag específico (o cualquier palabra clave).

Si no desea ver el tutorial completo de Twitter R, puede descargar el código de la aplicación Shiny and R más este artículo en formato R Markdown y PDF como un extra gratuito de Insider.

Código R original para buscar tweets

El episodio # 41 de Do More With R demostró cómo buscar tweets con el paquete rtweet y crear una tabla ordenable y filtrable con contenido reactable. Este primer bloque de código de ese artículo busca resultados de tweets y formatos para mostrar en una tabla.

# Configurar variables: número de tweets para descargar y consulta de búsqueda de hashtag
num_tweets_to_download <- 200
hashtag_to_search <- "#rstudioconf"
# Asegúrese de instalar los paquetes enumerados a continuación que aún no tiene en su sistema:
biblioteca ("rtweet")
biblioteca ("reactable")
biblioteca ("pegamento")
biblioteca ("stringr")
biblioteca ("httpuv")
biblioteca ("dplyr")
biblioteca ("ronroneo")
# Código para buscar tweets
tweet_df <- search_tweets (hashtag_to_search, n = num_tweets_to_download, include_rts = FALSE)
# seleccione algunas columnas deseadas y agregue un enlace en el que se pueda hacer clic para twittear texto para los datos de la tabla
tweet_table_data <- tweet_df %>%
select (user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url)%>%
mudar(
Tweet = pegamento :: pegamento ("{text} >> ")
)%>%
select (DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs = urls_expanded_url)

El siguiente bloque de código es una función para hacer clic en las URL de la columna de URL del tweet. Como mencioné en el episodio principal, esto es un poco más complicado que crear un enlace a un tweet porque puede haber más de una URL por tweet. Probablemente exista una forma más elegante de generar URL en las que se pueda hacer clic, pero la siguiente función funciona.

make_url_html <- function (url) {
if (longitud (url) <2) {
if (! is.na (url)) {
as.character (pegamento ("{url}"))
} más {
""
}
} más {
paste0 (purrr :: map_chr (url, ~ paste0 ("", .X, "", collapse =", ")), collapse =", ")
}
}
tweet_table_data $ URLs <- purrr :: map_chr (tweet_table_data $ URLs, make_url_html)

El tercer y último bloque de código crea una tabla interactiva reactable. La mayor parte del código en este bloque modifica el estilo predeterminado y el comportamiento de la tabla.

reactable :: reactable (tweet_table_data, 
filtrable = VERDADERO, buscable = VERDADERO, bordeado = VERDADERO, rayado = VERDADERO, resaltado = VERDADERO,
showSortable = TRUE, defaultSortOrder = "desc", defaultPageSize = 25, showPageSizeOptions = TRUE, pageSizeOptions = c (25, 50, 75, 100, 200),
columnas = lista (
DateTime = colDef (defaultSortOrder = "asc"),
Usuario = colDef (defaultSortOrder = "asc"),
Tweet = colDef (html = TRUE, minWidth = 190, redimensionable = TRUE),
Me gusta = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
RTs = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
URLs = colDef (html = TRUE)
)
)

Crea una aplicación Shiny básica para buscar tweets

Ahora, convierta esta tabla de datos en una aplicación Shiny local interactiva con aún más posibilidades de filtrado.

41 shiny01 IDG

Figura 1

Primero, vaya a RStudio y cree una nueva aplicación Shiny en un nuevo subdirectorio dentro de su proyecto yendo a Archivo> Nuevo archivo> Nueva aplicación web brillante. Llamaré a mi aplicación HashtagSearch pero puedes llamar a la tuya como quieras.

El archivo predeterminado app.R creado por RStudio se ve así:

biblioteca (brillante)
# Definir interfaz de usuario para la aplicación que dibuja un histograma
ui <- fluidPage (

# Titulo de la aplicación
titlePanel ("Datos del antiguo géiser fiel"),

# Barra lateral con una entrada de control deslizante para el número de contenedores
barra lateral
sidebarPanel (
sliderInput ("bins",
"Número de contenedores:",
min = 1,
max = 50,
valor = 30)
),

# Mostrar un diagrama de la distribución generada
panel principal(
plotOutput ("distPlot")
)
)
)

# Definir la lógica del servidor requerida para dibujar un histograma
servidor <- función (entrada, salida) {

salida $ distPlot <- renderPlot ({
# generar bins basados ​​en la entrada $ bins de ui.R
x <- fiel[, 2]
bins <- seq (min (x), max (x), length.out = input $ bins + 1)

# dibuja el histograma con el número especificado de contenedores
hist (x, breaks = bins, col = 'darkgray', border = 'white')
})
}

# Ejecuta la aplicación
shinyApp (ui = ui, servidor = servidor)

Crea la interfaz de usuario para tu aplicación Shiny

los UI parte de una aplicación brillante es el interfaz de usuario, o página HTML de front-end con la que el usuario, en este caso usted, interactúa. los servidor la porción es la código R de fondo eso hace toda la informática para que la solicitud de un usuario realmente funcione.

Por lo general, primero elimino la mayoría de los comentarios en el archivo predeterminado app.R, cambio el título y cargo todos los paquetes que necesito. La parte superior de mi aplicación. R ahora se ve así:

biblioteca (brillante)
biblioteca (rtweet)
biblioteca (dplyr)
biblioteca (pegamento)
biblioteca (reactable)
biblioteca (ronroneo)

A continuación, agregaré el código que busca los tweets, los importa a R y organiza una versión para mostrar en una tabla, pero voy a usar Shiny-fy un poco.

Sé que voy a querer mi función de formato HTML URL. Pondré eso en la parte superior de la aplicación, antes de todo el código interactivo. (Alternativamente, podría ponerlo en un archivo auxiliar separado y obtener ese archivo). La parte superior de mi aplicación ahora se ve así:

biblioteca (brillante)
biblioteca (rtweet)
biblioteca (dplyr)
biblioteca (pegamento)
biblioteca (reactable)
biblioteca (ronroneo)

make_url_html <- function (url) {
if (longitud (url) <2) {
if (! is.na (url)) {
as.character (pegamento ("
{url}"))
} más {
""
}
} más {
paste0 (purrr :: map_chr (url, ~ paste0 ("", .X, "", collapse =", ")), collapse =", ")
}
}

ui <- fluidPage (

A continuación, agregaré código para crear el marco de datos de Twitter inicial a partir de mi consulta de búsqueda. Eso va en la sección del servidor de la aplicación. Dado que ese marco de datos cambiará y se actualizará según lo que solicite el usuario, necesito que sea un valor reactivo.

Hasta ahora, hay dos elementos que el usuario puede cambiar: la consulta de búsqueda de hashtag y la cantidad de tweets que se devolverán. En lugar de codificar los valores en la parte superior del archivo, quiero agregarlos como las entradas que los usuarios pueden cambiar.

Eso significa agregar dos campos de entrada de usuario en la sección de la interfaz de usuario de app.R: hashtag_to_search y num_tweets_to_download. Crearé un cuadro de texto para ingresar un hashtag y un cuadro de control numérico o un control deslizante para ingresar el número de tweets que se solicitarán.

Para la cantidad de tweets, comenzaré manteniendo el control deslizante que vino en la aplicación predeterminada. Sin embargo, cambiaré su ID a num_tweets_to_download, la etiqueta que el usuario ve para "Número de tweets para descargar ", el valor mínimo a 100, el valor máximo a 18000, el valor predeterminado a 200 y el paso (cuánto se suma o resta con cada movimiento leve del control deslizante) a 100.

También voy a eliminar todo en la sección del servidor entre los corchetes de la línea servidor <- función (entrada, salida) {### BORRAR TODO AQUÍ ###} ya que la aplicación predeterminada ya no funcionará ahora que estoy cambiando las entradas.

Las secciones de IU y servidor de la aplicación ahora se ven así:

ui <- fluidPage (

# Titulo de la aplicación
titlePanel ("Buscar tweets"),

# Barra lateral
barra lateral
sidebarPanel (
sliderInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 30,
paso = 100)
),

# Mostrar resultados
panel principal(
plotOutput ("distPlot")
)
)
)

# Definir la lógica del servidor
servidor <- función (entrada, salida) {
salida $ distPlot <- renderPlot ({

})
}

41 shiny04 med IDG

Figura 2

Si ejecuto la aplicación haciendo clic en el botón Ejecutar aplicación en la parte superior derecha de mi panel de RStudio (Figura 2), puedo ver mi control deslizante (aunque todavía no hace nada).

Si le resulta un poco difícil obtener el valor exacto que desea al mover el control deslizante, puede cambiar ese control deslizante a numericInput () caja:

numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100)

Eso le dará un cuadro en el que puede escribir en lugar de un control deslizante (Figura 3).

41 brillante05 IDG

figura 3

A continuación, voy a agregar un cuadro de entrada de texto para la consulta de hashtag con Shiny's entrada de texto() función. Estableceré el inputId de la caja para que sea hashtag_to_search, la etiqueta como "Hashtag para buscar", y el valor predeterminado como "#Rstudioconf". Mi código de panel de barra lateral ahora se ve así:

# Barra lateral
barra lateral
sidebarPanel (
numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100), # <- No olvides la coma aquí
textInput ("hashtag_to_search",
"Hashtag para buscar:",
valor = "#rstudioconf")
),

Tenga en cuenta que como estoy agregando un segundo argumento de entrada al panel de la barra lateral, Necesito una coma después de la primera. como se muestra en la flecha comentada arriba. Obtener paréntesis y comas correctos puede ser un desafío al codificar aplicaciones brillantes. Crear entradas y salidas una por una y ejecutar el código después de cada adición puede ayudar a que sea más fácil detectar problemas.

41 brillante07 IDG

Figura 4

Haga clic para ejecutar el código más nuevo y debería ver algo como la Figura 4.

Lo básico barra lateral está terminado, pero necesito una entrada más en mi interfaz de usuario para decirle a Bright dónde quiero que se muestre mi tabla de tweets. Pondré ese marcador de posición en el panel principal. El panel principal de la aplicación predeterminada tiene plotOutput ("distPlot"), que le dice a shiny que ahorre espacio para un trama en la parte principal de la página. quiero un mesa reactable allí, así que voy a cambiar plotOutput () a ReactableOutput (). Más específicamente, estableceré la tabla inputId en "tweet_table" e intercambiaré reactableOutput ("tweet_table"). Si hago clic para ejecutar mi aplicación ahora, nada ha cambiado. Pero ya casi llegamos.

Codifique la lógica del servidor Shiny

Finalmente es hora de obtener y mostrar los tweets. Al igual que con el código original, usaré rtweet’s search_tweet () función para buscar tweets y almacenar resultados en tweets_df (que contendrá 90 columnas). Luego crearé un tweets_table_data marco de datos de mis resultados, formateado para mostrar en una tabla y codificar la tabla. Toda esta lógica del servidor debe entrar al servidor <- función (entrada, salida) {} porción del archivo app.R

Puedo reutilizar mi código original con algunas modificaciones. Los puntos más importantes:

  1. Cualquier variable que cambie según la entrada del usuario debe ser un valor reactivo, no es un objeto R convencional. Tengo que crearlos y manejarlos de maneras ligeramente diferentes a las de una variable convencional, pero felizmente, los ajustes son menores.
  2. Cada vez que necesito el valor de una entrada del usuario, tengo que referirme a él comonput $ my_variable_name y no solo my_variable_name.

Veamos cómo funciona eso.

Aquí está mi no-Código brillante para buscar tweets y crear una versión de los resultados para una tabla:

tweet_df <- search_tweets (hashtag_to_search, n = num_tweets_to_download, include_rts = FALSE)

# seleccione algunas columnas deseadas, agregue enlaces clicables para tweets y URL, cambie el nombre de algunas columnas
tweet_table_data <- tweet_df %>%
select (user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url)%>%
mudar(
Tweet = pegamento :: pegamento ("{text}
>> "),
URLs = purrr :: map_chr (urls_expanded_url, make_url_html)
)%>%
select (DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs)

Para convertir un valor "regular" en uno reactivo, use Shiny’s reactivo({}) función. Y recuerde: para referirse a las variables hashtag_to_search y num_tweets_to_download establecidas por la interacción del usuario con la aplicación, utilizar input $ var_name y no solo nombre_var. Eso convierte este código no brillante:

tweet_df <- search_tweets (hashtag_to_search, n = num_tweets_to_download, include_rts = FALSE)

En este código brillante:

tweet_df <- reactivo ({
search_tweets (input $ hashtag_to_search, n = input $ num_tweets_to_download, include_rts = FALSE)
})

y el código tweet_table_data en esto:

tweet_table_data <- reactiva ({
req (tweet_df ())
tweet_df ()%>%
select (user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url)%>%
mudar(
Tweet = pegamento :: pegamento ("{text} >> "),
URLs = purrr :: map_chr (urls_expanded_url, make_url_html)
)%>%
select (DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs)
})

Solo las primeras tres líneas, que crean el marco de datos tweet_table_data, han cambiado. La primera línea, tweet_table_data <- reactiva ({ , crea un objeto que puede cambiar según la entrada del usuario. La segunda línea, req (tweet_df ()), le dice a shiny que no comience ningún cálculo para tweet_table_data hasta que exista un marco de datos tweet_df (). Sin esa línea, mi aplicación podría generar un error si intenta ejecutar cálculos en un marco de datos que no existe. Tenga en cuenta, también, es tweet_df () y no tweet_df ya que ese marco de datos es reactivo.

El resto del código es el mismo que antes, excepto el cierre. }) al final.

Finalmente, el código de la tabla necesita tres cambios menores:

  1. Como la tabla es una visualización, Shiny necesita saber donde ponerlo y lo que es. Almacenaré la tabla en una variable llamada salida $ tweet_table. Eso lo conecta con el reactableOutput ("tweet_table") marcador de posición en la interfaz de usuario. También usaré el renderReactable () funcionan para que Shiny sepa qué tipo de visualización está creando. Eso hace que el código salida $ tweet_table <- renderReactable ({### código R para crear la tabla reactiva aquí ###}). Nota: la mayoría de las veces, cuando desea utilizar una visualización en Shiny, agrega algo como myfunctionOutput ("my_dataviz_id") en la interfaz de usuario y salida $ my_dataviz_id <- renderMyfunction ({### Código R para crear viz aquí ###}) en el servidor
  1. El código debe requerir la presencia de tweet_table_data marco de datos o la aplicación podría generar un error al intentar generar una tabla a partir de datos que no existen.
  2. El código también debe referirse a tweet_table_data como tweet_table_data () ya que es reactivo

El código de la tabla Shiny-fied:

salida $ tweet_table <- renderReactable ({
reactable :: reactable (tweet_table_data (),
filtrable = VERDADERO, buscable = VERDADERO, bordeado = VERDADERO, rayado = VERDADERO, resaltado = VERDADERO,
showSortable = TRUE, defaultSortOrder = "desc", defaultPageSize = 25, showPageSizeOptions = TRUE, pageSizeOptions = c (25, 50, 75, 100, 200),
columnas = lista (
DateTime = colDef (defaultSortOrder = "asc"),
Usuario = colDef (defaultSortOrder = "asc"),
Tweet = colDef (html = TRUE, minWidth = 190, redimensionable = TRUE),
Me gusta = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
RTs = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
URLs = colDef (html = TRUE)
)
)
})

Aquí está el código para toda la aplicación. R Aplicación brillante:

biblioteca (brillante)
ui <- fluidPage (

# Titulo de la aplicación
titlePanel ("Buscar tweets"),

# Barra lateral
barra lateral
sidebarPanel (
numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100),
textInput ("hashtag_to_search",
"Hashtag para buscar:",
valor = "#rstudioconf")
),

# Mostrar resultados
panel principal(
reactableOutput ("tweet_table")
)
)
)

# Definir la lógica del servidor
servidor <- función (entrada, salida) {

tweet_df <- reactivo ({
search_tweets (input $ hashtag_to_search, n = input $ num_tweets_to_download, include_rts = FALSE)
})

tweet_table_data <- reactiva ({
req (tweet_df ())
tweet_df ()%>%
select (user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url)%>%
mudar(
Tweet = pegamento :: pegamento ("{text} >> "),
URLs = purrr :: map_chr (urls_expanded_url, make_url_html)
)%>%
select (DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs)
})

salida $ tweet_table <- renderReactable ({
reactable :: reactable (tweet_table_data (),
filtrable = VERDADERO, buscable = VERDADERO, bordeado = VERDADERO, rayado = VERDADERO, resaltado = VERDADERO,
showSortable = TRUE, defaultSortOrder = "desc", defaultPageSize = 25, showPageSizeOptions = TRUE, pageSizeOptions = c (25, 50, 75, 100, 200),
columnas = lista (
DateTime = colDef (defaultSortOrder = "asc"),
Usuario = colDef (defaultSortOrder = "asc"),
Tweet = colDef (html = TRUE, minWidth = 190, redimensionable = TRUE),
Me gusta = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
RTs = colDef (filtrable = FALSO, formato = colFormat (separadores = VERDADERO)),
URLs = colDef (html = TRUE)
)
)
})

}

# Ejecuta la aplicación
shinyApp (ui = ui, servidor = servidor)

Ejecute la aplicación y listo! Debería verse más o menos así:

41 brillante08 IDG

Figura 5

Algunas mejoras prácticas

Hay algunas mejoras que quiero hacer a esta aplicación para que sea más práctica. Primero, cómo reacciona la aplicación cuando un usuario cambia el hashtag predeterminado o la cantidad de tweets a solicitar. De forma predeterminada, Shiny intentará actualizar los datos. mientras escribes. Ese es a menudo un comportamiento genial y útil. Pero en este caso, ¡no quiero que la aplicación realice una llamada a la API de Twitter cada vez que escribo una letra o un número! De lo contrario, puede intentar devolver una búsqueda de una solicitud parcial después de cada pulsación de tecla, y me arriesgo a tropezar con mi límite de 18,000 tweets en 15 minutos.

La otra característica que me gustaría agregar es guardar algunos de los datos que devuelve mi aplicación.

Para el primer problema, no quiero que mi aplicación haga una solicitud a la API de Twitter hasta que haga clic en el botón "Obtener datos". RStudio recomienda un "botón de acción" para esta funcionalidad. Como con la mayoría de las cosas en Shiny, eso implica dos partes: la interfaz de usuario y el servidor.

Para la interfaz de usuario, puedo agregar un botón de acción con el botón de acción() función. El primer argumento es el inputId del botón; el segundo es la etiqueta del botón que ve un usuario. Hay argumentos opcionales, como las clases integradas para cambiar la apariencia del botón. Me gusta la clase CSS btn-primary, así que la usaré para mi botón: actionButton ("get_data", "Obtener datos", clase = "btn-primary").

Para hacer que ese botón haga algo o, más exactamente, detener la aplicación haga algo hasta que toda la información de entrada esté lista. Necesito cambiar el tweet_df () objeto de un reactivo valor a un reactivo evento. Eso significa que no solo cambia su valor en función de un valor un usuario ingresa pero por un acción toma un usuario (como hacer clic en un botón). La sintaxis para eso en el servidor es la siguiente:

my_reactive_object <- eventReactive (input $ my_button_id, {
### Código R aquí ###
})

¡Tenga en cuenta la coma después de ingresar $ my_button_id! He pasado bastante tiempo tratando de rastrear errores brillantes porque olvido una coma después del primer argumento de una función reactiva.

A continuación, agregue la siguiente línea al panel de la barra lateral de la interfaz de usuario:

actionButton ("get_data", "Obtener datos", clase = "btn-primary")

Todo el panel debería verse así:

sidebarPanel (
numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100),
textInput ("hashtag_to_search",
"Hashtag para buscar:",
valor = "#rstudioconf"),
actionButton ("get_data", "Obtener datos", clase = "btn-primary")
),

Y cambie la definición de tweet_df en el código de su servidor de esto:

    tweet_df <- reactivo ({
search_tweets (input $ hashtag_to_search, n = input $ num_tweets_to_download, include_rts = FALSE)
})

A esto:

    tweet_df <- eventReactive (input $ get_data, {
search_tweets (input $ hashtag_to_search, n = input $ num_tweets_to_download, include_rts = FALSE)
})

Si ejecuta la aplicación ahora, no debería pasar nada hasta que haga clic en el botón "Obtener datos".

41 shiny09 lg IDG

Figura 6

Para guardar datos en su máquina local, puede agregar un botón de descarga de datos. Una vez más, necesitamos código en la interfaz de usuario y en el servidor.

Para que aparezca un botón de descarga en la aplicación, hay un especial downloadButton () funcionar con la sintaxis downloadButton ("id", "Label"). Mi código de botón, que incluye un par de br () los saltos de línea antes del botón para separarlo del elemento anterior son:

br (), br (),
downloadButton ("download_data", "Descargar datos")

Y el código completo del panel de la barra lateral ahora es:

        sidebarPanel (
numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100),
textInput ("hashtag_to_search",
"Hashtag para buscar:",
valor = "#rstudioconf"),
actionButton ("get_data", "Obtener datos", clase = "btn-primary"),
br (), br (),
downloadButton ("download_data", "Descargar datos")
),

Si ejecuta el código app.R ahora, descargará la página HTML, que por supuesto no es el comportamiento que desea. Para que la lógica del servidor haga que el botón realmente descargue datos, debe usar Shiny's downloadHandler () función. Esta función necesita dos datos: el nombre que desea para el archivo descargado y los datos que desea descargar. Utiliza el formato a continuación. Tenga en cuenta la necesidad de tener funciones tanto para el nombre del archivo como para el contenido descargado:

salida $ download_data <- downloadHandler (
filename = function () {
pegar (ingrese $ hashtag_to_search, "_", Sys.Date (), ".csv", sep = "")
},
contenido = función (archivo) {
write.csv (tweet_table_data (), file, row.names = FALSE)
}
)

Agregue eso en algún lugar del código del servidor app.R y pruébelo.

Tenga en cuenta que cualquier filtrado que haga dentro de la mesa no se reflejará en los datos que descargue. Además, es posible que desee descargar el conjunto de datos completo, en este caso tweet_df () con sus 90 columnas de datos en lugar de tweet_table_data () – ya que nunca sabes qué tipo de análisis querrás hacer en el futuro con los tweets de la conferencia. En ese caso, solo cambia la línea write.csv (tweet_table_data (), file, row.names = FALSE) a write.csv (tweet_df (), archivo, fila.nombres = FALSO).

Filtrado adicional

Hay muchos más filtros que puede hacer en los datos de Twitter una vez que se cargan. La galería de widgets de entrada Shiny muestra muchas de las opciones de entrada del usuario que puede agregar a una aplicación Shiny.

41 brillantes10 IDG

Figura 7

Por ejemplo, podría usar el filtro de rango de fechas para ver solo los tweets durante las fechas de la conferencia, eliminando las conversaciones previas y posteriores a la conferencia.

Para hacer eso, el código de la interfaz de usuario usa un formato como dateRangeInput ("my_date_picker_id", label = "Seleccionar fechas:", start = "2020-01-27", end = "2020-01-30") donde inicio y fin son los valores predeterminados.

Intente agregar ese código en algún lugar del código del panel de la barra lateral de la interfaz de usuario (eligiendo las fechas que desee y siempre recordando las comas adecuadas), junto con br () saltos de línea según sea necesario. Tenga en cuenta que sus fechas predeterminadas también pueden ser algo así como Fecha del sistema () - 7 para comenzar "hace siete días".

Mi código de panel lateral ahora se ve así:

sidebarPanel (
numericInput ("num_tweets_to_download",
"Número de tweets para descargar:",
min = 100,
max = 18000,
valor = 200,
paso = 100),
textInput ("hashtag_to_search",
"Hashtag para buscar:",
valor = "#rstudioconf"),
dateRangeInput ("date_picker", label = "Seleccionar fechas:", start = "2020-01-27", end = "2020-01-30"),
actionButton ("get_data", "Obtener datos", clase = "btn-primary"),
br (), br (),
downloadButton ("download_data", "Descargar datos")
),

Que produce el panel de la barra lateral que se muestra en la Figura 8.

41 brillante11 IDG

Figura 8

Para hacer que ese selector de rango de fechas realmente se filtre, vaya a tweet_table_data () definición y agregue código para filtrar filas según la columna DateTime. En este caso, dado que el selector de fecha tiene un inputId de "date_picker", el valor inicial es input $ date_picker[1] y el valor final es input $ date_picker[2].

Agregaré una fila en el tweet_table_data () definición para filtrar los tweets que se crearon entre las fechas de inicio y finalización solicitadas por el usuario:

filter (between (as.Date (created_at), input $ date_picker[1], ingrese $ date_picker[2]))

El código que crea el reactivo tweet_table_data () El marco de datos ahora se ve así:

tweet_table_data <- reactiva ({
req (tweet_df ())
tweet_df ()%>%
select (user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url)%>%
filter (between (as.Date (created_at), input $ date_picker[1], ingrese $ date_picker[2]))%>%
mudar(
Tweet = pegamento :: pegamento ("{text} >> "),
URLs = purrr :: map_chr (urls_expanded_url, make_url_html)
)%>%
select (DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs)
})

Más mejoras

Hay mucho más que podría hacer para agregar capacidades a esta aplicación. Puede agregar controles deslizantes para establecer un número mínimo de retweets o me gusta, y luego hacer un filtrado de tabla adicional en ese subconjunto de tweets. O bien, puede agregar una casilla de verificación para filtrar los tweets que contienen URL, lo que puede ser útil si está buscando tweets de conferencia que puedan incluir enlaces a presentaciones y otros recursos. Puede mantener otras columnas del conjunto de datos inicial para filtrar variables como el idioma y la geografía.

Para obtener más información sobre Shiny, RStudio tiene algunos tutoriales escritos y en video en shiny.rstudio.com. Otros recursos útiles: Zev Ross creó un fácil de seguir Tutorial brillante con ejemplos y una hoja de trucosy Hadley Wickham tiene un Dominar el libro brillante en progreso que está disponible gratis en línea.

Para más información sobre rtweet, vaya a rtweet.info.

Y para obtener más consejos sobre el uso de R, diríjase a Haz más con R página en InfoWorld!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *