Forem: msc2020

How to export a CSV with my data posts in DEV using its API

msc2020 — Tue, 21 May 2024 21:44:49 +0000

In this post we show a quick step-by-step guide to collecting data from "my" publications on DEV (dev.to) using its beta API. We use Python 3.9+ libraries (Requests, Json and Pandas) to make requests to DEV API endpoints, then pass them to the DataFrame format and then export as a .CSV file. This CSV will contain data from the posts that have been published by the user msc2020 so far. It is possible for you to collect your data too.

Contents ☕

DEV API, versions v0 and v1
Some API endpoints
Getting data from the API
Exporting collected data to CSV
Tests using another username
Conclusion

DEV API, versions v0 and v1 [^]

DEV needs no introduction, but it's worth mentioning that it's built on Forem, an "open source tool for building communities" 👊🏼. When visiting the Forem community homepage we noticed the many similarities between the two.

DEV currently has an API (beta version 0.9.7) with documentation at https://developers.forem.com/api. There are some differences between the two available versions. The main one is that some v0 endpoints can be accessed without an access token (API_TOKEN). v1 uses tokens on all its endpoints. According to the documentation, endpoints that do not require token authentication use CORS (Cross-origin resource sharing) to control access.

Some API endpoints [^]

The table below shows some DEV API endpoints accompanied by information that may be useful.

API version	Endpoint	HTTP method	Use API_KEY	Describe	Example
v0	/articles	GET	No	Returns all posts (articles, questions, announcements, etc.) published, 30 per page	`curl https://dev.to/api/articles`
v0	/articles	POST	Yes	Create an article	`curl -X POST -H "Content-Type: application/json" -H "api-key: API_KEY" -d '{"article": "title":"Title","body_markdown":"Body","published":false,"tags":["discuss", "javascript"]}}' https://dev.to/api/articles`
v0	/comments	GET	No	Returns all comments from an article or comments from a podcast, 30 per page	`curl https://dev.to/api/comments?a_id=270180`

Lists of API endpoints in version v0 and v1 can be found, respectively, at: https://developers.forem.com/api/v0 and https://developers.forem.com/api/v1.

🙈 Attention: Although some v0 version endpoints can be used without API_TOKEN, on the API website it is recommended that all of them use this authentication.

Getting data from the API [^]

The code below captures, via the DEV API, data relating to my (username = msc2020) posts:

import requests # install with: pip install requests

url = 'https://dev.to/api/articles'
querystring = {'username': 'msc2020'}
headers = requests.utils.default_headers()

response = requests.request('GET', url, headers=headers, params=querystring)

print(response.text)

'''
output:

[{
  "type_of":"article","id":1850779,"title":"Raspagem de dados de um site de notícias em pt-BR","description": ...
  ...
}]
'''

The output returned from the GET call above is an object (response) from the Requests library. To convert/parse the contents of response.text (type str) into a list of dictionaries (type dict) we use:

import json # python standard library

res_json = json.loads(response.text)

In order to facilitate analysis of data collected with Python libraries, we will be converting this JSON into a CSV.

🗒️ Note: In the script above we passed the username parameter in the GET call. To see other parameters available in endpoint /articles visit this link of the API documentation.

Exporting collected data to CSV [^]

After collecting the JSON data via API, we use Pandas' to_csv to export the data to CSV format.

Including this step, we obtain the complete export_posts.py code:

# export_posts.py

import requests # pip install requests
import pandas as pd # pip install pandas
import json # standard library

# define username
USER_NAME = 'msc2020'

# run the request
url = 'https://dev.to/api/articles'
querystring = {'username': USER_NAME}
headers = requests.utils.default_headers()
response = requests.request('GET', url, headers=headers, params=querystring)
# print(response.text)

# converts request response into a list of dict
res_json = json.loads(response.text)

# convert JSON to Pandas DataFrame
df_posts = pd.DataFrame(res_json)

# export post data to CSV
df_posts.to_csv('dataset_articles_published_msc2020.csv', index=None)

# displays the first 3 rows of the dataset
print(df_posts.head(3))

'''output:
. 1) content of the first three lines:
>>>
type_of       id  ...                                               tags                                               user
0  article  1850779  ...         tutorial, braziliandevs, python, beginners  {'name': 'msc2020', 'username': 'msc2020', 'tw...
1  article  1842575  ...  deeplearning, machinelearning, python, brazili...  {'name': 'msc2020', 'username': 'msc2020', 'tw...
2  article  1835701  ...                    python, tutorial, braziliandevs  {'name': 'msc2020', 'username': 'msc2020', 'tw...

[3 rows x 25 columns]

. 2) a CSV in local directory: `dataset_articles_published_msc2020.csv`
'''

Print of df_posts.head(3) output in Jupyter notebook

Tests using another username [^]

Currently, it is also possible to obtain data about other users' posts using the endpoint articles of the DEV API. For example, now using USER_NAME = 'anuragrana' and changing the output name to dataset_articles_published_user.csv in the full code export_posts.py the return is expected to be the following:

   type_of       id  ...                                               user flare_tag
0  article  1855307  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN
1  article  1276096  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN
2  article   262178  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN

[3 rows x 26 columns]

Print the output of df_posts.head(3) from the export_posts.py code in Jupyter notebook

Conclusion [^]

The CSV obtained in this post can help with data analysis with Python libraries. With few adaptations to the created code, we can obtain data from other endpoints of the DEV API. There are many possibilities for using the collected data.

☕ 🧘‍♂️ 💻 ☯️ 🪬

Como exportar um CSV com dados dos meus posts no DEV usando sua API

msc2020 — Sun, 19 May 2024 11:39:29 +0000

Neste post mostramos um passo a passo rápido para coletar dados de "minhas" publicações no DEV (dev.to) utilizando sua API versão beta. Usamos bibliotecas do Python 3.9+ (Requests, Json e Pandas) para realizar requisições a endpoints da API DEV, então passar para o formato DataFrame e, em seguida, exportar como um arquivo .CSV. Esse CSV terá os dados dos posts que foram publicados pelo usuário msc2020 até o momento.

Conteúdo ☕

API DEV, versões v0 e v1
Alguns endpoints da API
Obtendo dados da API via Python
Exportando os dados para CSV
Testes usando outro nome de usuário
Possibilidades de uso
Conclusão

🎶 Wayne Shorter (Featuring Milton Nascimento) - Native Dancer (1975) full album

API DEV, versões v0 e v1 [^]

O DEV dispensa apresentações, mas vale mencionar que ele é feito sobre o Forem, uma "ferramenta open source para construir comunidades" 👊🏼. Ao visitar a homepage da comunidade Forem notamos as várias semelhanças entre ambas.

Atualmente, o DEV possui uma API (versão beta 0.9.7) com documentação em https://developers.forem.com/api. Há algumas diferenças entre as duas versões disponíveis. A principal delas é que alguns endpoints da versão v0 podem ser acessados sem token de acesso (API_TOKEN). Já a v1 usa token em todos seus endpoints. Segundo a documentação, os endpoints que não exigem autenticação com o token usam o CORS (Cross-origin resource sharing) para controlar o acesso.

Alguns endpoints da API [^]

A tabela abaixo mostra alguns endpoints da API (https://dev.to/api/) acompanhados de informações que podem ser úteis.

Versão	Endpoint	Método	API_KEY	Descrição	Exemplo
v0	/articles	GET	Não	Retorna todos os posts (artigos, dúvidas, divulgações, etc) publicados, sendo 30 por página	`curl https://dev.to/api/articles`
v0	/articles	POST	Sim	Cria um artigo	`curl -X POST -H "Content-Type: application/json" -H "api-key: API_KEY" -d '{"article": "title":"Title","body_markdown":"Body","published":false,"tags":["discuss", "javascript"]}}' https://dev.to/api/articles`
v0	/comments	GET	Não	Retorna todos os comentários de um artigo ou comentários de um podcast, sendo 30 por página	`curl https://dev.to/api/comments?a_id=270180`

As documentações dos endpoints da API na versão v0 e v1 podem ser encontradas, respectivamente, em:

🙈 Atenção: Embora para alguns endpoints da versão v0 não seja exigido um token, no site da API recomendam o uso dessa autenticação.

Obtendo dados da API via Python [^]

O código abaixo realiza a captura, via API DEV, dos dados referentes as minhas (username = msc2020) postagens:

import requests # instalação: pip install requests

url = 'https://dev.to/api/articles'
querystring = {'username': 'msc2020'}
headers = requests.utils.default_headers()

response = requests.request('GET', url, headers=headers, params=querystring)

print(response.text)

'''
saída esperada:

[{
  "type_of":"article","id":1850779,"title":"Raspagem de dados de um site de notícias em pt-BR","description": ...
  ...
}]
'''

O retorno da chamada GET usada no código acima, é um objeto (response) da biblioteca Requests. Para converter/parsear o conteúdo de response.text (str) em uma lista de dicionários (dict) usamos:

import json # biblioteca padrão do Python

res_json = json.loads(response.text)

🗒️ Nota: No script da requisição passamos o parâmetro username na chamada GET. Para ver outros parâmetros disponíveis no endpoint /articles acesse este link da documentação da API.

A fim de facilitar uma futura análise dos dados coletado, estaremos convertendo esse JSON em um CSV. Para quem optar em trabalhar com o Pandas nas análises, o formato CSV poderá ajudar muito.

Exportando os dados para CSV [^]

Após coletar o JSON dos dados via API, utilizamos o to_csv do Pandas para exportar os dados para o formato CSV.

Incluindo essa etapa, obtemos o código completo exporta_posts.py:

# exporta_posts.py

import requests # instalação: pip install requests
import pandas as pd # instalação: pip install pandas
import json # biblioteca padrão do Python

# define nome do usuário
USER_NAME = 'msc2020'

# faz requisição GET
url = 'https://dev.to/api/articles'
querystring = {'username': USER_NAME}
headers = requests.utils.default_headers()
response = requests.request('GET', url, headers=headers, params=querystring)
# print(response.text)

# converte resposta da requisição em uma lista de dict
res_json = json.loads(response.text)

# converte o JSON para Pandas DataFrame
df_posts = pd.DataFrame(res_json)

# exporta os dados do posts para CSV
df_posts.to_csv('dataset_articles_published_msc2020.csv', index=None)

# exibe as 3 primeiras linhas do dataset
print(df_posts.head(3))

'''saídas esperadas:
. 1) 3 primeiras linhas do CSV:
>>>
type_of       id  ...                                               tags                                               user
0  article  1850779  ...         tutorial, braziliandevs, python, beginners  {'name': 'msc2020', 'username': 'msc2020', 'tw...
1  article  1842575  ...  deeplearning, machinelearning, python, brazili...  {'name': 'msc2020', 'username': 'msc2020', 'tw...
2  article  1835701  ...                    python, tutorial, braziliandevs  {'name': 'msc2020', 'username': 'msc2020', 'tw...

[3 rows x 25 columns]

. 2) criação de um arquivo CSV no diretório local: `dataset_articles_published_msc2020.csv`
'''

Print da saída de df_posts.head(3) no Jupyter notebook

Testes usando outro nome de usuário [^]

Atualmente, também é possível obter dados sobre os posts de outros usuários usando o endpoint articles da API DEV. Por exemplo, usando agora USER_NAME = 'anuragrana' e mudando o nome da saída para dataset_articles_published_user.csv no código completo exporta_posts.py é esperado que o retorno seja o seguinte:

   type_of       id  ...                                               user flare_tag
0  article  1855307  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN
1  article  1276096  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN
2  article   262178  ...  {'name': 'Anurag Rana', 'username': 'anuragran...       NaN

[3 rows x 26 columns]

Print da saída de df_posts.head(3) do código exporta_posts.py no Jupyter notebook

Possibilidades de uso [^]

É possível explorar os dados coletados de várias maneiras. A seguir listamos algumas:

Usar o Insomnia (https://insomnia.rest/download) ou Postman
(https://www.postman.com/downloads/) para acessar outros endpoints da v1 da API DEV. Por exemplo, os endpoints display_ads/, follows/tags/, reactions/ e readinglist.
Realizar uma análise exploratória do CSV construído, usando bibliotecas como Pandas, Scikit-learn, Seaborn e Plotly.
Aplicar um modelo de LLM como o Social-LLM: Modeling User Behavior at Scale using Language Models and Social Network Data para analisar um dataset formado com dados de vários endpoints selecionados da API DEV.
Contribuir para evolução do projeto Forem, colaborando em seu Github.

Conclusão [^]

O CSV obtido neste post pode ajudar nas análises de dados com bibliotecas Python. Com poucas adaptações no código criado, é possível obter dados de outros endpoints da API DEV. Se vc tem alguma ideia para usarmos os dados coletados da API, compartilhe.

Agradecemos a leitura!

☕ 🧘‍♂️ 💻 ☯️ 🪬

Raspagem de dados de um site de notícias em pt-BR

msc2020 — Mon, 13 May 2024 01:20:22 +0000

Neste post realizamos a raspagem de dados (web scraping) de um site de notícias em português do Brasil (pt-BR). Utilizando a biblioteca Requests do Python 3, coletamos o conteúdo HTML do site. Em seguida, extraímos as notícias mais lidas e seus respectivos links com o BeautifulSoup. Introduzimos alguns aspectos legais do scraping e apresentamos casos de uso que estão atualmente rodando na Internet.

Sumário ☕

Pré-requisitos
Coleta do conteúdo do HTML
Inspecionando o trecho HTML de interesse
Busca pela tag com o BeautifulSoup
Sobre o robots.txt
Exemplos de uso da raspagem de dados rodando em produção
Conclusão e próximos passos

📻 Sugestão de disco para acompanhar o tutorial:

Miles Davis - Round About Midnight (1957) Full Album

Pré-requisitos ^

Para rodar os códigos apresentados, é necessário instalar as seguintes bibliotecas do Python 3:

Beautiful Soup (pip install beautifulsoup4)
Requests (pip install requests)

Coleta do conteúdo do HTML ^

O primeiro passo para extrair as notícias mais lidas é obter o HTML do site de interesse. Para isso usamos a biblioteca Requests. Com ela é possível executar requisições HTTP como GET, POST, PUT e DELETE.

Homepage do site www.uol.com.br

A página escolhida para realizarmos a raspagem é a tela inicial do site de notícias UOL (https://www.uol.com.br). O código abaixo realiza a coleta do conteúdo HTML deste site:

import requests
url = ('https://www.uol.com.br')
content_html = requests.get(url).text

# descomente a linha abaixo para ver o conteúdo do HTML
# print(content_html)

Imagem do HTML coletado com a biblioteca Requests.

Após coletar o HTML, usamos o BeautifulSoup para extrair os dados de interesse. Essa biblioteca disponibiliza funções para a navegação e extração de elementos das tags HTML.

Para transformar o conteúdo de texto HTML coletado (content_html) em um objeto BeautifulSoup, é necessário realizar o parsing desse texto, convertendo ele numa estrutura de dados navegável.

from bs4 import BeautifulSoup

soup = BeautifulSoup(content_html, 'html.parser')

Após realizar o parsing do conteúdo HTML (content_html), temos um objeto que organiza as tags, e todo conteúdo do HTML, em forma de árvore. As relações das tags (pais, filhos, etc,) é mantida, o que facilita a navegação nos elementos HTML. No código acima, esse objeto é chamado de soup.

Exemplo

Como teste inicial, vamos extrair o título (tag <title>) do HTML coletado. Para isso basta acessar o elemento title do objeto soup:

print(soup.title)

# saída esperada: 
# <title>UOL - Seu universo online</title>

É possível extrair outros elementos de forma semelhante. Por exemplo, para obter o primeiro link (tag <a>) do HTML, usamos o elemento a:

print(soup.a)

'''
saída esperada: 
<a class="hyperlink" href="https://www.ingresso.com/?partnership=home&amp;utm_source=uol.com.br&amp;utm_medium=barrauol&amp;utm_campaign=linkfixo_barrauol&amp;utm_content=barrauol-link-ingressocom&amp;utm_term=barrauol-ingressocom" title="Ingresso.com">
Ingresso.com
</a>
'''

Podemos coletar todos os links do HTML com o método find_all('a'):

print(soup.find_all('a'))

'''saída esperada: uma lista com todos os links da página

[<a class="hyperlink" href="https://www.ingresso.com/?partnership=home&amp;utm_source=uol.com.br&amp;utm_medium=barrauol&amp;utm_campaign=linkfixo_barrauol&amp;utm_content=barrauol-link-ingressocom&amp;utm_term=barrauol-ingressocom" title="Ingresso.com">
Ingresso.com
</a>,
 <a class="hyperlink" href="https://batepapo.uol.com.br/?utm_source=uol.com.br&amp;utm_medium=barrauol&amp;utm_campaign=linkfixo_barrauol&amp;utm_term=barrauol-uolplay&amp;utm_content=barrauol" title="Bate-Papo">
Bate-Papo
</a>,
...
]
'''

Documentação: Uma lista completa dos comandos do BeautifulSoup pode ser encontrada em sua documentação. Clique aqui para acessá-la.

Inspecionando o trecho HTML de interesse ^

Agora veremos como coletar a seção das notícias mais lidas do site de notícias.

Atualmente (maio/2024), essa seção fica mais a direita da página. Para obter o elemento HTML referente a ela, inspecionamos a página . Posicionamos o cursor do mouse sobre a região da seção 'Mais lidas', clicamos com o botão direito do mouse e, em seguida, clicamos em Inspecionar.

Atalho: Também é possível acessar o Inspect (Inspetor) do navegador web com o atalho Ctrl + Shift + c.

Com o Inspetor é possível identificar a tag HTML que caracteriza o elemento HTML desejado.

A figura acima mostra essa etapa. Note que o trecho destacado, mostra que a seção "Mais Lidas" está na tag <li> e sua classe (class) é igual a mostRead__item.

Busca pela tag com o BeautifulSoup ^

Agora que identificamos a tag HTML correspondente as notícias mais lidas, basta procurarmos por ela no objeto soup.

O código abaixo procura por todas tags to tipo <li class= "mostRead__item"> e exibe o resultado.

all_most_read = soup.find_all('li', class_='mostRead__item')

print(all_most_read)

'''saída esperada:
[<li class="mostRead__item"><a class="mostRead__item__hyperlink hyperlink" href="https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/quatro-membros-da-mesma-familia-sao-encontrados-mortos-abracados-no-rs.htm" title="Quatro membros da mesma família são encontrados mortos abraçados no RS"><h3 class="title__element mostRead__title">
Quatro membros da mesma família são encontrados mortos abraçados no RS
<!-- --></h3><!-- --></a></li>, <li class="mostRead__item"><a class="mostRead__item__hyperlink hyperlink" href="https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/nunca-vi-um-rapaz-ele-conta-como-e-ser-marido-de-presa.htm" title="Ele narra a rotina de 'marido' de presa: 'Nunca vi um rapaz nas visitas'"><h3 class="title__element mostRead__title">
Ele narra a rotina de 'marido' de presa: 'Nunca vi um rapaz nas visitas'
<!-- --></h3><!-- --></a></li>, <li class="mostRead__item"><a class="mostRead__item__hyperlink hyperlink" href="https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/rs-prefeito-de-canoas-pede-evacuacao-imediata-de-quem-retornou-as-casas.htm" title="Com novo alerta de cheias, prefeitos do RS pedem que moradores deixem casas"><h3 class="title__element mostRead__title">
Com novo alerta de cheias, prefeitos do RS pedem que moradores deixem casas
<!-- --></h3><!-- --></a></li>, <li class="mostRead__item"><a class="mostRead__item__hyperlink hyperlink" href="https://noticias.uol.com.br/opiniao/coluna/2024/05/12/minha-indignacao.htm" title="'Confesso que perdi a paciência com mentirosos', diz ministro Paulo Pimenta"><h3 class="title__element mostRead__title">
'Confesso que perdi a paciência com mentirosos', diz ministro Paulo Pimenta
<!-- --></h3><!-- --></a></li>, <li class="mostRead__item"><a class="mostRead__item__hyperlink hyperlink" href="https://www.uol.com.br/esporte/futebol/colunas/futebol-pelo-mundo/2024/05/12/como-mensagem-de-rodrygo-para-o-rs-virou-fake-news-politica-na-europa.htm" title="Mensagem de Rodrygo para o RS vira fake news política na Europa"><h3 class="title__element mostRead__title">
Mensagem de Rodrygo para o RS vira fake news política na Europa
<!-- --></h3><!-- --></a></li>]
'''

Para melhorar a organização dos dados coletados, podemos separar o título e o link da notícia mais lida com o get_text().

Código completo

Incluindo essa etapa o código completo para coleta e exibição das notícias na seção mais lida fica:

import requests

url = ('https://www.uol.com.br')
html = requests.get(url).text

soup = BeautifulSoup(html, 'html.parser')

news_most_read = []
i=0
for row in soup.find_all('li', class_='mostRead__item'):
    print(f'\n{i}. {row.get_text().strip()}')
    for a in row.find_all('a', href=True):
        print(f'>>> {a["href"]}')
    i+=1

'''saída esperada:
0. Quatro membros da mesma família são encontrados mortos abraçados no RS
>>> https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/quatro-membros-da-mesma-familia-sao-encontrados-mortos-abracados-no-rs.htm

1. Ele narra a rotina de 'marido' de presa: 'Nunca vi um rapaz nas visitas'
>>> https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/nunca-vi-um-rapaz-ele-conta-como-e-ser-marido-de-presa.htm

2. Com novo alerta de cheias, prefeitos do RS pedem que moradores deixem casas
>>> https://noticias.uol.com.br/cotidiano/ultimas-noticias/2024/05/12/rs-prefeito-de-canoas-pede-evacuacao-imediata-de-quem-retornou-as-casas.htm

3. 'Confesso que perdi a paciência com mentirosos', diz ministro Paulo Pimenta
>>> https://noticias.uol.com.br/opiniao/coluna/2024/05/12/minha-indignacao.htm

4. Mensagem de Rodrygo para o RS vira fake news política na Europa
>>> https://www.uol.com.br/esporte/futebol/colunas/futebol-pelo-mundo/2024/05/12/como-mensagem-de-rodrygo-para-o-rs-virou-fake-news-politica-na-europa.htm
'''

Nota: Uma raspagem de dados como a que fizemos acessa os elementos HTML disponíveis no momento atual. Como os sites podem mudar ao longo do seu desenvolvimento, sempre que houver alterações, os nomes utilizados nas buscas e os resultados devem ser atualizados conforme necessidade. O site da UOL, em particular, tem mantido sua estrutura de HTML há um bom tempo, mudando apenas o conteúdo.

Sobre o `robots.txt` ^

Alguns sites não autorizam a raspagem de dados e informam isso no arquivo robots.txt. Para verificar o conteúdo deste arquivo basta acessar www.<nome-do-site.com.br>/robots.txt.

No caso do site de notícias aqui escolhido, ao acessar www.uol.com.br/robots.txt temos o seguinte retorno:

O asterisco em User-agent: * indica que todos os agentes (softwares/bots) podem acessar todo conteúdo do site (Allow: /) com exceção do conteúdo de /carros/dev/ (Disallow: /carros/dev/).

Ainda há outras restrições. Os agentes GPTBot e Google-Extended não podem acessar o site (Disalow: /).

Uma lista de agentes e mais informações sobre o robots.txt estão disponíveis em https://www.robotstxt.org/db.html.

Atenção: Embora o robots.txt possua recomendações do que o site permite ou não acessar via software, algumas vezes o webmaster responsável não inclui o robots.txt, pois não é algo obrigatório. O que de fato regulamenta a coleta, armazenamento, uso, etc. dos dados vindo da raspagem é a legislação do país. Geralmente, para projetos pessoais, sem fins lucrativos, sem requisições massivas, costuma ser tranquilo.

De toda forma, vale avaliar como os dados coletados serão usados, visto que dependendo do caso pode haver implicações legais.

Exemplos de uso da raspagem de dados rodando em produção ^

A fim de ilustrar as possibilidades de uso do web scraping, deixamos dois exemplos de uso.

Querido Diário (https://queridodiario.ok.org.br)

A plataforma Querido Diário disponibiliza vários conteúdos de interesse público, muitas vezes coletados através da raspagem de dados. Nela o usuário pode obter informações relacionadas ao Diário Oficial de inúmeros municípios brasileiros.

Os dados do Querido Diário muitas vezes servem de matéria-prima para reportagens, pesquisas e análises de diferentes tipos.

Para contribuir com o esse projeto open source acesse seu Github: https://github.com/okfn-brasil/querido-diario-comunidade

Mini-app ^

Outro exemplo que usa a raspagem de dados é esse mini-app experimental que fizemos algum tempo atrás:

https://newsaggapp-1-j9368482.deta.app/

Ele foi disponibilizado em produção de forma 100% gratuita com o Deta Space: https://deta.space/.

Conclusão e próximos passos ^

Assim como fizemos o scraping da seção "mais lidas", podemos coletar outras seções do site da UOL ou de outro de preferência. Basta usar a etapa de análise com o Inspetor do navegador web para conhecer a estrutura do HTML. Além disso, o que vimos sobre o robots.txt pode servir de base caso haja dúvidas sobre a viabilidade ou não de realizar a raspagem de algum site. Acreditamos que o conteúdo visto pode contribuir de alguma forma para iniciantes no assunto ou interessados. Dicas ou sugestões são bem-vindas.

Agradecemos a leitura! ☕ 💻 🗞️

Um "Hello World" em Deep Learning

msc2020 — Sun, 05 May 2024 13:20:22 +0000

Este post apresenta um passo a passo para rodar um modelo de Deep Learning (DL) que realiza uma tarefa que até pouco tempo atrás era um desafio. A partir de uma base de dados, devidamente organizada e rotulada, contendo dezenas de milhares de dígitos (0 a 9) escritos a mão, o modelo de DL será capaz de predizer qual é o dígito da imagem de entrada. Como nem todo mundo possui uma letra tão bonita, essa tarefa não é trivial, principalmente para um computador.

Modelos desse tipo, são comumente usados para identificar de forma automática o conteúdo de texto em documentos, PDFs, imagens, entre outros. Com poucas alterações no que veremos, é possível classificar outros conteúdos de outros datasets. No final do post falamos um pouco sobre isso.

Vamos lá!? ☕

Pré-requisitos

Para executar os códigos deste post precisamos das seguintes bibliotecas do Python 3:

Matplotlib (pip install matplotlib)
Numpy (pip install numpy)
Scikit-learn (pip install scikit-learn)

Dataset MNIST

Criado em 1994, o dataset MNIST (Modified National Institute of Standards and Technology) é bastante utilizado na área de visão computacional e processamento de imagens. A versão atual é composta por 60k imagens de treino e 10k de teste. Cada amostra do MNIST é uma imagem 28x28 em tons de cinza e representa um dígito manuscrito que assume valores entre 0 e 9.

Imagem de amostras do MNIST.

Download do MNIST: Usaremos a versão do dataset MNIST disponibilizada neste site: http://yann.lecun.com/exdb/mnist/. Devemos entrar no site e baixar os 4 datasets disponibilizados, colocando-os num diretório. Para facilitar criamos uma pasta chamada datasets e colocamos os arquivos .gz baixados nele.

Site para download do MNIST. http://yann.lecun.com/exdb/mnist/

Carregando o dataset

Usaremos as seguintes funções para abrir o MNIST, pois o mesmo está no formato .gz.

import gzip
import struct
import numpy as np

def load_dataset(path_dataset):
    with gzip.open(path_dataset,'rb') as f:
        magic, size = struct.unpack('>II', f.read(8))
        nrows, ncols = struct.unpack('>II', f.read(8))
        data = np.frombuffer(f.read(), dtype=np.dtype(np.uint8).newbyteorder('>'))
        data = data.reshape((size, nrows, ncols))
        return data

def load_label(path_label):
     with gzip.open(path_label,'rb') as f:
        magic, size = struct.unpack('>II', f.read(8))
        data = np.frombuffer(f.read(), dtype=np.dtype(np.uint8).newbyteorder('>'))        
        return data

O código abaixo carrega as 4 partes do dataset MNIST: train-images-idx3-ubyte.gz (conjunto de treino); train-labels-idx1-ubyte.gz (labels do conjunto de treino); t10k-images-idx3-ubyte.gz (conjunto de teste) e t10k-labels-idx1-ubyte.gz (labels do conjunto de teste).

X_train = load_dataset(r'./datasets/train-images-idx3-ubyte.gz')
y_train = load_label(r'./datasets/train-labels-idx1-ubyte.gz')
X_test = load_dataset(r'./datasets/t10k-images-idx3-ubyte.gz')
y_test = load_label(r'./datasets/t10k-labels-idx1-ubyte.gz')

Após carregar os datasets, checamos se suas dimensões estão dentro do esperado.

print(X_train.shape) # valor esperado: (60000, 28, 28)
print(y_train.shape) # (60000,)
print(X_test.shape) # (10000, 28, 28)
print(y_test.shape) # (10000, )

Note que a dimensão das imagens dos conjuntos de treino e de teste é 28 x 28.

Histograma dos labels

Uma etapa importante na construção dos datasets em DL é considerar classes balanceadas. Datasets de treino com classes desbalanceadas costumam introduzir um viés, fazendo com que as predições favoreçam algumas classes ao invés de outras. Por ex., se existe uma grande quantidade de amostras do dígito 1 e poucas do dígito 7, é comum que o modelo aprenda esse padrão e tente reproduzi-lo nas predições que fizer. Nesse caso, o modelo tende a achar que "tudo" se parece mais com o dígito 1 e considera o dígito 7 como algo menos comum. Como o MNIST possui 10 classes, referentes aos dígitos de 0 a 9, então é esperado que possuam distribuições semelhantes.

Curiosidade: Na prática, o viés pode levar a falhas brutais. Por ex., um caso ocorrido em 2022 levou um inocente a ficar preso por 26 dias devido a um erro "algorítmico", causando danos e prejuízos reais. Para mais detalhes do caso clique aqui.

Para avaliar a distribuição dos labels de treino do MNIST usaremos o histograma:

import matplotlib.pyplot as plt

fig, axs = plt.subplots(figsize=(15, 5), dpi=70)
x_ticks = np.arange(min(y_train), max(y_train)+2, 1)
bins = x_ticks - 0.5
plt.hist(y_train, edgecolor='k', rwidth=0.8, bins=bins, color='#ABCDEF')
plt.title('Histograma do label de treino y_train', size=16)
plt.xlabel('Classe - Label', size=14)
plt.ylabel('Frequência', size=14)
plt.xticks(x_ticks)
plt.show()

O gráfico acima mostra que as classes do dataset MNIST estão balanceadas. Sendo assim, seguimos para a etapa de treinar e utilizar os modelos treinados para predizer dígitos manuscritos de entrada (input).

Aplicando modelos de Machine Learning e Deep Learning

Para avaliar a performance do modelo de Deep Learning que usaremos, também vamos realizar predições dos dígitos manuscritos com um modelo de Machine Learning (ML).

Nota: Não entraremos nos detalhes do que é ou não é Machine Learning e Deep Learning. No entanto, vale ter em mente que os modelos de Deep Learning costumam ser considerados como um subconjunto dos modelos de Machine Learning. Isso porque eles são modelos capazes de aprender de forma automática (sem intervenção humana) e fazer predições baseadas naquilo que aprenderam. A grande diferença entre os dois é que os modelos de DL são capazes de aprender mais detalhes. Além disso, sua formulação é mais complexa e sua arquitetura, as famosas redes neurais artificiais, geralmente possuem inúmeras camada ocultas.

Imagem de uma MLP. (Rede gerada com ajuda do site https://alexlenail.me/NN-SVG)

O fato de um determinado modelo ser classificado como X ou Y, não mudará sua natureza intrínseca. Questões de nomenclatura/taxonomia geralmente buscam organizar e facilitar o entendimento do objeto de estudo e não criar barreiras ou complexidades extras.

Modelo SGD

O modelo SGD (Stochastic Gradient Descent) SGDClassifier do scikit-learn será o modelo de ML que iremos compara com o de DL. Ele realiza o ajuste de um modelo SVM (Support Vector Machine). O código a seguir treina/ajusta o SGDClassifier sobre o dataset MNIST. Note que usamos uma etapa de pré-processamento com o StandardScaler, que transforma a média dos dados para 0 e o desvio padrão igual a 1. Mais detalhes sobre podem ser encontrados em sua documentação.

from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

model_sgd_classifier = make_pipeline(StandardScaler(),
                                     SGDClassifier(random_state=2024))

model_sgd_classifier.fit((X_train).reshape(len(X_train), 28*28),
                         y_train)

Após o treinamento do modelo SGDClassifier, já podemos realizar as predições.

Modelo Multilayer Perceptron Classifier

Agora apresentaremos de fato o "Hello World!" (Olá, Mundo!) em DL. O modelo escolhido para isso é uma rede neural conhecida como Multilayer Percepetron ou MLP. Sua arquitetura geralmente possui 3 ou mais camadas ocultas. Esse modelo foi um marco, pois possui capacidade de aprender padrões não lineares e ser treinado em computadores pessoais. Além disso, suas implementações atuais, costumam ter um bom desempenho para tarefas um tanto complexas, como classificar dígitos manuscritos. Embora para os humanos, reconhecer dígitos ou letras seja algo aparentemente simples (principalmente no idioma raiz), para os computadores nem sempre foi assim. No caso do MNIST, de 1998 a 2012 houve um grande salto na performance dos modelos, passando de 88% de acerto para 99.77%.

O código abaixo treina o modelo MLPClassifier, uma implementação de um MLP classificador. Ele também está disponível na biblioteca open-source Scikit-learn.

from sklearn.neural_network import MLPClassifier
model_mlp = MLPClassifier(max_iter=300, random_state=2024)
model_mlp.fit((X_train/255).reshape(len(X_train), 28*28), y_train)

Realizando as predições com os modelos treinados

Agora que treinamos os modelos, realizamos as predições usando o método predict. A seguir realizamos a predição sobre o conjunto de testes (X_test).

print(model_sgd_classifier.score(X_test.reshape(len(X_test), 28*28), y_test))
print(model_mlp.score(X_test.reshape(len(X_test), 28*28), y_test))

'''
saída esperada:

0.9027
0.9784
'''

Comparando o valor do score de ambos, notamos que o desempenho do MLPClassifier foi maior. Vale a pena comentar que ambos modelos se saíram muito bem, com assertividades acima de 90%. No entanto, a diferença entre eles pode ser considerada alta, já que foi de 0.9784 - 0.9027 = 0.0757. Ou seja, cerca de 7.57% .

Salvando e carregando um modelo

As etapas de treinamento podem demorar e consumir recursos como energia, vida útil da CPU ou GPU entre outros. Dessa forma, é interessante salvarmos o modelo treinado em nosso computador e carregá-lo sempre que quisermos realizar uma predição.

Para salvar o modelo utilizamos a biblioteca pickle, responsável por serializar (passar de objeto Python/Scikit-learn para binário) e deserializar (fazer o processo contrário). Como o pickle é uma biblioteca padrão do Python 3, não é necessário sua instalação, basta importá-la de forma usual com o import.

import pickle

output = open('model_classifier_mnist.pkl', 'wb')

pickle.dump(model_mlp, output, -1)

output.close()

O código acima salva o modelo MLPClassifier já treinado (objeto model_mlp) com o nome model_classifier_mnist.pkl. Note que usamos o método dump() do pickle para realizar essa tarefa.

Já para carregar o modelo salvo, utilizamos o load():

pickle_file = open('model_classifier_mnist.pkl', 'rb')

model_test = pickle.load(pickle_file)

pickle_file.close()

Teste com uma amostra aletória

Para finalizar, vamos realizar um simples teste que sorteia de forma aleatória um dígito manuscrito e realiza a predição com ambos modelos. Será que ambos modelos vão reconhecer o dígito manuscrito?

idx_random = np.random.randint(0, len(X_train)) # sorteia um índice
print(f'idx_random = {idx_random}')

some_digit = X_train[idx_random] # seleciona o valor dos pixels no conjunto de treino

# exibe o dígito manuscrito como uma imagem
fig, axs = plt.subplots(figsize=(29, 29), dpi=60)
plt.imshow(some_digit, cmap='binary')
plt.axis('off')
plt.show()

# realiza predição do dígito sorteado com os modelos MLP e SGD
print(model_mlp.predict([some_digit.reshape(28*28)]))
print(model_sgd_classifier.predict([some_digit.reshape(28*28)]))

'''
saída esperada:

[2]
[8]
'''

Embora a tendência seja que ambos modelos acertem, visto que escolhemos uma amostra do conjunto de treino, apenas o modelo MLP acertou a predição do dígito sorteado. Para dificultar um pouco mais, podemos escolher uma amostra do conjunto de testes ou fazer uma imagem manuscrita com nossa própria letra e usar como entrada.

Datasets semelhantes

Outros exemplos de datasets que poderíamos ter usado ao invés do MNIST:

CIFAR-10: possui 10 classes com imagens de aviões, cães, gatos, carros, caminhões, etc.
Fashion MNIST: possui 10 classes com imagens de roupas, sapatos, bolsas e outros itens semelhantes.
CIFAR-100: possui 100 classes, contendo imagens como exemplos de animais, veículos, árvores e flores.

Esperamos que tenham gostado e agradecemos a leitura!

🤖 ☕ 🗿 🦥 ♟️

Envio e recebimento de mensagens de texto dentro de imagens com Python

msc2020 — Mon, 29 Apr 2024 22:51:07 +0000

O processo de enviar e receber mensagens de texto dentro de imagens faz parte da área de Esteganografia. No post de hoje, mostramos uma forma simples de como fazer isso utilizando a linguagem Python. ☕

Pré-requisitos

Para fazer este tutorial é necessário instalar a biblioteca Pillow (PIL) do Python 3:

 pip install pillow

Representação de um pixel RGB

Uma imagem digital é formada por pixels, sendo essas sua menor unidade. Por sua vez, cada pixel de imagens usuais como .JPG, .PNG, .JPEG, está associado a três valores inteiros (int) que representam a quantidade de cores R (red, vermelho), G (green, verde) e B (blue, azul). Os valores das cores R, G e B variam entre 0 e 255. A combinação desses valores irá formar uma ampla gama de cores do sistema RGB.

Algumas imagens contam com uma componente extra, além dos canais de cores R, G e B, chamada A (alpha) que controla a transparência da imagem. Esse valor varia de 0 a 1 (ou de 0 a 255, como no Pillow). Quanto mais próximo de 0, mais transparente a imagem ficará.

Neste post usaremos a imagem abaixo para realizar os testes.

Fonte: https://it.wikifur.com/wiki/Camaleonte

Exemplo

Vejamos um exemplo com a biblioteca Pillow.

# exemplo.py

from PIL import Image

# path para imagem de entrada
filename_path = './images/img_camaleao.jpeg' 
# download da imagem: https://it.wikifur.com/wiki/Camaleonte

# carrega imagem como um objeto Image
img = Image.open(filename_path)

# print do formato e sistema de cores
print(f'Formato: {img.format}')
print(f'Cores: {img.getbands()}')
print(f'Tamanho: {img.size}')
x, y = 400, 100
print(f'Valor das cores do pixel na posição \
(x, y) = ({x}, {y}): {img.getpixel( (x, y))}')

# exibe imagem
img.show()

'''
saída esperada no terminal:

Formato: JPEG
Cores: ('R', 'G', 'B')
Tamanho: (800, 500)
Valor das cores do pixel na posição (x, y) = (400, 100): (184, 215, 95)
'''

No exemplo considerado, o pixel selecionado faz parte do camaleão verde, pois a componente G tem o maior valor na tripla ordenada (R, G, B) = (184, 215, 95). Usando um site para facilitar na conversão, checamos que a cor do pixel escolhido:

Inserindo uma mensagem de texto em uma imagem RGB

Assim como o Pillow possui um método para coletar as informações sobre um determinado pixel de uma imagem, getpixel(), também há um para inserir um pixel. Para inserir um pixel com cores (R, G, B), onde 0 $≤\le$ R, G, B $≤\le$ 255 usamos o putpixel().

O código a seguir insere uma mensagem numa imagem com cores RGB:

def insert_msg(img_original, msg):
    '''
    Input:
      . img_original: imagem com cores em RGB
      . msg: uma mensagem em forma de string
    Output:
      . img_with_msg: imagem com a mensagem introduzida em alguns pixels
    '''

    img_with_msg = img_original.copy()

    x_cte = img_with_msg.size[0] - 1

    # codifica mensagem de string para números inteiros
    msg_encoded_bytes = msg.encode(encoding='utf-8', errors='strict')
    msg_encoded = str(int.from_bytes(bytes=msg_encoded_bytes, byteorder='little'))

    # insere mensagem no canal de cor R da imagem
    for j, n in enumerate(msg_encoded):
        rgb_pixel = list(img.getpixel((x_cte, j)))
        red_color = rgb_pixel[0] # (r, g, b)[0]
        try:
            if red_color < 255-9:
                r = red_color % 10
                rgb_pixel[0] =  red_color - r + int(n)
            else:                
                rgb_pixel[0] =  int(n)

            img_with_msg.putpixel((x_cte, j), tuple(rgb_pixel))
        except Exception as e:
            print(e)            
            img_with_msg.putpixel((x_cte, j), tuple(rgb_pixel))

    # adiciona pixels no fim como flag
    flag_pixel = (233, 233, 233)
    for j in range(5):
        k = len(msg_encoded) + j
        rgb_pixel = img.getpixel((x_cte, k))
        try: # tenta retorna um flag_pixel
            img_with_msg.putpixel((x_cte, k), flag_pixel)
        except: # se der exceção, retorna o pixel original
            img_with_msg.putpixel((x_cte, j), rgb_pixel)

    return img_with_msg, msg_encoded

Estratégia usada: Para inserir a mensagem na imagem, primeiramente codificamos ela como uma lista de inteiros e depois inserimos cada valor inteiro no canal de cor vermelho R, mantendo fixo um valor para coordenada x (x = x_cte).

As inserções alteram os pixels da imagem original. Por exemplo, suponha que o valor do pixel original escolhido for, digamos, (23, 127, 53) e vamos inserir o número 7 na lista de inteiros que codificam a mensagem. Então, o pixel alterado é (27, 127, 53).

Essa estratégia de inserir, foi definida na etapa r = red_color % 10. Caso haja valores maiores do que 255, que é o valor máximo permitido, tratamos com o try/except.

Nota: Essa forma de inserir pode não ser a mais eficiente, nem tem essa intenção. O objetivo do post é apresentar uma, dentre tantas, maneira de fazer a tarefa desejada.

Após inserir a mensagem codificada na imagem, finalizamos a lista de pixels alterados com uma flag. A flag corresponde em alterar os 5 próximos pixels, após o último que foi necessário, para o valor de (233, 233, 233). Isso nos ajudará no momento de recuperar a mensagem enviada.

Curiosidade: O número 233 tem um lado cabalístico, pois é ao mesmo tempo um número primo, primo de Shopie Germain, primo de Srinivasa Ramujan e também de Fibonacci. Números com essas características são de extrema importância para área de criptografia. Por exemplo, o projeto PrimeGrid investiga números primos como esses desde 2005.

Extraindo a mensagem de texto da imagem

Para extrair a mensagem presente na imagem, usamos essa função:

def exctract_msg(img_with_msg):
    '''
    Input:
      . img_with_msg: imagem com uma mensagem inserir pela função `insert_msg()`
    Output:
     . msg_decoded_str: mensagem na forma de string
    '''

    img_input = img_with_msg.copy()
    x_cte = img_input.size[0] - 1

    # pega posição da flag
    is_flag = 0
    flag_pixel = (233, 233, 233)
    list_pixels = []
    for j in range(img_input.size[1] - 1):
        rgb_pixel = img_input.getpixel((x_cte, j))
        if rgb_pixel == flag_pixel:
            is_flag += 1
            if is_flag == 5:
                j_end = j

    # cria lista com os números inteiros correspondentes a mensagem codificada como inteiros
    msg_encoded_int = []
    for j in range(j_end-4):
        rgb_pixel = list(img_input.getpixel((x_cte, j)))
        red_color = rgb_pixel[0] # (r, g, b)
        r = str(red_color % 10)
        msg_encoded_int.append(r)
        list_pixels.append(rgb_pixel)

    # decodifica, passando a lista de inteiros para uma string com a mensagem escolhida
    msg_encoded_int = ''.join(msg_encoded_int)
    msg_encoded_int = int(msg_encoded_int)
    msg_decoded_bytes = msg_encoded_int.to_bytes((msg_encoded_int.bit_length() + 7) // 8, 'little')
    msg_decoded_str = msg_decoded_bytes.decode('utf-8')

    return msg_decoded_str

Resumidamente, para extrair o texto da imagem, basta seguir o processo contrário do que foi feito em insert_msg(). Ou seja, capturar a lista de números inteiros que foram inseridos nos pixels alterados e decodificar essa lista para uma string que será a mensagem original.

Testes

Para testar as funções criadas, iremos considerar a imagem do camaleão já mostrada.

O seguinte código usa as duas funções, para inserção e posterior extração da mensagem. Para evitar repetir o código dessas funções, inserimos ambas, insert_msg() e exctract_msg (), no utils.py e importamos seu conteúdo com from utils import *.

#insere_extrai_msg_em_imagem.py

from PIL import Image
from utils import *

# caminho para imagem JPEG
img_path = './images/img_camaleao.jpeg' # https://it.wikifur.com/wiki/Camaleonte

# mensagem escolhida
msg_input = 'Há mais força no perdão do que na ofensa, há mais força no reparo do que no erro. Raduan Nassar.'

# carrega imagem como um objeto Image
img = Image.open(img_path)

# descomentar a linha abaixo para exibir imagem original
# img.show(title='Imagem original')

# insere mensagem na imagem
img_encoded = insert_msg(img, msg_input)

# descomentar para exibir imagem com a mensagem inserida
# img_encoded.show(title='Imagem com mensagem')

# extrai mensagem de imagem
msg_decoded = exctract_msg(img_encoded)
print(msg_decoded)

'''
saída esperada:

'Há mais força no perdão do que na ofensa, há mais força no reparo do que no erro. Raduan Nassar.'
'''

Sobre a figura: A imagem a esquerda é a original e a direita possui a mensagem inserida. Se dermos uma 'zoom in' na imagem a direita notaremos uma sequência de pixels brancos em um pedaço da borda.

Outras formas de inserir e extrair mensagens em imagem

Há maneiras mais eficientes de se inserir e extrair mensagens em imagens digitais. Uma forma muito usada é considerar a codificação binária da mensagem e dos pixels da imagem e alterar os bits menos significativos da imagem (LSB). Dessa maneira, as mensagens transmitidas podem ser um tanto longas e a chance das mudanças na imagem serem perceptíveis a olho nu é baixa. Um bom material sobre o assunto pode ser encontrado neste link ou aqui.

👾 👻 🦎 🐉 🧌 🖼️ 🕴️

Esperamos que tenham gostado e agradecemos a leitura!

Extração de metadados de imagens com Python

msc2020 — Sun, 14 Apr 2024 14:17:46 +0000

Neste post, falamos sobre os metadados de imagens. Mostramos como usar ferramentas na linguagem Python para extrair esse tipo de informação.

Atualmente, na "Era dos Dados/IA", é comum ouvir que "Dados são o novo petróleo". Não é difícil entender esse jargão, mas fica a dúvida: "Se os dados são análogos ao petróleo, nos dias de hoje, os metadados seriam comparáveis ao que"?

Um pouco sobre imagens e metadados

Antes de rodar o código Python que fará a extração dos metadados, vejamos rapidamente alguns pontos sobre as imagens digitais.

Como é formado um arquivo de imagem?

De forma resumida, uma imagem digital é um arquivo, no formato PNG, JPEG, GIF, etc., que segue as especificações que o definem. Assim como muitos arquivos digitais, no computador as imagens podem ser representadas por matrizes, onde cada entrada da matriz está associada a um pixel. Essa relação não é biunívoca, pois depende da configuração do computador usado para trabalhar com a imagem. Se uma imagem digital tem resolução 800 X 600 (largura X altura), então corresponde a um total de 480.000 pixels na tela do computador. Geralmente, quando se aplica alguma transformação numa imagem, estamos realizando operações com matrizes/submatrizes de pixels.

O que significa o prefixo meta?

Segundo o dicionário online Priberam, o prefixo meta é uma palavra que "exprime a noção de reflexão sobre si (ex.: metalinguagem)". Dessa maneira, o termo metadados significa "dados sobre algum dado". Neste post, focamos nas imagens e seus metadados. Muitas vezes o sistema operacional do computador acessa esses dados para alguma finalidade.

Os metadados de uma imagem são obrigatórios?

Assim como cada imagem pode ter um formato diferente, as informações que essas imagens carregam sobre si também podem mudar. Para ilustrar, nas respectivas extensões, os formatos GIF (lançado em 1987), JPEG (introduzida em 1982) e WebP (de 2010) possuem especificações diferentes para sua formação. A palavra hexadecimal usada para identificar cada um destes é diferente. Mais detalhes podem ser encontrados neste link.

Além disso, as imagens podem ser geradas em contextos particulares e por dispositivos com característica diferentes, como imagens de satélite, imagens médicas, imagens geofísicas, etc. Isso adiciona maior complexidade para uma padronização única dos metadados de imagens. Os metadados de imagens costumam variar ou mesmo serem excluídos. O WhatsApp serve de exemplo de um aplicativo que costuma remover alguns metadados de imagens enviadas através dele.

Como extrair os metadados usando Python?

Agora veremos como extrair os metadados de uma imagem na prática. Para isso usaremos a biblioteca open source chamada Hachoir.

Fonte: www.ecolibrary.org/page/DP43 | Licença: https://creativecommons.org/licenses/by-nc/3.0/us/

Hachoir

A ferramenta Hachoir é uma biblioteca Python que permite extrairmos metadados de arquivos como imagens, vídeos, áudio, entre outros. Sua documentação traz exemplos interessantes.

Instalação: Para instalá-lo Hachoir, basta digitar o seguinte comando num terminal com Python 3 instalado:

pip install hachoir

Código usado: Para realizar a extração dos metadados usaremos o script abaixo:

# extrai_metadados.py
import hachoir.metadata
import hachoir.parser
from hachoir.core import config as HachoirConfig
HachoirConfig.quiet = True

img_path = 'mata_atlantica.jpg'
# www.ecolibrary.org/page/DP43
# license: https://creativecommons.org/licenses/by-nc/3.0/us/

filename = img_path
parser = hachoir.parser.createParser(filename)

hachoir_metadata = hachoir.metadata.extractMetadata(parser)
metadata = hachoir_metadata.exportDictionary()['Metadata']
print(metadata)

Note que a variável img_path é onde definimos o caminho até o arquivo de imagem que escolhemos. No caso, foi escolhido uma foto em JPG, mas poderíamos ter escolhido um outro formato.

Podemos rodar o script extrai_metadados.py mencionado acima com:

python extrai_metadados.py

Saída esperada: Após rodar esse script, obtemos como resposta um dicionário Python (semelhante a um json):

{"Author": "Dan L. Perlman",
"Image width": "1024 pixels",
"Image height": "768 pixels",
"Image orientation": "Horizontal (normal)",
"Bits/pixel": "24",
"Pixel format": "YCbCr",
"Image DPI width": "93 DPI",
"Image DPI height": "93 DPI",
"Creation date": "2008-03-20 16:53:27",
"Camera focal": "19",
"Camera exposure": "1/4",
"Camera brightness": "5.16",
"Camera model": "FinePixS2Pro",
"Camera manufacturer": "FUJIFILM",
"Compression": "JPEG (Baseline)",
"Copyright": "© Dan L. Perlman 2008
http://creativecommons.org/licenses/by-nc/3.0/us/",
"Thumbnail size": "8471 bytes",
"ISO speed rating": "100",
"EXIF version": "0220",
"Date-time original": "2004-10-23 09:47:24",
"Date-time digitized": "2004-10-23 09:47:24",
"Compressed bits per pixel": "3.2",
"Shutter speed": "2",
"Aperture": "8.5",
"Exposure bias": "0",
"Focal length": "18",
"Flashpix version": "0100",
"Focal plane width": "1.86e+03",
"Focal plane height": "1.86e+03",
"Focal length in 35mm film": "27",
"Producer": "Adobe Photoshop CS3 Windows",
"Comment": "JPEG quality: 91% (approximate)",
"Format version": "JFIF 1.02",
"MIME type": "image/jpeg",
"Endianness": "Big endian"}

Acima temos os metadados extraídos da imagem que escolhemos para este teste. Parte desses itens são extraídos do EXIF, uma padronização que especifica formatos para imagens geradas por dispositivos como câmeras, smartphones, scanner, etc. Com o EXIF é possível obter dados de data e hora, informações do dispositivo usado na geração da imagem, geolocalização, métricas sobre os pixels e os direitos autorais da imagem.

Observações sobre os metadados extraídos

Para a imagem JPG que usamos (mata_atlantica.jpg), a resposta do script extrai_metadados.py fornece informações básicas como:

"Image width": "1024 pixels",
"Image height": "768 pixels",
"Image orientation": "Horizontal (normal)",
"Bits/pixel": "24",
"Pixel format": "YCbCr",
"MIME type": "image/jpeg",
"Endianness": "Big endian"
...

Também há informações sobre o dispositivo usado para gerar essa imagem:

"Camera focal": "19",
"Camera exposure": "1/4",
"Camera brightness": "5.16",
"Camera model": "FinePixS2Pro",
"Camera manufacturer": "FUJIFILM",
"Shutter speed": "2",
"Aperture": "8.5",
"Exposure bias": "0",
"Focal length": "18",
"Flashpix version": "0100",
"Focal plane width": "1.86e+03",
"Focal plane height": "1.86e+03",
"Focal length in 35mm film": "27"
...

Curiosidade: Pelos metadados, a máquina usada para tirar a foto foi uma FUJIFILM FinePix S2 Pro.

Os metadados extraídos ainda trazem a data de criação, autoria e licença de uso da imagem:

"Author": "Dan L. Perlman",
"Creation date": "2008-03-20 16:53:27",
"Date-time original": "2004-10-23 09:47:24",
"Date-time digitized": "2004-10-23 09:47:24",
"Copyright": "© Dan L. Perlman 2008
http://creativecommons.org/licenses/by-nc/3.0/us/"
...

Nota: Embora para mata_atlantica.jpg foi possível a extração de inúmeros metadados, pode ser que isso mude conforme a imagem escolhida. Dependendo da caso, os dados extraídos podem ser diferentes dos apresentados neste exemplo.

Lembremos ainda que os metadados são editáveis. Ou seja, uma imagem pode ter informações detalhadas, ou não, sobre sua criação. Já o objeto real, usado para gerar a imagem digital, não muda (excluindo situações particulares).

Agradecemos a leitura! Vc conhece algum caso de uso que ache interessante e envolva metadados? Compartilhe, será bem-vindo!

📖 . 🤖 .. ☕ ... 🐌 .... 🦥 ..... 👾 ..... 👻💡

* A imagem de capa deste post foi gerada com um text-to-image usando a frase "Data about data about data about data about data ad infinitum in pt-br".

Bot para assistir vídeos no YouTube

msc2020 — Sun, 24 Mar 2024 23:07:52 +0000

Neste post, usando ferramentas Python, desenvolvemos um robô (bot) 🤖 que seja capaz de assistir vídeos no Youtube de forma automatizada.

Iniciamos com a instalação do Selenium e falamos um pouco sobre WebDriver. Essas ferramentas são bastante usadas em testes de software. Em seguida, apresentamos o script Python que fizemos para automatizar a tarefa de ver um vídeo no Youtube, ou algo do tipo, por N vezes em M janelas abertas simultaneamente. Falamos "algo do tipo" porque de forma muito semelhante ao que será feito conseguimos criar novas tarefas de acordo com a preferência de cada um.

☕

Instalação do Selenium

Em um computador com Python 3, devemos instalar o Selenium. Para isso usamos o pip install:

pip install selenium

O Selenium é uma ferramentas para automatização de tarefas na web. Serve ainda para as mais diversas tarefas de automação no contexto da famosa área conhecida como RPA (Robotic Process Automation). Ele está disponível para download gratuito em algumas linguagens como Java e Ruby. Aqui usaremos a versão para linguagem Python.

Chrome Driver

Outra ferramenta bastante usada para automatizar testes na web é o WebDriver. Com ele conseguimos executar inúmeras tarefas para diferentes navegadores web. Aqui usaremos o navegador Chrome.

Pré-requisito: Um pré-requisito para instalar o WebDriver é ter uma versão do Chrome instalado ou algo equivalente a isso. Por ex., Firefox e o Webdriver do Firefox. Clique aqui para saber mais.

Agora devemos criar um diretório para salvar o WebDriver dentro dele. Chamaremos o diretório criado de bot-youtube. Isso pode ser feito pelo terminal, com o código abaixo.

mkdir bot-youtube

Download do driver: Para baixar o Chrome driver (WebDriver) correspondente ao seu navegador Google Chrome veja https://chromedriver.chromium.org/downloads ou https://googlechromelabs.github.io/chrome-for-testing/ (para versões mais recentes, i.e., versão > 115). Aqui usamos, e testamos, para a versão do drive para Linux 64 bits (123.0.6312.58) e mesma versão do navegador Chrome. Clique aqui para baixar o Chrome. Caso use Windows ou outro sistema operacional, basta baixar o driver e navegador Chrome adequados.

Estrutura dos arquivos após o download do WebDriver:

bot-youtube/
│
├── chromedriver_linux64/
│   └── chromedriver

Nota: Se usarmos o WebDriver na versão Windows, o nome padrão da pasta chromedriver_linux64 será outro.

Script Python

Para realizar as tarefas automatizadas, de forma que o bot veja um vídeo no Youtube, usaremos o seguinte script (bot_youtube.py) em Python:

#bot_youtube.py

import random
import time
from selenium import webdriver
from selenium.webdriver.common.by import By

PATH_DRIVER = './chromedriver_linux64/' # path para o driver
DEFAULT_LINK = r'https://www.youtube.com/watch?v=XlGLf7cWOJA' # link para o vídeo
DEFAULT_TIME = 56*60 # duração do vídeo em segundos (s)
DEFAULT_N = 2 # número de vezes que o vídeo será visto
DEFAULT_N_DRIVERS = 3 # número de janelas que serão abertas para ver o vídeo

# input - link do vídeo
url = input(f'\n1. Entre com o link do vídeo no YouTube \n[Sugestão: >>> {DEFAULT_LINK}, entrevista com Cornelius Lanczos]:\n\n>>> ')
# obs: o vídeo do Lanczos tem 55:51 min = ~(56 x 60)s = ~3600 s

# checa input
if not url:
    url = DEFAULT_LINK
print(f'>>> URL escolhida: {url}')

# input - tempo do vídeo
duration = input(f'\n\n2. Entre com a duração do vídeo em segundos\n[Por ex.: >>> {DEFAULT_TIME}, para o vídeo do pq ele tem cerca de 1h, ou seja, 3600 s]:\n\n>>> ')

# checa input
if not duration:
    duration = DEFAULT_TIME
else:
    duration = int(duration)
print(f'>>> Tempo de duração escolhido: {duration}')

# define o número de vezes que o bot verá o vídeo
n = input(f'\n\n3. Entre aqui com o número inteiro N correspondente ao número de vezes que o bot irá abrir a(s) janela(s) no navegador para assistir o vídeo\n[Sugestão: >>> {DEFAULT_N}]:\n\n>>> ')

# checa input
if not n:
    n = DEFAULT_N
else:
    n = int(n)
print(f'>>> N escolhido: {n}')

# define o número de janelas que abrirá
n_drivers = input(f'\n\n4. Entre com o número inteiro M que corresponderá ao total de janelas que serão abertas simultaneamente para assistir o vídeo\n[ Sugestão: >>> {DEFAULT_N_DRIVERS}]:\n\n>>> ')

# checa input
if not n_drivers:
    n_drivers = DEFAULT_N_DRIVERS
else:
    n_drivers = int(n_drivers)
print(f'>>> M escolhido: {n_drivers}')

# assistindo o vídeo N vezes em M janelas abertas
for k in range(n):    
    print(f'\n\n----- {k+1} of {n} times -----')

    time_to_refresh = int(duration+2*n_drivers)

    drivers = []
    print(f'Abrindo {n_drivers} web drivers . . .')

    for i in range(n_drivers):
        drivers.append(webdriver.Chrome(executable_path='chromedriver'))
        drivers[i].get(url)

        time.sleep(random.randint(1, 3))

        video = drivers[i].find_element(By.ID, 'movie_player')

        video.send_keys('k') # hits k        

        time.sleep(random.randint(1, 3))

        #drivers[i].minimize_window()
        print(f'  > Driver aberto [{i}]')

    print(f'  > Assistindo os vídeos [{time_to_refresh} seconds] . . .')
    time.sleep(time_to_refresh)

    print('')
    print(f'Fechando os {n_drivers} web drivers . . .')
    for i in range(n_drivers):
        drivers[i].close()
        print(f'  > Finalizado o browser [{i}]')

Arquivos do projeto após a criação do bot_youtube.py:

bot-youtube/
│
├── chromedriver_linux64/
│   └── chromedriver
│
└── bot_youtube.py

Rodando o bot

Para rodar o script bot_youtube.py que acabamos de criar, basta digitar o seguinte comando no terminal:

python bot_youtube.py

Após rodar o script, é necessário inserirmos as informações referentes ao vídeo que desejamos que nosso bot veja. A seguir temos a sequência de etapas para usar o bot:

1. Insira o link para o vídeo no Youtube.

2. Entre com a duração do vídeo em segundos (s)

3. Escolha o número de vezes que o bot irá assistir o vídeo (por ex., 2x ou 3x para testes)

4. Defina o número de janelas que deverão abrir para assistir o vídeo ao mesmo tempo

5. Aguarde o bot assistir os vídeos ⏳

Próximos passos: Agora que sabemos fazer um bot ver um vídeo na web, será que, com "algumas linhas de código a mais", daria para fazer o bot executar ações como pausar, adiantar ou dar likes nos vídeos?

⚠️ Alerta: Certas tarefas de automatização devem ser usadas com cautela!!! Uma boa discussão sobre o assunto pode ser encontrada neste post .

Forem: msc2020

How to export a CSV with my data posts in DEV using its API

Contents ☕

DEV API, versions v0 and v1 [^]

Some API endpoints [^]

Getting data from the API [^]

Exporting collected data to CSV [^]

Tests using another username [^]

Conclusion [^]

Como exportar um CSV com dados dos meus posts no DEV usando sua API

Conteúdo ☕

API DEV, versões v0 e v1 [^]

Alguns endpoints da API [^]

Obtendo dados da API via Python [^]

Exportando os dados para CSV [^]

Testes usando outro nome de usuário [^]

Possibilidades de uso [^]

Conclusão [^]

Raspagem de dados de um site de notícias em pt-BR

Sumário ☕

Pré-requisitos ^

Coleta do conteúdo do HTML ^

Exemplo

Inspecionando o trecho HTML de interesse ^

Busca pela tag com o BeautifulSoup ^

Código completo

Sobre o robots.txt ^

Exemplos de uso da raspagem de dados rodando em produção ^

Querido Diário (https://queridodiario.ok.org.br)

Mini-app ^

Conclusão e próximos passos ^

Agradecemos a leitura! ☕ 💻 🗞️

Um "Hello World" em Deep Learning

Pré-requisitos

Dataset MNIST

Carregando o dataset

Histograma dos labels

Aplicando modelos de Machine Learning e Deep Learning

Modelo SGD

Modelo Multilayer Perceptron Classifier

Realizando as predições com os modelos treinados

Salvando e carregando um modelo

Teste com uma amostra aletória

Datasets semelhantes

Esperamos que tenham gostado e agradecemos a leitura!

Envio e recebimento de mensagens de texto dentro de imagens com Python

Pré-requisitos

Representação de um pixel RGB

Exemplo

Inserindo uma mensagem de texto em uma imagem RGB

Extraindo a mensagem de texto da imagem

Testes

Outras formas de inserir e extrair mensagens em imagem

Extração de metadados de imagens com Python

Um pouco sobre imagens e metadados

Como é formado um arquivo de imagem?

O que significa o prefixo meta?

Os metadados de uma imagem são obrigatórios?

Como extrair os metadados usando Python?

Hachoir

Observações sobre os metadados extraídos

Bot para assistir vídeos no YouTube

Instalação do Selenium

Chrome Driver

Script Python

Rodando o bot

Referências

Sobre o `robots.txt` ^