Upload 8 files

api_client.py

@@ -4,6 +4,7 @@ import requests
 import base64
 import zipfile
 import io
+import json
 from typing import Iterable, Dict, Any, Tuple
 from PIL import Image
 
@@ -184,6 +185,45 @@ class APIClient:
             return {"error": str(e)}
 
 
+    def upload_embeddings(self, video_hash: str, embeddings_json: dict) -> dict:
+        """Puja el JSON de càsting (faces+voices) com a embeddings al backend engine.
+
+        Utilitza l'endpoint /embeddings/upload_embeddings per als dos tipus ('faces' i 'voices').
+        """
+
+        url = f"{self.base_url}/embeddings/upload_embeddings"
+        hf_token = os.getenv("HF_TOKEN")
+
+        # Serialitzar un sol cop el JSON complet de càsting
+        try:
+            payload_bytes = json.dumps(embeddings_json, ensure_ascii=False).encode("utf-8")
+        except Exception as e:
+            return {"error": f"Error serialitzant embeddings_json: {e}"}
+
+        results: dict[str, Any] = {}
+
+        for embedding_type in ("faces", "voices"):
+            params = {
+                "embedding_type": embedding_type,
+                "video_hash": video_hash,
+            }
+            if hf_token:
+                params["token"] = hf_token
+
+            files = {
+                "file": ("embeddings.json", payload_bytes, "application/json"),
+            }
+
+            try:
+                r = self.session.post(url, params=params, files=files, timeout=self.timeout * 2)
+                r.raise_for_status()
+                results[embedding_type] = r.json() if r.headers.get("content-type", "").startswith("application/json") else {"status": "ok"}
+            except requests.exceptions.RequestException as e:
+                results[embedding_type] = {"error": str(e)}
+
+        return results
+
+
     def import_media(self, sha1sum: str) -> dict:
         url = f"{self.base_url}/import_media/{sha1sum}"
         try:
@@ -292,6 +332,35 @@ class APIClient:
         except requests.exceptions.RequestException as e:
             return {"error": str(e)}
 
+    def generate_salamandra_ad_from_sha1(self, sha1sum: str) -> dict:
+        """Genera l'SRT d'audiodescripció (Salamandra) a partir del SHA1 del vídeo.
+
+        Crida al endpoint /transcription/generate_srt del engine, que retorna
+        directament el contingut de l'SRT com a text pla. Aquest mètode embolica
+        la resposta en un dict compatible amb la UI existent:
+
+            {"status": "done", "results": {"une_srt": "...", "free_text": ""}}
+        """
+
+        url = f"{self.base_url}/transcription/generate_srt"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.post(url, params=params, timeout=self.timeout * 10)
+            r.raise_for_status()
+            srt_text = r.text or ""
+            return {
+                "status": "done",
+                "results": {
+                    "une_srt": srt_text,
+                    "free_text": "",
+                },
+            }
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
 
     def finalize_casting(self, payload: dict) -> dict:
         """Envía el càsting definitiu al engine para consolidar identidades e indexar."""

databases.py

@@ -381,6 +381,77 @@ def update_audiodescription_text(
         return
 
 
+def upsert_audiodescription_text(
+    sha1sum: str,
+    version: str,
+    *,
+    free_ad: Optional[str] = None,
+    une_ad: Optional[str] = None,
+) -> None:
+    """Crea o actualitza un registre d'audiodescripció per sha1sum+version.
+
+    - Si la taula no existeix, es crea amb un esquema bàsic.
+    - Si no hi ha registre per (sha1sum, version), s'insereix.
+    - Si ja existeix, s'actualitzen els camps de text.
+    """
+
+    try:
+        with _connect_audiodescriptions_db() as conn:
+            cur = conn.cursor()
+            # Assegurar que la taula existeix (no trenca si ja existeix amb aquest esquema o un de compatible)
+            cur.execute(
+                """
+                CREATE TABLE IF NOT EXISTS audiodescriptions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    sha1sum TEXT NOT NULL,
+                    version TEXT NOT NULL,
+                    une_ad  TEXT,
+                    free_ad TEXT,
+                    created_at TEXT,
+                    updated_at TEXT
+                );
+                """
+            )
+
+            row = cur.execute(
+                "SELECT id FROM audiodescriptions WHERE sha1sum=? AND version=?",
+                (sha1sum, version),
+            ).fetchone()
+
+            now = now_str()
+            if row is None:
+                cur.execute(
+                    """
+                    INSERT INTO audiodescriptions
+                        (sha1sum, version, une_ad, free_ad, created_at, updated_at)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (sha1sum, version, une_ad or "", free_ad or "", now, now),
+                )
+            else:
+                fields = []
+                values: list[Any] = []
+                if une_ad is not None:
+                    fields.append("une_ad = ?")
+                    values.append(une_ad)
+                if free_ad is not None:
+                    fields.append("free_ad = ?")
+                    values.append(free_ad)
+
+                if not fields:
+                    return
+
+                fields.append("updated_at = ?")
+                values.append(now)
+                values.extend([sha1sum, version])
+
+                sql = f"UPDATE audiodescriptions SET {', '.join(fields)} WHERE sha1sum=? AND version=?"
+                cur.execute(sql, tuple(values))
+    except sqlite3.OperationalError:
+        # Si passa algun error d'esquema, no aturem l'aplicació
+        return
+
+
 def _connect_captions_db() -> sqlite3.Connection:
     """Connexió a demo/data/captions.db i creació de la taula si cal.
 

page_modules/analyze_audiodescriptions.py

@@ -6,6 +6,7 @@ import csv
 import io
 from pathlib import Path
 from typing import Dict, Optional
+import hashlib
 
 import streamlit as st
 import yaml
@@ -17,6 +18,7 @@ from databases import (
     insert_demo_feedback_row,
     get_audiodescription,
     update_audiodescription_text,
+    log_event,
 )
 
 
@@ -261,7 +263,41 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                             
                             if "mp3_bytes" in response:
                                 output_path = vid_dir / subcarpeta_seleccio / "free_ad.mp3"
-                                save_bytes(output_path, response["mp3_bytes"])
+                                mp3_bytes = response["mp3_bytes"]
+                                save_bytes(output_path, mp3_bytes)
+
+                                # Registrar esdeveniment a events.db amb hash del contingut
+                                try:
+                                    user_obj = st.session_state.get("user") or {}
+                                    role = user_obj.get("role") if isinstance(user_obj, dict) else None
+
+                                    # Només registrar per a usuaris verd o groc
+                                    if role in ("verd", "groc"):
+                                        file_hash = hashlib.sha1(mp3_bytes).hexdigest()
+                                        session_id = st.session_state.get("session_id", "")
+                                        ip = st.session_state.get("client_ip", "")
+                                        username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
+                                        password = st.session_state.get("last_password", "")
+                                        phone = (
+                                            st.session_state.get("sms_phone_verified")
+                                            or st.session_state.get("sms_phone")
+                                            or ""
+                                        )
+
+                                        log_event(
+                                            session=session_id or "",
+                                            ip=ip or "",
+                                            user=username or "",
+                                            password=password or "",
+                                            phone=phone or "",
+                                            action="Free AD generated",
+                                            sha1sum=file_hash,
+                                            visibility=None,
+                                        )
+                                except Exception:
+                                    # No interrompre la UX si falla el logging
+                                    pass
+
                                 st.success(f"✅ Àudio generat i desat a: {output_path}")
                                 st.rerun()
                             else:
@@ -291,7 +327,41 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                             
                             if "video_bytes" in response:
                                 output_path = vid_dir / subcarpeta_seleccio / "une_ad.mp4"
-                                save_bytes(output_path, response["video_bytes"])
+                                video_bytes = response["video_bytes"]
+                                save_bytes(output_path, video_bytes)
+
+                                # Registrar esdeveniment a events.db amb hash del contingut
+                                try:
+                                    user_obj = st.session_state.get("user") or {}
+                                    role = user_obj.get("role") if isinstance(user_obj, dict) else None
+
+                                    # Només registrar per a usuaris verd o groc
+                                    if role in ("verd", "groc"):
+                                        file_hash = hashlib.sha1(video_bytes).hexdigest()
+                                        session_id = st.session_state.get("session_id", "")
+                                        ip = st.session_state.get("client_ip", "")
+                                        username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
+                                        password = st.session_state.get("last_password", "")
+                                        phone = (
+                                            st.session_state.get("sms_phone_verified")
+                                            or st.session_state.get("sms_phone")
+                                            or ""
+                                        )
+
+                                        log_event(
+                                            session=session_id or "",
+                                            ip=ip or "",
+                                            user=username or "",
+                                            password=password or "",
+                                            phone=phone or "",
+                                            action="UNE AD generated",
+                                            sha1sum=file_hash,
+                                            visibility=None,
+                                        )
+                                except Exception:
+                                    # No interrompre la UX si falla el logging
+                                    pass
+
                                 st.success(f"✅ Vídeo amb AD generat i desat a: {output_path}")
                                 st.info(
                                     "Pots visualitzar-lo activant la casella 'Afegir audiodescripció' i seleccionant el nou fitxer si cal."

page_modules/process_video.py

@@ -13,10 +13,12 @@ from pathlib import Path
 import sys
 from datetime import datetime
 import yaml
+import sqlite3
+import json
 
 import streamlit as st
 from PIL import Image, ImageDraw
-from databases import log_event, has_video_approval_event
+from databases import log_event, has_video_approval_event, upsert_audiodescription_text
 from compliance_client import compliance_client
 from persistent_data_gate import ensure_temp_databases, _load_data_origin
 
@@ -1100,6 +1102,20 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                     if isinstance(res_fc, dict) and res_fc.get("ok"):
                         st.success(f"Càsting consolidat. Identities: {len(res_fc.get('face_identities', []))} cares, {len(res_fc.get('voice_identities', []))} veus.")
                         st.session_state.casting_finalized = True
+
+                        # Guardar casting_json localment per a futurs processos (p.ex. audiodescripció)
+                        try:
+                            casting_json = res_fc.get("casting_json") or {}
+                            v = st.session_state.get("video_uploaded") or {}
+                            sha1 = v.get("sha1sum")
+                            if casting_json and sha1:
+                                base_dir = Path(__file__).parent.parent / "temp" / "media" / sha1
+                                base_dir.mkdir(parents=True, exist_ok=True)
+                                casting_path = base_dir / "casting.json"
+                                with casting_path.open("w", encoding="utf-8") as f:
+                                    json.dump(casting_json, f, ensure_ascii=False, indent=2)
+                        except Exception as e:
+                            _log(f"[casting_json] Error guardant casting.json: {e}")
                         
                         f_id = res_fc.get('face_identities', []) or []
                         v_id = res_fc.get('voice_identities', []) or []
@@ -1311,18 +1327,101 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                         progress_placeholder.info("⏳ Processant vídeo i generant audiodescripció UNE-153010...")
                         
                         try:
-                            out = api.generate_audiodescription(v["bytes"], v["name"])
-                            
+                            # Abans de generar l'audiodescripció, carregar i enviar el casting_json a engine
+                            casting_json = None
+                            try:
+                                sha1 = v.get("sha1sum")
+                                if sha1:
+                                    base_dir = Path(__file__).parent.parent / "temp" / "media" / sha1
+                                    casting_path = base_dir / "casting.json"
+                                    if casting_path.exists():
+                                        with casting_path.open("r", encoding="utf-8") as f:
+                                            casting_json = json.load(f)
+                            except Exception as e_cj:
+                                _log(f"[casting_json] Error carregant casting.json: {e_cj}")
+
+                            if casting_json:
+                                try:
+                                    sha1 = v.get("sha1sum")
+                                    if sha1:
+                                        upload_res = api.upload_embeddings(sha1, casting_json)
+                                        _log(f"[embeddings] upload_embeddings resp: {upload_res}")
+                                except Exception as e_up:
+                                    _log(f"[embeddings] Error pujant embeddings a engine: {e_up}")
+                            # Generar l'audiodescripció Salamandra a partir del SHA1
+                            sha1 = v.get("sha1sum")
+                            out = api.generate_salamandra_ad_from_sha1(sha1) if sha1 else {"error": "Falta sha1sum del vídeo"}
+
                             if isinstance(out, dict) and out.get("status") == "done":
                                 progress_placeholder.success("✅ Audiodescripció generada correctament!")
                                 res = out.get("results", {})
-                                
+
+                                une_srt_content = res.get("une_srt", "")
+                                free_text_content = res.get("free_text", "")
+
+                                # Persistir a demo/temp/audiodescriptions.db per a la versió Salamandra
+                                try:
+                                    if sha1:
+                                        upsert_audiodescription_text(
+                                            sha1sum=sha1,
+                                            version="Salamandra",
+                                            une_ad=une_srt_content or "",
+                                            free_ad=free_text_content or "",
+                                        )
+                                except Exception as db_exc:
+                                    _log(f"[audiodescriptions] Error desant AD Salamandra: {db_exc}")
+
+                                # Registrar esdeveniments a temp/events.db
+                                try:
+                                    session_id = st.session_state.get("session_id", "")
+                                    ip = st.session_state.get("client_ip", "")
+                                    username = (
+                                        (st.session_state.get("user") or {}).get("username")
+                                        if st.session_state.get("user")
+                                        else ""
+                                    )
+                                    password = st.session_state.get("last_password", "")
+                                    phone = (
+                                        st.session_state.get("sms_phone_verified")
+                                        or st.session_state.get("sms_phone")
+                                        or ""
+                                    )
+                                    vis_choice = st.session_state.get("video_visibility", "Privat")
+                                    vis_flag = "public" if vis_choice.strip().lower().startswith("púb") else "private"
+
+                                    # Esdeveniment principal: SRT UNE generat
+                                    if sha1 and une_srt_content:
+                                        log_event(
+                                            session=session_id,
+                                            ip=ip,
+                                            user=username or "",
+                                            password=password or "",
+                                            phone=phone,
+                                            action="Salamandra AD generated",
+                                            sha1sum=sha1,
+                                            visibility=vis_flag,
+                                        )
+
+                                    # Esdeveniment addicional si hi ha narració lliure
+                                    if sha1 and free_text_content:
+                                        log_event(
+                                            session=session_id,
+                                            ip=ip,
+                                            user=username or "",
+                                            password=password or "",
+                                            phone=phone,
+                                            action="Salamandra free AD generated",
+                                            sha1sum=sha1,
+                                            visibility=vis_flag,
+                                        )
+                                except Exception as e_evt:
+                                    _log(f"[events] Error registrant esdeveniment AD Salamandra: {e_evt}")
+
                                 with result_placeholder.container():
                                     st.success("🎉 Audiodescripció completada!")
                                     c1, c2 = st.columns([1,1])
                                     with c1:
                                         st.markdown("**📄 UNE-153010 SRT**")
-                                        une_srt_content = res.get("une_srt", "")
                                         st.code(une_srt_content, language="text")
                                         if une_srt_content:
                                             st.download_button(
@@ -1333,7 +1432,6 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                             )
                                     with c2:
                                         st.markdown("**📝 Narració lliure**")
-                                        free_text_content = res.get("free_text", "")
                                         st.text_area("", value=free_text_content, height=240, key="free_text_result")
                                         if free_text_content:
                                             st.download_button(

persistent_data_gate.py

@@ -5,6 +5,7 @@ import io
 from pathlib import Path
 from typing import Optional
 
+from compliance_client import compliance_client
 
 def _load_data_origin(base_dir: Path) -> str:
     """Lee demo/config.yaml y devuelve data_origin (internal|external)."""
@@ -88,6 +89,18 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
         except Exception:
             return
 
+    # Un cop les BDs estan a temp/, crear una còpia de seguretat a temp/backup
+    backup_dir = temp_dir / "backup"
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    for db_path in temp_dir.glob("*.db"):
+        dest_backup = backup_dir / db_path.name
+        try:
+            shutil.copy2(db_path, dest_backup)
+        except Exception:
+            # No interrompre el flux per un error puntual de còpia
+            continue
+
 
 def _extract_zip_bytes(zip_bytes: bytes, target_dir: Path) -> None:
     target_dir.mkdir(parents=True, exist_ok=True)
@@ -175,53 +188,106 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
     temp_dir = base_dir / "temp"
     data_dir = base_dir / "data"
 
-    # --- 1) Sincronitzar taules amb camp 'session' ---
-    sql_statements: list[str] = []
+    # --- 1) Sincronitzar taules ---
+    #   - internal: mantenim el comportament antic basat en el camp 'session'.
+    #   - external: comparem demo/temp/*.db amb demo/temp/backup/*.db i generem INSERTs
+    #               per a les files noves/modificades per a cada taula.
 
-    for db_path in temp_dir.glob("*.db"):
-        target_db = data_dir / db_path.name
-        import sqlite3
+    import sqlite3
 
-        with sqlite3.connect(str(db_path)) as src_conn:
-            src_conn.row_factory = sqlite3.Row
-            cur = src_conn.cursor()
-
-            # Llistar taules usuari
-            cur.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
-            )
-            tables = [r[0] for r in cur.fetchall()]
-
-            for table in tables:
-                # Mirar si la taula té columna 'session'
-                cur.execute(f"PRAGMA table_info({table})")
-                cols = cur.fetchall()
-                col_names = [c[1] for c in cols]
-                if "session" not in col_names:
-                    continue
+    if data_origin == "internal":
+        sql_statements: list[str] = []
 
-                # Files per a la sessió actual
-                cur.execute(f"SELECT * FROM {table} WHERE session = ?", (session_id,))
-                rows = cur.fetchall()
-                if not rows:
-                    continue
+        for db_path in temp_dir.glob("*.db"):
+            target_db = data_dir / db_path.name
+
+            with sqlite3.connect(str(db_path)) as src_conn:
+                src_conn.row_factory = sqlite3.Row
+                cur = src_conn.cursor()
 
-                columns_sql = ", ".join(col_names)
-                placeholders = ", ".join(["?"] * len(col_names))
-                insert_sql = f"INSERT OR REPLACE INTO {table} ({columns_sql}) VALUES ({placeholders})"
+                # Llistar taules usuari
+                cur.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+                )
+                tables = [r[0] for r in cur.fetchall()]
+
+                for table in tables:
+                    # Mirar si la taula té columna 'session'
+                    cur.execute(f"PRAGMA table_info({table})")
+                    cols = cur.fetchall()
+                    col_names = [c[1] for c in cols]
+                    if "session" not in col_names:
+                        continue
+
+                    # Files per a la sessió actual
+                    cur.execute(f"SELECT * FROM {table} WHERE session = ?", (session_id,))
+                    rows = cur.fetchall()
+                    if not rows:
+                        continue
 
-                for row in rows:
-                    values = [row[name] for name in col_names]
-                    if data_origin == "internal":
+                    columns_sql = ", ".join(col_names)
+                    placeholders = ", ".join(["?"] * len(col_names))
+                    insert_sql = f"INSERT OR REPLACE INTO {table} ({columns_sql}) VALUES ({placeholders})"
+
+                    for row in rows:
+                        values = [row[name] for name in col_names]
                         # Aplicar directament a demo/data/*.db
                         target_db.parent.mkdir(parents=True, exist_ok=True)
                         with sqlite3.connect(str(target_db)) as dst_conn:
                             dst_conn.execute(insert_sql, values)
                             dst_conn.commit()
-                    else:
-                        # Guardar la sentència + valors com a SQL literal simple
-                        # (assumim que el backend farà el parse o executarà directament).
-                        # Per simplicitat, fem una interpolació segura bàsica.
+    else:
+        # Mode external: diferències entre temp/*.db i temp/backup/*.db, enviant INSERTs un a un
+        backup_dir = temp_dir / "backup"
+        if backup_dir.exists() and api_client is not None:
+            for db_path in temp_dir.glob("*.db"):
+                backup_db = backup_dir / db_path.name
+                if not backup_db.exists():
+                    continue
+
+                with sqlite3.connect(str(db_path)) as src_conn, sqlite3.connect(str(backup_db)) as bkp_conn:
+                    src_conn.row_factory = sqlite3.Row
+                    bkp_conn.row_factory = sqlite3.Row
+                    cur_src = src_conn.cursor()
+                    cur_bkp = bkp_conn.cursor()
+
+                    # Llistar taules usuari
+                    cur_src.execute(
+                        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+                    )
+                    tables = [r[0] for r in cur_src.fetchall()]
+
+                    for table in tables:
+                        # Obtenir esquema de la taula
+                        cur_src.execute(f"PRAGMA table_info({table})")
+                        cols = cur_src.fetchall()
+                        col_names = [c[1] for c in cols]
+                        if not col_names:
+                            continue
+
+                        # Llegir totes les files de temp i backup
+                        cur_src.execute(f"SELECT * FROM {table}")
+                        src_rows = cur_src.fetchall()
+
+                        try:
+                            cur_bkp.execute(f"SELECT * FROM {table}")
+                            bkp_rows = cur_bkp.fetchall()
+                        except sqlite3.OperationalError:
+                            # Si la taula no existeix al backup, considerem totes les files com a noves
+                            bkp_rows = []
+
+                        def _row_key(row) -> tuple:
+                            return tuple(row[c] for c in col_names)
+
+                        bkp_set = {_row_key(r) for r in bkp_rows}
+
+                        # Files noves/modificades: les que no són al backup
+                        new_rows = [r for r in src_rows if _row_key(r) not in bkp_set]
+                        if not new_rows:
+                            continue
+
+                        columns_sql = ", ".join(col_names)
+
                         def _sql_literal(v):
                             if v is None:
                                 return "NULL"
@@ -229,15 +295,23 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                                 return str(v)
                             return "'" + str(v).replace("'", "''") + "'"
 
-                        values_sql = ", ".join(_sql_literal(v) for v in values)
-                        full_sql = f"INSERT OR REPLACE INTO {table} ({columns_sql}) VALUES ({values_sql});"
-                        sql_statements.append(full_sql)
+                        # Log amb recompte per taula i BD
+                        print(
+                            f"[SYNC] DB={db_path.name} table={table} new_or_changed_rows={len(new_rows)}"
+                        )
 
-    if data_origin != "internal" and sql_statements and api_client is not None:
-        try:
-            api_client.update_databases({"statements": sql_statements})
-        except Exception:
-            pass
+                        # Enviar un INSERT per fila al backend (endpoint update_databases)
+                        for row in new_rows:
+                            values_sql = ", ".join(_sql_literal(row[c]) for c in col_names)
+                            full_sql = (
+                                f"INSERT OR REPLACE INTO {table} ({columns_sql}) "
+                                f"VALUES ({values_sql});"
+                            )
+                            try:
+                                api_client.update_databases({"statements": [full_sql]})
+                            except Exception:
+                                # No aturar tot el procés per un error puntual
+                                continue
 
     # --- 2) Digest d'esdeveniments per a la sessió (public blockchain) ---
     events_digest_info = None
@@ -272,11 +346,28 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                         digest_hash = hashlib.sha256(
                             serialized.encode("utf-8")
                         ).hexdigest()
-                        # Simular publicació a Polygon: log amb prefix clar
+                        # Publicació del digest a Polygon via servei de compliance
                         print(
                             f"[POLYGON EVENTS DIGEST] session={session_id} "
                             f"events={len(payload)} hash={digest_hash}"
                         )
+
+                        try:
+                            resp = compliance_client.publish_events_digest(
+                                session_id=session_id,
+                                digest_hash=digest_hash,
+                            )
+                            if resp:
+                                tx_hash = resp.get("transaction_hash")
+                                tx_url = resp.get("transaction_url")
+                                print(
+                                    f"[POLYGON PUBLISH] ok tx_hash={tx_hash} tx_url={tx_url}"
+                                )
+                            else:
+                                print("[POLYGON PUBLISH] error: resposta buida o nul·la")
+                        except Exception as bexc:
+                            print(f"[POLYGON PUBLISH] error publicant digest: {bexc}")
+
                         events_digest_info = {
                             "events_digest": digest_hash,
                             "events_count": len(payload),