1. Introduction

This article aims to present the RSelenium package’s basic functionalities and show how it can help you to perform many useful daily tasks automatically in your internet browser. RSelenium also offers a great opportunity to observe object-oriented programming (OOP) fully implemented in R.

In order to use RSelenium, first you need to install it with the install.packages("RSelenium") command. Be carefull to write the first two letter as capital ones. Besides, the Java software needs to be installed in your machine too, or later you will face the following error: error in java_check () : PATH to JAVA not found. A very few functions from the tidyverse will also appear in our code, so install it with install.packages("tidyverse") if you haven’t yet. Also, the package getPass might be useful if we want to send sensitive login information in our code.

In our examples of browser manipulation, we used the version 91.0.4472.77 of Google Chrome in a Windows environment and R version 4.0.5. However, RSelenium can be used with other combinations of internet browser and operational system. Check out the RSelenium official documentation page for more information about these topics.

The following images in this article are all mines, except the few times when the webpages https://quotes.toscrape.com/ and http://httpbin.org/forms/post (two popular sites for webscraping exercises) or their HTML code are reproduced here. I used an R Jupyter Notebook during development but the code can be run in RStudio for sure too. You will find both a Jupyter Notebook and an R script with the complete code on my Github repository.

For people who might be interested in learning Selenium for Python, there is another notebook on the same Github repository with the code translated to this programming language.

2. Importing packages and writing a helper function

Let’s start by importing the libraries to be used in our code.

# Import libraries
library("RSelenium")
library("tidyverse")
library("getPass")

# This line makes R show messages in English.
# Use "pt" if you want them to be displayed in Portuguese
Sys.setenv("LANG" = "en")

I also created a customized function called check_object that will print the class and typeof functions info, which will help us to analyze the new RSelenium objects we will find on our way.

# Customized function to check class() and typeof() at once:
check_object <- function(object) {
    cat("\nclass: ",
        class(object),
        "\ntypeof: ",
        typeof(object),
        "\n")
}

3. First RSelenium objects: rsClientServer and remoteDriver

The next step is to create an RSelenium rsClientServer, which we will save in the computational variable called client_server. The code below will automatically open a new Chrome window and give us more information about the object we have just created.

# Create rsClientServer object with Google Chrome browser.
# Change the chromever argument for the Chrome version used in your machine
client_server <- RSelenium::rsDriver(browser=c("chrome"), 
                                     chromever="91.0.4472.101", 
                                     port=4545L, 
                                     verbose=F)
check_object(client_server)

Note that I passed a specific Chrome version as a string in the chromever argument. So, you will need to adjust it according to your reality. Some arguments in RSelenium::rsDriver() use "latest" as default value, which can cause errors if an installed version from Selenium or the chosen browser is different from the latest available version, even if it is a beta one. I experienced that issue with Chrome while finishing this article and I want you to be prepared if you wind up facing a similar obstacle.

Now it is time to save the RSelenium remoteDriver into the computational variable called driver. This object is by far the most important one in our code. As we will discover later, we will spend most of the time calling methods from the remoteDriver object to manipulate the browser and get the information we need.

# Save the remoteDriver object in the computational variable called "driver"
driver <- client_server[["client"]]
check_object(driver)

4. Navigate to a new webpage

We will start by telling the remote driver to open the site https://quotes.toscrape.com/. One can do that by calling the navigate() method from the remoteDriver object and using the URL as the method argument:

# Navigate to the page to be scraped
url <- "https://quotes.toscrape.com/"
driver$navigate(url)

After running this code, the Chrome window controlled by RSelenium will open the chosen site.

Whenever you need your code to return the current webpage URL, you can call driver$getCurrentUrl(). And if you want to work with a maximized browser window, just call driver$maxWindowSize().

# Get the current url
driver$getCurrentUrl()

# Maximize window
driver$maxWindowSize()

Here I would like to make a very important observation: the browser window controlled by RSelenium will close automatically if there is no new activity for a while. If that happens, you will probably have to run the code below in order to free the port you last used in your RSelenium program. I found this line of code on StackOverflow after facing this problem for the first fime and now I use it whenever I run into such an issue.

# This line is very important: run it if your Selenium 
# remoteDriver crashes and you can't open another one in the same port

system("taskkill /im java.exe /f", intern=FALSE, ignore.stdout=FALSE)

5. The driver$findElement() method

The first element to be manipulated will be the login link, located in the webpage upper right corner. We will do that later by calling the driver$findElement() method with its two arguments (using and value).

However, since this method is so important, let’s take a quick look at all options available to the using parameter. Running driver$findElement, without the parentheses, will return information about this method. Please note that only the first lines from the output are reproduced below.

driver$findElement

As we can observe from the last reproduced output, the using parameter accepts one of the following strings:

• "xpath" => find the element in the page by using the Xpath query language;
• "css selector" => use a selector from the CSS style sheet language to find the element;
• "id" | "name" | "class name" => these three options use respectively the id attribute, the name attribute, and the class attribute from the HTML tags to find an element in the webpage;
• "link text" | "partial link text" => when you deal with an HTML anchor tag (example: <a>this is the link text</a>), you can find them by searching for either the partial or the complete link text.

6. Working with an RSelenium webElement

So, let’s use the Xpath to find the login link element. One can do that on Chrome by right-clicking on the login link and then choosing the inspect option. This will open the DOM panel and show its HTML code.

Now, in your browser, right-click on the HTML <a> login element (the line highlighted in blue in the image above) and then choose “Copy” and “Copy full Xpath” in the auxiliary menu. Paste the Xpath information into a string and use it inside driver$findElement(), as follow:

# Get the login link element by using xpath
login_xpath <- "/html/body/div/div[1]/div[2]/p/a"
login_link <- driver$findElement(using = "xpath", value = login_xpath)
check_object(login_link)

As one can observe, the method driver$findElement() returns an RSelenium webElement object. When saved in a computational variable like login_link, this webElement can be used to call other methods too, as shown below:

# This method returns the element tag name
login_link$getElementTagName()

# This method returns the element inner text
login_link$getElementText()

# This method returns an element attribute (in this case, "href")
login_link$getElementAttribute("href")

You can also click on a webElement. In the current example, this will send us to the login page.

# Click on the element
login_link$clickElement()

7. Make your code take a little break with Sys.sleep()

We will manipulate this login page later. By now, let’s run the following code so that we can go back to the main page and wait for 2.5 seconds. Then we return to the login page and wait for another 2 seconds:

# Go back to the last page and wait 2.5 seconds
driver$goBack()
Sys.sleep(2.5)
cat("ok")

# Go forward in the browser history and wait 2 seconds
driver$goForward()
Sys.sleep(2)
cat("ok")

When we work with RSelenium, asking the program to wait a couple of seconds before moving to a new page is an excellent strategy. Actually, this additional time before moving on is almost a mandatory strategy in order to avoid errors that can crash the code.

For example, if we go to a new page and ask RSelenium to find an HTML element that has not been loaded yet, we will get a NoSuchElement Error. And if that happens during a long loop and a lot of data has already been scraped, all the effort done by then might get lost. Thus, waiting a few seconds is a more preferable approach. You could also use try() and tryCatch() statements so that your code can be prepared for some of the most common errors before they occur.

8. Write a function to go back to the first page

If we were to click on the Quotes to Scrape link, the browser goes back to the first page. The image below shows this link HTML code:

Let’s find this link now with RSelenium by using the following CSS selector:

# This code uses a css selector to get the link to the main page
css_selector <- "div.header-box.row > div.col-md-8 > h1 > a"
main_page_link <- driver$findElement("css selector", css_selector)
check_object(main_page_link)

In CSS, class attributes are represented by a dot, and id attributes are represented by a hashtag symbol. The css_selector string we reproduced above can be read as follow: “find the first div HTML tag that has both the header-box and row classes, then find a div with the col-md-8 class inside it. Next, find a h1 heading, and then return the first link element inside it”.

We can get some info from this new element and click on it too so that the browser goes to the first page.

# Get the element info
main_page_link$getElementTagName()
main_page_link$getElementText()
main_page_link$getElementAttribute("style")

# Click on the link
main_page_link$clickElement()

Now we are ready to write our first customized function using RSelenium code, which will be helpful whenever we want to go back to the first page in this website. Note here the phenomenon of method-chaining (a method called right after another method), which is a very common practice when working with OOP. This new function of ours will not return a webElement object, since the last action it performs is to click on the link. So, the function will return NULL because that is the value returned by the clickElement() method.

# This function makes the browser return to the main page
return_to_main_page <- function() {
    css_selector <- "div.header-box.row > div.col-md-8 > h1 > a"
    driver$findElement("css selector", css_selector)$clickElement()
}

9. Gather all links in a webpage with driver$findElements()

Our next action will be to scrape all links in the first page. This can be done by the findElements() method (note the additional letter s in the end). While findElement() (singular) returns the first webElement object in the DOM to match the search criteria, findElements() (plural) returns a list with ALL webElements objects with given criteria. findElements() will also demand the same using and value parameters we talked about earlier. If no webElement is found with the arguments passed to findElements(), an empty list will be returned by it.

If we perform a search using only the <a> tag name, we will find 55 links in the first page.

# The method findElements() returns a list of Web Elements.
# This code finds all links in page 1 by using the tag name
return_to_main_page()

all_links_page_1 <- driver$findElements("tag name", "a")

cat(paste("number of links in main page: ",
          length(all_links_page_1),
          "\n\n")
   )

cat("object", quote(all_links_page_1), "\n")
check_object(all_links_page_1)

cat("\n\nseventh object in", quote(all_links_page_1), "list:\n")
check_object(all_links_page_1[[7]])

We can choose to print to the console the inner text and URL from all the link elements in the first page. In order to do that, let’s first create another function.

# The function below, when used in a webElement with the "a" tag name,
# returns the link inner text and its url.
# Both info are also printed on the console if print_output = TRUE
show_links_info <- function(link_element, print_output = TRUE) {
    text <- as.character(link_element$getElementText())
    url <- as.character(link_element$getElementAttribute("href"))
    if (print_output) {
        cat(paste0(text, ": "),
            url,
            "\n")
        # line below makes the info be displayed during iteration
        flush.console()
    }
        
    c(text, url)
}

This new function must receive an RSelenium webElement with an HTML <a> tag, since we will look for its inner text and href attibute. So, if the print_output parameter is set to TRUE, the code inside the if statement is executed and the element inner text and URL will be printed to the console gradually, since flush.console() is called there. A vector with text and urlis returned by the function.

The code below with lapply will print all the information from the all_links_page_1 list. The computational variable saved_list allows to access this info in a list of lists too, if necessary. Only part of the output is reproduced below:

# Use lapply to apply the show_links_info function to the list with
# all the links in the first page
saved_list <- lapply(all_links_page_1, show_links_info)

If we prefer to save the links information into a data frame, that can be done by a for loop, with each iteration calling show_links_info() and appending this info to a new computational variable called links_dataframe.

# The code below saves all links from page 1 in a dataframe

links_dataframe <- data.frame()

for (i in 1:length(all_links_page_1)) {
    links_info <- show_links_info(all_links_page_1[[i]], print = FALSE)
    temp_data_frame <- data.frame(index = nrow(links_dataframe) + 1,
                                  text = stringr::str_trim(links_info[1]),
                                  url = links_info[2])
    links_dataframe <- rbind(links_dataframe, temp_data_frame)

10. Go through all pages in a website

Another very common task we might need to perform is to visit all pages in a website by following a next link, for example. And in each page, we can perform an action, like scraping some information.

Since we cannot be sure of how many pages a site has beforehand, we need code that keeps repeating an action until a condition becomes true and the code stops executing. That is right, this is a perfect scenario to use a repeat loop with a break inside an if statement. At first, this loop of ours will only go through every page and then print the page number to the console.

# This code clicks on the "next" link and moves along the pages.
# When the last page is reached and there is no next link, break the loop.
return_to_main_page()
i <- 1

repeat {
    cat("\npage ", i)
    flush.console()
    i <- i + 1
    
    next_link_as_list <- driver$findElements(using="css selector", "li.next > a")

    if (length(next_link_as_list) == 0) {
        break
    }
    
    next_link_as_list[[1]]$clickElement()
    Sys.sleep(2)
    
    
}

cat("\nwe reached the last page")
return_to_main_page()
cat("\nback to page 1\n")

Note that the next link is located by using driver$findElements() in line 11. So, this code will return either a list with one webElement or a list with no element at all. This is a nice way of avoiding the NoSuchElement Error that would have been raised in the last page if we had used the driver$findElement() method instead. So, when next_link_as_list has a length of zero, the code will enter the conditional and break the loop, and we will have accomplished our goal of going through all pages in the website.

11. Writing code to open a specific page in the website

After the last code execution, we discovered that the site has only 10 pages with quotes. Besides, all pages from 2 to 10 share the following url pattern: https://quotes.toscrape.com/page/ plus the page number added to its end. This kind of situation is a very desirable one because it allows you to move to new pages by just sending the specific url pattern directly to the driver$navigate() method. So, if you know all the pages range beforehand, this approach will be much easier than finding link elements and clicking on them to change pages.

Let’s now create a function that will send us directly to a chosen page in our website. We will add some boolean conditions in it so that the function can check the argument class and raise an exception if it is a character one. The function will also truncate decimal numbers and raise an error if the number passed to it is not between 1 to 10.

# From the code above, we discovered that there are 10 pages in the website.
# The function below goes to a chosen page and it will raise an error
# if the argument passed is not an integer number between 1 and 10
go_to_page <- function(page_number=1) {
    if (is.character(page_number)) {
        cat("Error: you passed a string as argument.")
    }
    
    if (!is.numeric(page_number) ||
        as.integer(page_number) < 1 ||
        as.integer(page_number) > 10 ) {
        stop("Provide an integer number between 1 and 10 as argument")
    }
    
    if (page_number %% 1 != 0) {
        page_number <- trunc(page_number)
        cat(quote(page_number), "truncated to", page_number)
    }
    
    if (page_number != 1) {
        base_url_page <- "https://quotes.toscrape.com/page/"
        driver$navigate(paste(base_url_page, as.character(page_number), sep=""))    
    } else {
        return_to_main_page()
    }
}

Now, we can go to page 3 and page 7 directly by running this code:

# Go to page 3, wait 2.5 seconds and then go to page 7
go_to_page(3)
driver$getCurrentUrl()

Sys.sleep(2.5)

go_to_page(7)
driver$getCurrentUrl()

If we ask to go to page pi by mistake instead of page 3, the function will let us know that it used a truncated version of pi, leading us then to page 3.

# This code truncates 3.14 to 3 and then go to page 3
go_to_page(pi)
Sys.sleep(2.5)
driver$getCurrentUrl()

And any of the following function calls will return an error:

# The following function calls will return errors

go_to_page("page number 3")
go_to_page("3")
go_to_page("3.1415")
go_to_page(25)
go_to_page(97.75)

And what if we wanted to retrieve an information from the current URL and save it in a computational variable, like the current page number, for example? The following code will transform the current URL in a string, split it by the / characters and save this info in a list of strings. Then it will get the last element of this list, which will be the page number for any page but the first one.

# The code below will extract the page number from the current url
go_to_page(10)

my_url <- as.character(driver$getCurrentUrl())
cat(my_url, "\n")

split <- base::strsplit(my_url, "/")
cat(unlist(split)[length(unlist(split))])

return_to_main_page()

12. Saving the quotes info as strings

Now, it is time for us to tackle the main information in the website: the quotes. Before we can save them all in a nice data frame (R programmers do like saving info in data frames, don’t they?), I will show you a way of accessing all the quotes text information at once. Below we reproduce the HTML structure from one of these quotes (the vertical blue line marks all children tags inside a quote box):

When we use the getElementText() method from a webElement object, we not only access its own inner text but also the inner texts from all its children tags. So, if each quote info is inside a div tag with a quote class, represented in CSS selector by div.quote, we can print all quotes information from page 1 by running the following code (output is only parcially reproduced below):

# This code reproduces all the first ten quotes as a long string.
# It shows how you can use the getElementText() method to access the
# inner text from all children elements at once.
string <- ""
quotes_divs_list <- driver$findElements("css selector", "div.quote")
string <- unlist(lapply(quotes_divs_list, function(element) {
    string <- paste(string, 
                    as.character(element$getElementText()),
                    "\n\n",
                    sep="")
    return(string)
}))

cat(string)

13. Saving the quotes info as a data frame

In our effort to save the quotes information into a data frame, let’s first create the following auxiliary functions:

# Customized functions to be used in the next sapply() and lapply() calls in this code:
get_element_text <- function(element) {
    as.character(element$getElementText())
}

get_link_href <- function(element) {
    as.character(element$getElementAttribute("href"))
}

click_element <- function(element) {
    element$clickElement()
}

If we run the code below, we can get all quotes info in the first page and save them to computational variables:

# With this code one can get all the info for the quotes in the current page
return_to_main_page()
quotes_text <- sapply(driver$findElements("css selector", "span.text"),
                      get_element_text)
authors_text <- sapply(driver$findElements("css selector", "small.author"),
                       get_element_text)
authors_links <- sapply(driver$findElements("partial link text", "(about)"),
                        get_link_href)
tags_text <- sapply(driver$findElements("css selector", "div.tags"),
                    get_element_text)

These three functions we created will be used to get the quotes information from each page (like we did for page 1) and save it in vectors that will eventually be appended to the all_quotes data frame. Notice that we will also loop over the pages using the repeat structure we built before, even though we use a while (TRUE) loop here instead.

# Now, we only need to loop over all pages and save the quotes info into a dataframe
return_to_main_page()
all_quotes <- data.frame()
i <- 0

while (TRUE) {
    quotes_texts <- sapply(driver$findElements("css selector", "span.text"),
                           get_element_text)
    authors_texts <- sapply(driver$findElements("css selector", "small.author"),
                            get_element_text)
    authors_links <- sapply(driver$findElements("partial link text", "(about)"),
                            get_link_href)
    tags_texts <- sapply(driver$findElements("css selector", "div.tags"),
                         get_element_text)
    page_quotes <- data.frame("sequence" = (i * 10 + 1):(i * 10 +10),
                              "quote" = quotes_texts,
                              "author" = authors_texts,
                              "author_biography_link" = authors_links,
                              "tags" = tags_texts)
    
    all_quotes <- rbind(all_quotes, page_quotes)
    i <- i + 1
    cat("\npage", i)
    flush.console()
    
    try(next_link_as_list <- driver$findElements(using="css selector", "li.next > a"),
        silent = TRUE)
    
    if (length(next_link_as_list) == 0) {
        break
    }
    
    next_link_as_list[[1]]$clickElement()
    Sys.sleep(2)
    
}

If we want, we can save the all_quotes data frame as a CSV file, check the data frame dimensions and look at its first rows.

# save the all_quots dataframe as a CSV file
write.csv(all_quotes,
          file = "quotes.csv",
          quote = FALSE,
          row.names = FALSE,
          fileEncoding = "UTF-8")

cat(paste0("all_quote data frame dimensions: ", nrow(all_quotes), ", ", ncol(all_quotes)))

head(all_quotes, 3)

Pretty amazing, right?

14. Saving the authors’ biographical info as a data frame

However, there are still some interesting information in this website waiting to be scraped by us. If you navigate to the first link in the statistical variable all_quotes$author_biography_link, you will find biographical information about Albert Einstein. Every author quoted in the website has a page like that. The good news is that we already gathered all these biographical links, we only need to loop over them and save the scraped information into another data frame called authors_info. The following code accomplishes that task.

# Each author has a biography page. We can get that info too.
# This will get all the unique authors biography links
unique_links_biographies <- unique(all_quotes$author_biography_link)
cat("total of biographical pages:", length(unique_links_biographies))

# Now we can loop over these biography links and save their info in a dataframe
authors_info <- data.frame()

for (link in unique_links_biographies) {
    driver$navigate(link)
    Sys.sleep(3)
    index <- nrow(authors_info) + 1
    name <- driver$findElement("css selector", "h3.author-title")$getElementText()
    born_date <- driver$findElement("css selector", "span.author-born-date")$getElementText()
    born_location <- driver$findElement("css selector", "span.author-born-location")$getElementText()
    description <- driver$findElement("css selector", "div.author-description")$getElementText()
    
    cat("\n", index, "of", length(unique_links_biographies))
    flush.console()
    
    new_row <- data.frame("index" = index,
                          "name" = as.character(name),
                          "born_date" = as.character(born_date),
                          "born_location" = as.character(born_location),
                          "description" = as.character(description))
    
    authors_info <- rbind(authors_info, new_row) 
}

head(authors_info)

After we loop over all the 50 biographical pages, we will have a new nice data frame with all this information and we can saved it in a new CSV file, for example. Notice that this program logic can be reused and applied to many web scraping tasks. Find the data you need, make sure to follow the website robots.txt instructions and be happy!

15. Manipulate text input boxes in the login page

Now it is time for us to start manipulating form elements, which is a very important skill to add to our task automation kit. Let’s go back to the login page and save the two text input boxes into computational variables.

# Now we go to the login page and play a little with the text input boxes.

# Go to the login page
login_xpath <- "/html/body/div/div[1]/div[2]/p/a"
driver$findElement(using = "xpath", value = login_xpath)$clickElement()

# Save the text input boxes elements in variables, using their id (two forms):
username_input <- driver$findElement("id", "username") 
password_input <- driver$findElement("css selector", "#password")

When handling text input HTML elements, two methods are definitely very useful: clearElement() and sendKeysToElement(). It is a good idea to start by calling the former so that any previous content might get cleared before you start sending new information to the text box. As for the second method, it receives a list with a string as its sole element.

# Username and password values
# (one can also use base::readline() or getPass::getPass() 
# to ask for user input)
username <- "Fabrício"
password <- "1234 is not a secure password!"

# When dealing with input boxes, it is good practice to clear their value first
username_input$clearElement()

# Send the username information (it needs to be passed as a list)
username_input$sendKeysToElement(list(username))

# Do the same with password
password_input$clearElement()
password_input$sendKeysToElement(list(password))

# Once you don't need the username and password variables anymore, delete them
rm(username, password)

In order to submit the form and login in the site, we still need to press the login button. We can do that by using the submitElement(), available for some HTML elements that have the ability of submiting information to the website.

# Find the submit button
submit_button <- driver$findElement("css selector", "input.btn.btn-primary")

# Use the submitElement() method to submit the form information
submit_button$submitElement()

After we do that, nothing extraordinary will happen: we will be redirected to the first page and the login text will be changed to Logout. But we did perform some fancy activity: we wrote code to login automatically in a website. If we desire, we could do the same operation in many other sites.

Just be careful about letting important information, like passwords, hard-coded in your program. Don’t make the life of bad people who can steal your personal info too easy, ok? A very good option to avoid such problems is to use the getPass package to send sensitive input data.

16. Working with other types of HTML input tags

Even though they are found on the internet very often, textboxes are not the only HTML input we can manipulate with RSelenium code in our browser. We will move now to a new website (http://httpbin.org/forms/post) and automate the boring task of ordering pizza online. Because eating pizza is a lot of fun but ordering it… well, not that much. We can let our R program to do the ordering for us so that we can focus only on the eating, fun part.

As we can observe, besides three text boxes, this form uses radio buttons for the pizza size, checkboxes for the toppings, and a time input for the delivery time. These four elements are all input HTML tags, but they differ in their type attribute value. And depending on the chosen input type, they can have very specific HTML attributes that are not present in the others ones. We also have a textarea tag used in the delivery instructions, and a submit button to the form.

So, I want a large pizza with bacon, extra cheese and mushrooms to be delivered around 19:45 at my home. I just need to let my code to do the ordering for me.

Below you will find my answer to this challenge. However, before you check it out, see if you can imagine how this code would look like. And to make it more interesting, use a one liner to order the three toppings at once with the help of the base::lapply() and the click_element() functions (this last one was created by us earlier).

Another quick tip: radioboxes and checkboxes can be manipulated using the $clickElement() method.

My code to perform this task goes below:

# This code choose the large option in the radio buttons
radio_buttons <- driver$findElements("css selector", 'input[type="radio"]')
radio_buttons[[3]]$clickElement()

# Choose the first, second and fourth toppings to your pizza
checkboxes <- driver$findElements("css selector", 'input[name="topping"]')
lapply(checkboxes[-3], click_element)

# Set delivery time to 19h45
time <- driver$findElement("css selector", 'input[type="time"]')
time$sendKeysToElement(list("19:45"))

poetry <- "
Two households, both alike in dignity\n
(In fair Verona, where we lay our scene),\n
From ancient grudge break to new mutiny,\n
Where civil blood makes civil hands unclean.\n
From forth the fatal loins of these two foes\n
A pair of star-crossed lovers take their life;\n
Whose misadventured piteous overthrows\n
Doth with their death bury their parents’ strife.\n
The fearful passage of their death-marked love\n
And the continuance of their parents’ rage,\n
Which, but their children’s end, naught could remove,\n
Is now the two hours’ traffic of our stage;\n
The which, if you with patient ears attend,\n
What here shall miss, our toil shall strive to mend.\n"

# Send aditional information to the textarea input
textarea <- driver$findElement("tag name", "textarea")
textarea$sendKeysToElement(list(poetry))

# Submit form and go back
driver$findElement("css selector", "p > button")$submitElement()
Sys.sleep(5)
driver$goBack()

# Refresh the form page:
driver$refresh()

17. Finishing your work with RSelenium

Finally, we can ask RSelenium to close the browser window and shut down the server. We should also release the port we were using.

# When you are done working with selenium, 
# Quit the browser and end the session
driver$quit()
driver$closeServer()
rm(driver, client_server)

# This releases the port.
system("taskkill /im java.exe /f", intern=FALSE, ignore.stdout=FALSE)

18. Last words

Now, we could create code to order 20 diferent pizzas, for example, if we desired to make a good surprise for our great work colleages. Then, whenever you want to ask another 20 pizzas (or 15, or 1000!), you just need to hit the run button, and RSelenium makes all the work for you.

That’s the beauty of task automation, and with this tutorial, we only scratched the surface of what RSelenium can do for us. However, the information published here is more than enough to allow you to continue your learning path in this area and create fantastic scripts that will save you and your team a lot of time.

And this saved time can be applied later in other important activities, like spending quality time with family or friends, reading, learning new skills, birdwatching, or simply relaxing. You definitely earned it after writing your automation script!

Good luck and happy automation!

P.S.: You will find more info about my work on LinkedIn, Medium, and Github:

https://www.linkedin.com/in/fabriciobrasil

https://fabriciusbr.medium.com/

https://github.com/fabricius1

Link do post original: https://fabriciusbr.medium.com/using-rselenium-for-task-automation-and-web-scraping-250c4f2f5979

#coletadadedadosdaweb #linguagemR #automacao

O post Using RSelenium for task automation and web scraping apareceu primeiro em Estatidados.

Hoje vamos executar um programa de machine learning (aprendizado de máquina)para verificar se a pessoa está propensa ter diabetes ou não, com base nas informações que ela vai inserir.

A nossa base de dados utilizada, é da Kaggle e se encontra disponível no seguinte link: https://www.kaggle.com/uciml/pima-indians-diabetes-database

Recomendo que antes de utilizá-la, você faça o tratamento dos dados, ok?

Vamos precisar também utilizar o Streamlit, mas o que ele é?

O Streamlit é um framework desenvolvido em Python que torna possível a criação de aplicativos elegantes para modelos de machine learning (aprendizagem de máquina) ou mesmo visualização de dados para uma simples análise exploratória de um dataset (conjunto de dados), além de possuir de forma nativa HTML e JavaScript, desta forma não é necessário saber programar nessas linguagens.

vai precisar estar realizando o download do Streamlit, através do link: https://streamlit.io/

Vamos utilizar também o PyCharm (IDE Python para desenvolvedores), link: https://www.jetbrains.com/pt-br/pycharm/download/#section=windows.

Vale lembrar que o seu ambiente Python deve estar já configurado para que possamos dar os primeiros passos na construção do nosso App.

Para começarmos precisamos instalar as bibliotecas que vamos utilizar. Para isso com o PyCharm aberto no seu terminal, basta inserir os seguintes comandos:

1) pip install streamlit

2) pip install scikit-learn

3) pip install matplotlib

4) pip install pandas

Se você não lembra o que essas bibliotecas significam, temos um artigo dedicado para a explicação delas, vale a pena conferir.

Agora que instalamos as bibliotecas que vamos utilizar, vamos fazer a importação delas.

Para isto para inserir o seguinte código:

#importando as bibliotecas
import pandas as pd
import streamlit as st
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

Explicando: Aqui estamos utilizando a biblioteca Pandas para trabalharmos com o conjunto de dados, a biblioteca Streamlit para a interface do nosso App, Sklearn para dividir o nosso conjunto de dados em treino e teste, utilizando para isso um classificador baseado em árvore de decisão, podendo no final verificar a acurácia do nosso modelo criado.

Vamos agora atribuir um título ao nosso aplicativo

#título
st.write(“Prevendo Diabetes”)

Realizando a leitura da base de dados:

#dataset

df = pd.read_csv(“C:/Users/Usuario/Desktop/dash/diabetes.csv”)

Criando um cabeçalho:

#cabeçalho

st.subheader(“Informações dos dados”)

Permitindo a inserção do nome do usuário pelo próprio.

#nomedousuário

user_input = st.sidebar.text_input(“Digite seu nome”)

Escrevendo o nome do usuário que foi dado na entrada:

#escrevendo o nome do usuário

st.write(“Paciente:”, user_input)

A partir daqui, vamos criar o nosso modelo, como dito anteriormente.

Vamos começar dividindo os nossos dados de entrada. Aqui o “x” recebe o “df.drop”, porque não queremos a coluna do campo “Outcome”, que é o campo com o resultado que diz se está ou não com diabetes, que é o que vamos estar treinando. Criamos depois a variável que precisamos para que apareça o resultado.

#dados de entrada

x = df.drop([‘Outcome’],1)

y = df[‘Outcome’]

Agora, vamos separar o conjunto de dados em treino e teste, utilizando 20% da base para teste e o restante para treinamento.

#separa dados em treinamento e teste

x_train, x_text, y_train, y_test = train_test_split(x, y, test_size=0.2)

Nesta etapa, vamos criar uma função para coletar os dados que irão ser inseridos pelos usuários. Como parâmetro, vamos definir um valor mínimo, um valor máximo e um valor default.

#dados dos usuários com a função

def get_user_date():

pregnancies = st.sidebar.slider(“Gravidez”,0, 15, 1)

glicose = st.sidebar.slider(“Glicose”, 0, 200, 110)

blood_pressure = st.sidebar.slider(“Pressão Sanguínea”, 0, 122, 72)

skin_thickness = st.sidebar.slider(“Espessura da pele”, 0, 99, 20)

insulin = st.sidebar.slider(“Insulina”, 0, 900, 30)

bni= st.sidebar.slider(“Índice de massa corporal”, 0.0, 70.0, 15.0)

dpf = st.sidebar.slider(“Histórico familiar de diabetes”, 0.0, 3.0, 0.0)

age = st.sidebar.slider (“Idade”, 15, 100, 21)

Criação de um dicionário para recebimento dessas informações.

#dicionário para receber informações

user_data = {‘Gravidez’: pregnancies,

‘Glicose’: glicose,

‘Pressão Sanguínea’: blood_pressure,

‘Espessura da pele’: skin_thickness,

‘Insulina’: insulin,

‘Índice de massa corporal’: bni,

‘Histórico familiar de diabetes’: dpf,

‘Idade’: age

}

features = pd.DataFrame(user_data, index=[0])


return features

Agora estamos finalizando nosso aplicativo!!!

Vamos chamar a função criada e gerar um gráfico para exibir as informações.

O critério utilizado aqui foi a “entropia”, pois é usada para estimar a aleatoriedade da variável a prever (classe).

user_input_variables = get_user_date()

#grafico

graf = st.bar_chart(user_input_variables)

dtc = DecisionTreeClassifier(criterion=’entropy’, max_depth=3)

dtc.fit(x_train, y_train)

Aqui verificamos a acurácia do nosso modelo:

#acurácia do modelo

st.subheader(‘Acurácia do modelo’)

st.write(accuracy_score(y_test, dtc.predict(x_text))*100)

Vamos agora com o resultado da previsão, para verificar se o usuário tem ou não diabetes.

Se o resultado for igual a “0” ele não possui diabetes, caso seja igual a “1” ele possui diabetes.

#previsão do resultado

prediction = dtc.predict(user_input_variables)

st.subheader(‘Previsão:’)

st.write(prediction)

Agora vamos ver o resultado final?

Basta no seu terminal do PyCharm, inserir o comando para o Streamlit executar o seu script criado em Python, da seguinte forma: streamlit run “nome do seu script”

A seguir vamos visualizar o resultado:

Pronto, você possui o seu primeiro aplicativo!!!

Deixe o seu comentário, e me siga no LinkedIn para acompanhar mais informações.

Obrigada pela leitura, até a próxima!

Link do post original: https://medium.com/data-hackers/desenvolvimento-de-um-aplicativo-web-utilizando-python-e-streamlit-b929888456a5

LinkedIn da autora: https://www.linkedin.com/in/debora-gobbo-a63a3392/

O post Desenvolvimento de um aplicativo Web utilizando Python e Streamlit apareceu primeiro em Estatidados.

O que é Crontab?

“O Cron é utilizado para agendar tarefas recorrentes, as tarefas são chamadas de cronjobs e são gerenciadas pelo crontab (tabela do cron).

Esta ferramenta vem instalada em diversas distribuições Linux, mas caso o Cron não esteja instalado na sua máquina é possível instalar através do comando abaixo (No Ubuntu)”:

# apt-get install cron

Para criar uma nova tarefa usamos o comando crontab -e que irá abrir o arquivo do cron para inserir o agendamento para o usuário atual.

# crontab -e

• Se necessário usar o sudo nos comandos acima.

O crontab possui seis colunas, que correspondem aos minutos, horas, dias, meses, semanas e, por fim, aos comandos que serão executados.

Abaixo segue detalhes sobre eles:

• Minuto: Valores de 0 a 59 ou *
• Hora: Valores de 0 a 23 ou *
• Dia: Valores de 1 a 31 ou *
• Mês: Valores de 1 a 12, jan a dec ou *
• Semana: 0 a 6, sun a sat ou * (0 e 7 representa Domingo)
• Comando: O comando a ser executado ou script

O caractere asterisco (*) significa do primeiro ao último.

Com o arquivo do Crontab aberto vamos adicionar a seginte linha */15 * * * * Rscript script.R, após o Rscript coloca todo o caminho até o arquivo a ser executado, e nos minutos foram colocados ’*/15’ para o arquivo ser executado a cada 15 minutos.

# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
# m h  dom mon dow   command

*/15 * * * * Rscript 'script.R'

Script R

Vamos utilizar um script R que envia uma mensagem para o Telegram toda vez que for executado. Para isso, vou utilizar um Bot que criei no post anterior: https://jodavid.github.io/post/construindo-um-chatbot-para-telegram-com-r/

script.R:

# Pacote Necessário: telegram.bot

# Token do Bot:
bot <- telegram.bot::Bot(token = "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11")

# Adicionando id do Recepetor (abaixo como descobrir seu id no Telegram)
chatid <- "574895214" #id aleatório aqui

# Enviando o horário atual
bot$sendMessage(chat_id = chatid,
                text = format(Sys.time(), "%X")
                )

Como descobrir seu id

1. Acesse esse link pelo Telegram: https://t.me/my_id_bot;
2. Utiliza o /start;
3. Seu id do Telegram vai aparecer na tela de conversa.

Com esse código acima, estando correto o token do bot e o id do receptor, a mensagem chegará no Telegram corretamente.

OBS.: É necessário interagir com o bot após a criação dele, para que as mensagens cheguem corretamente. Não fazendo isso, o bot não consegue enviar mensagens ao usuário.

Fontes:

https://medium.com/totvsdevelopers/entendendo-o-crontab-607bc9f00ed3

“Post gerado com framework HUGO (http://gohugo.io/), R Markdown (http://rmarkdown.rstudio.com/), no qual os resultados são gerados na geração da página.”

Post original:

https://jodavid.github.io/post/construindo-um-chatbot-para-telegram-com-r/

LinkedIndo autor:

https://www.linkedin.com/in/jodavidferreira/

O post Refresh de um script R com Crontab apareceu primeiro em Estatidados.

Essas ferramentas usam inteligência artificial e estão cada vez mais aperfeiçoadas. Ou seja, você não sabe, mas provavelmente já conversou com um robô.

Neste post vamos criar um ChatBot para o Telegram e controlado com software R.

Criando o Bot no Telegram

Primeiro passo é criar o Bot no Telegram, para esse passo crie uma conta no Telegram e em seguida procure o usuário @BotFather e inicie uma conversa da seguinte forma com o seguinte comando para criar um novo bot:

/newbot

Você deve obter uma resposta instantânea:

Alright, a new bot. How are we going to call it? Please choose a name for your bot.

que pede para você escolher um nome para o seu Bot. Você deve enviar então o nome que deseja para o bot, que pode ser qualquer um, por exemplo:

JFRBot

Em seguida receberá a seguinte mensagem:

Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.

O BotFather agora pedirá que você escolha um nome de usuário para o seu Bot. Este nome de usuário deve terminar em bot e ser globalmente único. Neste tutorial, vou alterar um pouco o nome, mas levando em consideração que seja parecido como nome escolhido anteriormente. Envie seu nome de usuário escolhido para BotFather:

J_frbot

Depois de fazer isso, o BotFather enviará a você uma mensagem de “Parabéns”, que incluirá um token.

Done! Congratulations on your new bot. You will find it at t.me/J_frbot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.

Use this token to access the HTTP API:
123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
Keep your token secure and store it safely, it can be used by anyone to control your bot.

For a description of the Bot API, see this page: https://core.telegram.org/bots/api

eu substituí o token pois ele é único, este acima é apenas um exemplo.

O token é esta parte: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Alguns comandos do @BotFather podem ser encontrados https://core.telegram.org/bots#6-botfather.

Para o restante deste tutorial, indicaremos onde você precisa colocar seu token usando <your-bot-token> ou apenas TOKEN. Anote o token, pois você precisará dele no código que está prestes a escrever.

Iniciando código no R

Com a criação do Bot pelo Telegram concluído, vamos agora configurar o R para que consigamos consevar com o Bot e assim criar esse robô que está cada vez mais ganhando espaço.

O primeiro passo é instalar e chamar a biblioteca no qual usaremos:

# Pacote Necessário
# install.packages(telegram.bot)

library(telegram.bot) #Pacote para Telegram

Com o pacote instalado, é o momento de utilização do Token:

#Token do Bot:
bot <- Bot(token = "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11")
updater <- Updater(token = "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11")

print(bot$getMe())

## $id
## [1] 1406230646
## 
## $is_bot
## [1] TRUE
## 
## $first_name
## [1] "JFRBot"
## 
## $username
## [1] "J_frbot"
## 
## $can_join_groups
## [1] TRUE
## 
## $can_read_all_group_messages
## [1] FALSE
## 
## $supports_inline_queries
## [1] FALSE

Pelo resultado anterior é possível verificar que estamos conectados ao nosso Bot corretamente.

A seguir vamos criar algumas funções e verificar se obtemos respostas quando conversarmos com nosso Bot pelo Telegram.

#Funcao start
start <- function(bot, update)
{
  bot$sendMessage(chat_id = update$message$chat_id,
                  text = sprintf("Olá %s, se estiver recebendo está mensagem, significa que eu existo e estou aqui!",
                                 update$message$from$first_name))
}
start_handler <- CommandHandler("start", start)
updater <- updater + start_handler

#Funcao hoje
hoje <- function(bot, update)
{
  bot$sendMessage(chat_id = update$message$chat_id,
                  text = sprintf("A data de hoje é %s",
                                 format(Sys.Date(), "%d-%b-%Y")))
}
hoje_handler <- CommandHandler("hoje", hoje)
updater <- updater + hoje_handler

#Funcao echo
echo <- function(bot, update){
  bot$sendMessage(chat_id = update$message$chat_id, text = update$message$text)
}

updater <- updater + MessageHandler(echo, MessageFilters$text)

#Funcao histograma de uma normal
historama_normal <- function(bot, update)
{
  png("my_plot.png")
  hist(rnorm(1000))
  dev.off()
  bot$sendPhoto(chat_id = update$message$chat_id, photo = 'my_plot.png')
}

hist_norm_handler <- CommandHandler("hist_norm", historama_normal)
updater <- updater + hist_norm_handler

Para iniciar o chatBot utilize a função abaixo:

updater$start_polling()

Nosso Bot atualmente possui 4 funções, que podem ser acessadas com /start, /hoje, /hist_norm e a quarta função é repetir tudo que é digitado.

Abaixo segue uma imagem das funções funcionando no Telegram:

Menu de itens

Será mostrado a seguir como criar um menu de itens como destacado na imagem abaixo. Este menu ajuda a definir e mostrar aos usuários os comandos prontos e existentes no Bot.

Para criar o menu de itens, acesse o chat do @BotFather que é quem comanda os Bot, e exeute o seguinte comando:

/setcommands

Você receberá a mensagem abaixo se possuir mais de um Bot

Choose a bot to change the list of commands.

ao escolher o Bot desejado será novamente emitida uma mensagem

OK. Send me a list of commands for your bot. Please use this format:

command1 - Description
command2 - Another description

Send /empty to keep the list empty.

A seguir pode colocar a lista com todos os comandos e as descrições, no nosso exemplo, como possui 3 funções, /start, /hoje, /hist_norm foram colocadas essas funções como mostrados abaixo.

start - inicio do Bot
hoje - data atual
hist_norm - Histograma da distribuição Normal

Se conseguiu chegar aqui e com o código em R mostrado estando em execução, o seu ChatBot deve estar funcionando e respondendo a seus comandos pelo Telegram.

O Bot só funciona se o arquivo estiver rodando no R, ou, uma outra forma é colocar num servidor que suporte códigos em R. Eu possuo o shiny-server instalado em minha máquina local, e dessa forma foi possível criar um arquivo, no qual, quando este aberto, o ChatBot fica funcionando, ou seja, quando eu estiver com o notebook ligado, esse Bot ensinado nesse post está funcionando e voê pode conversar com ele pesquisado-o no Telegram por JFRBot ou @J_frbot.

O artigo Como Instalar o shiny server em seu Próprio Servidor do Marcus Nunes mostra como instalar um servidor Shiny, o artigo é encontrado no link: https://marcusnunes.me/posts/como-instalar-o-shiny-em-seu-proprio-servidor/.

Fontes:

https://www.techtudo.com.br/noticias/2018/03/o-que-e-chatbot-entenda-como-funciona-o-robo-que-conversa-com-voce.ghtml

https://cran.r-project.org/web/packages/telegram.bot/vignettes/telegrambot-introduction.html

https://chatbotsmagazine.com/building-a-telegram-chatbot-with-r-2754cb75759f

“Post gerado com framework HUGO (http://gohugo.io/), R Markdown (http://rmarkdown.rstudio.com/), no qual os resultados são gerados na geração da página.”

Post original:

https://jodavid.github.io/post/construindo-um-chatbot-para-telegram-com-r/

LinkedIndo autor:

https://www.linkedin.com/in/jodavidferreira/

O post Construindo um ChatBot para Telegram com R apareceu primeiro em Estatidados.

O estudo será realizado sobre o projeto “SERENATA DE AMOR” https://serenata.ai/, que é um projeto aberto no qual usa data science (ciência de dados) – a mesma tecnolgia usada por gigantes como Google, Facebook e Netflix – com o objetivo de monitorar os gastos públicos e compartilhar informações de forma acessível a todos.

Até a data da publicação deste post, o projeto já reportou mais de 8.276 ressarcimentos suspeitos à Câmara dos Deputados envolvendo 735 parlamentares diferentes com valor total superior a R$ 3,6 mi.

Quer saber como funciona o sistema de relatórios? Você pode ler mais neste post – clicando aqui!.

Explicado o projeto Serenata, voltamos ao Web Scraping. A coleta de dados será sobre o Jarbas ), que é a plataforma onde ficam armazenados os documentos considerados suspeitos. Com o intuito de mostrar que é possível analisar os dados da forma que desejar para tomada de decisões, um gráfico será gerado com os dados coletados de alguns deputados e os valores de reembolso solicitados por eles.

Passo 1: Lendo a URL.

Para ler a página em html, será utilizado a função “read_html” do pacote rvest.

library(rvest)

## Carregando pacotes exigidos: xml2

url <- "https://jarbas.serenata.ai/dashboard/chamber_of_deputies/reimbursement/"
jarbas_webpage <- read_html(url)

Passo 2: Agora, a melhor parte da biblioteca rvest é que você pode extrair os dados de html em forma de nós, o que significa que você pode selecionar imediatamente quais os nós através dos ids ou classes css e extrair o texto das tags do html. Então eu fui para o meu url e abri o “firebug ” no navegador e percebi que os nomes dos deputados foram encapsulados na classe css “.field-congressperson_name ”, usando esta classe css que posso extrair todos os nomes dos deputados na página da web.

Existem 2 funções que usaremos aqui:

1. html_nodes: Use esta função para extrair os nós que desejamos (neste caso nós com “.field-congressperson_name” como classe css
2. html_text: Use esta função para extrair o texto entre dos nós html (neste caso, os nomes de nossos representantes)

#Scraping  usando classe css ‘field-congressperson_name’
jarbas_names_html <-html_nodes(jarbas_webpage, '.field-congressperson_name')
jarbas_names <- html_text(jarbas_names_html)
head(jarbas_names)

## [1] "Valmir Assunção" "Hélio Leite"     "Hélio Leite"     "Hélio Leite"    
## [5] "Bacelar"         "Hélio Leite"

Da mesma forma, agora farei isso para todos os outros atributos: SUBQUOTA TRANSLATED, FORNECEDOR. Cada um desses atributos tem suas próprias classes css: field-subquota_translated, field-supplier_info.

#SUBQUOTA TRANSLATED
jarbas_subquota_html <-html_nodes(jarbas_webpage, '.field-subquota_translated')
jarbas_subquota <- html_text(jarbas_subquota_html)
head(jarbas_subquota)

## [1] "Combustíveis e lubrificantes"                
## [2] "Divulgação da atividade parlamentar"         
## [3] "Divulgação da atividade parlamentar"         
## [4] "Combustíveis e lubrificantes"                
## [5] "Consultorias, pesquisas e trabalhos técnicos"
## [6] "Combustíveis e lubrificantes"

#Fornecedor
jarbas_provider_html <-html_nodes(jarbas_webpage, '.field-supplier_info')
jarbas_provider <- html_text(jarbas_provider_html)
head(jarbas_provider)

## [1] "POSTO MK 107 NORTE LTDA05.625.571/0001-35"                        
## [2] "PRISCILLA DE CASSIA PORTELA VINHOTE 7054665724934.314.072/0001-25"
## [3] "M SANTOS GUIMARAES EIRELI23.936.281/0001-94"                      
## [4] "SUPER POSTO PALMEIRA LTDA83.838.839/0001-20"                      
## [5] "NARCISO COELHO E MATOS ADVOGADOS ASSOCIADOS17.359.366/0001-54"    
## [6] "Posto de Combustiveis Garantia Ltda72.578.438/0002-43"

A seguir serão mostrados o valor do reembolso, note que eles são extraídos em tipo de variável caracter: Ex: R$ 139,76, R$ 40,23. Entretanto, como desejamos manipular esses números, precisamos convertê-los para tipo de variável numérica, dessa forma será utilizado a biblioteca: “Stringr” mais especificamente a função: str_extract. Segue o script para conversão da variável.

library(stringr)
#valores em Real
jarbas_value_html <-html_nodes(jarbas_webpage, '.field-value')
jarbas_value <- html_text(jarbas_value_html)
head(jarbas_value)

## [1] "R$ 198,84"   "R$ 900,00"   "R$ 300,00"   "R$ 5022,28"  "R$ 13000,00"
## [6] "R$ 168,94"

#R$ 139,76" "R$ 40,23"  "R$ 72,05"  "R$ 72,05"  "R$ 56,39"  "R$ 235,64"  
#dados extraídos na forma de caracter, vamos converter para tipo numérico
jarbas_value <- as.numeric(sub(",",".",str_extract(jarbas_value,pattern = "\\-*\\d+,\\s{0,}\\d+")))
head(jarbas_value,25)

##  [1]   198.84   900.00   300.00  5022.28 13000.00   168.94   600.65   129.17
##  [9]    88.42    26.54   800.62    64.84   164.00    25.84  1817.62   199.35
## [17]  1889.55    64.45    60.40  2214.45   139.32    25.65  3000.00  5000.00
## [25]  1500.00

Passo 3: Com essas informações disponíveis, vamos gerar um dataframe. Para facilitar a visualização, apenas o primeiro nome de cada deputado foi selecionado.

#Combinando todas as características obtidas
jarbas_names <- str_extract(jarbas_names,pattern = boundary("word"))
jarbas_df <- data.frame(
  Name = jarbas_names,
  Subquota = jarbas_subquota,
  Provider = jarbas_provider,
  Value = jarbas_value
  )
str(jarbas_df)

## 'data.frame':    100 obs. of  4 variables:
##  $ Name    : chr  "Valmir" "Hélio" "Hélio" "Hélio" ...
##  $ Subquota: chr  "Combustíveis e lubrificantes" "Divulgação da atividade parlamentar" "Divulgação da atividade parlamentar" "Combustíveis e lubrificantes" ...
##  $ Provider: chr  "POSTO MK 107 NORTE LTDA05.625.571/0001-35" "PRISCILLA DE CASSIA PORTELA VINHOTE 7054665724934.314.072/0001-25" "M SANTOS GUIMARAES EIRELI23.936.281/0001-94" "SUPER POSTO PALMEIRA LTDA83.838.839/0001-20" ...
##  $ Value   : num  199 900 300 5022 13000 ...

Passo 4: Numa primeira análise, podemos utilizar gráfico entre o valor do reembolso e o nome dos deputados. Foram utilizados as 50 primeiras linhas do data.frame e uma biblioteca ggplot2 para geração do gráfico.

library(ggplot2)

jarbas_df <- jarbas_df[1:50,]

ggplot(
  jarbas_df, aes(Value,Name,colour=Subquota)) +
  geom_point() +
  labs(title="", x ="pedidos de reembolso (R$)",
       y = "deputados",colour="SUBQUOTA TRANSLATED")

“Post gerado com framework HUGO (http://gohugo.io/), R Markdown (http://rmarkdown.rstudio.com/), no qual os resultados são gerados na geração da página.”

Post original:

https://jodavid.github.io/post/web-scraping-introduction-with-r/

LinkedIn do autor:

https://www.linkedin.com/in/jodavidferreira/

#webscraping #R #dadosweb #extrairdados

O post Introdução a Web Scraping com R apareceu primeiro em Estatidados.

Como instalar os dois e usá-los de forma integrada.

AUTHOR

José de Jesus Filho

PUBLISHED

Jan. 3, 2021

Introdução

Este tutorial irá mostrar como instalar o R e o PostgreSQL num mesmo servidor Ubuntu 20.04 ou 18.04. Em seguida, falaremos sobre como chamar o R a partir do PostgreSQL.

Farei uma série de tutoriais. Este primeiro é voltado para aqueles com familiaridade com funções do R e que gostariam de rodá-las no PostgreSQL, sem necessariamente conhecer muito de SQL. Num próximo, iremos mostrar como criar queries e declarações do PostgreSQL do R, ou seja, será mais voltado para quem tem familiaridade com o SQL, mas não necessariamente versada em R.

Os tutoriais posteriores serão voltados para aqueles com bastante familiaridade em tidyverse e que gostariam de realizar as mesmas coisas em SQL. Igualmente, servirão para aqueles que sabem manipular dados em SQL, mas gostariam de fazer as mesmas coisas no R.

Em futuros tutoriais, falaremos quando compensa iniciar no PostgreSQL e terminar no R. Por exemplo, quando é mais vantajoso dar um join no R em vez de fazê-lo no PostgreSQL e vice-versa.

Instalando o PostgreSQL

A primeira coisa a fazer é atualizar os pacotes do sistema:

sudo apt update
sudo apt -y install vim bash-completion wget
sudo apt -y upgrade


### Configuração do locale

Além disso, é importante configurar o locale. Crie um arquivo chamado set_locale.sh:

```sh
$ vim set_locale.sh

E cole o seguinte conteúdo:

#!/bin/bash

# Set locales in /etc/default/locale file
echo "Ajustando o locale..."
echo "# Locale settings
export LANGUAGE=pt_BR.UTF-8
export LANG=pt_BR.UTF-8
export LC_ALL=pt_BR.UTF-8">>~/.bash_profile

locale-gen pt_BR.UTF-8

sudo dpkg-reconfigure locales

source ~/.bash_profile

autorize execução do arquivo:

$ sudo chmod +x set_locale.sh

E rode o script:

$ sudo ./set_locale.sh

Reinicie a máquina:

$ sudo reboot

Acesse novavamente via ssh e verifique se o locale foi configurado para pt_BR-UTF8.

$ locale

O console deverá imprimir a seguinte configuração:

LANG=pt_BR.UTF-8
LANGUAGE=pt_BR.UTF-8
LC_CTYPE="pt_BR.UTF-8"
LC_NUMERIC="pt_BR.UTF-8"
LC_TIME="pt_BR.UTF-8"
LC_COLLATE="pt_BR.UTF-8"
LC_MONETARY="pt_BR.UTF-8"
LC_MESSAGES="pt_BR.UTF-8"
LC_PAPER="pt_BR.UTF-8"
LC_NAME="pt_BR.UTF-8"
LC_ADDRESS="pt_BR.UTF-8"
LC_TELEPHONE="pt_BR.UTF-8"
LC_MEASUREMENT="pt_BR.UTF-8"
LC_IDENTIFICATION="pt_BR.UTF-8"
LC_ALL=pt_BR.UTF-8

Como última etapa, configure também o fuso horário:

$ sudo timedatectl set-timezone America/Sao_Paulo

Confirme que o fuso horário foi configurado para São Paulo:

$ timedatectl

Você deverá visualizar o seguinte resultado:

Local time: Qua 2020-06-17 19:34:30 -03
  Universal time: Qua 2020-06-17 22:34:30 UTC
        RTC time: Qua 2020-06-17 22:34:30
       Time zone: America/Sao_Paulo (-03, -0300)
 Network time on: yes
NTP synchronized: yes
 RTC in local TZ: no

Importe a chave GPG:

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

Adicione a chave GPG ao systema:

echo "deb http://apt.postgresql.org/pub/repos/apt/ `lsb_release -cs`-pgdg main" |sudo tee  /etc/apt/sources.list.d/pgdg.list

Atualize os pacotes do sistema e instale os pacotes do PostgreSQL necessários. Os dois primeiros são necessários para rodar o PostgreSQL, os três últimos são necessários para instalar o plr, o RPostgres e outras extensões. Falaremos deles mais adiante.

sudo apt update
sudo apt install postgresql-12 postgresql-client-12 postgresql-server-dev-all libpq-dev postgresql-contrib

Instalação do R

sudo echo "deb https://cloud.r-project.org/bin/linux/ubuntu `lsb_release -cs`-cran40/" | sudo tee -a /etc/apt/sources.list

Adicionar a chave GPG

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9

Instale o R

sudo apt-get update
sudo apt-get install -y r-base r-base-dev 

Instale também o git

sudo apt install git

Agora use o git para clonar o plr. Não importa o local onde você irá cloná-lo. Desde que você tenha seguido fielmente os passos anteriores, tudo terminará bem.

git clone https://github.com/postgres-plr/plr

Feito isso, entre no diretório plr e rode os seguintes comandos para instalá-lo como extensão.

cd plr
USE_PGXS=1 make
USE_PGXS=1 make install

Criando uma base de dados

Vamos para o Postgres a fim de criar uma base de dados.

sudo -u postgres psql

CREATE DATABASE datasets;

Além disso, você deve incluir a extensão plr na base de dados recentemente criada:

\c datasets -- conectar-se à base
CREATE EXTENSION plr;
\q -- sair do psql

De volta ao R.

R

Instale os pacotes RPostgres e broom

Instalando esses dois pacotes é suficiente para instalar também outras dependências como o DBI e o dplyr, as quais igualmente usaremos.

install.packages(c("RPostgres","broom"))

Connexão do R ao Postgres

Eventualmente, você terá de autorizar a conexão local. Vá para o arquivo:

vim /etc/postgresql/12/main/pg_hba.conf

E altere a seguinte linha de:

local all all peer

Para:

local all all trust

Colocando uma tabela na base de dados

Admitindo que você ainda se encontra no R, estamos em condições de incluir uma tabela na base de dados.

Primeiramente, vamos conectar-nos à base:

conn <- DBI::dbConnect(RPostgres::Postgres(), dbname="datasets")

Estou admidindo com o código acima que você está usando o R na mesma máquina do Postgres, usando o usuário postgres e dispensou o uso de senha para conexão local.

Vamos enviar o dataframe mtcars para a base de dados. O exemplo do mtcars não é muito feliz porque ele poderia ser chamado do próprio R quando rodado no Postgres, mas apenas a título de exemplo, iremos assumir que ele seja qualquer outro data.frame.

DBI::dbWriteTable(conn,"tabela", mtcars)

De volta ao Postgres

Mostraremos num próximo tutorial como realizar os procedimentos a seguir sem sair do R, mas o propósito deste tutorial é justamente ilustrar como podemos chamar o R do Postgres. Assim, faremos tudo no Postgres mesmo.

Voltando para o shell, vamos conectar-nos à base datasets:

sudo -u postgres psql datasets

Verifique se a tabela chamada “tabela” se encontra na base de dados:

\d+ -- ou 
\d+ tabela

Preparando o terreno

Vamos criar uma tabela que servirá de referência para receber os resultados de uma regressão linear. Veja que as colunas são as mesmas do tibble retornado pela função tidy do pacote broom, com a diferença de que os pontos foram substituídos pelo sublinhado e os nomes das colunas passados para o português.

create table modelo (termo text, estimativa float8, erro_padrao float8, estatistica float8, p_valor float8);

Criando uma função plr

Enfim estamos em condições de criar uma função no PostgreSQL que chama o R para rodar uma regressão linear em uma tabela contida no próprio Postgres:

CREATE OR REPLACE FUNCTION lm_teste() RETURNS SETOF modelo AS
$$ 
base <<- pg.spi.exec('select mpg, wt, qsec, am  from tabela')
df <- lm(mpg ~ wt + qsec + factor(am), data=base)
df <- broom::tidy(df)
names(df) <- c('termo','estimativa','erro_padrao','estatistica','p_valor')
df <- dplyr::mutate_at(df,dplyr::vars(2:5), ~round(.,2))
return(df)
$$
language 'plr';

Note que o esqueleto da função é o mesmo para qualquer outra função do PostgreSQL. A diferença é que, para importar um objeto da base de dados para nossa função, devemos usar a função pg.spi.exec.

Rodando a regressão linear

Agora ficou fácil. Basta chamar a função e ver os resultados:

select * from lm_teste();

datasets=# select * from lm_teste();
    termo    | estimativa | erro_padrao | estatistica | p_valor
-------------+------------+-------------+-------------+---------
 (Intercept) |       9.62 |        6.96 |        1.38 |    0.18
 wt          |      -3.92 |        0.71 |       -5.51 |       0
 qsec        |       1.23 |        0.29 |        4.25 |       0
 factor(am)1 |       2.94 |        1.41 |        2.08 |    0.05
(4 rows)

Vantagens

Eu apontaria duas principais vantagens em usar o plr:

1 – Uma vez que a base se encontra no PostgreSQL, você não precisa mais transferi-la para o R a fim de rodar o modelo e retornar o resultado ao PostgreSQL. Essa viagem dos dados torna-se dispensável. No exemplo mostrado, porém, a base irá para uma sessão do R de qualquer forma. Veremos como solucionar isso em tutoriais futuros.

2 – Você pode continuar trabalhando no R, enquanto seu modelo roda no PostgreSQL. Se o modelo tomar horas, este se torna um problema menor.

Link da publicação original:

https://rpg.consudata.com.br/posts/2021-01-04-chamando-o-r-do-postgresql/

Linkedin Autor:

https://www.linkedin.com/in/jjesusfilho/

#linguagemdeprogramação #R #SQL #cienciadedados

O post Chamando o R do PostgreSQL apareceu primeiro em Estatidados.

A Pesquisa Operacional consiste na utilização de métodos científicos para auxiliar a tomada de decisão frente a problemas complexos que exigem alocações eficientes de recursos escassos.

A resolução desses problemas se dá por várias etapas, sendo que a modelagem e a escolha do software para resolução se caracterizam como partes fundamentais para o sucesso da resolução.

Nesse trabalho, vamos utilizar o software R na resolução de problemas de Pesquisa Operacional, especificamente problemas de Programação Linear, modelados ou não por redes.

O objetivo é mostrar que, embora o software R seja utilizado majoritariamente em Matemática e Estatística, ele pode ser uma ferramenta bastante útil na Programação Linear, posto que possui muitas funções associadas à Otimização de forma geral e, além disso, é um software livre e gratuito.

INTRODUÇÃO

A Pesquisa Operacional (PO) surgiu durante a Segunda Guerra Mundial, especificamente na Inglaterra. Um grupo de cientistas foi convocado para determinar uma utilização eficiente de recursos militares limitados e, os resultados positivos obtidos por esses cientistas, fizeram com que a PO fosse difundida para os Estados Unidos, onde ela se desenvolveu de forma consistente. Desde então, essa ciência vem sendo aplicada com sucesso na otimização de recursos em diferentes segmentos (FÁVERO & BELFIORE, 2013).

Segundo Arenales et al. (2011), a PO consiste na utilização de métodos científicos para auxiliar a tomada de decisão frente a problemas complexos que exigem alocações eficientes de recursos escassos (ou seja, problemas de otimização).

De forma simplificada, Marins (2011) propõe a resolução de um problema de PO em cinco etapas:

a) Formulação do problema (identificação do sistema);

b) Construção do modelo matemático;

c) obtenção da solução;

d) teste do modelo e da solução obtida;

e) implementação.

Uma das ferramentas mais utilizadas dentro da PO é a Programação Linear (PL). A PL tem como objeto, essencialmente, encontrar a melhor solução para os problemas que tenham expressões lineares representando seus modelos. Essencialmente, atribui-se a PL a maximização ou minimização de uma função linear (função objetivo), satisfazendo as restrições do modelo (sistema linear de igualdades ou desigualdades).

Incorporado a programação linear pode-se ressaltar o método simplex, que é uma técnica utilizada para se determinar, numericamente a solução ótima para um determinado modelo.

É necessário utilizar-se de software para a resolução de problemas de programação linear, pois a maioria dos impasses podem apresentar funções de várias variáveis, tornando-se assim inviável a solução de tal problema sem o auxílio dos softwares. Contudo, grande parte desses softwares apresentam código fechado, isto é, seu acesso é restrito, deixando de apresentar para o usuário uma solução de forma didática (MARINS, 2011).

Para a resolução dessa modelagem, vários softwares foram desenvolvidos, como: LINDO, CPLEX, PROMODEL, ARENA e Solver do Excel. Porém, tais programas não possuem código livre e não são gratuitos, limitando seu acesso e utilização.

Dessa forma, esse estudo tem como objetivo mostrar a utilização de softwares livres e gratuitos para a resolução de problemas de pesquisa operacional, especificamente problemas de programação linear. Nesse caso, mostrar a potencialidade do software R para a resolução de problemas aplicados pesquisa operacional.

Software R

O software R (R CORE TEAM, 2018), que surge pela criação da R Foundation for Statistical Computing, além de um tipo de linguagem, é um software computacional e gráfico, que tem como vantagens a gratuidade, código aberto e livre acesso, para que inúmeros usuários desenvolvam novos comandos e de forma que possam compartilhar em redes sociais (RSTUDIO, 2020).

Além disso, o programa oferece uma gama de funções, podendo adaptá-la de acordo com suas necessidades.

O R tem compatibilidade com diversas plataformas, como LINUX e Windows, e permite a ligação de interfaces de diferentes formatos, como Excel e SQL Server. Sendo fonte aberta, permite ao utilizador alterar funcionalidades existentes, bem como criar funcionalidades para responder aos seus problemas específicos de forma mais eficaz (LIMA et al., 2015).  

Atualmente, o software R não é o meio de resolução de problema de pesquisa operacional e programação linear mais utilizado, pois há uma cultura de que o EXCEL (Solver) tenha usabilidade mais fácil e prática que o R (RSTUDIO, 2020).

Entretanto, o R oferece diversas opções de pacotes (conjuntos de funções) para resolver problemas de Pesquisa Operacional, como orloca, linprog, quadprog, BB, boot, kernlab, limSolve, LowRankQP, rcdd, Rglpk, entre outros (LIMA et al., 2015).  

Resolução de um problema de Pesquisa Operacional utilizando o Software R

O problema proposto a seguir é denominado Caso LCL Motores Ltda. É um exemplo que mostra uma das típicas situações enfrentadas no dia a dia por diversas empresas (LACHTERMACHER, 2009).

Para resolver o exemplo proposto, foi utilizado o pacote lpSolve (Berkelaar, 2020).

Problema: A LCL Motores Ltda. uma fábrica de motores especiais recebeu recentemente R$ 900.000.00 em pedidos de seus três tipos de motores. Cada motor necessita de um determinado número de horas de trabalho no setor de montagem e acabamento. A LCL pode terceirizar parte da sua produção. A tabela abaixo resume estes dados. A LCL Motores deseja determinar quanto motores devem ser produzidos em sua fábrica e quantos devem ser produzidos de forma terceirizada para atender à demanda de pedidos.

Solução:

O primeiro passo para a modelagem é a determinação das variáveis de decisão. Neste caso, o objetivo é determinar a quantidade de motores de cada tipo que deve ter sua produção terceirizada. Sendo assim, as variáveis são:

O segundo passo é determinar a expressão da função objetivo. Neste caso, a empresa deseja maximizar seus lucros. Ou seja,

Equivalentemente, pode-se escrever a função como:

Por fim, deve-se determinar as restrições que se aplicam ao modelo. Estas restrições estão relacionadas aos recursos da empresa e são descritas a seguir:

1) Restrição de Montagem

2) Restrição do Acabamento

3) Restrições de Demanda

O nosso problema pode ser resumido na seguinte modelagem:

Sujeito a:

Figura 1: Instalação do pacote lpSolve:

Figura 2: Script da resolução do problema no software R

Figura 3: Script da resolução do problema no software R

Figura 4: Valor das variáveis de decisão e da função objetivo do problema proposto

Na Figura 1, encontra-se a forma de instalação dos pacotes do R. Quando o software é instalado, apenas as configurações mínimas são instaladas. Um dado pacote deve ser pesquisado em packages e instalado para seu total funcionamento.

Na Figura 2, tem-se o script do R para resolução do problema proposto. Para utilizar o pacote lpSolve com a função lp é necessário definir:

a) Função objetivo;

b) Matriz de restrições;

c) Tipos de desigualdades;

d) Lado direito das desigualdades ou limites

Todos os elementos na programação do R (vetores, matrizes, data frame) podem ser arquivados por meio do sinal “<-“.

Ainda pela Figura 2, nota-se que para os elementos “coef_func_objetivo”, “coef_restricoes”, “sinais_restricoes” e “limites_restricoes” ficam atribuídos, respectivamente, o vetor de coeficientes da função objetivo, a matriz dos coeficientes das restrições, os sinais associados às restrições e os limites numéricos das restrições.

Para entender a função lp do pacote lpSolve, o R fornece a descrição de todas suas funções no Help. Todos os argumentos e as formas corretas para considerar as informações são encontradas nesse tópico, além de exemplos que ilustram a utilização da função. Pode-se observar na Figura 3, o item de ajuda do software R.

Na Figura 4, encontra-se os valores da função objetivo e das variáveis de decisão do problema proposto. Conclui-se que, para o custo mínimo de R$ 439000, a empresa deve terceirizar a produção de 2000 motores do modelo 2 e produzir 3000, 5000 e 500 motores dos modelos 1, 2 e 3, respectivamente

Conclusão

O software R é uma importante ferramenta utilizada na resolução de problemas de Estatística e Matemática. Porém, esse software possui diversos tipos de pacotes que contêm funções capazes de resolver problemas dos mais diversos assuntos. Dentre esses problemas, pode-se incluir a Pesquisa Operacional e, em particular, a Programação Linear e Não Linear.

Conforme abordado acima, o software R apresenta uma série de vantagens para a pesquisa operacional e com o desenvolver do estudo é possível concluir que o programa é de fácil manuseio, além de trazer funções diversas que outros softwares mais populares não possuem. Além disso, pode-se dizer que o software R oferece auxílio suficiente para um aprendizado autodidata, posto que sua função de ajuda é bastante detalhada e informativa, com exemplos e explicações detalhadas das funções.

Portanto, o estudo apresentado tem importância associada à formação de um engenheiro de produção, pois permite a utilização de um software livre e de fácil aplicação mesmo em problemas de difícil solução, aumentando as possibilidades de ferramentas que podem ser utilizadas por um profissional completo.

Autor: Julio César Proença da Costa

Linkedin: https://www.linkedin.com/in/julio-proen%C3%A7a-43499315b/

#R #pesquisaoperacional #metódodedecisão

O post A utilização do Software R na resolução de problemas na Pesquisa Operacional apareceu primeiro em Estatidados.

Introdução

No Brasil, diante da emergência sanitária mundial, as autoridades estabeleceram diversas portarias/decretos com regras e normas para funcionamento de serviços de saúde e serviços não essenciais.

Na maioria das unidades da federação, as aulas na rede pública e na rede privada foram suspensas. Eventos com grande número de pessoas foram proibidos. Houve mudanças no transporte público, com redução de frota, e alterações nas regras de abertura de comércios, bares, restaurantes e shoppings.

O objetivo dessas restrições era de evitar a sobrecarga dos serviços de saúde e esgotamento dos leitos de tratamento, à medida que, a União, Estados e Municípios poderiam se preparar para o aumento no número de casos com a construção de hospitais de campanha e importação de respiradores.

Ao longo dos últimos meses os decretos vêm sendo moldados de acordo com a realidade da pandemia no país. Mudanças como aumento das restrições de circulação e expansão na oferta de crédito, foram mais recentemente transformadas em medidas de reabertura de algumas atividades econômicas com estruturas e horários de funcionamento diferenciados, entre outros tipos. Uma forma de olhar o panorama do Covid-19 no país é observando como os agentes políticos legislaram a respeito do tema.

No texto a seguir explico como gerar um banco de dados no R com informações atualizadas sobre os decretos nos níveis municipal, estadual e federal, com registro da data, sua classificação em decreto ou lei e algumas outras informações.

Vamos lá!

Carregando os dados e os pacotes no R

A fonte dos dados vem do site https://leismunicipais.com.br/, que é totalmente confiável, tanto que vários municípios utilizam a ferramenta. Você pode encontrar mais informações sobre eles aqui.

O ‘Leis Municipais’ vem mantendo uma página com dados sobre os decretos relacionados ao Covid-19, é dessa página que vamos extrair as informações, de dentro do R, é claro.

# Pacotes
library(dplyr)
library(tidyr)
library(purrr)
library(xml2)
library(stringr)
library(rvest)
library(mgsub)
library(gsubfn)
library(lubridate)# Pasta de trabalho - altere o caminho para onde os arquivos serão salvos #
setwd("C:\\Users\\pc\\Desktop\\Cidacs\\ETL")########################################################
#### DECRETOS POR ESTADO
########################################################Acre <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=AC", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Acre")Alagoas <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=AL", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Alagoas")Amapá <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=AP", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "Amapá")Amazonas <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=AM", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Amazonas")Bahia<- read.csv2("https://leismunicipais.com.br/coronavirus?estado=BA", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Bahia")Ceará <-read.csv2("https://leismunicipais.com.br/coronavirus?estado=CE", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Ceará")Distrito_Federal<- read.csv2("https://leismunicipais.com.br/coronavirus?estado=DF", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Distrito Federal")Espírito_Santo <-read.csv2("https://leismunicipais.com.br/coronavirus?estado=ES", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Espírito Santo")Goiás <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=GO", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Goiás")Maranhão <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=MA", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Maranhão")Mato_Grosso <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=MT", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Mato Grosso")Mato_Grosso_do_Sul <-read.csv2("https://leismunicipais.com.br/coronavirus?estado=MS", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Mato Grosso do Sul")Minas_Gerais <- read.csv2
("https://leismunicipais.com.br/coronavirus?estado=MG", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Minas Gerais")Pará <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=PA", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Pará")Paraíba  <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=PB", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Paraíba")Paraná  <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=PR", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "Paraná")Pernambuco <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=PE", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "Pernambuco")Piauí <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=PI", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "Piauí")Rio_de_Janeiro <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=RJ", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Rio de Janeiro")Rio_Grande_do_Norte <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=RN", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Rio Grande do Norte")Rio_Grande_do_Sul  <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=RS", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "Rio Grande do Sul")Rondônia <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=RO", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Rondônia")Roraima <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=RR", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Roraima")Santa_Catarina  <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=SC", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Santa Catarina")São_Paulo <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=SP", encoding =  'UTF-8', sep=",", stringsAsFactors = F)  %>% mutate(Estado = "São Paulo")Sergipe <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=SE", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Sergipe")Tocantins <- read.csv2("https://leismunicipais.com.br/coronavirus?estado=TO", encoding =  'UTF-8', sep=",", stringsAsFactors = F) %>% mutate(Estado = "Tocantins")

O que foi feito aqui é bem simples: eu gerei um dataset dos decretos em cada estado, usando como fonte o link do site. Também foi criado uma coluna com o nome do respectivo estado. O que precisa ser feito agora? Ponto para quem disse unir tudo isso.

####################################################
######## Dataset com todos os decretos, por Estado
####################################################DECRETOS_ESTADOS <- list(Acre,Alagoas,Amapá,Amazonas,
                         Bahia,Ceará,Distrito_Federal,
                         Espírito_Santo,Goiás,
                         Maranhão,Mato_Grosso,Mato_Grosso_do_Sul,
                         Minas_Gerais,Pará,Paraíba,
                         Paraná, Pernambuco, Piauí,
                         Rio_de_Janeiro,Rio_Grande_do_Norte,
                         Rio_Grande_do_Sul,Rondônia,Roraima,
                         Santa_Catarina,São_Paulo,
                         Sergipe,Tocantins) %>%
                  reduce(full_join, by = c("X.U.FEFF.Epigrafe",
                                           "Localidade","Ementa",
                                           "Url","Estado")) %>%
                    rename(Decretos = "X.U.FEFF.Epigrafe")

E prontinho! Agora temos um banco de dados com todos os estados. Observem que utilizei a função reduce. Ela é do pacote purrr e ajuda na hora de unir todos os bancos, para que não seja necessário unir de dois em dois, com o reduce eu faço a união de todos simultaneamente. A união (ou merge) em si é feita com a função full_join do dplyr, nela eu informo as colunas em comum que serão usadas como base para agregar os dados. Depois eu renomeei o nome de uma coluna para um nome mais agradável (cá entre nós, “X.U.FEFF.Epigrafe” não é um bom nome para uma coluna).

Nossa base de dados tem essa cara por enquanto:

Agora nos precisamos saber se o decreto é municipal ou estadual. Para isso, basta criar uma coluna e aplicar um ifelse usando a ‘localidade’ como informação. Vejam:

### Criando coluna 'Tipo' com informação se o decreto é Estadual ou MunicipalDECRETOS_ESTADOS <- DECRETOS_ESTADOS %>% mutate(Tipo="")DECRETOS_ESTADOS$Tipo <- ifelse(DECRETOS_ESTADOS$Localidade %in%   c("Acre","Alagoas","Amapá","Amazonas",
  "Bahia","Ceará","Distrito Federal",
  "Espírito Santo","Goiás","Maranhão",
  "Mato Grosso","Mato Grosso do Sul",
  "Minas Gerais","Pará","Paraíba","Paraná",
  "Pernambuco","Piauí","Rio de Janeiro",
  "Rio Grande do Norte","Rio Grande do Sul",
  "Rondônia","Roraima","Santa Catarina",
  "São Paulo","Sergipe","Tocantins"), "Estadual", "Municipal")

Agora é necessário incluir os decretos federais. É legal ter um pouco de noção em webscrapping e html. Vamos ver.

Incluindo os Decretos Federais

O site do Governo Federal para obter as informações sobre a legislação sobre o COVID-19 é esse. Se você acessar o site vai notar que ele tem uma interface bem simples, mas não tem nele uma opção de baixar os dados, por isso, precisamos “raspar” as informações que queremos diretamente da página. O R oferece uma gama de opções para raspar informações de páginas da web, o R Selenium é a mais popular, mas aqui optei por usar o PhantomJs.

Faça o download do PhantomJs acessando a página deles, que é essa aqui. Feito o download e depois de descompactar, coloque o arquivo phantomjs.exe na pasta de trabalho que você definiu (a minha, por exemplo, é “C:\\Users\\pc\\Desktop\\Cidacs\\ETL”), basta olhar o primeiro script, no começo do texto, caso não se recorde.

Certo, com o arquivo na pasta, vamos voltar para o R.

###################################################################
###### Decretos Federais - Capturando página e gerando ela em HTML 
###################################################################writeLines("var url = 'http://www.planalto.gov.br/ccivil_03/Portaria/quadro_portaria.htm';
var page = new WebPage();
var fs = require('fs');page.open(url, function (status) {
        just_wait();
});function just_wait() {
    setTimeout(function() {
               fs.write('dec_federal.html', page.content, 'w');
            phantom.exit();
    }, 2500);
}
", con = "scrape.js")js_scrape <- function(url = "http://www.planalto.gov.br/ccivil_03/Portaria/quadro_portaria.htm", 
                      js_path = "scrape.js", 
                      phantompath = "phantomjs.exe"){
  
  lines <- readLines(js_path)
  lines[1] <- paste0("var url ='", url ,"';")
  writeLines(lines, js_path)
  
  command = paste(phantompath, js_path, sep = " ")
  system(command)
  
}js_scrape()###################################################################
######### Carregando o HTML convertido
################################################################### lendo o html
html2 <- read_html("dec_federal.html", encoding="UTF-8")# criando formato de tabela com dados do html
html_tabela <- html2 %>% html_nodes("table") %>% html_table(fill = T)fed_covid <- html_tabela[[3]]# Ajustando nome das colunas
fed_covid <- fed_covid %>% rename(Decretos = "X1") %>% rename(Ementa = "X2")# Ajustando dados no dataset (Excesso de espaçamento, etc)
fed_covid$Decretos <- gsub("[\t\n]", "", fed_covid$Decretos)
fed_covid$Ementa <- gsub("[\t\n]", "", fed_covid$Ementa)fed_covid$Decretos <- gsub("\\s+"," ", fed_covid$Decretos)
fed_covid$Ementa <- gsub("\\s+"," ", fed_covid$Ementa)# Criando coluna 'Tipo' e 'Localidade'
fed_covid <- fed_covid %>% mutate(Tipo="Federal") %>% mutate(Localidade="Brasil")

Na primeira parte do código, o PhantomJs pelo R é usado para acessar a página do planalto e gerar um arquivo em html. Usando esse arquivo em html, na segunda parte do código, foi utilizada algumas funções do pacote rvest para pegar as informações em html e transformá-la em uma tabela. Após isso, foi necessário aplicar alguns processos de limpeza e ajuste nos dados: renomear colunas, usar um pouco de conhecimento em regex para retirar espaçamento em excesso e por fim criar uma coluna ‘Tipo’ e ‘Localidade’.

Essa é a cara do nosso dataset de decretos federais:

O próximo passo é fazer um merge entre os decretos federais e o restante.

##################################################################
######## Dataset unindo decretos Federais, Estaduais e Municipais
##################################################################Decretos_Covid_Brasil <- full_join(DECRETOS_ESTADOS, fed_covid, by=c("Decretos","Localidade","Ementa","Tipo"))

Criando coluna ‘Tipo do documento’ e limpando os dados

Para saber se o documento é uma Lei, Decreto ou Portaria é preciso usar a função word do pacote stringr. Essa função pega a primeira palavra de cada linha de determinada coluna, no caso, a coluna ‘Decretos’. Também, por questão de limpeza nos dados, é bom deixar o nome do município, na coluna ‘Localidade’, sem nenhum tipo de ‘/’ ou algo que atrapalhe na busca pelo seu nome.

#### Criando coluna 'Tipo do Documento'Decretos_Covid_Brasil$Tipo_Documento <- word(Decretos_Covid_Brasil$Decretos)### Retirando '/' depois do nome do município 
Decretos_Covid_Brasil$Localidade <- gsub("\\/.*","",Decretos_Covid_Brasil$Localidade)### Removendo coluna não utilizada
Decretos_Covid_Brasil$Url <- NULL

Inserindo o código dos municípios

Para ajudar na hora de buscar por um determinado município, é sempre melhor usar o código dele do que o nome. Isso porque muitas vezes ocorrem erros de digitação, problemas com acentuação, entre outros. Por isso, é prudente acrescentar uma coluna com o código dos municípios.

Como a coluna que contém o nome dos municípios também tem o nome dos estados, é necessário criar uma condição para que apenas municípios sejam registrados (Para não ter problema, por exemplo, com estados que também tem nome de municípios, como SP ou RJ).

############################################################################## Carregando dataset com códigos dos municípios
####################################################################codigos_igbe <- read.csv2("https://raw.githubusercontent.com/CleitonOERocha/Scripts/master/Decretos%20Covid/codigo_municipios_IBGE.csv",
                          encoding = "ISO-8859-1", stringsAsFactors = F)### Merge entre códigos e dataset
Decretos_Covid_Brasil <- left_join(Decretos_Covid_Brasil, codigos_igbe, by = c("Localidade","Estado"))### Criando condições para registrar apenas Municípios, e não Estados 
  Decretos_Covid_Brasil$Codigo_Municipio <- ifelse(Decretos_Covid_Brasil$Tipo == "Municipal",
                                                  Decretos_Covid_Brasil$Codigo_Municipio, NA)
  
  Decretos_Covid_Brasil$Nome_Mesorregião <- ifelse(Decretos_Covid_Brasil$Tipo == "Municipal",
                                                   Decretos_Covid_Brasil$Nome_Mesorregião, NA)
  
  Decretos_Covid_Brasil$Cod_UF <- ifelse(Decretos_Covid_Brasil$Tipo == "Municipal",
                                         Decretos_Covid_Brasil$Cod_UF, NA)

Inserindo a data do decreto e gerando o banco de dados final

É importante ver a data em que cada decreto foi publicado, tanto para traçar uma linha do tempo, como também para olhar o volume de decretos mês a mês. Para criar a coluna contendo a data é preciso de três pacotes: lubridate, mgsub e gsubfn. Depois de mostrar o script, explico melhor sobre o uso de cada um.

############################################################################# Criando coluna com data dos decretos 
####################################################################
  
### criando lista com nome dos meses em português e seu respectivo número 
  meses_pt <- c("de janeiro de", "de fevereiro de",
                "de março de", "de abril de", "de maio de",
                "de junho de","de julho de", "de agosto de",
                "de setembro de", "de outubro de",
                "de novembro de", "de dezembro de")meses_numb <- c("/01/", "/02/", "/03/", "/04/", "/05/", "/06/", "/07/", "/08/", "/09/", "/10/", "/11/", "/12/")### condição para filtrar data na coluna - criando coluna mês
  Decretos_Covid_Brasil$Decretos_date <- ifelse(Decretos_Covid_Brasil$Tipo %in% c("Estadual","Municipal"), 
         mgsub::mgsub(Decretos_Covid_Brasil$Decretos, meses_pt, meses_numb),
         strapplyc(Decretos_Covid_Brasil$Decretos, ", de \\d+.\\d+.\\d+", simplify = TRUE))
  
### Transformando lista em carácter
  Decretos_Covid_Brasil$Decretos_date <- as.character(Decretos_Covid_Brasil$Decretos_date)### Criando condição para extrair datas de acordo com seu padrão
  Decretos_Covid_Brasil$Decretos_date <- ifelse(Decretos_Covid_Brasil$Tipo %in% c("Estadual","Municipal"),
                                              strapplyc(Decretos_Covid_Brasil$Decretos_date, "\\d+ /\\d+/ \\d+", simplify = TRUE), 
                                               Decretos_Covid_Brasil$Decretos_date)### Convertendo coluna para formato 'Date'
  Decretos_Covid_Brasil$Decretos_date <- dmy(Decretos_Covid_Brasil$Decretos_date)

Vamos a explicação:

Os decretos municipais e estaduais tem um padrão: primeiro vem o dia em formato numérico, depois o mês por extenso, seguido pelo ano em formato numérico. Já os decretos federais vem em formato numérico separados por “.”. É preciso, portanto, elaborar duas formas de extrair as datas.

Para os decretos municipais e estaduais: criei duas listas, a primeira com o formato que a data vem no dataset e uma outra com o formato que eu quero que os dados apareceram (/xx/). Ou seja, pretendo aqui fazer uma substituição dos caracteres para um formato de data mais conciso. Para fazer a substituição, foi utilizado a função mgsub do pacote de mesmo nome.

Para os decretos federais: Como não é necessário fazer nenhuma substituição, apenas o recorte da informação, a função strapplyc do pacote gsubfn foi utilizada. Com ela eu consigo recortar a cadeira de caracteres que desejo.

Com essas duas informações em mãos, foi preciso apenas fazer uma condição usando o ifelse. Mas acaba por ai? Nãaaao.

Depois de fazer criar esse if é preciso converter a coluna criada em carácter. Isso porque depois de usar a função strapplyc,o resultado é uma coluna no formato lista. Essa conversão é necessária porque é preciso criar mais uma condição. Explico:

Na primeira condição, apenas houve uma substituição nos valores dos decretos municipais e estaduais. É preciso, como foi feito nos decretos federais, recortar os dados desejados usando a função strapplyc e como não é preciso fazer mais nada com os decretos federais, apenas repete-se o nome da coluna na condição.

Agora que todos os dados estão recortados, contendo apenas a data, é preciso converter essa coluna para o formato correto dela, ou seja, “Date” (que não é de encontro, rsrs). Para isso, bastar usar a função super simples do pacote lubridate, a dmy, que os dados são automaticamente padronizados.

Este é o nosso banco de dados final:

Salvando

Só é preciso agora salvar. Vou salvar do seguinte modo: apenas Salvador, todos da Bahia (estaduais e municipais), Bahia (apenas estaduais), Federais e a base de dados completa, ou seja, para o Brasil todo.

############################################################
############# Dataset com todos os decretos em Salvador
############################################################DECRETOS_SALVADOR <- Decretos_Covid_Brasil %>% filter(Localidade == "Salvador")####################################################################### Dataset com todos os decretos na Bahia - Apenas Estaduais e Estaduais/Municipais ######################################################DECRETOS_BAHIA_ESTADUAL <- Decretos_Covid_Brasil %>% filter(Localidade == "Bahia") %>% 
                           select(Localidade, Decretos, Ementa, Tipo, Tipo_Documento) # Decretos EstaduaisDECRETOS_BAHIA_TODOS <- Decretos_Covid_Brasil %>% filter(Estado == "Bahia") # Decretos do Estado e Municipios#############################################
######## Dataset com decretos Federais
#############################################DECRETOS_FEDERAIS <- Decretos_Covid_Brasil %>% filter(Localidade == "Brasil") %>% select(Localidade, Decretos, Ementa, Tipo, Tipo_Documento)###########################################################
########## Salvando em CSV
###########################################################write.csv2(DECRETOS_SALVADOR,"Decretos_em_Salvador.csv", row.names = F) # SSA
write.csv2(DECRETOS_BAHIA_ESTADUAL,"DecretosEstaduais_na_Bahia.csv", row.names = F) # BA Estadual
write.csv2(DECRETOS_BAHIA_TODOS,"Decretos_na_Bahia.csv", row.names = F) # Ba Estaduais e Municipais
write.csv2(Decretos_Covid_Brasil,"Decretos_Covid_Brasil.csv", row.names = F) # Todos os decretos no Brasil
write.csv2(DECRETOS_FEDERAIS,"Decretos_Federais.csv", row.names = F) # Federais

Conclusão

O script completo está aqui no meu GitHub. Usem! Porém, levou um tempo considerável para elaborar, solucionar erros e ir aprimorando o script, então, se gostou do conteúdo e ele foi realmente útil, por favor, lembre-se de dar os créditos. Isso ajuda pra caramba .

Aqui estão minhas redes sociais: Instagram, LinkedIn, GitHub.

Bônus

Não poderia encerrar sem construir uns gráficos, hahaha.

library(viridis)
library(dplyr)
library(ggplot2)
library(Cairo)
library(tidyr)
library(ggrepel)# Pasta de trabalho
setwd("C:\\Users\\pc\\Desktop\\Cidacs\\ETL")# Dados
Decretos_Covid_Brasil <- read.csv2("Decretos_Covid_Brasil.csv")Decretos_Covid_Brasil <- Decretos_Covid_Brasil %>% mutate(one=1)

Decretos, por mês:

######################## Gráficos - Decretos por mês ################################# Recortando apenas o mês do decreto
Decretos_Covid_Brasil$mes_dec <- format(as.Date(Decretos_Covid_Brasil$Decretos_date), "%m")# Nome do mês
Decretos_Covid_Brasil$mes_dec <- factor(Decretos_Covid_Brasil$mes_dec, levels = c("01","02","03","04",
                                                                                  "05","06","07","08","09"),
                                        labels = c("Janeiro","Fevereiro","Março","Abril","Maio","Junho","Julho",
                                                   "Agosto","Setembro"))# Agrupando
total_mes <- Decretos_Covid_Brasil %>% 
  group_by(mes_dec) %>% 
  summarise(total=sum(one)) %>% 
  drop_na()# gráfico
graph_mes <- ggplot(total_mes, aes(fill = mes_dec, y = total, x =mes_dec)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=total),size = 2.5, position =position_dodge(width=0.9),
             vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=8),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "none") +
  labs(x = "", y="", caption = "Fonte: https://leismunicipais.com.br/\nDados coletados em 08/09/2020",
       title = "Total de decretos no Brasil, por mês") +
  scale_fill_viridis(discrete=TRUE,option = "B") +
  scale_y_discrete(limits=factor(0:6000), breaks = c(0,1000,2000,3000,4000,5000,6000), name = "")# Salvando em PNG
ggsave(plot = graph_mes, "graph_mes.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Por ato normativo:

######################## Tipo de ato normativo #################### Agrupando 
total_doc <- Decretos_Covid_Brasil %>% 
  group_by(Tipo_Documento) %>% 
  summarise(total=sum(one)) %>% 
  drop_na()# Classificando decretos menores que 100 em 'Outros'
total_doc$Tipo_Documento <- ifelse(total_doc$total < 100,"Outros",
                                   total_doc$Tipo_Documento)# reagrupando e calculando porcentagem 
total_doc <- total_doc %>% 
  group_by(Tipo_Documento) %>% 
  summarise(total=sum(total)) %>% 
  drop_na() %>% 
  mutate(percent = total/sum(total)*100)# criando coluna com a posicao da legenda
total_doc <- total_doc %>% arrange(desc(Tipo_Documento)) %>%
  mutate(yposicao_legenda = cumsum(percent)- 0.5*percent)# gráfico
ato_graph <- ggplot(total_doc,aes(x= "", y= percent, fill=Tipo_Documento)) +
  geom_bar(width=1, stat = "identity") +
  coord_polar("y", start=0) +
   geom_label_repel(aes(y=yposicao_legenda, label = sprintf("%1.1f%%",percent)), size = 4,
                         color = 'black',fontface='bold') +
  labs(x="",y="",title = "Tipo de ato normativo", fill = "Ato normativo: ",
       caption = "Fonte: https://leismunicipais.com.br/\nDados coletados em 08/09/2020") +
  theme_minimal() +
  theme(legend.position="bottom",
        legend.background = element_rect(fill="ghostwhite", size=0.5, linetype="blank"),
        axis.text.x = element_text(face="bold",color="#000000", size=12),
        legend.text = element_text(size=10, face="bold"),
        legend.title = element_text(size = 8, face = "bold"),
        plot.title = element_text(colour = "black", size = 12, hjust=0.5, face="bold")) +
  scale_fill_manual(values = c("#581845","#900C3F","#C70039","#FF5733","#FFC300"))# Salvando em PNG
ggsave(plot = ato_graph, "ato_graph.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

O script dos gráficos vocês encontram aqui.

#R #datascience #Rstats

O post Utilizando o R para obter decretos relacionados ao COVID-19 no Brasil apareceu primeiro em Estatidados.

Edit: Quando fiz esse texto, os dados da PNAD Covid-19 mais recentes foram de Maio. Recentemente, o IBGE publicou dados mais atualizados, com o mês de Junho. Por isso, estou atualizando os gráficos com os novos dados, para além disso, fiz alguns ajustes no script.

Introdução

Os microdados da PNAD são, na minha opinião, uma das formas mais preciosas para compreender as condições socioeconômicas e demográficas do Brasil. Trata-se de uma base com ampla capilaridade e milhões de linhas repleta de informações da população brasileira. O indivíduo trabalha? Qual o valor da remuneração? Estudou até quando? Sabe ler? Como são as condições na sua residência? Nela tem água tratada? Esgoto? São questões abordadas na PNAD Continua e que servem de base para desenvolver e analisar políticas públicas diversas.

Em um período de pandemia, cuja solução momentânea que se mostra mais eficiente é o isolamento social, levar pesquisadores à campo para aplicar questionários da maneira habitual se mostrou uma tarefa pouco adequada. Pensando nisso e para manter a sociedade informada, o IBGE buscou contornar a situação via entrevistas realizadas por telefone. Com as informações coletadas foi gerada a PNAD COVID19. O IBGE frisa que os dados são experimentais e devem ser usadas com cautela, isso porque essa é uma PNAD diferente das outras, ou seja, é arriscado comparar os dados dessa PNAD com a PNADC de 2019, por exemplo. Todavia, isso não quer dizer que a informação seja inválida, longe disso, na verdade, ela fornece um olhar para o período atípico que nos encontramos.

Dentro do R existe uma gama de opções para analisar amostras, geralmente o pacote Survey é o predileto dos pesquisadores. Porém, optei pelo srvyr, por ser um pacote que fornece opções para trabalhar com o dplyr. Foquei em analisar o que se passa em Salvador, mas é possível reproduzir os resultados para outras capitais, UF’s ou simplesmente para o Brasil todo, a curiosidade de cada um é o que faz com que tenhamos novas descobertas e inovações.

Então, depois de toda essa explicação, vamos ao que é mais legal: botar a mão na massa!

Carregando pacotes e os microdados

Primeira coisa: faça o download dos microdados no site do IBGE. Depois de descompactar, verá que existe um arquivo CSV (que são os dados) e o dicionário. Tudo bem usual pra quem já trabalhou com PNAD antes.

Com os dados no computador, vamos instalar os pacotes e carregar os dados no RStudio.

library(dplyr)
library(srvyr) 
library(readr)
library(ggplot2)
library(Cairo)# Pasta de Trabalho
setwd("C:\\Users\\pc\\Desktop\\PNAD\\PNAD_COVID19\\PNAD_COVID_062020")# Carregando dataset
pnad_covid <- read_csv("PNAD_COVID_062020.csv", col_types = cols(.default = "d"))

O dataset completo tem 381.270 linhas e 114 colunas (woooow).

Colocando os pesos e criando variáveis

Se você abrir o dicionário da PNAD COVID19 vai notar uma variável chamada V1032. É essa variável que define o peso do domicílio e das pessoas. Precisamos ligar isso no nosso dataset. Também vou filtrar a capital para Salvador.

# ligando Pesos e filtrando Salvador
pnad_com_pesos <- pnad_covid %>% as_survey_design(ids = UPA, strata = Estrato, weights = V1032, nest = TRUE) %>%
  filter(CAPITAL == "29")

Agora vamos criar algumas colunas com as informações que queremos trabalhar.

# Criando colunas com Variáveis 
pnad_com_pesos <- pnad_com_pesos %>% mutate(one = 1,
Sexo = ifelse(A003 == 1, "Homem", "Mulher"), 
Idade = case_when(
   A002 %in% 15:24 ~ "15-24",
   A002 %in% 25:34 ~ "25-34", 
   A002 %in% 35:49 ~ "35-49", 
   A002 %in% 50:64 ~ "50-64", 
   A002 > 64 ~ "65+"),
Cor = case_when(
   A004 == 1 ~ "Branca", 
   A004 == 2 ~ "Preta", 
   A004 == 4 ~ "Parda"),
Escolaridade = factor(case_when( 
   A005 %in% 1:2 ~ "Sem Instrução ou Fundamental Incompleto", 
   A005 %in% 3:4 ~ "Fundamental completo ou Médio Incompleto", 
   A005 %in% 5:6 ~ "Médio completo ou Superior Incompleto", 
   A005 == 7 ~ "Superior completo", 
   A005 == 8 ~ "Pós-graduação"), 
     levels = c( "Sem Instrução ou Fundamental Incompleto",
                 "Fundamental completo ou Médio Incompleto", 
                 "Médio completo ou Superior Incompleto",
                 "Superior completo",
                 "Pós-graduação")), 
Tipo_emprego = factor(case_when(
   C007 == 1 ~ "Trabalhador doméstico (empregado doméstico, cuidados, babá)",
   C007 == 2 ~ "Militar",
   C007 == 3 ~ "Policial ou Bombeiro",
   C007 == 4 ~ "Setor privado",
   C007 == 5 ~ "Setor público",
   C007 == 6 ~ "Empregador",
   C007 == 7 ~ "Autônomo (Conta própria)"),
     levels = c( "Trabalhador doméstico (empregado doméstico, cuidados, babá)",
               "Militar", 
               "Policial ou Bombeiro",
               "Setor privado",
               "Setor público",
               "Empregador",
               "Autônomo (Conta própria)")), 
Faixa_salario = factor(case_when(
  C01012 <= 1044 ~ "Menos de um salário mínimo",
  C01012 %in% c(1045:2090) ~ "Entre 1 e 2",
  C01012 %in% c(2091:3135) ~ "Entre 2 e 3",
  C01012 %in% c(3136:4180) ~ "Entre 3 e 4",
  C01012 %in% c(4181:5225) ~ "Entre 4 e 5",
  C01012 >= 5226 ~ "Mais de 5"),
    levels = c("Menos de um salário mínimo",
               "Entre 1 e 2",
               "Entre 2 e 3",
               "Entre 3 e 4",
               "Entre 4 e 5",
               "Mais de 5")),
domicilio_situacao = factor(case_when(
  F001 == 1 ~ "Próprio - já pago",
  F001 == 2 ~ "Próprio - ainda pagando" ,                                  
  F001 == 3 ~ "Alugado",
  F001 %in% 4:6 ~ "Cedido (Por empregador, Familiar ou outro)"),
      levels = c("Próprio - já pago",
                 "Próprio - ainda pagando",
                 "Alugado", 
                 "Cedido (Por empregador, Familiar ou outro)")),
home_office = ifelse(C013 == 1, "Home Office", "Presencial"),
auxilio_emergencial = ifelse(D0051 == 1, "Auxílio", "Sem auxílio")
)

Ficaria um texto muuuuito longo se eu fosse detalhar cada etapa, mas em resumo: Foram criadas novas colunas e nelas eu apliquei um rótulo baseado nas colunas que já existem, ou seja, ao invés de uma coluna chamada A003, contendo apenas os valores 1 e 2, eu criei uma nova coluna chamada “Sexo” com as informações “Homem” e “Mulher”, assim fica mais fácil de interpretar. Para fazer sua análise, confira o dicionário que veio junto com os dados (O dicionário é muito importante, não se esqueça dele).

Gerando gráficos e analisando resultados

Um ponto importante sobre os gráficos a seguir: Cada percentual é referente ao total daquele grupo, não tendo uma relação com o percentual ao lado. Por exemplo, quando eu digo que 31,91% das mulheres de cor branca estão em home office, isso significa que 68,09% das mulheres de cor branca não estão em home office. Ou seja, cada grupo tem seu percentual próprio. Optei por fazer isso por achar mais interessante comparar cada grupo com o total dele na sociedade. Maaas, caso queiram trabalhar com gráficos em que a soma dos percentuais atinjam 100%, fiz um outro script que está disponível aqui. Lá no git também tem uma pasta com os gráficos desse outro script, você poderá encontrar aqui. Dito tudo isso, vamos partir para as análises!

Primeiro vamos olhar o sexo e a cor das pessoas que estão em Home Office em Salvador.

############### Home office - Por sexo e cor ################### Criando dataset para conferir pessoas em Home Office
home_sexo_cor <- pnad_com_pesos %>%
  group_by(Sexo, Cor) %>%
  summarise(
    home_office = survey_total(C013 == 1, na.rm = TRUE),
    mao_de_obra = survey_total(C001 == 1, na.rm = TRUE)) %>%
  mutate(trab_home_office = (home_office/mao_de_obra)*100) %>%
  drop_na()# gráfico
home_sexo_cor_ssa <- ggplot(home_sexo_cor, aes(fill = Cor, y = trab_home_office, x = Sexo)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",trab_home_office)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "bottom", legend.background = element_rect(fill="ghostwhite", size=0.7, linetype="blank")) +
  labs(x = "Sexo", fill = "Cor/Raça: ", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas em home office, por cor/raça e sexo - Salvador/BA") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3","#6c5ce7")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando
ggsave(plot = home_sexo_cor_ssa, "home_sexo_cor_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Podemos ver que mulheres de cor branca são o grupo predominante em home office, 31,91% dos indivíduos com essas duas características se encontram trabalhando em casa. Já o menor grupo são o de homens de cor preta, com um singelo percentual de 9,14%.

Mas e quanto ao nível de escolaridade? Como ele se comporta? Vamos observar.

############## Home office - Por Cor e Escolaridade ###########home_edu_cor <- pnad_com_pesos %>%
  group_by(Escolaridade, Cor) %>%
  summarise(
    home_office = survey_total(C013 == 1, na.rm = TRUE),
    mao_de_obra = survey_total(C001 == 1, na.rm = TRUE)
  ) %>%
  mutate(trab_home_office = (home_office/mao_de_obra)*100) %>%
  drop_na()# gráfico
home_edu_cor_ssa <- ggplot(home_edu_cor, aes(fill = Escolaridade, y = trab_home_office, x = Cor)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",trab_home_office)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "bottom", legend.background = element_rect(fill="ghostwhite", size=0.7, linetype="blank")) +
  labs(x = "Cor/Raça", fill = "Escolaridade: ", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas em home office, por cor/raça e escolaridade - Salvador/BA ") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3","#6c5ce7","#fdcb6e")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = home_edu_cor_ssa, "home_edu_cor_ssa.png",
       width = 14, height = 7, dpi = 150, units = "in",type = "cairo")

Podemos ver algumas coisas interessantes com esse gráfico:

1. Pessoas sem instrução ou com o fundamental incompleto não aparecem em home office ou aparecem com um percentual muito pequeno. Isso pode estar acontecendo pelas condições econômicas dessas pessoas, que não possuem um emprego formal que sustente a condição de fazer um home office ou porque essas pessoas no geral se encontram em algum tipo de trabalho informal. Um outra olhar é de que a pesquisa não conseguiu alcançar essas pessoas, dado que a coleta dos dados ocorreu por meio de entrevista por telefone. Cabe uma análise mais profunda a posteriori.
2. Existe um pequeno grupo de pessoas de cor parda e que tem fundamental completo ou médio incompleto que estão em home office. Também existe um pequeno grupo de pessoas de cor preta sem instrução ou com fundamental incompleto que estão em home office.
3. O nível de escolaridade é um fator preponderante para estar ou não em home office, isso pode ser notado pela evolução do nível de escolaridade e aumento no percentual de pessoas em home office. Pessoas com pós-graduação tem mais chances de estar trabalhando remotamente do que alguém com apenas o ensino médio.

Vamos ver agora como está a relação Sexo/Idade.

################## Home office - Por Sexo e Idade ################home_sexo_idade <- pnad_com_pesos %>%
  group_by(Sexo, Idade) %>%
  summarise(
    home_office = survey_total(C013 == 1, na.rm = TRUE),
    mao_de_obra = survey_total(C001 == 1, na.rm = TRUE)
  ) %>%
  mutate(trab_home_office = (home_office/mao_de_obra)*100) %>%
  drop_na()# gráfico
home_sexo_idade_ssa <- ggplot(home_sexo_idade, aes(fill = Idade, y = trab_home_office, x = Sexo)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",trab_home_office)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "bottom", legend.background = element_rect(fill="ghostwhite", size=0.7, linetype="blank")) +
  labs(x = "Sexo", fill = "Faixa Etária: ", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas em home office, por sexo e faixa etária - Salvador/BA") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3","#6c5ce7","#fdcb6e")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = home_sexo_idade_ssa, "home_sexo_idade_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Empiricamente é tentador pensar que quanto maior a idade, maior a chance de estar em home office. Talvez porque imagina-se que pessoas com mais idade tenderiam a ocupar cargos mais altos e que estariam aptas a exercer suas funções em casa. Mas não foi isso que os dados mostraram para Salvador. Os valores são muitos semelhantes em todas as faixas. Com exceção no grupo das mulheres, onde 70,32% daquelas com mais de 65 anos estão em home office.

E quanto ao emprego dessas pessoas? Qual vinculo empregatício mantém mais pessoas trabalhando em casa?

################### Home office - Por trabalho ####################home_emprego <- pnad_com_pesos %>%
  group_by(Tipo_emprego) %>%
  summarise(
    home_office = survey_total(C013 == 1, na.rm = TRUE),
    mao_de_obra = survey_total(C001 == 1, na.rm = TRUE)) %>%
  mutate(trab_home_office = (home_office/mao_de_obra)*100) %>%
  drop_na()# ordenando eixo X
legenda_trabalhos <- c("Trabalhador doméstico\n (empregado doméstico,\n cuidados, babá)",
"Militar", 
"Policial ou\n Bombeiro",
"Setor privado",
"Setor público",
"Empregador",
"Autônomo\n (Conta própria)")# Gráfico
home_emprego_ssa <- ggplot(home_emprego, aes(fill = Tipo_emprego, y = trab_home_office, x = Tipo_emprego)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",trab_home_office)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=8),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "none") +
  labs(x = "Tipo de Ocupação",
       caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas em home office, por tipo de ocupação - Salvador/BA") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3","#6c5ce7","#fdcb6e","#636e72", "#55efc4")) +
  scale_x_discrete(labels = legenda_trabalhos) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = home_emprego_ssa, "home_emprego_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Podemos ver que é no setor público onde mais pessoas estão em home office. Trabalhadores autônomos são os que mais exercem suas atividades fora de casa. Para categorias da segurança pública, militares ou trabalhadores domésticos não foram encontrados resultados na capital baiana.

Como está a distribuição entre cor/raça e salários das pessoas em home office?

############## Home office - Por faixa salarial e cor ##############home_renda <- pnad_com_pesos %>%
  group_by(Faixa_salario, Cor) %>%
  summarise(
    home_office = survey_total(C013 == 1, na.rm = TRUE),
    mao_de_obra = survey_total(C001 == 1, na.rm = TRUE)) %>%
  mutate(trab_home_office = (home_office / mao_de_obra) * 100) %>%
  drop_na()# gráfico
home_renda_ssa <- ggplot(home_renda, aes(fill = Faixa_salario, y = trab_home_office, x = Cor)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",trab_home_office)),size = 2.5, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "bottom", legend.background = element_rect(fill="ghostwhite", size=0.7, linetype="blank")) +
  labs(x = "Cor/Raça", fill = "Faixa Salarial:\n(Salários mínimos) ", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas em home office, por cor/raça e faixa salarial - Salvador/BA ") +
  scale_fill_manual(values = c("#fad390","#e55039","#4a69bd","#60a3bc","#78e08f","#079992")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = home_renda_ssa, "home_renda_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Podemos observar um percentual alto de pessoas que recebem 4, 5 ou mais salários mínimos em home office. Mas o mais interesse é ver que entre pessoas brancas que recebem menos de um salário mínimo, 23,20% estão mantendo suas atividades em home office. Olhando o mesmo rendimento para pardos e pretos, o percentual encontrado é bem menor, 12,89% e 9,05% respectivamente.

Mas vamos mudar o foco agora. Deixar de olhar apenas trabalhadores em home office e passar a ver como o auxilio emergencial tem sido direcionado; qual o reflexo desse auxilio na população.

Vamos começar olhando quem recebeu o auxilio.

#################### Auxilio - Sexo e Cor #######################
auxilio_cor_sexo <- pnad_com_pesos %>%
  group_by(Cor, Sexo) %>%
  summarise(
    auxilio = survey_total(D0051 == 1, na.rm = TRUE),
    total = survey_total(one, na.rm = TRUE)
  ) %>%
  mutate(pessoas_auxilio = (auxilio/total)*100) %>%
  drop_na()# gráfico
auxilio_cor_sexo_ssa <- ggplot(auxilio_cor_sexo, aes(fill = Cor, y = pessoas_auxilio, x = Sexo)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",pessoas_auxilio)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "bottom", legend.background = element_rect(fill="ghostwhite", size=0.7, linetype="blank")) +
  labs(fill = "Cor: ", x = "Sexo", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas que receberam auxílio emergencial, por cor/raça e sexo -\n Salvador/BA") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = auxilio_cor_sexo_ssa, "auxilio_cor_sexo_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Pardos e Pretos são os grupos que mais receberam o auxilio. Entre os gêneros, os valores são muitos próximos. 50,60% dos homens de cor parda receberam o auxilio, já entre as mulheres de mesma cor, 50,90%. Brancos são o menor grupo em ambos os sexos.

E como anda a renda dessas pessoas que receberam o auxílio?

##################### Auxilio - Faixa Salarial ####################auxilio_renda <- pnad_com_pesos %>%
  group_by(Faixa_salario) %>%
  summarise(
    auxilio = survey_total(D0051 == 1, na.rm = TRUE),
    total = survey_total(one, na.rm = TRUE)) %>%
  mutate(pessoas_auxilio = (auxilio/total)*100) %>%
  drop_na()# gráfico
auxilio_renda_ssa <- ggplot(auxilio_renda, aes(fill = Faixa_salario, y = pessoas_auxilio, x = Faixa_salario)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",pessoas_auxilio)),size = 3, position =position_dodge(width=0.9),
            hjust=-0.1, color = 'black',fontface='bold') +
  theme_classic() +
  coord_flip() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "none") +
  labs(x = "Faixa Salarial", caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Pessoas que receberam auxílio emergencial, por renda - Salvador/BA") +
  scale_fill_manual(values = c("#00b894","#ff7675","#0984e3","#6c5ce7","#fdcb6e","#636e72")) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = auxilio_renda_ssa, "auxilio_renda_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

Nota-se que 73,90% das pessoas que viviam com menos de um salário mínimo receberam o auxílio. Dentre aqueles cuja renda permeiam entre 1 e 2 salários, uma parcela expressiva, 45,39%, recebeu o dinheiro. Uma pequena parcela da população, com renda entre 4 e 5, ou mais de 5 salários mínimos também foram contempladas.

Sabemos que o custo de moradia é algo que pesa no orçamento das famílias, por isso considero interessante ver a situação domiciliar daqueles que estão recebendo o auxilio.

################ Auxilio - Por tipo do domicilio ###################auxilio_domicilio <- pnad_com_pesos %>%
  group_by(domicilio_situacao) %>%
  summarise(
    auxilio = survey_total(D0051 == 1, na.rm = TRUE),
    total = survey_total(one, na.rm = TRUE)) %>%
  mutate(pessoas_auxilio  = (auxilio/total)*100) %>%
  drop_na()# ordenando eixo X
legenda_domicilio <- c("Próprio (já pago)",
                       "Próprio (ainda pagando)",
                       "Alugado", 
                       "Cedido (Por empregador,\n Familiar ou outro)")# gráfico
auxilio_domicilio_ssa <- ggplot(auxilio_domicilio, aes(fill = domicilio_situacao, y = pessoas_auxilio, x = domicilio_situacao)) +
  geom_bar(position = "dodge", stat = "identity") +
  geom_text(aes(label=sprintf("%1.2f%%",pessoas_auxilio)),size = 3, position =position_dodge(width=0.9),
            vjust=-0.5, color = 'black',fontface='bold') +
  # geom_text(aes(label=paste0(format(round(auxilio,0),
  #                            nsmall=0,big.mark=".", decimal.mark=",")," com auxilio")),
  #           size = 3,position = position_stack(vjust = .5),
  #           vjust=-0.5, color = 'black',fontface='bold') +
  # geom_text(aes(label=paste0(format(round(total,0),
  #                                   nsmall=0,big.mark=".", decimal.mark=",")," total")),
  #           size = 3,position = position_stack(vjust = .3),
  #           vjust=-0.5, color = 'black',fontface='bold') +
 theme_classic() +
  theme(axis.title.x = element_text(colour = "black"),
        axis.title.y = element_text(colour = "black"),
        axis.text.y = element_text(face="bold", color="#000000", 
                                   size=10),
        axis.line = element_line(colour = "black", 
                                 size = 1, linetype = "solid"),
        axis.text=element_text(size=6, face="bold"),
        axis.text.x = element_text(face="bold", color="#000000", size=10),
        plot.title = element_text(colour = "black", size = 17, hjust=0.5),
        legend.position = "none") +
  labs(x = "Tipo de domicílio", y ="Percentual (%)",caption = "Fonte: Microdados da Pnad Covid19 - IBGE. Junho 2020.",
       title = "Situação do domicílio daqueles que receberam o auxílio emergencial -\n Salvador/BA") +
  scale_fill_manual(values = c("#fad390","#e55039","#4a69bd","#60a3bc","#78e08f","#079992")) +
  scale_x_discrete(labels = legenda_domicilio) +
  scale_y_discrete(limits=factor(0:100), breaks = c(0,10,20,30,40,50,60,70,80,90,100), name = "Percentual (%)")# Salvando em PNG
ggsave(plot = auxilio_domicilio_ssa, "auxilio_domicilio_ssa.png",
       width = 10, height = 5, dpi = 120, units = "in",type = "cairo")

É interessante ver que 48,56% das pessoas com imóvel próprio receberam o auxilio. 65,65% daqueles que de alguma forma vivem em um imóvel cedido também foram beneficiados. 40,75% dos que pagam aluguel foram contemplados, isso significa que dentre os que pagam aluguel, 59,25% não receberam o pagamento do governo.

Considerações Finais

Todo o script você poderá encontrar no meu GitHub. Ademais, muito do que foi apresentado aqui teve como inspiração o trabalho do professor Regis A. Ely, da Universidade Federal de Pelotas, o trabalho dele poderá ser encontrado aqui. Agradeço a todos que, porventura, caíram nesse site e acharam o conteúdo interessante.

Aqui estão minhas redes sociais: Instagram, LinkedIn, GitHub.

#R #Rstats #datascience #cienciadedados

O post Trabalhando com os microdados da PNAD COVID19 no R apareceu primeiro em Estatidados.

Como um frequente usuário do R, em certo momento questionei como criar um aplicativo Shiny executável em desktop, sem a dependência de instalação prévia do R e dos pacotes utilizados. Encontrei dois excelentes artigos que apresentam algumas passibilidades: Deploying Desktop Apps with R e Packaging your Shiny App as an Windows desktop app.

Após algumas tentativas, criei uma “receita de bolo” que funcionou bem para mim. Irei compartilhá-la aqui, sem me preocupar com o motivo de algumas etapas, pois foram bem detalhados nos artigos citados. Este processo foi feito no Windows, mas deve ser semelhante para Linux ou macOS (nunca testei).

1 – Esqueleto

1.1. Criar uma pasta para estruturar o aplicativo:

1.2. Baixar o R Portable e instalar na pasta executavel/:

Permitirá utilizar o R como um “motor” independente, sem a necessidade do usuário possuí-lo instalado no sistema.

Obs: a versão 4.0.0 do R apresentou alguns problemas no Windows. Caso ainda não esteja disponível a versão 4.0.2 do R Portable, baixe a versão anterior (3.6.3).

1.3. Ir em R-Portable/App/R-Portable/etc/Rprofile.site e, ao final do arquivo, colar o código:

.First = function(){
    .libPaths(.Library)
}

Isso forçará o R Portable a usar apenas sua biblioteca local para instalar/carregar pacotes.

1.4. Inicie o R Portable e instale os pacotes utilizados no aplicativo Shiny desenvolvido. No mínimo deve ser instalado o pacote shiny.

1.5. Crie a pasta executavel/shiny/ com o aplicativo Shiny desenvolvido.

A proposta não é ensinar a funcionalidade Shiny, mas sim explicar como transformá-la em um executável. Portanto, em app.R, criei um exemplo simples e sem utilidade. Note que incluí session como um parâmetro na função do servidor, e utilizei este objeto para encerrar corretamente o aplicativo quando sua tela for fechada.

library(shiny)


ui <- fluidPage(
  
  titlePanel("Hello Shiny!"),
  
)


server <- function(input, output, session) {
  
  # FINALIZANDO APLICATIVO
  session$onSessionEnded(function() stopApp())
  
}


shinyApp(ui = ui, server = server)

2 – Criar scripts de inicialização do aplicativo

2.1. Criar o script runShinyApp.R na pasta executavel/ com o seguinte código:

chrome.sys = 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'


if (file.exists(chrome.sys))
  options(browser = chrome.sys)
shiny::runApp('./shiny/app.R', launch.browser=T)

A ideia é verificar se o usuário possui o Google Chrome instalado: se sim, abrir o aplicativo neste navegador e, se não, abri-lo no seu navegador padrão.

Lee Pang sugere que se instale uma versão portátil do Google Chrome, assim como o R Portable, para o caso do usuário não ter um navegador instalado. Entendo não ser necessário, por ser um programa mais comum (e também acho mais legal abrir como uma aba adicional no Chrome).

2.2. Criar o script run.vbs para ser um botão de inicialização do aplicativo. Para tal, abra um bloco de notas e cole o seguinte código:

Rexe           = "R-Portable\App\R-Portable\bin\Rscript.exe"
Ropts          = "--no-save --no-environ --no-init-file --no-restore --no-Rconsole"
RScriptFile    = "runShinyApp.R"
Outfile        = "ShinyApp.log" 
strCommand     = Rexe & " " & Ropts & " " & RScriptFile & " 1> " & Outfile & " 2>&1"

intWindowStyle = 0     ' Hide the window and activate another window.'
bWaitOnReturn  = False ' continue running script after launching R   '

' the following is a Sub call, so no parentheses around arguments'
CreateObject("Wscript.Shell").Run strCommand, intWindowStyle, bWaitOnReturn

Salve o arquivo com o nome rub.vbs na pasta executavel/ para criar um inicializador da aplicação.

2.3. Se todas as etapas até aqui foram feitas corretamente, ao clicar duas vezes em run.vbs, o aplicativo abrirá em uma aba do navegador do Google Chrome.

Obs: O arquivo ShinyApp.txt é criado automaticamente para salvar o log de dados.

3 – Compactar em um executável de instalação

Até o momento conseguimos compartilhar a pasta executavel/ e rodar o aplicativo simplesmente clicando duas vezes em run.vbs.

Essa seção busca embelezar o processo, criando um executável de instalação e um atalho personalizado para o desktop.

3.1. Baixe a ferramenta Inno Setup (não precisa instalar na pasta executavel/).

Obs: Você pode baixar um “módulo de criptografia” separado, se quiser utilizar os recursos de criptografia do Inno Setup.

3.2. Salve uma imagem no formato ICO na pasta executavel/. Utilizarei o ico_hello.ico.

Obs: Sites que convertem PNG em ICO são de fácil acesso, costumo utilizar o Convertio.

3.3. Abra um script no Inno Setup e cole o código abaixo:

#define MyAppName "HELLO"  ; NOME DO APLICATIVO
#define MyAppVersion "1.0"  ; VERSÃO
#define MyAppPublisher "My Company, Inc."   ; COMPANHIA
#define MyAppURL "http://www.example.com/"  ; SITE


[Setup]
; NOTA: O valor de AppId identifica exclusivamente este aplicativo. Não use o mesmo valor AppId em instaladores para outros aplicativos.
; (Para gerar um novo GUID, clique em Ferramentas | Gerar GUID dentro do IDE.)
AppId={{E8C494FB-1AE3-45C6-8B6F-F00649056FF7}


AppName={#MyAppName}
AppVersion={#MyAppVersion}
;AppVerName={#MyAppName} {#MyAppVersion}
AppPublisher={#MyAppPublisher}
AppPublisherURL={#MyAppURL}
AppSupportURL={#MyAppURL}
AppUpdatesURL={#MyAppURL}
DefaultDirName=C:\{#MyAppName}
DefaultGroupName={#MyAppName}
AllowNoIcons=yes


; Remova o comentário da linha a seguir para executar no modo de instalação não administrativa (instalar apenas para o usuário atual).
;PrivilegesRequired=lowest


; Endereço da pasta que será salvo o instalador
OutputDir=C:\Users\Administrador\Documents\Shiny


; Nome do instalador
OutputBaseFilename=HELLO_INSTALADOR


; Endereço do ICO
SetupIconFile=C:\Users\Administrador\Documents\Shiny\executavel\\ico_hello.ico


Compression=lzma
SolidCompression=yes
PrivilegesRequired=none


; Criptografar Instalador
; Encryption=yes


; Senha, se quiser
Password=12345678    


[Languages]
Name: "brazilianportuguese"; MessagesFile: "compiler:Languages\BrazilianPortuguese.isl"


[Files]
; Endereço da pasta que será compactada com \* no final
Source: "C:\Users\Administrador\Documents\Shiny\executavel\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
;  NOTA: Não use "Flags: ignoreversion" em nenhum arquivo de sistema compartilhado


; Criar programa de desinstalação
[Icons]
Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"


; Substituir com o nome do aplicativo, o nome do arquivo VBS e do arquivo ICO
[Icons]
Name: "{commondesktop}\HELLO"; Filename: "{app}\run.vbs"; IconFilename: {app}\ico_hello.ico

Segue abaixo como fica a visualização do código acima no Inno Setup. Os comentários (em verde) irão indicar os códigos que deverão se alterados para adaptar a um outro executável de instalação.

Após ajustar o script, o execute.

3.4. Será criado um instalador na pasta indicada pelo script. No meu caso o nomeei de HELLO_INSTALADOR.

Caso não tenha instalado o aplicativo logo após o Inno Setup criar o executável, clique duas vezes para instalar.

Esse executável de instalação poderá ser compartilhado com os usuários.

3.5. Após a instalação, será criado um atalho na sua tela principal que abrirá o aplicativo Shiny automáticamente:

Pronto. Temos um aplicativo disponibilizado a partir de um executável de instalação.

Considerações finais

De nada adianta criar um executável, se o aplicativo Shiny não tiver utilidade. Acho que ninguém irá apresentar para o chefe um “Hello Shiny!”.

Para uma maior aprendizado dessa ferramenta, recomendo a consulta dos seguintes links:

• https://shiny.rstudio.com/tutorial/
• https://rstudio.github.io/shinydashboard
• https://shiny.rstudio.com/gallery
• https://rstudio.github.io/DT/shiny.html
• https://shiny.rstudio.com/articles/css.html

#R #R hashtag#Shiny hashtag#RShiny hashtag#AppShiny hashtag#Desktop hashtag#Innosetup

O post Criando um aplicativo desktop em Shiny apareceu primeiro em Estatidados.