Radar DOU

Este guia apresenta exemplos praticos de integracao com a API do Radar DOU utilizando Python, incluindo uso do SDK oficial, requisicoes diretas e integracao com pandas para analise de dados.

Instalacao do SDK

Instale o SDK oficial do Radar DOU via pip:

# Instalacao basica
pip install radardou

# Com dependencias para analise de dados
pip install radardou[pandas]

# Instalacao em ambiente virtual
python -m venv venv
source venv/bin/activate  # Linux/macOS
venv\Scripts\activate     # Windows
pip install radardou

Configuracao Inicial

Usando o SDK

import os
from radardou import RadarDOU

# Carregar API Key de variavel de ambiente
api_key = os.environ.get('RADAR_DOU_API_KEY')

# Inicializar o cliente
radar = RadarDOU(api_key=api_key)

# Ou com configuracoes adicionais
radar = RadarDOU(
    api_key=api_key,
    timeout=30,      # Timeout em segundos
    max_retries=3,   # Tentativas em caso de erro
    base_url='https://radardou.com.br/api/v1'  # URL base (opcional)
)

Usando Requests Diretamente

import os
import requests

API_KEY = os.environ.get('RADAR_DOU_API_KEY')
BASE_URL = 'https://radardou.com.br/api/v1'

def api_request(endpoint, params=None):
    """Funcao auxiliar para requisicoes a API."""
    headers = {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json'
    }

    response = requests.get(
        f'{BASE_URL}{endpoint}',
        headers=headers,
        params=params
    )

    response.raise_for_status()
    return response.json()

# Exemplo de uso
resultado = api_request('/buscar', {'termo': 'licitacao'})

Busca de Publicacoes

Busca Simples

from radardou import RadarDOU
import os

radar = RadarDOU(api_key=os.environ['RADAR_DOU_API_KEY'])

# Busca simples por termo
resultado = radar.buscar(termo='licitacao', limite=10)

print(f"Total encontrado: {resultado['total']}")
print(f"Pagina {resultado['pagina']} de {resultado['total_paginas']}")

for pub in resultado['resultados']:
    print(f"- {pub['titulo']}")
    print(f"  Data: {pub['data_publicacao']}")
    print(f"  Orgao: {pub['orgao']}")
    print()

Busca com Filtros Avancados

# Busca com multiplos filtros
resultado = radar.buscar(
    termo='contrato administrativo',
    data_inicio='2024-01-01',
    data_fim='2024-06-30',
    secao='3',
    orgao='Ministerio da Saude',
    tipo_ato='Extrato de Contrato',
    limite=50,
    pagina=1
)

# Filtrar por palavras exatas usando aspas
resultado = radar.buscar(
    termo='"pregao eletronico" licitacao',
    secao='3'
)

# Excluir termos usando operador -
resultado = radar.buscar(
    termo='licitacao -dispensa -inexigibilidade'
)

Paginacao e Coleta de Todos os Resultados

import time

def buscar_todos(termo, **filtros):
    """Coleta todas as publicacoes de uma busca paginada."""
    todas_publicacoes = []
    pagina = 1

    while True:
        resultado = radar.buscar(
            termo=termo,
            pagina=pagina,
            limite=100,  # Maximo permitido
            **filtros
        )

        todas_publicacoes.extend(resultado['resultados'])

        print(f"Pagina {pagina}/{resultado['total_paginas']} - "
              f"{len(todas_publicacoes)}/{resultado['total']} coletados")

        if pagina >= resultado['total_paginas']:
            break

        pagina += 1
        # Respeitar rate limit
        time.sleep(0.1)

    return todas_publicacoes

# Uso
publicacoes = buscar_todos(
    termo='pregao eletronico',
    data_inicio='2024-01-01',
    secao='3'
)

print(f"Total coletado: {len(publicacoes)}")

Obtendo Detalhes de uma Publicacao

def obter_detalhes(publicacao_id):
    """Obtem detalhes completos de uma publicacao."""
    try:
        pub = radar.publicacao(publicacao_id)

        print("=" * 50)
        print(f"Titulo: {pub['titulo']}")
        print(f"Data: {pub['data_publicacao']}")
        print(f"Secao: {pub['secao']} | Pagina: {pub['pagina']}")
        print(f"Edicao: {pub['edicao']}")
        print(f"Orgao: {pub['orgao']}")
        print(f"Tipo: {pub['tipo_ato']}")
        print("-" * 50)
        print("Conteudo:")
        print(pub['conteudo_completo'])
        print("-" * 50)
        print(f"Assinatura: {pub.get('assinatura', 'N/A')}")
        print(f"URL Original: {pub['url_original']}")

        if pub.get('publicacoes_relacionadas'):
            print(f"Relacionadas: {pub['publicacoes_relacionadas']}")

        return pub

    except Exception as e:
        print(f"Erro ao obter publicacao: {e}")
        return None

# Uso
detalhes = obter_detalhes('pub_abc123')

Integracao com Pandas

import pandas as pd
from radardou import RadarDOU
import os

radar = RadarDOU(api_key=os.environ['RADAR_DOU_API_KEY'])

# Buscar e converter para DataFrame
resultado = radar.buscar(termo='licitacao', limite=100)
df = pd.DataFrame(resultado['resultados'])

# Converter data para datetime
df['data_publicacao'] = pd.to_datetime(df['data_publicacao'])

# Analises basicas
print("Publicacoes por orgao:")
print(df['orgao'].value_counts().head(10))

print("\nPublicacoes por secao:")
print(df['secao'].value_counts())

print("\nDistribuicao por mes:")
print(df.groupby(df['data_publicacao'].dt.to_period('M')).size())

# Filtrar DataFrame
contratos = df[df['tipo_ato'].str.contains('Contrato', na=False)]

# Exportar para CSV
df.to_csv('publicacoes_licitacao.csv', index=False, encoding='utf-8-sig')

# Exportar para Excel
df.to_excel('publicacoes_licitacao.xlsx', index=False)

Extracao e Analise de Valores

import re
import pandas as pd

def extrair_valor(texto):
    """Extrai valor monetario do texto."""
    if not texto:
        return None

    # Padrao para valores em reais
    padrao = r'R\$\s*([\d.,]+)'
    match = re.search(padrao, texto)

    if match:
        valor_str = match.group(1)
        # Converter para float
        valor_str = valor_str.replace('.', '').replace(',', '.')
        try:
            return float(valor_str)
        except ValueError:
            return None
    return None

# Aplicar extracao no DataFrame
df['valor'] = df['resumo'].apply(extrair_valor)

# Estatisticas de valores
valores_validos = df[df['valor'].notna()]
print(f"Publicacoes com valor: {len(valores_validos)}")
print(f"Valor total: R$ {valores_validos['valor'].sum():,.2f}")
print(f"Valor medio: R$ {valores_validos['valor'].mean():,.2f}")
print(f"Valor maximo: R$ {valores_validos['valor'].max():,.2f}")

# Top 10 maiores valores
top_10 = valores_validos.nlargest(10, 'valor')[['titulo', 'orgao', 'valor']]
print("\nTop 10 maiores valores:")
print(top_10.to_string())

Monitoramento Automatizado

import json
import smtplib
from email.mime.text import MIMEText
from datetime import date, timedelta
from radardou import RadarDOU
import os

radar = RadarDOU(api_key=os.environ['RADAR_DOU_API_KEY'])

# Arquivo para rastrear publicacoes ja processadas
ARQUIVO_PROCESSADOS = 'publicacoes_processadas.json'

def carregar_processados():
    try:
        with open(ARQUIVO_PROCESSADOS, 'r') as f:
            return set(json.load(f))
    except FileNotFoundError:
        return set()

def salvar_processados(ids):
    with open(ARQUIVO_PROCESSADOS, 'w') as f:
        json.dump(list(ids), f)

def enviar_email(assunto, corpo, destinatario):
    """Envia email de notificacao."""
    msg = MIMEText(corpo)
    msg['Subject'] = assunto
    msg['From'] = os.environ['EMAIL_FROM']
    msg['To'] = destinatario

    with smtplib.SMTP(os.environ['SMTP_SERVER'], 587) as server:
        server.starttls()
        server.login(os.environ['EMAIL_USER'], os.environ['EMAIL_PASS'])
        server.send_message(msg)

def monitorar_termos(termos, destinatario_email):
    """Monitora lista de termos e notifica sobre novas publicacoes."""
    processados = carregar_processados()
    novas_publicacoes = []

    for termo in termos:
        resultado = radar.buscar(
            termo=termo,
            data_inicio=str(date.today() - timedelta(days=1)),
            limite=100
        )

        for pub in resultado['resultados']:
            if pub['id'] not in processados:
                novas_publicacoes.append(pub)
                processados.add(pub['id'])

    if novas_publicacoes:
        # Criar corpo do email
        corpo = f"Encontradas {len(novas_publicacoes)} novas publicacoes:\n\n"
        for pub in novas_publicacoes:
            corpo += f"- {pub['titulo']}\n"
            corpo += f"  Data: {pub['data_publicacao']}\n"
            corpo += f"  Orgao: {pub['orgao']}\n\n"

        enviar_email(
            assunto=f'[Radar DOU] {len(novas_publicacoes)} novas publicacoes',
            corpo=corpo,
            destinatario=destinatario_email
        )

    salvar_processados(processados)
    return novas_publicacoes

# Uso - pode ser agendado via cron ou scheduler
termos_monitorados = ['licitacao saude', 'pregao eletronico', 'contrato emergencial']
novas = monitorar_termos(termos_monitorados, 'seuemail@empresa.com')

Tratamento de Erros

from radardou import RadarDOU
from radardou.exceptions import (
    RadarDOUError,
    AuthenticationError,
    RateLimitError,
    NotFoundError
)
import time

def buscar_com_retry(radar, termo, max_tentativas=3):
    """Busca com tratamento de erros e retry automatico."""

    for tentativa in range(max_tentativas):
        try:
            return radar.buscar(termo=termo)

        except AuthenticationError as e:
            print(f"Erro de autenticacao: {e}")
            print("Verifique se sua API Key esta correta")
            raise

        except RateLimitError as e:
            if tentativa < max_tentativas - 1:
                tempo_espera = e.retry_after or (2 ** tentativa)
                print(f"Rate limit excedido. Aguardando {tempo_espera}s...")
                time.sleep(tempo_espera)
            else:
                raise

        except NotFoundError as e:
            print(f"Recurso nao encontrado: {e}")
            return None

        except RadarDOUError as e:
            print(f"Erro da API [{e.status_code}]: {e.message}")
            print(f"Request ID: {e.request_id}")
            if tentativa < max_tentativas - 1:
                time.sleep(2 ** tentativa)
            else:
                raise

        except Exception as e:
            print(f"Erro inesperado: {e}")
            raise

# Uso
radar = RadarDOU(api_key=os.environ['RADAR_DOU_API_KEY'])
resultado = buscar_com_retry(radar, 'licitacao')

Boas Praticas

Recomendacoes

Use variaveis de ambiente para a API Key (nunca hardcode)
Implemente cache para consultas frequentes
Respeite os rate limits com delays entre requisicoes
Use ambientes virtuais (venv) para isolar dependencias
Implemente logging para debug e monitoramento
Valide dados de entrada antes de enviar a API

Estrutura de Projeto Recomendada

meu_projeto/
├── .env                    # Variaveis de ambiente (nao commitar!)
├── .gitignore
├── requirements.txt
├── config.py               # Configuracoes do projeto
├── radar_client.py         # Cliente configurado do Radar DOU
├── monitoramento.py        # Scripts de monitoramento
├── analise.py              # Scripts de analise de dados
└── notebooks/
    └── exploracao.ipynb    # Jupyter notebooks para exploracao

# .env
RADAR_DOU_API_KEY=rdou_live_sua_chave_aqui
SMTP_SERVER=smtp.seuservidor.com
EMAIL_USER=usuario
EMAIL_PASS=senha

# .gitignore
.env
*.pyc
__pycache__/
venv/
*.csv
*.xlsx

Precisa de ajuda? Consulte a documentacao completa do SDK Python no repositorio oficial ou use nosso assistente virtual para tirar duvidas sobre a integracao.

Exemplos em Python