bps-kit 1.0.1 → 1.0.2

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

@@ -0,0 +1,233 @@
+"""
+Scraper JUCESP — Junta Comercial do Estado de São Paulo
+
+MECANISMO REAL (descoberto em 2025-02-25):
+  A URL https://www.institucional.jucesp.sp.gov.br/tradutores-leiloeiros.html
+  é apenas uma página institucional com links para downloads e um accordeon.
+  O accordion "Localizar Leiloeiro e Tradutor" aponta para:
+    https://www.institucional.jucesp.sp.gov.br/consultaLeilao.html
+  Essa página contém um <iframe> carregando o sistema real:
+    https://www.institucional.jucesp.sp.gov.br/relatorio/ConsultasLeiloeiroTradutor
+
+  O sistema real é um app ASP.NET MVC com:
+    - GET  /relatorio/ConsultasLeiloeiroTradutor
+          -> retorna formulário de busca com token CSRF anti-forgery
+    - POST /relatorio/ConsultasLeiloeiroTradutor/ListaLeiloeirosTradutores
+          -> retorna HTML com tabela id="example" contendo TODOS os registros
+             (sem paginação — 2.3 MB com 1152 leiloeiros na resposta completa)
+
+  Campos do POST:
+    __RequestVerificationToken  (obrigatório, obtido no GET)
+    AgeTipo                     1 = Leiloeiro | 2 = Tradutor
+    AgeMatricula                filtro opcional
+    AgeNome                     filtro opcional
+    AgeSituacao                 -1 = todos | 1=Atuante | 14=Atuante Regular |
+                                 13=Atuante Irregular | 2=Destituído | 3=Exonerado |
+                                 4=Falecido | 9=Licenciado | 10=Matrícula Cancelada |
+                                 12=Registro Cassado | 11=Registro Suspenso |
+                                 8=Regular | 7=Suspenso | 6=Suspenso Por Ordem Judicial |
+                                 5=Transferido
+    AgeDataPosseDe / AgeDataPosseAte  filtro de data (dd/mm/aaaa)
+    AgeEndeComeLogradouro / AgeEndeComeBairro / AgeEndeComeMunicipio  filtro de endereço
+    MatriculaCancelada          true/false
+    MatriculaCancelada120       true/false
+
+  Colunas da tabela retornada (id="example"):
+    Nome | Matricula | PosseYMD | Posse | Logradouro | Bairro | Cidade |
+    CEP | Telefones | E-Mail | Web Site | Situação | Preposto |
+    Férias/Licença | Data do D.O.E. | Prazo para Publicação - 120 dias |
+    Data do Cancelamento | PDF
+
+  Total coletável: 1152 leiloeiros (todos os status)
+  Atuante Regular: 577 | Exonerado: 273 | Destituído: 214 | Falecido: 47 | ...
+
+Método: httpx com sessão (GET para CSRF, POST para dados)
+"""
+from __future__ import annotations
+
+import re
+from html import unescape
+from typing import List, Optional
+
+import httpx
+from bs4 import BeautifulSoup
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+
+class JucespScraper(AbstractJuntaScraper):
+    estado = "SP"
+    junta = "JUCESP"
+    url = "https://www.institucional.jucesp.sp.gov.br/tradutores-leiloeiros.html"
+
+    # Endpoint real do sistema de consulta
+    _FORM_URL = "https://www.institucional.jucesp.sp.gov.br/relatorio/ConsultasLeiloeiroTradutor"
+    _POST_URL = (
+        "https://www.institucional.jucesp.sp.gov.br"
+        "/relatorio/ConsultasLeiloeiroTradutor/ListaLeiloeirosTradutores"
+    )
+
+    # Busca todos os status (-1).  Para coletar apenas ativos use "14" (Atuante Regular).
+    _AGE_SITUACAO = "-1"
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        """
+        Fluxo:
+        1. GET /relatorio/ConsultasLeiloeiroTradutor  -> extrai token CSRF
+           (o servidor emite um cookie de sessão junto com o token)
+        2. POST /relatorio/ConsultasLeiloeiroTradutor/ListaLeiloeirosTradutores
+               com AgeTipo=1 e AgeSituacao=-1 (todos)
+           IMPORTANTE: GET e POST devem usar o MESMO AsyncClient para que os
+           cookies de sessão sejam enviados. Sem isso o servidor retorna 500.
+        3. Parseia a tabela id="example" do HTML retornado
+        """
+        import asyncio as _aio
+        import logging as _log
+        logger = _log.getLogger(__name__)
+
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                soup = await self._fetch_with_session()
+                if soup:
+                    return self._parse_table(soup)
+            except Exception as exc:
+                # Mask any CSRF tokens that might appear in error messages
+                safe_exc = str(exc)
+                if hasattr(self, '_last_csrf') and self._last_csrf and self._last_csrf in safe_exc:
+                    safe_exc = safe_exc.replace(self._last_csrf, "***csrf-masked***")
+                logger.warning("[SP] Tentativa %d/%d falhou: %s", attempt, self.max_retries, safe_exc)
+                if attempt < self.max_retries:
+                    await _aio.sleep(2 ** attempt)
+
+        return []
+
+    # ── helpers privados ─────────────────────────────────────────────────────
+
+    async def _fetch_with_session(self) -> Optional[BeautifulSoup]:
+        """
+        GET + POST dentro do mesmo AsyncClient.
+        O servidor ASP.NET emite um cookie de sessão no GET que deve ser
+        reenviado no POST — sem ele o servidor retorna HTTP 500.
+        """
+        import logging
+        logger = logging.getLogger(__name__)
+
+        async with httpx.AsyncClient(
+            headers=self.HEADERS,
+            verify=False,
+            http2=False,          # servidor rejeita HTTP/2
+            follow_redirects=True,
+            timeout=120.0,        # resposta do POST é ~2.3 MB
+        ) as client:
+            # 1. GET — obtém CSRF token e cookie de sessão
+            r_get = await client.get(self._FORM_URL)
+            r_get.raise_for_status()
+
+            csrf_match = re.search(
+                r'name="__RequestVerificationToken"[^>]*value="([^"]+)"',
+                r_get.text,
+            )
+            if not csrf_match:
+                logger.warning("[SP] CSRF token não encontrado")
+                return None
+            csrf = csrf_match.group(1)
+            self._last_csrf = csrf  # Store for safe error masking
+
+            # 2. POST — mesmo client envia os cookies de sessão automaticamente
+            r_post = await client.post(
+                self._POST_URL,
+                data={
+                    "__RequestVerificationToken": csrf,
+                    "AgeTipo": "1",                 # Leiloeiro
+                    "AgeMatricula": "",
+                    "AgeNome": "",
+                    "AgeSituacao": self._AGE_SITUACAO,
+                    "AgeDataPosseDe": "",
+                    "AgeDataPosseAte": "",
+                    "AgeEndeComeLogradouro": "",
+                    "AgeEndeComeBairro": "",
+                    "AgeEndeComeMunicipio": "",
+                    "MatriculaCancelada": "false",
+                    "MatriculaCancelada120": "false",
+                },
+                headers={
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Referer": self._FORM_URL,
+                    "Origin": "https://www.institucional.jucesp.sp.gov.br",
+                },
+            )
+            r_post.raise_for_status()
+            return BeautifulSoup(r_post.text, "lxml")
+
+    def _parse_table(self, soup: BeautifulSoup) -> List[Leiloeiro]:
+        """
+        Parseia a tabela id="example" retornada pelo POST.
+
+        Colunas (índice 0-based):
+          0  Nome
+          1  Matricula
+          2  PosseYMD   (hidden, usado para ordenação)
+          3  Posse      (dd/mm/aaaa)
+          4  Logradouro
+          5  Bairro
+          6  Cidade
+          7  CEP
+          8  Telefones
+          9  E-Mail
+         10  Web Site
+         11  Situação
+         12  Preposto
+         13  Férias/Licença
+         14  Data do D.O.E.
+         15  Prazo para Publicação - 120 dias
+         16  Data do Cancelamento
+         17  PDF
+        """
+        results: List[Leiloeiro] = []
+
+        table = soup.find("table", {"id": "example"})
+        if not table:
+            # Fallback: procurar a maior tabela da página
+            tables = soup.find_all("table")
+            if not tables:
+                return []
+            table = max(tables, key=lambda t: len(t.find_all("tr")))
+
+        rows = table.find_all("tr")
+        if not rows:
+            return []
+
+        for row in rows[1:]:   # pula o cabeçalho
+            cells = row.find_all("td")
+            if len(cells) < 12:
+                continue
+
+            def cell(idx: int) -> Optional[str]:
+                if idx < len(cells):
+                    return self.clean(unescape(cells[idx].get_text()))
+                return None
+
+            nome = cell(0)
+            if not nome:
+                continue
+
+            # Monta endereço completo
+            logradouro = cell(4)
+            bairro = cell(5)
+            cidade = cell(6)
+            cep = cell(7)
+            partes = [p for p in [logradouro, bairro, cidade, cep] if p]
+            endereco = ", ".join(partes) if partes else None
+
+            results.append(self.make_leiloeiro(
+                nome=nome,
+                matricula=cell(1),
+                data_registro=cell(3),   # data de posse
+                endereco=endereco,
+                municipio=cidade,
+                telefone=cell(8),
+                email=cell(9),
+                situacao=cell(11),
+            ))
+
+        return results

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

@@ -0,0 +1,134 @@
+"""
+Scraper JUCETINS — Junta Comercial do Estado do Tocantins
+URL: https://www.to.gov.br/jucetins/leiloeiros/152aezl6blm0
+Metodo: httpx + BeautifulSoup com parser regex para texto numerado plano
+Estrutura: Texto numerado plano sem tabela, padrao:
+  N. Nome Completo
+  Matricula no X, de DD/MM/AAAA
+  Endereco: ... CEP: XXXXX-XXX, Cidade/TO
+  Telefone: (XX) XXXXX-XXXX
+  E-mail: email@exemplo.com
+Registros: ~55, todos em pagina unica. Ultima atualizacao: 24/02/2026.
+"""
+from __future__ import annotations
+
+import re
+from typing import List, Optional
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+RE_ENTRY_START = re.compile(r"^\d+\.\s+(.+)$")
+RE_MATRICULA = re.compile(r"[Mm]atr[íi]cula\s+n[oº]?\s*[\.\s]*(\d+).*?de\s+(\d{2}/\d{2}/\d{4})", re.IGNORECASE)
+RE_ENDERECO = re.compile(r"[Ee]ndere[çc]o:\s+(.+)", re.IGNORECASE)
+RE_TELEFONE = re.compile(r"[Tt]elefone:\s+(.+)", re.IGNORECASE)
+RE_EMAIL = re.compile(r"[Ee]-?mail:\s+(.+)", re.IGNORECASE)
+RE_CANCELADO = re.compile(r"CANCELAMENTO\s+DE\s+MATR[ÍI]CULA", re.IGNORECASE)
+
+
+class JucetinsScraper(AbstractJuntaScraper):
+    estado = "TO"
+    junta = "JUCETINS"
+    url = "https://www.to.gov.br/jucetins/leiloeiros/152aezl6blm0"
+
+    def _parse_text_block(self, text: str) -> List[dict]:
+        records = []
+        current: Optional[dict] = None
+        for raw_line in text.split("\n"):
+            line = (raw_line or "").strip()
+            if not line:
+                continue
+            m_start = RE_ENTRY_START.match(line)
+            if m_start:
+                if current and current.get("nome"):
+                    records.append(current)
+                nome_raw = m_start.group(1).strip()
+                is_cancelado = bool(RE_CANCELADO.search(nome_raw))
+                nome = RE_CANCELADO.sub("", nome_raw).strip(" -")
+                current = {"nome": nome, "municipio": "Palmas", "situacao": "CANCELADO" if is_cancelado else None}
+                continue
+            if current is None:
+                continue
+            m = RE_MATRICULA.search(line)
+            if m:
+                current["matricula"] = m.group(1)
+                current.setdefault("data_registro", m.group(2))
+                continue
+            m = RE_ENDERECO.search(line)
+            if m:
+                current["endereco"] = m.group(1).strip()
+                m_city = re.search(r"([A-Za-záéíóúàãõçÁÉÍÓÚÀÃÕÇ\s]+)/TO", m.group(1))
+                if m_city:
+                    current["municipio"] = m_city.group(1).strip()
+                continue
+            m = RE_TELEFONE.search(line)
+            if m:
+                current["telefone"] = m.group(1).strip()
+                continue
+            m = RE_EMAIL.search(line)
+            if m:
+                current["email"] = m.group(1).strip()
+                continue
+        if current and current.get("nome"):
+            records.append(current)
+        return records
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        soup = await self.fetch_page()
+        if not soup:
+            soup = await self.fetch_page_js(url=self.url, wait_ms=4000)
+        if not soup:
+            return []
+
+        results: List[Leiloeiro] = []
+
+        # Encontra container principal do CMS
+        content = soup.select_one(
+            ".field--name-body, article .content, .node__content, main article, .conteudo, #content .field"
+        )
+        if not content:
+            candidates = sorted(soup.find_all(["div", "article", "section"]),
+                                 key=lambda el: len(el.get_text()), reverse=True)
+            content = candidates[0] if candidates else soup.body
+
+        if content:
+            records = self._parse_text_block(content.get_text("\n"))
+            if records:
+                for r in records:
+                    results.append(self.make_leiloeiro(**r))
+                return results
+
+        # Fallback tabela
+        for table in soup.find_all("table"):
+            rows = table.find_all("tr")
+            if len(rows) < 2:
+                continue
+            headers = [self.clean(th.get_text()) for th in rows[0].find_all(["th", "td"])]
+            col = {(h or "").lower(): i for i, h in enumerate(headers)}
+
+            def gcol(cells, frags):
+                for k, i in col.items():
+                    if any(f in k for f in frags) and i < len(cells):
+                        return self.clean(cells[i].get_text())
+                return None
+
+            for row in rows[1:]:
+                cells = row.find_all(["td", "th"])
+                if not cells:
+                    continue
+                nome = gcol(cells, ["nome", "leiloeiro"]) or self.clean(cells[0].get_text())
+                if not nome or len(nome) < 3:
+                    continue
+                results.append(self.make_leiloeiro(
+                    nome=nome,
+                    matricula=gcol(cells, ["matr", "registro"]),
+                    situacao=gcol(cells, ["situ", "status"]),
+                    municipio=gcol(cells, ["munic", "cidade"]) or "Palmas",
+                    telefone=gcol(cells, ["tel", "fone"]),
+                    email=gcol(cells, ["email"]),
+                    endereco=gcol(cells, ["ender", "logr"]),
+                    data_registro=gcol(cells, ["data", "posse"]),
+                ))
+            if results:
+                break
+
+        return results

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

@@ -0,0 +1,63 @@
+"""
+Scraper JUCIS-DF — Junta Comercial, Industrial e Serviços do Distrito Federal
+URL: https://jucis.df.gov.br/leiloeiros/
+Método: httpx + BeautifulSoup
+"""
+from __future__ import annotations
+
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+
+class JucisDfScraper(AbstractJuntaScraper):
+    estado = "DF"
+    junta = "JUCIS-DF"
+    url = "https://jucis.df.gov.br/leiloeiros/"
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        soup = await self.fetch_page()
+        if not soup:
+            return []
+
+        results: List[Leiloeiro] = []
+
+        tables = soup.find_all("table")
+        for table in tables:
+            rows = table.find_all("tr")
+            if len(rows) < 2:
+                continue
+            headers = [self.clean(th.get_text()) for th in rows[0].find_all(["th", "td"])]
+            col = {(h or "").lower(): i for i, h in enumerate(headers)}
+
+            def gcol(cells, frags):
+                for k, i in col.items():
+                    if any(f in k for f in frags) and i < len(cells):
+                        return self.clean(cells[i].get_text())
+                return None
+
+            for row in rows[1:]:
+                cells = row.find_all(["td", "th"])
+                if not cells:
+                    continue
+                nome = gcol(cells, ["nome"]) or self.clean(cells[0].get_text())
+                if not nome or len(nome) < 3:
+                    continue
+                results.append(self.make_leiloeiro(
+                    nome=nome,
+                    matricula=gcol(cells, ["matr", "registro"]),
+                    cpf_cnpj=gcol(cells, ["cpf", "cnpj"]),
+                    situacao=gcol(cells, ["situ", "status"]),
+                    municipio="Brasília",
+                    telefone=gcol(cells, ["tel", "fone"]),
+                    email=gcol(cells, ["email"]),
+                    endereco=gcol(cells, ["ender", "logr"]),
+                ))
+
+        if not results:
+            for el in soup.select("ul li, .leiloeiro, article p"):
+                text = self.clean(el.get_text(" | "))
+                if text and len(text) > 5:
+                    results.append(self.make_leiloeiro(nome=text, municipio="Brasília"))
+
+        return results