bps-kit 1.0.1 → 1.0.2

package/templates/vault/instagram/scripts/templates.py

@@ -0,0 +1,155 @@
+"""
+Templates reutilizáveis de conteúdo para Instagram.
+
+Uso:
+    python scripts/templates.py --create --name "promo" --caption "Oferta: {produto}! {desconto}% OFF" --hashtags "#oferta,#promo"
+    python scripts/templates.py --list
+    python scripts/templates.py --show --name promo
+    python scripts/templates.py --delete --name promo
+    python scripts/templates.py --preview --name promo --vars produto=Tênis desconto=30
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from db import Database
+
+db = Database()
+db.init()
+
+
+def create_template(name: str, caption: str, hashtags: str = None, schedule_time: str = None) -> None:
+    """Cria ou atualiza um template."""
+    hashtag_list = None
+    if hashtags:
+        hashtag_list = json.dumps([h.strip() for h in hashtags.split(",")])
+
+    template_id = db.upsert_template({
+        "name": name,
+        "caption_template": caption,
+        "hashtag_set": hashtag_list,
+        "default_schedule_time": schedule_time,
+    })
+    print(json.dumps({
+        "status": "created",
+        "id": template_id,
+        "name": name,
+        "caption_template": caption,
+        "hashtags": json.loads(hashtag_list) if hashtag_list else [],
+    }, indent=2, ensure_ascii=False))
+
+
+def list_templates() -> None:
+    """Lista todos os templates."""
+    templates = db.get_templates()
+    for t in templates:
+        if t.get("hashtag_set") and isinstance(t["hashtag_set"], str):
+            try:
+                t["hashtag_set"] = json.loads(t["hashtag_set"])
+            except json.JSONDecodeError:
+                pass
+    print(json.dumps({"total": len(templates), "templates": templates}, indent=2, ensure_ascii=False))
+
+
+def show_template(name: str) -> None:
+    """Mostra detalhes de um template."""
+    t = db.get_template_by_name(name)
+    if not t:
+        print(json.dumps({"error": f"Template '{name}' não encontrado"}, indent=2))
+        return
+    if t.get("hashtag_set") and isinstance(t["hashtag_set"], str):
+        try:
+            t["hashtag_set"] = json.loads(t["hashtag_set"])
+        except json.JSONDecodeError:
+            pass
+    print(json.dumps(t, indent=2, ensure_ascii=False))
+
+
+def delete_template(name: str) -> None:
+    """Deleta um template."""
+    if db.delete_template(name):
+        print(json.dumps({"status": "deleted", "name": name}, indent=2))
+    else:
+        print(json.dumps({"error": f"Template '{name}' não encontrado"}, indent=2))
+
+
+def preview_template(name: str, variables: list) -> None:
+    """Preview de um template com variáveis aplicadas."""
+    t = db.get_template_by_name(name)
+    if not t:
+        print(json.dumps({"error": f"Template '{name}' não encontrado"}, indent=2))
+        return
+
+    caption = t["caption_template"] or ""
+    var_dict = {}
+    for v in variables:
+        if "=" in v:
+            key, val = v.split("=", 1)
+            var_dict[key.strip()] = val.strip()
+
+    try:
+        rendered = caption.format(**var_dict)
+    except KeyError as e:
+        print(json.dumps({"error": f"Variável faltando: {e}"}, indent=2))
+        return
+
+    hashtags = []
+    if t.get("hashtag_set"):
+        try:
+            hashtags = json.loads(t["hashtag_set"]) if isinstance(t["hashtag_set"], str) else t["hashtag_set"]
+        except json.JSONDecodeError:
+            pass
+
+    full_caption = rendered
+    if hashtags:
+        full_caption = f"{rendered}\n\n{' '.join(hashtags)}"
+
+    print(json.dumps({
+        "template": name,
+        "variables": var_dict,
+        "rendered_caption": full_caption,
+    }, indent=2, ensure_ascii=False))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Templates de conteúdo Instagram")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--create", action="store_true", help="Criar template")
+    group.add_argument("--list", action="store_true", help="Listar templates")
+    group.add_argument("--show", action="store_true", help="Ver template")
+    group.add_argument("--delete", action="store_true", help="Deletar template")
+    group.add_argument("--preview", action="store_true", help="Preview com variáveis")
+    parser.add_argument("--name", help="Nome do template")
+    parser.add_argument("--caption", help="Template de caption (use {var} para variáveis)")
+    parser.add_argument("--hashtags", help="Hashtags separadas por vírgula")
+    parser.add_argument("--schedule-time", help="Horário padrão (HH:MM)")
+    parser.add_argument("--vars", nargs="+", help="Variáveis (key=value)")
+    args = parser.parse_args()
+
+    if args.create:
+        if not args.name or not args.caption:
+            parser.error("--name e --caption são obrigatórios com --create")
+        create_template(args.name, args.caption, args.hashtags, args.schedule_time)
+    elif args.list:
+        list_templates()
+    elif args.show:
+        if not args.name:
+            parser.error("--name é obrigatório com --show")
+        show_template(args.name)
+    elif args.delete:
+        if not args.name:
+            parser.error("--name é obrigatório com --delete")
+        delete_template(args.name)
+    elif args.preview:
+        if not args.name:
+            parser.error("--name é obrigatório com --preview")
+        preview_template(args.name, args.vars or [])
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,216 @@
+"""
+Camada de persistência SQLite para dados de leiloeiros das Juntas Comerciais.
+
+Uso:
+    from db import Database
+    db = Database()           # abre/cria o banco em data/leiloeiros.db
+    db.init()                 # cria tabelas se não existirem
+    db.upsert_many(records)   # insere/atualiza lista de Leiloeiro
+    rows = db.get_all()       # retorna todos os registros
+    rows = db.get_by_estado("SP")
+    stats = db.get_stats()
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Caminho padrão do banco — relativo ao diretório pai de scripts/
+_DEFAULT_DB = Path(__file__).parent.parent / "data" / "leiloeiros.db"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS leiloeiros (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    estado           TEXT    NOT NULL,
+    junta            TEXT    NOT NULL,
+    matricula        TEXT,
+    nome             TEXT    NOT NULL,
+    cpf_cnpj         TEXT,
+    situacao         TEXT,
+    endereco         TEXT,
+    municipio        TEXT,
+    telefone         TEXT,
+    email            TEXT,
+    data_registro    TEXT,
+    data_atualizacao TEXT,
+    url_fonte        TEXT,
+    scraped_at       TEXT    NOT NULL,
+    UNIQUE (estado, matricula) ON CONFLICT REPLACE
+);
+
+CREATE INDEX IF NOT EXISTS idx_estado    ON leiloeiros (estado);
+CREATE INDEX IF NOT EXISTS idx_nome      ON leiloeiros (nome);
+CREATE INDEX IF NOT EXISTS idx_situacao  ON leiloeiros (situacao);
+CREATE INDEX IF NOT EXISTS idx_scraped   ON leiloeiros (scraped_at);
+"""
+
+UPSERT_SQL = """
+INSERT INTO leiloeiros
+    (estado, junta, matricula, nome, cpf_cnpj, situacao,
+     endereco, municipio, telefone, email,
+     data_registro, data_atualizacao, url_fonte, scraped_at)
+VALUES
+    (:estado, :junta, :matricula, :nome, :cpf_cnpj, :situacao,
+     :endereco, :municipio, :telefone, :email,
+     :data_registro, :data_atualizacao, :url_fonte, :scraped_at)
+ON CONFLICT(estado, matricula) DO UPDATE SET
+    junta            = excluded.junta,
+    nome             = excluded.nome,
+    cpf_cnpj         = excluded.cpf_cnpj,
+    situacao         = excluded.situacao,
+    endereco         = excluded.endereco,
+    municipio        = excluded.municipio,
+    telefone         = excluded.telefone,
+    email            = excluded.email,
+    data_registro    = excluded.data_registro,
+    data_atualizacao = excluded.data_atualizacao,
+    url_fonte        = excluded.url_fonte,
+    scraped_at       = excluded.scraped_at
+"""
+
+# Para registros sem matrícula, usa INSERT simples (não upsert)
+INSERT_SQL = """
+INSERT INTO leiloeiros
+    (estado, junta, matricula, nome, cpf_cnpj, situacao,
+     endereco, municipio, telefone, email,
+     data_registro, data_atualizacao, url_fonte, scraped_at)
+VALUES
+    (:estado, :junta, :matricula, :nome, :cpf_cnpj, :situacao,
+     :endereco, :municipio, :telefone, :email,
+     :data_registro, :data_atualizacao, :url_fonte, :scraped_at)
+"""
+
+
+class Database:
+    def __init__(self, db_path: Path = _DEFAULT_DB):
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        return conn
+
+    def init(self) -> None:
+        """Cria tabelas e índices se não existirem."""
+        with self._connect() as conn:
+            conn.executescript(DDL)
+
+    def upsert_many(self, records: List[Dict[str, Any]]) -> int:
+        """
+        Insere ou atualiza registros.
+        Registros sem matrícula são inseridos sempre (para não perder dados).
+        Retorna o número de registros processados.
+        """
+        with_matricula = [r for r in records if r.get("matricula")]
+        without_matricula = [r for r in records if not r.get("matricula")]
+
+        count = 0
+        with self._connect() as conn:
+            if with_matricula:
+                conn.executemany(UPSERT_SQL, with_matricula)
+                count += len(with_matricula)
+            if without_matricula:
+                # Evitar duplicatas exatas por (estado + nome + scraped_at)
+                conn.executemany(INSERT_SQL, without_matricula)
+                count += len(without_matricula)
+        return count
+
+    def get_all(
+        self,
+        estado: Optional[str] = None,
+        situacao: Optional[str] = None,
+        nome_like: Optional[str] = None,
+        limit: int = 0,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """Retorna registros com filtros opcionais."""
+        conditions = []
+        params: List[Any] = []
+
+        if estado:
+            conditions.append("estado = ?")
+            params.append(estado.upper())
+        if situacao:
+            conditions.append("situacao = ?")
+            params.append(situacao.upper())
+        if nome_like:
+            conditions.append("nome LIKE ?")
+            params.append(f"%{nome_like}%")
+
+        where = f"WHERE {' AND '.join(conditions)}" if conditions else ""
+
+        if limit > 0:
+            sql = f"SELECT * FROM leiloeiros {where} ORDER BY estado, nome LIMIT ? OFFSET ?"
+            params.extend([limit, offset])
+        else:
+            sql = f"SELECT * FROM leiloeiros {where} ORDER BY estado, nome"
+
+        with self._connect() as conn:
+            rows = conn.execute(sql, params).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_by_estado(self, estado: str) -> List[Dict[str, Any]]:
+        return self.get_all(estado=estado)
+
+    def get_stats(self) -> List[Dict[str, Any]]:
+        """Retorna contagem de leiloeiros por estado."""
+        sql = """
+            SELECT
+                estado,
+                junta,
+                COUNT(*) as total,
+                SUM(CASE WHEN situacao = 'ATIVO' THEN 1 ELSE 0 END) as ativos,
+                MAX(scraped_at) as ultima_coleta
+            FROM leiloeiros
+            GROUP BY estado, junta
+            ORDER BY total DESC
+        """
+        with self._connect() as conn:
+            rows = conn.execute(sql).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_total(self) -> int:
+        with self._connect() as conn:
+            return conn.execute("SELECT COUNT(*) FROM leiloeiros").fetchone()[0]
+
+    def search(self, query: str, limit: int = 50) -> List[Dict[str, Any]]:
+        """Busca full-text por nome, matrícula ou município."""
+        sql = """
+            SELECT * FROM leiloeiros
+            WHERE nome LIKE ? OR matricula LIKE ? OR municipio LIKE ? OR email LIKE ?
+            ORDER BY estado, nome
+            LIMIT ?
+        """
+        q = f"%{query}%"
+        with self._connect() as conn:
+            rows = conn.execute(sql, [q, q, q, q, limit]).fetchall()
+        return [dict(r) for r in rows]
+
+    def dump_all_json(self) -> str:
+        """Retorna todos os dados como string JSON."""
+        return json.dumps(self.get_all(), ensure_ascii=False, indent=2)
+
+
+# ── CLI rápido para verificação ──────────────────────────────────────────────
+if __name__ == "__main__":
+    import sys
+    db = Database()
+    db.init()
+    stats = db.get_stats()
+    if not stats:
+        print("Banco vazio. Execute run_all.py primeiro.")
+        sys.exit(0)
+    total = db.get_total()
+    print(f"\nTotal de leiloeiros: {total}\n")
+    print(f"{'Estado':<8} {'Junta':<12} {'Total':>6} {'Ativos':>6} {'Última Coleta'}")
+    print("-" * 60)
+    for r in stats:
+        print(
+            f"{r['estado']:<8} {r['junta']:<12} "
+            f"{r['total']:>6} {r['ativos']:>6}  {r['ultima_coleta'][:10]}"
+        )

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

@@ -0,0 +1,137 @@
+"""
+Exportação de dados de leiloeiros para diferentes formatos.
+
+Uso:
+    python scripts/export.py --format json
+    python scripts/export.py --format csv
+    python scripts/export.py --format jsonl
+    python scripts/export.py --format parquet   # requer pandas + pyarrow
+    python scripts/export.py --format all       # exporta todos os formatos
+    python scripts/export.py --format csv --estado SP
+    python scripts/export.py --output /caminho/personalizado/
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from db import Database
+
+OUTPUT_DIR = Path(__file__).parent.parent / "data" / "exports"
+
+
+def export_json(records: list, output_dir: Path, suffix: str = "") -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = output_dir / f"leiloeiros{suffix}_{ts}.json"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(
+            {"exported_at": datetime.now(timezone.utc).isoformat(), "total": len(records), "data": records},
+            f,
+            ensure_ascii=False,
+            indent=2,
+        )
+    print(f"[JSON] {len(records)} registros → {path}")
+    return path
+
+
+def export_jsonl(records: list, output_dir: Path, suffix: str = "") -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = output_dir / f"leiloeiros{suffix}_{ts}.jsonl"
+    with open(path, "w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"[JSONL] {len(records)} registros → {path}")
+    return path
+
+
+def export_csv(records: list, output_dir: Path, suffix: str = "") -> Path:
+    if not records:
+        print("[CSV] Nenhum registro para exportar.")
+        return None
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = output_dir / f"leiloeiros{suffix}_{ts}.csv"
+
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        writer = csv.DictWriter(f, fieldnames=list(records[0].keys()), extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(records)
+    print(f"[CSV] {len(records)} registros → {path}")
+    return path
+
+
+def export_parquet(records: list, output_dir: Path, suffix: str = "") -> Optional[Path]:
+    try:
+        import pandas as pd
+    except ImportError:
+        print("[PARQUET] pandas não instalado. Execute: pip install pandas pyarrow")
+        return None
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = output_dir / f"leiloeiros{suffix}_{ts}.parquet"
+
+    df = pd.DataFrame(records)
+    df.to_parquet(path, index=False, engine="pyarrow")
+    print(f"[PARQUET] {len(records)} registros → {path}")
+    return path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Exporta dados de leiloeiros")
+    parser.add_argument(
+        "--format", choices=["json", "jsonl", "csv", "parquet", "all"],
+        default="csv", help="Formato de exportação (default: csv)"
+    )
+    parser.add_argument(
+        "--estado", nargs="*", metavar="UF",
+        help="Filtrar por estado(s) (ex: SP RJ)"
+    )
+    parser.add_argument(
+        "--output", default=str(OUTPUT_DIR),
+        help=f"Diretório de saída (default: {OUTPUT_DIR})"
+    )
+    args = parser.parse_args()
+
+    db = Database()
+    db.init()
+
+    output_dir = Path(args.output)
+    estados = [e.upper() for e in args.estado] if args.estado else None
+
+    if estados:
+        all_records = []
+        for uf in estados:
+            all_records.extend(db.get_by_estado(uf))
+        suffix = "_" + "_".join(estados)
+    else:
+        all_records = db.get_all()
+        suffix = ""
+
+    if not all_records:
+        print("Banco vazio. Execute run_all.py primeiro.")
+        sys.exit(0)
+
+    fmt = args.format
+    if fmt in ("json", "all"):
+        export_json(all_records, output_dir, suffix)
+    if fmt in ("jsonl", "all"):
+        export_jsonl(all_records, output_dir, suffix)
+    if fmt in ("csv", "all"):
+        export_csv(all_records, output_dir, suffix)
+    if fmt in ("parquet", "all"):
+        export_parquet(all_records, output_dir, suffix)
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/junta-leiloeiros/scripts/requirements.txt

@@ -0,0 +1,15 @@
+# Dependências principais
+httpx>=0.27.0
+beautifulsoup4>=4.12.0
+lxml>=5.0.0
+
+# API
+fastapi>=0.111.0
+uvicorn[standard]>=0.30.0
+
+# Scraping JS (instalar browser: playwright install chromium)
+playwright>=1.44.0
+
+# Exportação avançada (opcional)
+pandas>=2.0.0
+pyarrow>=15.0.0