agrobr 0.1.0__py3-none-any.whl

agrobr/normalize/units.py

@@ -0,0 +1,278 @@
+"""
+Conversão de unidades agrícolas.
+
+Suporta conversões entre:
+- Sacas (sc) de diferentes pesos
+- Toneladas (ton/t)
+- Bushels (bu)
+- Quilogramas (kg)
+- Arrobas (@)
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Literal
+
+UnidadeOrigem = Literal[
+    "sc60kg",
+    "sc50kg",
+    "sc40kg",
+    "ton",
+    "t",
+    "kg",
+    "bu",
+    "bushel",
+    "arroba",
+    "@",
+    "mil_ton",
+    "mil_t",
+    "mil_ha",
+    "ha",
+]
+
+UnidadeDestino = UnidadeOrigem
+
+PESO_SACA_KG: dict[str, Decimal] = {
+    "sc60kg": Decimal("60"),
+    "sc50kg": Decimal("50"),
+    "sc40kg": Decimal("40"),
+}
+
+PESO_BUSHEL_KG: dict[str, Decimal] = {
+    "soja": Decimal("27.2155"),
+    "milho": Decimal("25.4012"),
+    "trigo": Decimal("27.2155"),
+}
+
+PESO_ARROBA_KG = Decimal("15")
+
+FATORES_CONVERSAO: dict[tuple[str, str], Decimal] = {
+    ("kg", "ton"): Decimal("0.001"),
+    ("ton", "kg"): Decimal("1000"),
+    ("kg", "t"): Decimal("0.001"),
+    ("t", "kg"): Decimal("1000"),
+    ("kg", "sc60kg"): Decimal("1") / Decimal("60"),
+    ("sc60kg", "kg"): Decimal("60"),
+    ("kg", "sc50kg"): Decimal("1") / Decimal("50"),
+    ("sc50kg", "kg"): Decimal("50"),
+    ("ton", "sc60kg"): Decimal("1000") / Decimal("60"),
+    ("sc60kg", "ton"): Decimal("60") / Decimal("1000"),
+    ("t", "sc60kg"): Decimal("1000") / Decimal("60"),
+    ("sc60kg", "t"): Decimal("60") / Decimal("1000"),
+    ("kg", "arroba"): Decimal("1") / Decimal("15"),
+    ("arroba", "kg"): Decimal("15"),
+    ("kg", "@"): Decimal("1") / Decimal("15"),
+    ("@", "kg"): Decimal("15"),
+    ("arroba", "@"): Decimal("1"),
+    ("@", "arroba"): Decimal("1"),
+    ("ton", "arroba"): Decimal("1000") / Decimal("15"),
+    ("arroba", "ton"): Decimal("15") / Decimal("1000"),
+    ("mil_ton", "ton"): Decimal("1000"),
+    ("ton", "mil_ton"): Decimal("0.001"),
+    ("mil_t", "t"): Decimal("1000"),
+    ("t", "mil_t"): Decimal("0.001"),
+    ("mil_ha", "ha"): Decimal("1000"),
+    ("ha", "mil_ha"): Decimal("0.001"),
+}
+
+
+def converter(
+    valor: Decimal | float | int,
+    de: UnidadeOrigem,
+    para: UnidadeDestino,
+    produto: str | None = None,
+) -> Decimal:
+    """
+    Converte valor entre unidades.
+
+    Args:
+        valor: Valor a converter
+        de: Unidade de origem
+        para: Unidade de destino
+        produto: Produto (necessário para conversões com bushel)
+
+    Returns:
+        Valor convertido como Decimal
+
+    Raises:
+        ValueError: Se conversão não suportada
+
+    Examples:
+        >>> converter(100, 'sc60kg', 'ton')
+        Decimal('6.0')
+
+        >>> converter(1, 'ton', 'sc60kg')
+        Decimal('16.666...')
+
+        >>> converter(100, 'kg', 'arroba')
+        Decimal('6.666...')
+    """
+    if not isinstance(valor, Decimal):
+        valor = Decimal(str(valor))
+
+    de_norm = _normalizar_unidade(de)
+    para_norm = _normalizar_unidade(para)
+
+    if de_norm == para_norm:
+        return valor
+
+    if de_norm in ("bu", "bushel") or para_norm in ("bu", "bushel"):
+        return _converter_bushel(valor, de_norm, para_norm, produto)
+
+    chave = (de_norm, para_norm)
+    if chave in FATORES_CONVERSAO:
+        return valor * FATORES_CONVERSAO[chave]
+
+    valor_kg = _para_kg(valor, de_norm)
+    return _de_kg(valor_kg, para_norm)
+
+
+def _normalizar_unidade(unidade: str) -> str:
+    """Normaliza nome da unidade."""
+    unidade = unidade.lower().strip()
+
+    aliases = {
+        "t": "ton",
+        "tonelada": "ton",
+        "toneladas": "ton",
+        "quilograma": "kg",
+        "quilogramas": "kg",
+        "saca": "sc60kg",
+        "sacas": "sc60kg",
+        "bushel": "bu",
+        "bushels": "bu",
+        "@": "arroba",
+        "arrobas": "arroba",
+        "mil_t": "mil_ton",
+        "hectare": "ha",
+        "hectares": "ha",
+    }
+
+    return aliases.get(unidade, unidade)
+
+
+def _para_kg(valor: Decimal, unidade: str) -> Decimal:
+    """Converte qualquer unidade para kg."""
+    if unidade == "kg":
+        return valor
+    if unidade == "ton":
+        return valor * Decimal("1000")
+    if unidade == "mil_ton":
+        return valor * Decimal("1000000")
+    if unidade in PESO_SACA_KG:
+        return valor * PESO_SACA_KG[unidade]
+    if unidade == "sc60kg":
+        return valor * Decimal("60")
+    if unidade == "arroba":
+        return valor * PESO_ARROBA_KG
+
+    raise ValueError(f"Conversão de '{unidade}' para kg não suportada")
+
+
+def _de_kg(valor_kg: Decimal, unidade: str) -> Decimal:
+    """Converte kg para qualquer unidade."""
+    if unidade == "kg":
+        return valor_kg
+    if unidade == "ton":
+        return valor_kg / Decimal("1000")
+    if unidade == "mil_ton":
+        return valor_kg / Decimal("1000000")
+    if unidade in PESO_SACA_KG:
+        return valor_kg / PESO_SACA_KG[unidade]
+    if unidade == "sc60kg":
+        return valor_kg / Decimal("60")
+    if unidade == "arroba":
+        return valor_kg / PESO_ARROBA_KG
+
+    raise ValueError(f"Conversão de kg para '{unidade}' não suportada")
+
+
+def _converter_bushel(
+    valor: Decimal,
+    de: str,
+    para: str,
+    produto: str | None,
+) -> Decimal:
+    """Converte envolvendo bushels (requer produto)."""
+    if produto is None:
+        raise ValueError("Produto é necessário para conversões com bushel")
+
+    produto_norm = produto.lower()
+    if produto_norm not in PESO_BUSHEL_KG:
+        raise ValueError(f"Peso do bushel para '{produto}' não definido")
+
+    peso_bu = PESO_BUSHEL_KG[produto_norm]
+
+    if de in ("bu", "bushel"):
+        valor_kg = valor * peso_bu
+        return _de_kg(valor_kg, para)
+    else:
+        valor_kg = _para_kg(valor, de)
+        return valor_kg / peso_bu
+
+
+def sacas_para_toneladas(sacas: Decimal | float, peso_saca_kg: int = 60) -> Decimal:
+    """
+    Converte sacas para toneladas.
+
+    Args:
+        sacas: Quantidade de sacas
+        peso_saca_kg: Peso da saca em kg (default: 60)
+
+    Returns:
+        Toneladas
+    """
+    if not isinstance(sacas, Decimal):
+        sacas = Decimal(str(sacas))
+    return sacas * Decimal(str(peso_saca_kg)) / Decimal("1000")
+
+
+def toneladas_para_sacas(toneladas: Decimal | float, peso_saca_kg: int = 60) -> Decimal:
+    """
+    Converte toneladas para sacas.
+
+    Args:
+        toneladas: Quantidade em toneladas
+        peso_saca_kg: Peso da saca em kg (default: 60)
+
+    Returns:
+        Sacas
+    """
+    if not isinstance(toneladas, Decimal):
+        toneladas = Decimal(str(toneladas))
+    return toneladas * Decimal("1000") / Decimal(str(peso_saca_kg))
+
+
+def preco_saca_para_tonelada(preco_saca: Decimal | float, peso_saca_kg: int = 60) -> Decimal:
+    """
+    Converte preço por saca para preço por tonelada.
+
+    Args:
+        preco_saca: Preço por saca (R$/sc)
+        peso_saca_kg: Peso da saca em kg (default: 60)
+
+    Returns:
+        Preço por tonelada (R$/t)
+    """
+    if not isinstance(preco_saca, Decimal):
+        preco_saca = Decimal(str(preco_saca))
+    sacas_por_ton = Decimal("1000") / Decimal(str(peso_saca_kg))
+    return preco_saca * sacas_por_ton
+
+
+def preco_tonelada_para_saca(preco_ton: Decimal | float, peso_saca_kg: int = 60) -> Decimal:
+    """
+    Converte preço por tonelada para preço por saca.
+
+    Args:
+        preco_ton: Preço por tonelada (R$/t)
+        peso_saca_kg: Peso da saca em kg (default: 60)
+
+    Returns:
+        Preço por saca (R$/sc)
+    """
+    if not isinstance(preco_ton, Decimal):
+        preco_ton = Decimal(str(preco_ton))
+    sacas_por_ton = Decimal("1000") / Decimal(str(peso_saca_kg))
+    return preco_ton / sacas_por_ton

agrobr/noticias_agricolas/__init__.py

@@ -0,0 +1,6 @@
+"""Módulo para coleta de dados do Notícias Agrícolas (fonte alternativa CEPEA)."""
+
+from agrobr.noticias_agricolas.client import fetch_indicador_page
+from agrobr.noticias_agricolas.parser import parse_indicador
+
+__all__ = ["fetch_indicador_page", "parse_indicador"]

agrobr/noticias_agricolas/client.py

@@ -0,0 +1,222 @@
+"""Cliente HTTP async para Notícias Agrícolas (fonte alternativa CEPEA).
+
+Nota: Este site carrega dados via JavaScript/AJAX, então usa Playwright por padrão.
+"""
+
+from __future__ import annotations
+
+import httpx
+import structlog
+
+from agrobr import constants
+from agrobr.exceptions import SourceUnavailableError
+from agrobr.http.rate_limiter import RateLimiter
+from agrobr.http.retry import retry_async, should_retry_status
+from agrobr.http.user_agents import UserAgentRotator
+from agrobr.normalize.encoding import decode_content
+
+logger = structlog.get_logger()
+
+# Por padrão usa browser pois a página carrega dados via AJAX
+_use_browser: bool = True
+
+
+def _get_timeout() -> httpx.Timeout:
+    """Retorna configuração de timeout."""
+    settings = constants.HTTPSettings()
+    return httpx.Timeout(
+        connect=settings.timeout_connect,
+        read=settings.timeout_read,
+        write=settings.timeout_write,
+        pool=settings.timeout_pool,
+    )
+
+
+def _get_produto_url(produto: str) -> str:
+    """Retorna URL do indicador para o produto."""
+    produto_key = constants.NOTICIAS_AGRICOLAS_PRODUTOS.get(produto.lower())
+    if produto_key is None:
+        raise ValueError(
+            f"Produto '{produto}' não disponível no Notícias Agrícolas. "
+            f"Produtos disponíveis: {list(constants.NOTICIAS_AGRICOLAS_PRODUTOS.keys())}"
+        )
+    base = constants.URLS[constants.Fonte.NOTICIAS_AGRICOLAS]["cotacoes"]
+    return f"{base}/{produto_key}"
+
+
+def set_use_browser(enabled: bool) -> None:
+    """Habilita ou desabilita uso de browser para Notícias Agrícolas."""
+    global _use_browser
+    _use_browser = enabled
+    logger.info("noticias_agricolas_browser_mode", enabled=enabled)
+
+
+async def _fetch_with_browser(url: str, produto: str) -> str:
+    """Busca usando Playwright (necessário pois página carrega dados via AJAX)."""
+    from agrobr.http.browser import get_page
+
+    logger.info(
+        "browser_fetch",
+        source="noticias_agricolas",
+        url=url,
+        produto=produto,
+    )
+
+    try:
+        async with get_page() as page:
+            response = await page.goto(
+                url,
+                wait_until="domcontentloaded",
+                timeout=30000,
+            )
+
+            if response is None:
+                raise SourceUnavailableError(
+                    source="noticias_agricolas",
+                    url=url,
+                    last_error="No response received",
+                )
+
+            # Aguarda tabela de cotações carregar
+            try:
+                await page.wait_for_selector(
+                    "table.cot-fisicas",
+                    timeout=15000,
+                )
+            except Exception:
+                # Tenta seletor alternativo
+                await page.wait_for_selector(
+                    "table",
+                    timeout=10000,
+                )
+
+            # Aguarda AJAX terminar
+            await page.wait_for_timeout(2000)
+
+            html: str = await page.content()
+
+            logger.info(
+                "browser_fetch_success",
+                source="noticias_agricolas",
+                url=url,
+                content_length=len(html),
+                status=response.status,
+            )
+
+            return html
+
+    except Exception as e:
+        logger.error(
+            "browser_fetch_failed",
+            source="noticias_agricolas",
+            url=url,
+            error=str(e),
+        )
+        raise SourceUnavailableError(
+            source="noticias_agricolas",
+            url=url,
+            last_error=str(e),
+        ) from e
+
+
+async def _fetch_with_httpx(url: str) -> str:
+    """Busca usando httpx (pode não ter todos os dados se página usa AJAX)."""
+    headers = UserAgentRotator.get_headers(source="noticias_agricolas")
+
+    async def _fetch() -> httpx.Response:
+        async with (
+            RateLimiter.acquire(constants.Fonte.NOTICIAS_AGRICOLAS),
+            httpx.AsyncClient(
+                timeout=_get_timeout(),
+                follow_redirects=True,
+            ) as client,
+        ):
+            response = await client.get(url, headers=headers)
+
+            if should_retry_status(response.status_code):
+                raise httpx.HTTPStatusError(
+                    f"Retriable status: {response.status_code}",
+                    request=response.request,
+                    response=response,
+                )
+
+            response.raise_for_status()
+            return response
+
+    response = await retry_async(_fetch)
+
+    declared_encoding = response.charset_encoding
+    html, actual_encoding = decode_content(
+        response.content,
+        declared_encoding=declared_encoding,
+        source="noticias_agricolas",
+    )
+
+    logger.info(
+        "http_response",
+        source="noticias_agricolas",
+        status_code=response.status_code,
+        content_length=len(response.content),
+        encoding=actual_encoding,
+        method="httpx",
+    )
+
+    return html
+
+
+async def fetch_indicador_page(produto: str, force_httpx: bool = False) -> str:
+    """
+    Busca página de indicador CEPEA via Notícias Agrícolas.
+
+    Esta é uma fonte alternativa que republica dados CEPEA/ESALQ
+    sem proteção Cloudflare. Por padrão usa Playwright pois a página
+    carrega dados via JavaScript/AJAX.
+
+    Args:
+        produto: Nome do produto (soja, milho, boi, cafe, algodao, trigo)
+        force_httpx: Se True, usa httpx ao invés de browser (pode faltar dados)
+
+    Returns:
+        HTML da página como string
+
+    Raises:
+        SourceUnavailableError: Se não conseguir acessar após retries
+        ValueError: Se o produto não estiver disponível
+    """
+    url = _get_produto_url(produto)
+
+    logger.info(
+        "http_request",
+        source="noticias_agricolas",
+        url=url,
+        method="GET",
+        produto=produto,
+    )
+
+    # Por padrão usa browser pois a página carrega dados via AJAX
+    if not force_httpx and _use_browser:
+        try:
+            return await _fetch_with_browser(url, produto)
+        except SourceUnavailableError:
+            logger.warning(
+                "browser_failed_trying_httpx",
+                source="noticias_agricolas",
+                url=url,
+            )
+            # Fallback para httpx
+
+    # Tenta httpx (pode ter dados incompletos)
+    try:
+        return await _fetch_with_httpx(url)
+    except httpx.HTTPError as e:
+        logger.error(
+            "http_request_failed",
+            source="noticias_agricolas",
+            url=url,
+            error=str(e),
+        )
+        raise SourceUnavailableError(
+            source="noticias_agricolas",
+            url=url,
+            last_error=str(e),
+        ) from e

agrobr/noticias_agricolas/parser.py

@@ -0,0 +1,187 @@
+"""Parser para indicadores CEPEA via Notícias Agrícolas."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from decimal import Decimal, InvalidOperation
+
+import structlog
+from bs4 import BeautifulSoup
+
+from agrobr.constants import Fonte
+from agrobr.models import Indicador
+
+logger = structlog.get_logger()
+
+# Mapeamento de produtos para unidades
+UNIDADES = {
+    "soja": "BRL/sc60kg",
+    "soja_parana": "BRL/sc60kg",
+    "milho": "BRL/sc60kg",
+    "boi": "BRL/@",
+    "boi_gordo": "BRL/@",
+    "cafe": "BRL/sc60kg",
+    "cafe_arabica": "BRL/sc60kg",
+    "algodao": "BRL/@",
+    "trigo": "BRL/ton",
+}
+
+# Mapeamento de produtos para praça
+PRACAS = {
+    "soja": "Paranaguá/PR",
+    "soja_parana": "Paraná",
+    "milho": "Campinas/SP",
+    "boi": "São Paulo/SP",
+    "boi_gordo": "São Paulo/SP",
+    "cafe": "São Paulo/SP",
+    "cafe_arabica": "São Paulo/SP",
+    "algodao": "São Paulo/SP",
+    "trigo": "Paraná",
+}
+
+
+def _parse_date(date_str: str) -> datetime | None:
+    """Converte string de data para datetime."""
+    date_str = date_str.strip()
+
+    # Formato: DD/MM/YYYY
+    match = re.match(r"(\d{2})/(\d{2})/(\d{4})", date_str)
+    if match:
+        day, month, year = match.groups()
+        try:
+            return datetime(int(year), int(month), int(day))
+        except ValueError:
+            return None
+
+    return None
+
+
+def _parse_valor(valor_str: str) -> Decimal | None:
+    """Converte string de valor para Decimal."""
+    valor_str = valor_str.strip()
+
+    # Remove "R$" e espaços
+    valor_str = re.sub(r"R\$\s*", "", valor_str)
+
+    # Substitui vírgula por ponto
+    valor_str = valor_str.replace(".", "").replace(",", ".")
+
+    try:
+        return Decimal(valor_str)
+    except InvalidOperation:
+        return None
+
+
+def _parse_variacao(var_str: str) -> Decimal | None:
+    """Converte string de variação para Decimal."""
+    var_str = var_str.strip()
+
+    # Remove % e espaços
+    var_str = re.sub(r"[%\s]", "", var_str)
+
+    # Substitui vírgula por ponto
+    var_str = var_str.replace(",", ".")
+
+    try:
+        return Decimal(var_str)
+    except InvalidOperation:
+        return None
+
+
+def parse_indicador(html: str, produto: str) -> list[Indicador]:
+    """
+    Faz parse do HTML do Notícias Agrícolas e extrai indicadores CEPEA.
+
+    Args:
+        html: HTML da página
+        produto: Nome do produto (soja, milho, boi, etc)
+
+    Returns:
+        Lista de objetos Indicador
+    """
+    soup = BeautifulSoup(html, "lxml")
+    indicadores: list[Indicador] = []
+
+    produto_lower = produto.lower()
+    unidade = UNIDADES.get(produto_lower, "BRL/unidade")
+    praca = PRACAS.get(produto_lower)
+
+    # Estrutura do Notícias Agrícolas:
+    # Tabela com classe "cot-fisicas" ou tabelas genéricas
+    # Headers: Data | Valor R$ | Variação (%)
+
+    # Primeiro tenta tabela específica de cotações
+    tables = soup.find_all("table", class_="cot-fisicas")
+
+    # Se não encontrar, tenta todas as tabelas
+    if not tables:
+        tables = soup.find_all("table")
+
+    for table in tables:
+        # Verifica se é tabela de cotação
+        headers = table.find_all("th")
+        header_text = " ".join(h.get_text(strip=True).lower() for h in headers)
+
+        if "data" not in header_text or "valor" not in header_text:
+            continue
+
+        # Extrai todas as linhas de dados (tbody > tr)
+        tbody = table.find("tbody")
+        rows = tbody.find_all("tr") if tbody else table.find_all("tr")[1:]
+
+        for row in rows:
+            cells = row.find_all("td")
+
+            if len(cells) < 2:
+                continue
+
+            # Extrai data e valor
+            data_str = cells[0].get_text(strip=True)
+            valor_str = cells[1].get_text(strip=True)
+
+            data = _parse_date(data_str)
+            valor = _parse_valor(valor_str)
+
+            if data is None or valor is None:
+                logger.warning(
+                    "parse_row_failed",
+                    source="noticias_agricolas",
+                    data_str=data_str,
+                    valor_str=valor_str,
+                )
+                continue
+
+            # Extrai variação se disponível
+            meta: dict[str, str | float] = {}
+            if len(cells) >= 3:
+                var_str = cells[2].get_text(strip=True)
+                variacao = _parse_variacao(var_str)
+                if variacao is not None:
+                    meta["variacao_percentual"] = float(variacao)
+
+            meta["fonte_original"] = "CEPEA/ESALQ"
+            meta["via"] = "Notícias Agrícolas"
+
+            indicador = Indicador(
+                fonte=Fonte.NOTICIAS_AGRICOLAS,
+                produto=produto_lower,
+                praca=praca,
+                data=data.date(),
+                valor=valor,
+                unidade=unidade,
+                metodologia="CEPEA/ESALQ via Notícias Agrícolas",
+                meta=meta,
+                parser_version=1,
+            )
+
+            indicadores.append(indicador)
+
+    logger.info(
+        "parse_complete",
+        source="noticias_agricolas",
+        produto=produto,
+        count=len(indicadores),
+    )
+
+    return indicadores