bps-kit 1.0.1 → 1.0.2

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

@@ -0,0 +1,256 @@
+"""
+Scraper JUCER — Junta Comercial do Estado de Rondonia
+URL: https://rondonia.ro.gov.br/jucer/lista-de-leiloeiros-oficiais/
+Metodo: httpx + BeautifulSoup com parser DL/DT/DD
+Estrutura descoberta em 2026-02-25:
+  WordPress CMS com estrutura DL/DT/DD aninada e malformada:
+  <dt><strong>NOME</strong></dt>
+  <dd><em>Matricula: <i>007/1995</i></em></dd>
+  <dd><em>Data da posse: <i>19/05/1995</i></em></dd>
+  <dd><em>Cidade: <i>Porto Velho</i></em></dd>
+  <dd><em>Endereco: <i>...</i></em></dd>
+  <dd><em>Telefone: <i>...</i></em></dd>
+  <dd><em>E-mail: <a href="mailto:...">...</a></em></dd>
+  <dd><em>Situacao:<strong>REGULAR</strong></em></dd>
+  <hr />
+Total: ~47 leiloeiros separados por <hr>
+Situacoes: Regular, Irregular, Afastado judicial
+"""
+from __future__ import annotations
+
+import logging
+import re
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+logger = logging.getLogger(__name__)
+
+RE_MATRICULA_RO = re.compile(r"[Mm]atr[íi]cula:?\s*(.+)")
+RE_POSSE_RO = re.compile(r"[Dd]ata\s+da\s+[Pp]osse:?\s*(.+)")
+RE_CIDADE_RO = re.compile(r"[Cc]idade:?\s*(.+)")
+RE_ENDERECO_RO = re.compile(r"[Ee]ndere[çc]o:?\s*(.+)")
+RE_TELEFONE_RO = re.compile(r"[Tt]elefone:?\s*(.+)")
+RE_EMAIL_RO = re.compile(r"[Ee]-?[Mm]ail:?\s*(.+)")
+RE_SITUACAO_RO = re.compile(r"[Ss]itua[çc][aã]o:?\s*(.+)")
+
+
+class JucerScraper(AbstractJuntaScraper):
+    estado = "RO"
+    junta = "JUCER"
+    url = "https://rondonia.ro.gov.br/jucer/lista-de-leiloeiros-oficiais/"
+
+    def _parse_dl_structure(self, soup) -> List[dict]:
+        """
+        Parseia estrutura DL/DT/DD do WordPress com anotacao malformada.
+        Estrategia: encontrar todos <dt><strong>NOME</strong></dt>
+        e coletar os <dd> subsequentes ate o proximo <dt> ou <hr>.
+        """
+        records = []
+
+        # Encontrar area de conteudo
+        content = soup.select_one(
+            ".entry-content, .post-content, article .content, .conteudo, "
+            "#conteudo, main article, .page-content"
+        )
+        if not content:
+            content = soup.body or soup
+
+        # Abordagem 1: dt/dd estruturado
+        dts = content.find_all("dt")
+        for dt in dts:
+            strong = dt.find("strong")
+            if not strong:
+                continue
+            nome = self.clean(strong.get_text())
+            if not nome or len(nome) < 3:
+                continue
+
+            record = {"nome": nome, "municipio": "Porto Velho"}
+
+            # Coletar dd's subsequentes
+            sibling = dt.next_sibling
+            for _ in range(15):
+                if sibling is None:
+                    break
+                if hasattr(sibling, "name"):
+                    if sibling.name == "dt":
+                        break
+                    if sibling.name == "hr":
+                        break
+                    if sibling.name == "dd":
+                        text = self.clean(sibling.get_text())
+                        if text:
+                            self._extract_dd_field(text, record)
+                sibling = sibling.next_sibling
+
+            records.append(record)
+
+        if records:
+            return records
+
+        # Abordagem 2: Segmentar por <hr> e parsear cada bloco
+        # Obter HTML como string e dividir por <hr>
+        full_text = content.get_text("\n")
+        # Usa separadores de linha longa como delimitadores de entrada
+        segments = re.split(r"\n\s*[-_]{5,}\s*\n|\n(?=\d+\.\s+[A-Z])", full_text)
+
+        for seg in segments:
+            lines = [l.strip() for l in seg.strip().split("\n") if l.strip()]
+            if len(lines) < 2:
+                continue
+
+            # Primeira linha substancial e o nome
+            nome = None
+            remaining = []
+            for i, line in enumerate(lines):
+                if (len(line) > 3 and
+                        re.search(r"[A-ZÁÉÍÓÚÀÃÕÇ]", line) and
+                        not re.match(r"[Mm]atr|[Dd]ata|[Cc]idad|[Ee]ndere|[Tt]ele|[Ee]-?mail|[Ss]itua", line)):
+                    nome = line
+                    remaining = lines[i+1:]
+                    break
+
+            if not nome:
+                continue
+
+            record = {"nome": nome, "municipio": "Porto Velho"}
+            for line in remaining:
+                self._extract_dd_field(line, record)
+            records.append(record)
+
+        return records
+
+    def _extract_dd_field(self, text: str, record: dict) -> None:
+        """Extrai campos de uma linha de texto e popula o record."""
+        m = RE_MATRICULA_RO.match(text)
+        if m:
+            record["matricula"] = self.clean(m.group(1))
+            return
+        m = RE_POSSE_RO.match(text)
+        if m:
+            record["data_registro"] = self.clean(m.group(1))
+            return
+        m = RE_CIDADE_RO.match(text)
+        if m:
+            record["municipio"] = self.clean(m.group(1))
+            return
+        m = RE_ENDERECO_RO.match(text)
+        if m:
+            record["endereco"] = self.clean(m.group(1))
+            return
+        m = RE_TELEFONE_RO.match(text)
+        if m:
+            record["telefone"] = self.clean(m.group(1))
+            return
+        m = RE_EMAIL_RO.match(text)
+        if m:
+            record["email"] = self.clean(m.group(1))
+            return
+        m = RE_SITUACAO_RO.match(text)
+        if m:
+            record["situacao"] = self.clean(m.group(1))
+            return
+
+    def _parse_hr_blocks(self, soup) -> List[dict]:
+        """
+        Estrategia alternativa: coleta conteudo entre tags <hr>.
+        Cada bloco entre <hr> e uma entrada de leiloeiro.
+        """
+        records = []
+        content = soup.select_one(".entry-content, .post-content, article .content, main, body")
+        if not content:
+            return []
+
+        # Coletar todos os elementos ate os <hr>
+        current_block = []
+        blocks = []
+
+        for el in content.descendants:
+            if not hasattr(el, "name"):
+                continue
+            if el.name == "hr":
+                if current_block:
+                    blocks.append(current_block)
+                    current_block = []
+            elif el.name in ("dt", "dd", "strong", "i", "em", "a", "p"):
+                text = self.clean(el.get_text())
+                if text:
+                    current_block.append((el.name, text))
+
+        if current_block:
+            blocks.append(current_block)
+
+        for block in blocks:
+            if not block:
+                continue
+
+            record = {"municipio": "Porto Velho"}
+            nome_found = False
+
+            for tag, text in block:
+                if not nome_found and tag in ("dt", "strong"):
+                    if len(text) > 3 and re.search(r"[A-ZÁÉÍÓÚÀÃÕÇ]", text):
+                        # Verificar se nao e um campo de dado
+                        if not re.match(r"[Mm]atr|[Dd]ata|[Cc]idad|[Ee]ndere|[Tt]ele|[Ee]-?mail|[Ss]itua", text):
+                            record["nome"] = text
+                            nome_found = True
+                            continue
+                self._extract_dd_field(text, record)
+
+            if record.get("nome"):
+                records.append(record)
+
+        return records
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        soup = await self.fetch_page()
+        if not soup:
+            soup = await self.fetch_page_js(wait_ms=3000)
+        if not soup:
+            return []
+
+        # Estrategia 1: Parser DL/DT/DD estruturado
+        records = self._parse_dl_structure(soup)
+
+        if not records:
+            # Estrategia 2: Parser por blocos HR
+            records = self._parse_hr_blocks(soup)
+
+        if not records:
+            # Estrategia 3: Tabela generica (fallback)
+            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
+                    records.append({
+                        "nome": nome,
+                        "matricula": gcol(cells, ["matr", "registro"]),
+                        "situacao": gcol(cells, ["situ", "status"]),
+                        "municipio": gcol(cells, ["munic", "cidade"]) or "Porto Velho",
+                        "telefone": gcol(cells, ["tel", "fone"]),
+                        "email": gcol(cells, ["email"]),
+                        "endereco": gcol(cells, ["ender", "logr"]),
+                        "data_registro": gcol(cells, ["data", "posse"]),
+                    })
+                if records:
+                    break
+
+        logger.info("[RO] Total: %d registros encontrados", len(records))
+        return [self.make_leiloeiro(**r) for r in records if r.get("nome")]

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

@@ -0,0 +1,170 @@
+"""
+Scraper JUCERJA — Junta Comercial do Estado do Rio de Janeiro
+URL: https://www.jucerja.rj.gov.br/AuxiliaresComercio/Leiloeiros
+Metodo: httpx com paginacao AJAX
+Endpoints reais descobertos em 2026-02-25:
+  - Lista paginada (5/pg): GET /AuxiliaresComercio/FiltrarLeiloeiros?pagina=N&ordenacao=matricula&SituacaoFuncionalId=
+  - SituacaoFuncionalId vazio = todos os status
+Estrutura HTML: <ul class="ats-listaLnks ats-container--estrutura">
+  com <li class="ats-listaLnks-item"> contendo pares <h5>label</h5><h6>valor</h6>
+Total: ~334 leiloeiros (108 Regular + 132 Cancelados + 94 outros)
+67 paginas x 5 registros/pagina com SituacaoFuncionalId em branco
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+logger = logging.getLogger(__name__)
+
+
+class JucerjaScraper(AbstractJuntaScraper):
+    estado = "RJ"
+    junta = "JUCERJA"
+    url = "https://www.jucerja.rj.gov.br/AuxiliaresComercio/Leiloeiros"
+
+    # Endpoint AJAX real da paginacao (descoberto em 2026-02-25)
+    _PAGINAR_URL = "https://www.jucerja.rj.gov.br/AuxiliaresComercio/FiltrarLeiloeiros"
+
+    def _parse_lista(self, soup) -> List[dict]:
+        """
+        Extrai leiloeiros da lista HTML.
+        Estrutura: <ul class="ats-listaLnks"> com <li> contendo <h5> (label) e <h6> (valor).
+        """
+        records = []
+
+        # Seletor primario: li dentro da lista de leiloeiros
+        items = soup.select("ul.ats-listaLnks li, ul.ats-container--estrutura li, #listaLeiloeiros li, .listagemLeiloeiros li")
+        if not items:
+            # Fallback: qualquer li com h5 e h6
+            items = [li for li in soup.find_all("li") if li.find("h5") and li.find("h6")]
+
+        for li in items:
+            labels = [self.clean(h.get_text()) for h in li.find_all("h5")]
+            values = [self.clean(h.get_text()) for h in li.find_all("h6")]
+            if not labels or not values:
+                continue
+
+            # Mapa label.lower() -> valor
+            data = {}
+            for label, val in zip(labels, values):
+                if label:
+                    data[label.lower().rstrip(":")] = val
+
+            def get_val(*frags):
+                for k, v in data.items():
+                    if any(f in k for f in frags) and v:
+                        return v
+                return None
+
+            # Nome: pode ser "leiloeiro", "nome" ou o primeiro valor
+            nome = get_val("leiloeiro", "nome") or (values[0] if values else None)
+            if not nome or len(nome) < 3:
+                continue
+
+            records.append({
+                "nome": nome,
+                "matricula": get_val("matr", "registro", "nº matr", "n° matr"),
+                "situacao": get_val("situ", "funcional", "status"),
+                "municipio": get_val("munic", "cidade"),
+                "telefone": get_val("tel", "fone"),
+                "email": get_val("email", "e-mail"),
+                "endereco": get_val("ender", "logr", "rua", "endere"),
+                "data_registro": get_val("data matrícula", "posse", "data"),
+            })
+
+        return records
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        """
+        Coleta todos os leiloeiros via endpoint AJAX de paginacao.
+        GET /AuxiliaresComercio/FiltrarLeiloeiros?pagina=N&ordenacao=matricula&SituacaoFuncionalId=
+        Pagina 5 registros por vez; SituacaoFuncionalId em branco = todos os status.
+        """
+        import httpx
+        results: List[Leiloeiro] = []
+        pagina = 1
+        seen_names: set = set()
+
+        headers = {
+            **self.HEADERS,
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": self.url,
+        }
+
+        try:
+            async with httpx.AsyncClient(
+                headers=headers,
+                verify=True,
+                follow_redirects=True,
+                timeout=60.0,
+            ) as client:
+                # Primeiro GET na pagina principal para obter cookies
+                await client.get(self.url)
+
+                while True:
+                    url_pagina = (
+                        f"{self._PAGINAR_URL}"
+                        f"?pagina={pagina}&ordenacao=matricula&Nome=&SituacaoFuncionalId="
+                    )
+                    try:
+                        resp = await client.get(url_pagina)
+                        if resp.status_code >= 400:
+                            logger.warning("[RJ] Pagina %d retornou HTTP %d", pagina, resp.status_code)
+                            break
+                    except Exception as exc:
+                        logger.error("[RJ] Erro na pagina %d: %s", pagina, exc)
+                        break
+
+                    from bs4 import BeautifulSoup
+                    soup = BeautifulSoup(resp.text, "lxml")
+                    page_records = self._parse_lista(soup)
+
+                    if not page_records:
+                        logger.debug("[RJ] Pagina %d sem registros — fim da paginacao", pagina)
+                        break
+
+                    # Evita duplicatas (mesmo nome ja visto)
+                    novos = 0
+                    for r in page_records:
+                        key = r["nome"].upper()
+                        if key not in seen_names:
+                            seen_names.add(key)
+                            if not r.get("municipio"):
+                                r["municipio"] = "Rio de Janeiro"
+                            results.append(self.make_leiloeiro(**r))
+                            novos += 1
+
+                    logger.debug("[RJ] Pagina %d: %d novos (total=%d)", pagina, novos, len(results))
+
+                    if novos == 0:
+                        break  # Pagina repetiu dados — parar
+
+                    pagina += 1
+                    if pagina > 100:  # Limite de seguranca
+                        logger.warning("[RJ] Limite de paginas atingido")
+                        break
+
+                    await asyncio.sleep(0.3)  # Evita sobrecarga
+
+        except Exception as exc:
+            logger.error("[RJ] Erro geral na coleta: %s", exc)
+
+        if not results:
+            # Fallback: Playwright para pagina estatica com qualquer registro
+            logger.info("[RJ] Tentando Playwright como fallback")
+            soup = await self.fetch_page_js(
+                url=self.url,
+                wait_selector="li",
+                wait_ms=5000,
+            )
+            if soup:
+                for r in self._parse_lista(soup):
+                    if not r.get("municipio"):
+                        r["municipio"] = "Rio de Janeiro"
+                    results.append(self.make_leiloeiro(**r))
+
+        return results

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

@@ -0,0 +1,71 @@
+"""
+Scraper JUCERN — Junta Comercial do Estado do Rio Grande do Norte
+URL: http://www.jucern.rn.gov.br/Conteudo.asp?TRAN=ITEM&TARG=8695&ACT=&PAGE=0&PARM=&LBL=Leiloeiros
+Método: httpx (HTTP sem TLS — site usa HTTP apenas)
+Nota: URL com parâmetros de query é a página correta de leiloeiros.
+      Usar HTTP (não HTTPS). Referenciado em FENAJU e InnLei como ativo.
+"""
+from __future__ import annotations
+
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+
+class JucernScraper(AbstractJuntaScraper):
+    estado = "RN"
+    junta = "JUCERN"
+    url = "http://www.jucern.rn.gov.br/Conteudo.asp?TRAN=ITEM&TARG=8695&ACT=&PAGE=0&PARM=&LBL=Leiloeiros"
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        soup = await self.fetch_page()
+        if not soup:
+            # Tenta domínio sem www
+            soup = await self.fetch_page(url="http://jucern.rn.gov.br/Conteudo.asp?TRAN=ITEM&TARG=8695&ACT=&PAGE=0&PARM=&LBL=Leiloeiros")
+        if not soup:
+            soup = await self.fetch_page_js(wait_ms=3000)
+        if not soup:
+            return []
+
+        results: List[Leiloeiro] = []
+
+        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", "nº"]),
+                    situacao=gcol(cells, ["situ", "status"]),
+                    municipio=gcol(cells, ["munic", "cidade"]) or "Natal",
+                    telefone=gcol(cells, ["tel", "fone"]),
+                    email=gcol(cells, ["email"]),
+                    endereco=gcol(cells, ["ender", "logr"]),
+                    data_registro=gcol(cells, ["data", "posse"]),
+                ))
+            if results:
+                break
+
+        if not results:
+            for el in soup.select("td, li, p"):
+                text = self.clean(el.get_text())
+                if text and len(text) > 10 and any(c.isupper() for c in text[:20]):
+                    results.append(self.make_leiloeiro(nome=text, municipio="Natal"))
+
+        return results

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

@@ -0,0 +1,89 @@
+"""
+Scraper JUCESC — Junta Comercial do Estado de Santa Catarina
+URL: https://leiloeiros.jucesc.sc.gov.br/site/
+     https://leiloeiros.jucesc.sc.gov.br/site/porcidade.php (por cidade)
+Método: httpx + BeautifulSoup (sistema dedicado com tabela HTML)
+Nota: Sistema migrou para subdomínio dedicado leiloeiros.jucesc.sc.gov.br
+"""
+from __future__ import annotations
+
+from typing import List
+
+from .base_scraper import AbstractJuntaScraper, Leiloeiro
+
+
+class JucescScraper(AbstractJuntaScraper):
+    estado = "SC"
+    junta = "JUCESC"
+    url = "https://leiloeiros.jucesc.sc.gov.br/site/"
+
+    async def parse_leiloeiros(self) -> List[Leiloeiro]:
+        soup = await self.fetch_page()
+        if not soup:
+            soup = await self.fetch_page_js(wait_ms=3000)
+        if not soup:
+            return []
+
+        results: List[Leiloeiro] = []
+
+        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"])]
+            if not headers:
+                continue
+
+            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", "nº", "numero", "antiguidade"]),
+                    cpf_cnpj=gcol(cells, ["cpf", "cnpj"]),
+                    situacao=gcol(cells, ["situ", "status"]),
+                    municipio=gcol(cells, ["munic", "cidade"]) or "Florianópolis",
+                    telefone=gcol(cells, ["tel", "fone"]),
+                    email=gcol(cells, ["email"]),
+                    endereco=gcol(cells, ["ender", "logr", "rua"]),
+                    data_registro=gcol(cells, ["data", "posse", "registro"]),
+                ))
+            if results:
+                break
+
+        # Se não achou tabela, tenta página por cidade para pegar todos
+        if not results:
+            soup2 = await self.fetch_page(url="https://leiloeiros.jucesc.sc.gov.br/site/porcidade.php")
+            if soup2:
+                for table in soup2.find_all("table"):
+                    rows = table.find_all("tr")
+                    if len(rows) < 2:
+                        continue
+                    for row in rows[1:]:
+                        cells = row.find_all(["td", "th"])
+                        if not cells:
+                            continue
+                        nome = self.clean(cells[0].get_text())
+                        if not nome or len(nome) < 3:
+                            continue
+                        results.append(self.make_leiloeiro(
+                            nome=nome,
+                            matricula=self.clean(cells[1].get_text()) if len(cells) > 1 else None,
+                            municipio=self.clean(cells[2].get_text()) if len(cells) > 2 else "Florianópolis",
+                        ))
+                    if results:
+                        break
+
+        return results