bps-kit 1.0.1 → 1.0.2

package/templates/vault/junta-leiloeiros/scripts/scraper/jucisrs.py

@@ -0,0 +1,299 @@
+"""
+Scraper JUCISRS — Junta Comercial, Industrial e Servicos do Rio Grande do Sul
+URL: https://sistemas.jucisrs.rs.gov.br/leiloeiros/
+Metodo: httpx POST com verify=False (SSL invalido mas conteudo OK)
+Mecanismo real descoberto em 2026-02-25:
+  - GET  https://sistemas.jucisrs.rs.gov.br/leiloeiros/
+         -> retorna formulario de busca PHP/Bootstrap
+  - POST https://sistemas.jucisrs.rs.gov.br/leiloeiros/busca/listar
+         com Nome=Todos (retorna todos os 376 registros)
+Estrutura HTML: <b><font color="#A01A14">MATRICULA</font> - NOME<br>
+  separados por <hr> entre entradas
+Total: 376 leiloeiros (261 ativos + 111 cancelados)
+Nota: Antigo dominio jucers.rs.gov.br foi aposentado. Junta renomeada para JUCISRS.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+logger = logging.getLogger(__name__)
+
+# Regex para extrair dados do formato plano JUCISRS
+RE_MATRICULA_NOME = re.compile(r"(\d+)\s*-\s*(.+)")
+RE_POSSE = re.compile(r"[Pp]osse\s*:\s*(\d{2}/\d{2}/\d{4})")
+RE_TELEFONE = re.compile(r"[Tt]elefone\s*:\s*(.+)")
+RE_EMAIL = re.compile(r"[Ee]-[Mm]ail\s*:\s*(.+)")
+RE_PREPOSTO = re.compile(r"[Pp]reposto\s*:\s*(.+)")
+RE_CEP = re.compile(r"CEP\s+([\d.]+)")
+RE_CANCELADO = re.compile(r"CANCELAD|CANCELAMENTO|canc\.", re.IGNORECASE)
+RE_CIDADE_UF = re.compile(r"^([A-ZÁÉÍÓÚÀÃÕÇ][A-ZÁÉÍÓÚÀÃÕÇ\s]+)\s+-\s+RS$")
+
+
+class JucisrsScraper(AbstractJuntaScraper):
+    estado = "RS"
+    junta = "JUCISRS"
+    url = "https://sistemas.jucisrs.rs.gov.br/leiloeiros/"
+    url_fallback = "https://jucisrs.rs.gov.br/leiloeiro"
+
+    _POST_URL = "https://sistemas.jucisrs.rs.gov.br/leiloeiros/busca/listar"
+
+    def _parse_plain_html(self, html: str) -> List[dict]:
+        """
+        Parseia o formato plano HTML da JUCISRS.
+        Toda a lista esta dentro de um unico grande <b> com <hr> como separadores.
+        Estrutura por entrada (separada por <hr/>):
+          <font color="#A01A14">173</font> - NOME<br/>
+          [www.site.com.br<br/>]
+          <b>Posse : </b>DD/MM/AAAA<br/>
+          ENDERECO<br/>
+          CIDADE - RS<br/>
+          CEP XXXXX-XXX<br/>
+          Telefone : XXXXX<br/>
+          e-Mail : xxx@yyy<br/>
+          Preposto : NOME<hr/>
+        """
+        from bs4 import BeautifulSoup
+
+        records = []
+
+        # Dividir o HTML bruto pelo separador <hr> ou <hr/>
+        # Isso e mais confiavel que navegar o DOM pois o <b> gigante contem tudo
+        blocks = re.split(r"<hr\s*/?>", html, flags=re.IGNORECASE)
+        logger.debug("[RS] Total de blocos (separados por <hr>): %d", len(blocks))
+
+        for block in blocks:
+            if not block.strip():
+                continue
+
+            # Parsear o bloco como HTML para extrair texto estruturado
+            block_soup = BeautifulSoup(block, "lxml")
+            lines_raw = block_soup.get_text("\n").splitlines()
+            lines = [l.strip() for l in lines_raw if l.strip()]
+
+            if not lines:
+                continue
+
+            # Primeira linha com matricula e nome: "NNN - NOME SOBRENOME"
+            # NOTA: O <font> de cor separa matricula e nome em linhas distintas:
+            #   lines[0] = "365"  (matricula dentro do <font>)
+            #   lines[1] = "- ADAIR ABRAAO..."  (nome apos o <font>)
+            # Precisamos reconhecer e juntar esses dois fragmentos.
+            nome = None
+            matricula = None
+            situacao = None
+            remaining = []
+
+            for i, line in enumerate(lines):
+                # Padrao 1: matricula e nome na mesma linha "365 - NOME"
+                m = RE_MATRICULA_NOME.match(line)
+                if m:
+                    matricula = m.group(1)
+                    nome_raw = m.group(2).strip()
+                    if RE_CANCELADO.search(nome_raw):
+                        situacao = "CANCELADO"
+                        nome_raw = RE_CANCELADO.sub("", nome_raw).strip(" ")
+                    nome = self.clean(nome_raw)
+                    remaining = lines[i+1:]
+                    break
+                # Padrao 2: so matricula (numero puro), proximo e "- NOME"
+                if line.isdigit() and i + 1 < len(lines):
+                    next_line = lines[i+1]
+                    if next_line.startswith("- ") or next_line.startswith("– "):
+                        matricula = line
+                        nome_raw = next_line[2:].strip()
+                        if RE_CANCELADO.search(nome_raw):
+                            situacao = "CANCELADO"
+                            nome_raw = RE_CANCELADO.sub("", nome_raw).strip(" ")
+                        nome = self.clean(nome_raw)
+                        remaining = lines[i+2:]
+                        break
+
+            if not nome or len(nome) < 3:
+                continue
+
+            record = {
+                "nome": nome,
+                "matricula": matricula,
+                "situacao": situacao,
+                "municipio": "Porto Alegre",
+                "data_registro": None,
+                "telefone": None,
+                "email": None,
+                "endereco": None,
+            }
+
+            for line in remaining:
+                if not line:
+                    continue
+                # Cancelado inline (linha separada como "(Cancelado)")
+                if RE_CANCELADO.search(line) and not record["situacao"]:
+                    record["situacao"] = "CANCELADO"
+                    continue
+                m = RE_POSSE.search(line)
+                if m:
+                    record["data_registro"] = m.group(1)
+                    continue
+                m = RE_TELEFONE.search(line)
+                if m:
+                    record["telefone"] = self.clean(m.group(1))
+                    continue
+                m = RE_EMAIL.search(line)
+                if m:
+                    record["email"] = self.clean(m.group(1))
+                    continue
+                m = RE_PREPOSTO.match(line)
+                if m:
+                    continue  # ignorar preposto
+                # Cidade/UF: "CANELA - RS" ou "PORTO ALEGRE - RS"
+                m = RE_CIDADE_UF.search(line)
+                if m:
+                    record["municipio"] = m.group(1).strip()
+                    continue
+                if RE_CEP.search(line):
+                    continue  # linha de CEP
+                # Linha de url (site)
+                if line.startswith("www.") or line.startswith("http"):
+                    continue
+                # Linha de endereco
+                if (not record["endereco"] and len(line) > 5 and
+                        re.search(r"[A-ZÁÉÍÓÚÀÃÕÇ]", line)):
+                    record["endereco"] = line
+
+            records.append(record)
+
+        return records
+
+    async def _fetch_post(self) -> List[dict]:
+        """
+        POST para /leiloeiros/busca/listar com Nome=Todos.
+        Retorna todos os 376 registros em resposta unica.
+        """
+        import httpx
+
+        try:
+            async with httpx.AsyncClient(
+                headers=self.HEADERS,
+                verify=False,  # Cert autoassinado/invalido
+                follow_redirects=True,
+                timeout=60.0,
+            ) as client:
+                # GET primeiro para obter cookies/CSRF se necessario
+                try:
+                    await client.get(self.url)
+                except Exception:
+                    pass
+
+                resp = await client.post(
+                    self._POST_URL,
+                    data={
+                        "Nome": "",
+                        "CodMunicipio": "0",  # 0 = Todas as cidades
+                        "Situacao": "TODOS",
+                        "Funcao": "LEILOEIRO",
+                    },
+                    headers={
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Referer": self.url,
+                        "Origin": "https://sistemas.jucisrs.rs.gov.br",
+                    },
+                )
+                if resp.status_code >= 400:
+                    logger.warning("[RS] POST retornou HTTP %d", resp.status_code)
+                    return []
+
+                logger.info("[RS] POST OK - tamanho resposta: %d bytes", len(resp.content))
+                return self._parse_plain_html(resp.text)
+
+        except Exception as exc:
+            logger.error("[RS] Erro no POST: %s", exc)
+            return []
+
+    async def _fetch_get_all(self) -> List[dict]:
+        """
+        Fallback: GET simples na URL principal com verify=False.
+        Pode retornar formulario ou lista parcial.
+        """
+        import httpx
+        from bs4 import BeautifulSoup
+
+        try:
+            async with httpx.AsyncClient(
+                headers=self.HEADERS,
+                verify=False,
+                follow_redirects=True,
+                timeout=30.0,
+            ) as client:
+                resp = await client.get(self.url)
+                if resp.status_code >= 400:
+                    return []
+                soup = BeautifulSoup(resp.text, "lxml")
+                return self._parse_plain_html(resp.text)
+        except Exception as exc:
+            logger.error("[RS] Erro no GET: %s", exc)
+            return []
+
+    async def _playwright_ssl_bypass(self, url: str):
+        """Playwright com SSL completamente desabilitado para cert autoassinado."""
+        try:
+            from playwright.async_api import async_playwright
+            from bs4 import BeautifulSoup
+            async with async_playwright() as pw:
+                browser = await pw.chromium.launch(
+                    headless=True,
+                    args=[
+                        "--ignore-certificate-errors",
+                        "--ignore-ssl-errors",
+                        "--disable-web-security",
+                        "--allow-insecure-localhost",
+                    ],
+                )
+                ctx = await browser.new_context(
+                    user_agent=self.HEADERS["User-Agent"],
+                    ignore_https_errors=True,
+                )
+                page = await ctx.new_page()
+                try:
+                    await page.goto(url, timeout=60000, wait_until="networkidle")
+                    # Submeter o formulario com "Todos"
+                    try:
+                        await page.fill("input[name='Nome']", "Todos")
+                        await page.click("button[type='submit'], input[type='submit']")
+                        await page.wait_for_load_state("networkidle", timeout=30000)
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
+                html = await page.content()
+                await browser.close()
+                return self._parse_plain_html(html)
+        except Exception as exc:
+            logger.error("[RS] Playwright SSL bypass falhou: %s", exc)
+            return []
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        # Estrategia 1: POST direto (mais eficiente, retorna todos de uma vez)
+        records = await self._fetch_post()
+
+        if not records:
+            # Estrategia 2: GET simples
+            logger.info("[RS] POST falhou, tentando GET simples")
+            records = await self._fetch_get_all()
+
+        if not records:
+            # Estrategia 3: Playwright com SSL bypass e submissao de formulario
+            logger.info("[RS] GET falhou, tentando Playwright com SSL bypass")
+            records = await self._playwright_ssl_bypass(self.url)
+
+        if not records:
+            # Estrategia 4: Pagina informativa (pode ter lista estatica)
+            logger.info("[RS] Tentando pagina informativa: %s", self.url_fallback)
+            soup = await self.fetch_page(url=self.url_fallback)
+            if soup:
+                records = self._parse_plain_html(str(soup))
+
+        logger.info("[RS] Total de registros encontrados: %d", len(records))
+        return [self.make_leiloeiro(**r) for r in records if r.get("nome")]

package/templates/vault/junta-leiloeiros/scripts/scraper/states.py

@@ -0,0 +1,99 @@
+"""
+Registro de todos os 27 scrapers das Juntas Comerciais do Brasil.
+Cada entrada define estado, junta, URL e scraper a ser usado.
+
+URLs verificadas e atualizadas em 2026-02-25.
+Scrapers customizados têm lógica específica para cada site.
+"""
+from __future__ import annotations
+
+from typing import Type
+
+from .base_scraper import AbstractJuntaScraper
+from .generic_scraper import GenericJuntaScraper
+
+# Scrapers customizados — lógica específica por estado
+from .jucesp import JucespScraper       # SP
+from .jucerja import JucerjaScraper     # RJ (Playwright)
+from .jucemg import JucemgScraper       # MG
+from .jucec import JucecScraper         # CE
+from .jucis_df import JucisDfScraper    # DF
+from .jucisrs import JucisrsScraper     # RS (Playwright - JUCISRS, domínio antigo aposentado)
+from .jucepar import JuceparScraper     # PR (URL migrou para juntacomercial.pr.gov.br)
+from .jucesc import JucescScraper       # SC (sistema dedicado leiloeiros.jucesc.sc.gov.br)
+from .juceb import JucebScraper         # BA (URL migrou para ba.gov.br/juceb)
+from .jucepe import JucepeScraper       # PE (Playwright - portal.jucepe.pe.gov.br)
+from .jucepa import JucepaScraper       # PA (Drupal node/171)
+from .jucema import JucemaScraper       # MA (múltiplas tentativas de URL)
+from .jucepi import JucepiScraper       # PI (URL migrou para portal.pi.gov.br/jucepi)
+from .jucern import JucernScraper       # RN (HTTP com query string)
+from .jucep import JucepScraper         # PB (JUCEP - domínio migrou para jucep.pb.gov.br)
+from .juceal import JucealScraper       # AL (URL correta: /servicos/leiloeiros)
+from .jucer import JucerScraper         # RO (URL migrou para rondonia.ro.gov.br/jucer)
+from .jucap import JucapScraper         # AP (HTTP - cert TLS inválido)
+from .juceac import JuceacScraper       # AC (URL correta: /leiloeiro/ singular)
+from .jucetins import JucetinsScraper   # TO (JUCETINS - URL migrou para to.gov.br/jucetins)
+
+
+def _make(estado: str, junta: str, url: str, municipio_default: str = None) -> Type[AbstractJuntaScraper]:
+    """Cria dinamicamente uma classe de scraper genérico para o estado."""
+    attrs = {
+        "estado": estado,
+        "junta": junta,
+        "url": url,
+        "municipio_default": municipio_default,
+    }
+    return type(f"{junta}Scraper", (GenericJuntaScraper,), attrs)
+
+
+# Mapeamento completo: UF -> Classe de Scraper
+# Todos os 27 estados com URLs verificadas e atualizadas em 2026-02-25
+SCRAPERS: dict[str, Type[AbstractJuntaScraper]] = {
+    # Região Sudeste
+    "SP": JucespScraper,    # JUCESP - https://www.institucional.jucesp.sp.gov.br/tradutores-leiloeiros.html
+    "RJ": JucerjaScraper,   # JUCERJA - https://www.jucerja.rj.gov.br/AuxiliaresComercio/Leiloeiros (JS)
+    "MG": JucemgScraper,    # JUCEMG - https://jucemg.mg.gov.br/pagina/139/leiloeiros-oficiais
+    "ES": _make("ES", "JUCEES", "https://jucees.es.gov.br/leiloeiros", "Vitória"),
+
+    # Região Sul
+    "RS": JucisrsScraper,   # JUCISRS - https://sistemas.jucisrs.rs.gov.br/leiloeiros/ (JS)
+    "PR": JuceparScraper,   # JUCEPAR - https://www.juntacomercial.pr.gov.br/Pagina/LEILOEIROS-OFICIAIS
+    "SC": JucescScraper,    # JUCESC - https://leiloeiros.jucesc.sc.gov.br/site/
+
+    # Região Nordeste
+    "BA": JucebScraper,     # JUCEB - https://www.ba.gov.br/juceb/home/matriculas-e-carteira-profissional/leiloeiros
+    "PE": JucepeScraper,    # JUCEPE - https://portal.jucepe.pe.gov.br/leiloeiros (JS)
+    "CE": JucecScraper,     # JUCEC - https://www.jucec.ce.gov.br/leiloeiros/
+    "MA": JucemaScraper,    # JUCEMA - múltiplas URLs tentadas
+    "PI": JucepiScraper,    # JUCEPI - https://portal.pi.gov.br/jucepi/leiloeiro-oficial/
+    "RN": JucernScraper,    # JUCERN - http://www.jucern.rn.gov.br/Conteudo.asp?TRAN=ITEM&TARG=8695...
+    "PB": JucepScraper,     # JUCEP - https://jucep.pb.gov.br/contatos/leiloeiros
+    "AL": JucealScraper,    # JUCEAL - http://www.juceal.al.gov.br/servicos/leiloeiros
+    "SE": _make("SE", "JUCESE", "https://jucese.se.gov.br/leiloeiros/", "Aracaju"),
+
+    # Região Centro-Oeste
+    "DF": JucisDfScraper,   # JUCIS-DF - https://jucis.df.gov.br/leiloeiros/
+    "GO": _make("GO", "JUCEG", "https://goias.gov.br/juceg/", "Goiânia"),
+    "MT": _make("MT", "JUCEMAT", "https://www.jucemat.mt.gov.br/leiloeiros", "Cuiabá"),
+    "MS": _make("MS", "JUCEMS", "https://www.jucems.ms.gov.br/empresas/controles-especiais/agentes-auxiliares/leiloeiros/", "Campo Grande"),
+
+    # Região Norte
+    "PA": JucepaScraper,    # JUCEPA - https://www.jucepa.pa.gov.br/node/171
+    "AM": _make("AM", "JUCEA", "https://www.jucea.am.gov.br/leiloeiros/", "Manaus"),
+    "RO": JucerScraper,     # JUCER - https://rondonia.ro.gov.br/jucer/lista-de-leiloeiros-oficiais/
+    "RR": _make("RR", "JUCERR", "https://jucerr.rr.gov.br/leiloeiros/", "Boa Vista"),
+    "AP": JucapScraper,     # JUCAP - http://www.jucap.ap.gov.br/leiloeiros (HTTP - TLS inválido)
+    "AC": JuceacScraper,    # JUCEAC - https://juceac.ac.gov.br/leiloeiro/
+    "TO": JucetinsScraper,  # JUCETINS - https://www.to.gov.br/jucetins/leiloeiros/152aezl6blm0
+}
+
+
+def get_all_scrapers() -> list[AbstractJuntaScraper]:
+    """Retorna instâncias de todos os scrapers."""
+    return [cls() for cls in SCRAPERS.values()]
+
+
+def get_scraper(estado: str) -> AbstractJuntaScraper | None:
+    """Retorna o scraper para um estado específico (UF)."""
+    cls = SCRAPERS.get(estado.upper())
+    return cls() if cls else None

package/templates/vault/junta-leiloeiros/scripts/serve_api.py

@@ -0,0 +1,164 @@
+"""
+API REST para consulta de leiloeiros das Juntas Comerciais do Brasil.
+
+Uso:
+    python scripts/serve_api.py
+    python scripts/serve_api.py --port 8080 --host 0.0.0.0
+
+Endpoints:
+    GET /                       → info da API
+    GET /leiloeiros             → lista todos (filtros: estado, situacao, nome, limit, offset)
+    GET /leiloeiros/{estado}    → por UF
+    GET /busca?q=texto          → busca por nome/matrícula/município
+    GET /stats                  → contagem por estado
+    GET /export/json            → dump completo em JSON
+    GET /export/csv             → dump completo em CSV
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import io
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from db import Database
+
+try:
+    from fastapi import FastAPI, HTTPException, Query
+    from fastapi.responses import JSONResponse, PlainTextResponse, StreamingResponse
+    import uvicorn
+except ImportError:
+    print("FastAPI não instalado. Execute: pip install fastapi uvicorn")
+    sys.exit(1)
+
+app = FastAPI(
+    title="Leiloeiros Juntas Comerciais Brasil",
+    description="API de dados de leiloeiros oficiais de todas as 27 Juntas Comerciais do Brasil",
+    version="1.0.0",
+)
+
+db = Database()
+db.init()
+
+
+@app.get("/", summary="Informações da API")
+def root():
+    total = db.get_total()
+    return {
+        "name": "Leiloeiros Juntas Comerciais Brasil",
+        "version": "1.0.0",
+        "total_registros": total,
+        "endpoints": {
+            "lista": "/leiloeiros",
+            "por_estado": "/leiloeiros/{estado}",
+            "busca": "/busca?q=texto",
+            "stats": "/stats",
+            "export_json": "/export/json",
+            "export_csv": "/export/csv",
+        },
+    }
+
+
+@app.get("/leiloeiros", summary="Lista leiloeiros com filtros")
+def list_leiloeiros(
+    estado: Optional[str] = Query(None, description="UF ex: SP, RJ, MG"),
+    situacao: Optional[str] = Query(None, description="ATIVO, CANCELADO, SUSPENSO"),
+    nome: Optional[str] = Query(None, description="Busca parcial por nome"),
+    limit: int = Query(100, ge=1, le=5000),
+    offset: int = Query(0, ge=0),
+):
+    records = db.get_all(
+        estado=estado,
+        situacao=situacao,
+        nome_like=nome,
+        limit=limit,
+        offset=offset,
+    )
+    return {"total": len(records), "offset": offset, "data": records}
+
+
+@app.get("/leiloeiros/{estado}", summary="Leiloeiros de um estado específico")
+def leiloeiros_por_estado(estado: str):
+    estado = estado.upper()
+    if len(estado) != 2:
+        raise HTTPException(status_code=400, detail="Estado deve ser a UF com 2 letras (ex: SP)")
+    records = db.get_by_estado(estado)
+    return {"estado": estado, "total": len(records), "data": records}
+
+
+@app.get("/busca", summary="Busca por nome, matrícula ou município")
+def busca(
+    q: str = Query(..., description="Texto para buscar"),
+    limit: int = Query(50, ge=1, le=500),
+):
+    if len(q) < 2:
+        raise HTTPException(status_code=400, detail="Query deve ter pelo menos 2 caracteres")
+    records = db.search(q, limit=limit)
+    return {"query": q, "total": len(records), "data": records}
+
+
+@app.get("/stats", summary="Estatísticas por estado")
+def stats():
+    data = db.get_stats()
+    total = sum(r["total"] for r in data)
+    return {"total_geral": total, "por_estado": data}
+
+
+@app.get("/export/json", summary="Exporta todos os dados em JSON")
+def export_json():
+    records = db.get_all()
+    return JSONResponse(
+        content={"total": len(records), "data": records},
+        headers={"Content-Disposition": "attachment; filename=leiloeiros.json"},
+    )
+
+
+@app.get("/export/csv", summary="Exporta todos os dados em CSV")
+def export_csv():
+    records = db.get_all()
+    if not records:
+        return PlainTextResponse("Nenhum dado encontrado.")
+
+    output = io.StringIO()
+    writer = csv.DictWriter(
+        output,
+        fieldnames=list(records[0].keys()),
+        extrasaction="ignore",
+    )
+    writer.writeheader()
+    writer.writerows(records)
+    output.seek(0)
+
+    return StreamingResponse(
+        iter([output.getvalue()]),
+        media_type="text/csv",
+        headers={"Content-Disposition": "attachment; filename=leiloeiros.csv"},
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Servidor API de leiloeiros")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--reload", action="store_true")
+    args = parser.parse_args()
+
+    print(f"\nAPI disponível em: http://{args.host}:{args.port}")
+    print(f"Docs interativos: http://{args.host}:{args.port}/docs\n")
+
+    uvicorn.run(
+        "serve_api:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        app_dir=str(Path(__file__).parent),
+    )
+
+
+if __name__ == "__main__":
+    main()