API Clima - Extrator de Dados Meteorológicos

Descrição

Este projeto é uma aplicação de automação robótica de processos (RPA) que extrai dados meteorológicos em tempo real de uma API externa, transforma-os conforme necessário, armazena em um banco de dados SQLite e apresenta os resultados de forma estruturada.

O projeto segue a arquitetura ETL (Extração, Transformação, Carga) com módulos bem separados e cobertura de testes unitários e de integração.

Estrutura do Projeto

API_Clima/
├── main.py                          # Ponto de entrada da aplicação
├── requirements.txt                 # Dependências do projeto
├── pytest.ini                        # Configuração do pytest
│
├── config/                          # Módulo de configuração
│   └── __init__.py
│
├── model/                           # Módulo de modelo de dados
│   ├── __init__.py
│   ├── database.py                  # Configuração da conexão com banco
│   └── table_clima.py               # Definição da tabela de clima
│
├── src/                             # Módulo principal da aplicação
│   ├── __init__.py
│   ├── extract.py                   # Extração de dados da API
│   ├── transform.py                 # Transformação e tratamento de dados
│   ├── load.py                      # Carga de dados no banco
│   └── output.py                    # Exibição de dados
│
├── tests/                           # Testes da aplicação
│   ├── __init__.py
│   ├── unit_tests.py                # Testes unitários
│   └── integration_tests.py         # Testes de integração

Pré-requisitos

• Python 3.7 ou superior
• pip (gerenciador de pacotes Python)

Instalação

1. Clone ou baixe o repositório

cd API_Clima

2. Instale as dependências

pip install -r requirements.txt

3. Configure as variáveis de ambiente

Crie um arquivo .env na raiz do projeto com as seguintes variáveis:

API_KEY=sua_chave_api_aqui

Como Usar

Execução Básica

python main.py

A aplicação irá:

1. Solicitar a cidade
2. Extrair dados de clima da API
3. Transformar os dados obtidos
4. Exibir os dados na tela
5. Armazenar os dados no banco de dados SQLite

Testes

Executar todos os testes

pytest

Executar apenas testes unitários

pytest tests/unit_tests.py

Executar apenas testes de integração

pytest tests/integration_tests.py

Executar com verbosidade

pytest -v

Executar com cobertura de código

pytest --cov=src --cov=model --cov-report=html

Módulos

src/extract.py

Responsável pela extração de dados:

• obter_cidade() - Obtém a cidade do usuário
• obter_api_key() - Obtém a chave da API
• obter_dados_clima() - Realiza a chamada à API de clima

src/transform.py

Responsável pela transformação de dados:

• filtrar_dados() - Filtra e processa os dados brutos da API
• calcular_horario_local() - Calcula o horário local baseado na timezone

src/load.py

Responsável pelo carregamento de dados:

• inserir_dados_clima() - Insere dados transformados no banco de dados

src/output.py

Responsável pela saída de dados:

• exibir_dados_clima() - Exibe os dados de forma formatada

model/database.py

Gerencia a conexão com o banco de dados SQLite:

• configurar_banco_dados() - Estabelece conexão e cria cursor

model/table_clima.py

Define a estrutura da tabela:

• criar_tabela_clima() - Cria a tabela de dados meteorológicos no banco

Dependências

Pacote	Versão	Propósito
requests	-	Requisições HTTP para a API
python-dotenv	-	Carregamento de variáveis de ambiente
pandas	-	Manipulação e análise de dados
pytest	-	Framework de testes
pytest-mock	-	Plugin para mocking em testes

Arquitetura

O projeto segue a arquitetura ETL (Extract, Transform, Load):

┌─────────────────────────────────────────────────────────────┐
│                    APLICAÇÃO API CLIMA                       │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌────────────┐    ┌────────────┐    ┌────────────┐         │
│  │  EXTRACT   │    │ TRANSFORM  │    │   LOAD     │         │
│  │            │───▶│            │───▶│            │         │
│  │ API Clima  │    │  Filtragem │    │ SQLite DB  │         │
│  └────────────┘    └────────────┘    └────────────┘         │
│                                              │                │
│                                              ▼                │
│                                       ┌────────────┐          │
│                                       │   OUTPUT   │          │
│                                       │            │          │
│                                       │  Exibição  │          │
│                                       └────────────┘          │
│                                                               │
└─────────────────────────────────────────────────────────────┘

Cobertura de Testes

A aplicação possui testes cobrindo:

Testes Unitários

• Extração de dados da API
• Transformação e tratamento de dados
• Exibição de dados
• Configuração do banco de dados
• Criação de tabelas
• Inserção de dados

Testes de Integração

• Fluxo completo de extração-transformação-carga
• Múltiplas cidades
• Criação e inserção de dados
• Tratamento de erros e exceções

Status do Projeto

• Estrutura base implementada
• Testes unitários e de integração
• Módulos separados (Extract, Transform, Load, Output)

Melhorias Futuras

1. Configuração e Segurança: Centralização de settings, validação de API key
2. Robustez da API: Timeout explícito, retry com backoff exponencial
3. Qualidade de Código: Lint, formatação, análise de tipos, CI/CD
4. Banco de Dados: Constraints, índices, prevenção de duplicidade
5. Observabilidade: Logging estruturado, CLI melhorada, exportação de dados

Licença

Este projeto é de código aberto e disponível sob a licença MIT.

Autor

Felipe Viana

---

Última atualização: Maio de 2026