Update app.py

app.py

@@ -7,9 +7,9 @@ import gradio as gr
 from b2sdk.v2 import *
 # Newer b2sdk versions no longer export the exceptions through "import *": import it by name
 try:
-    from b2sdk.v2.exception import NonExistentBucket
+    from b2sdk.v2.exception import NonExistentBucket, RestrictedBucket
 except ImportError:
-    from b2sdk.exception import NonExistentBucket
+    from b2sdk.exception import NonExistentBucket, RestrictedBucket
 import dropbox
 import gspread
 import gspread.exceptions
@@ -143,6 +143,15 @@ STRINGS = {
                    "{p} MP4 (≤ 100 Mo) *", "{p} MP4 (≤ 100MB) *", "{p} MP4 (≤ 100MB) *"),
 
     # ---- upload button + result ----
+    "uploading": ("⏳ Uploading… please keep this page open", "⏳ A carregar… mantém esta página aberta",
+                  "⏳ Bezig met uploaden… houd deze pagina open", "⏳ Import en cours… gardez cette page ouverte",
+                  "⏳ Caricamento… tieni aperta questa pagina", "⏳ Subiendo… mantén esta página abierta"),
+    "m_storage_full": ("⚠ Your cloud storage is full. Please wait for your currently scheduled posts to be published, or contact support for assistance.",
+                       "⚠ O teu armazenamento na cloud está cheio. Aguarda que as publicações agendadas sejam publicadas, ou contacta o suporte para obter ajuda.",
+                       "⚠ Je cloudopslag is vol. Wacht tot je ingeplande berichten zijn gepubliceerd, of neem contact op met support voor hulp.",
+                       "⚠ Votre stockage cloud est plein. Attendez que vos publications programmées soient publiées, ou contactez le support pour obtenir de l'aide.",
+                       "⚠ Il tuo spazio cloud è pieno. Attendi che i post programmati vengano pubblicati, oppure contatta l'assistenza.",
+                       "⚠ Tu almacenamiento en la nube está lleno. Espera a que se publiquen tus publicaciones programadas o contacta con soporte para obtener ayuda."),
     "upload_ready": ("Upload", "Carregar", "Uploaden", "Importer", "Carica", "Subir"),
     "upload_waiting": ("Waiting for files to finish uploading…", "À espera que os ficheiros terminem de carregar…",
                        "Wachten tot de bestanden klaar zijn met uploaden…",
@@ -210,6 +219,18 @@ STRINGS = {
                         "⚠ Nom de l'auteur / Nom du jeu / Partie doivent contenir au moins un caractère valide.",
                         "⚠ Nome autore / Nome del gioco / Parte devono contenere almeno un carattere valido.",
                         "⚠ Nombre del autor / Nombre del juego / Parte deben contener al menos un carácter válido."),
+    "m_key_restricted": ("⚠ The B2 application key set in this Space only opens the bucket '{a}', so it can't reach '{b}'. "
+                         "Create a B2 key with access to all buckets and put it in B2_KEY_ID / B2_APP_KEY.",
+                         "⚠ A chave de aplicação B2 configurada neste Space só abre o bucket '{a}', por isso não chega a '{b}'. "
+                         "Cria uma chave B2 com acesso a todos os buckets e coloca-a em B2_KEY_ID / B2_APP_KEY.",
+                         "⚠ De B2-applicatiesleutel van deze Space opent alleen bucket '{a}', dus '{b}' is niet bereikbaar. "
+                         "Maak een B2-sleutel met toegang tot alle buckets en zet die in B2_KEY_ID / B2_APP_KEY.",
+                         "⚠ La clé d'application B2 de ce Space n'ouvre que le bucket '{a}', elle ne peut donc pas atteindre '{b}'. "
+                         "Créez une clé B2 avec accès à tous les buckets et mettez-la dans B2_KEY_ID / B2_APP_KEY.",
+                         "⚠ La chiave applicativa B2 di questo Space apre solo il bucket '{a}', quindi non raggiunge '{b}'. "
+                         "Crea una chiave B2 con accesso a tutti i bucket e inseriscila in B2_KEY_ID / B2_APP_KEY.",
+                         "⚠ La clave de aplicación B2 de este Space solo abre el bucket '{a}', así que no llega a '{b}'. "
+                         "Crea una clave B2 con acceso a todos los buckets y ponla en B2_KEY_ID / B2_APP_KEY."),
     "m_no_bucket": ("⚠ No B2 bucket named '{b}' was found. Please create it (with Non-Shorts and Shorts subfolders) before uploading.",
                     "⚠ Não foi encontrado nenhum bucket B2 chamado '{b}'. Cria-o (com as subpastas Non-Shorts e Shorts) antes de fazer upload.",
                     "⚠ Er is geen B2-bucket met de naam '{b}' gevonden. Maak hem aan (met de submappen Non-Shorts en Shorts) voordat je uploadt.",
@@ -276,7 +297,8 @@ def find_missing_fields(fields: dict):
 # ---------- FILENAME SANITIZATION ----------
 # Characters that Windows (and B2/Dropbox in practice) don't allow in file/folder
 # names: \ / : * ? " < > |
-INVALID_FILENAME_CHARS = '\\/:*?"<>|'
+# also apostrophes (straight and curly) and backticks: "Assassin's" -> "Assassins"
+INVALID_FILENAME_CHARS = '\\/:*?"<>|' + "'\u2018\u2019\u02bc`\u00b4"
 
 def strip_invalid_filename_chars(text):
     """Removes every character in INVALID_FILENAME_CHARS from text."""
@@ -295,6 +317,13 @@ def sanitize_author_component(author_name):
     cleaned = re.sub(r"\s+", "_", cleaned)
     return cleaned.upper()
 
+def clean_game_name(game_name):
+    """The Game Name exactly as it is written to the Google Sheet AND used in the file names:
+    'Tomb Raider/ 4' -> 'Tomb_Raider_4' | "Pokémon's Adventure" -> 'Pokémons_Adventure'"""
+    words = strip_invalid_filename_chars(game_name or "").split()
+    return "_".join(w.capitalize() for w in words if w)
+
+
 def sanitize_game_part_component(game_name, part):
     """'Silent hill 2' + 'full game' -> 'Silent_Hill_2_Full_Game'"""
     combined = strip_invalid_filename_chars(f"{game_name or ''} {part or ''}").strip()
@@ -310,6 +339,13 @@ def sanitize_filename_component(text):
     return cleaned
 
 # ---------- B2 BUCKET-PER-AUTHOR RESOLUTION ----------
+class B2KeyRestricted(Exception):
+    """The B2 application key in the Space settings only opens one bucket (not every Author's)."""
+    def __init__(self, allowed):
+        super().__init__(allowed)
+        self.allowed = allowed
+
+
 def get_author_bucket(safe_author):
     """Resolves the B2 bucket named exactly like the sanitized Author, or
     returns None if no such bucket exists."""
@@ -317,12 +353,107 @@ def get_author_bucket(safe_author):
         return b2_api.get_bucket_by_name(safe_author)
     except NonExistentBucket:
         return None
+    except RestrictedBucket as e:
+        allowed = getattr(e, "bucket_name", None) or str(e).rsplit(":", 1)[-1].strip()
+        print(f"B2: the application key only allows bucket {allowed!r}, not {safe_author!r}")
+        raise B2KeyRestricted(allowed)
 
 # ---------- DUPLICATE-FILE CHECK HELPERS ----------
 def b2_existing_filenames(bucket):
     """Returns the set of file names currently stored in a B2 bucket."""
     return {file_version.file_name for file_version, _ in bucket.ls(recursive=True)}
 
+
+# ---------- CLOUD STORAGE LIMIT (STORAGE_LIMIT_GB of each world) ----------
+# The limit lives in /home/Gamifypt/Universes/<WORLD>/.env on admin.gamify.pt, which this Space
+# can't read, so it asks the admin panel (/api/storage-limit/<BUCKET>) with a short-lived token
+# signed with GAMIFY_GATE_SECRET (the same secret the access gate already uses). What is in use
+# is measured here, live: Non-Shorts/ + Shorts/ of the Author's bucket.
+import base64
+import hashlib
+import hmac
+import time
+import requests
+from urllib.parse import quote as _url_quote
+
+def _admin_base_url():
+    """The admin panel address. Taken from GAMIFY_LOGIN_URL (already set for the access gate,
+    e.g. admin.gamify.pt/home -> https://admin.gamify.pt); GAMIFY_ADMIN_URL overrides it if set."""
+    from urllib.parse import urlsplit
+    raw = (os.getenv("GAMIFY_ADMIN_URL") or os.getenv("GAMIFY_LOGIN_URL") or "https://admin.gamify.pt").strip()
+    if "://" not in raw:
+        raw = "https://" + raw
+    parts = urlsplit(raw)
+    return f"{parts.scheme}://{parts.netloc}"
+
+
+GAMIFY_ADMIN_URL = _admin_base_url()
+BYTES_PER_GB = 1024 ** 3                 # same unit the admin panel uses for STORAGE_LIMIT_GB
+STORAGE_FOLDERS = ("Non-Shorts/", "Shorts/")
+
+
+def b2_bucket_contents(bucket):
+    """(set of file names, bytes used by Non-Shorts/ + Shorts/) — one listing of the bucket."""
+    names, used = set(), 0
+    for file_version, _ in bucket.ls(recursive=True):
+        names.add(file_version.file_name)
+        if file_version.file_name.startswith(STORAGE_FOLDERS):
+            used += int(getattr(file_version, "size", 0) or 0)
+    return names, used
+
+
+def _admin_call_token():
+    secret = os.getenv("GAMIFY_GATE_SECRET", "").strip()
+    if not secret:
+        return None
+    b64 = lambda raw: base64.urlsafe_b64encode(raw).decode().rstrip("=")
+    payload = b64(json.dumps({"u": "upload-center", "exp": int(time.time()) + 120, "src": "home"}).encode())
+    sig = b64(hmac.new(secret.encode(), payload.encode(), hashlib.sha256).digest())
+    return f"{payload}.{sig}"
+
+
+def storage_limit_bytes(bucket_name):
+    """The world's STORAGE_LIMIT_GB in bytes, or None (no limit set, or the admin panel can't be
+    reached — then the upload is NOT blocked, and the reason goes to the logs)."""
+    token = _admin_call_token()
+    if not token:
+        print("STORAGE LIMIT: GAMIFY_GATE_SECRET is not set in this Space -- limit not checked")
+        return None
+    try:
+        r = requests.get(f"{GAMIFY_ADMIN_URL}/api/storage-limit/{_url_quote(bucket_name)}",
+                         headers={"X-Gamify-Gate": token}, timeout=15)
+        data = r.json() if r.content else {}
+        if not r.ok:
+            print(f"STORAGE LIMIT: admin answered {r.status_code} for {bucket_name}: {data}")
+            return None
+        limit = data.get("limit_gb")
+        return float(limit) * BYTES_PER_GB if limit is not None else None
+    except Exception as e:
+        print(f"STORAGE LIMIT: could not ask the admin panel for {bucket_name}: {e!r}")
+        return None
+
+
+def report_storage_used(bucket_name, used_bytes):
+    """After an upload: tells the admin panel how full the bucket is now (STORAGE_LIMIT_USED +
+    its 'almost full' alerts). Never fails the upload."""
+    token = _admin_call_token()
+    if not token:
+        return
+    try:
+        requests.post(f"{GAMIFY_ADMIN_URL}/api/storage-limit/{_url_quote(bucket_name)}",
+                      headers={"X-Gamify-Gate": token}, json={"used_bytes": int(used_bytes)}, timeout=15)
+    except Exception as e:
+        print(f"STORAGE LIMIT: could not report usage for {bucket_name}: {e!r}")
+
+
+def storage_would_overflow(bucket_name, used_bytes, incoming_bytes):
+    limit = storage_limit_bytes(bucket_name)
+    if limit is None or incoming_bytes <= 0:
+        return False
+    print(f"STORAGE LIMIT: {bucket_name} uses {used_bytes / 2**20:.0f} MB of {limit / 2**20:.0f} MB, "
+          f"upload needs {incoming_bytes / 2**20:.0f} MB")
+    return used_bytes + incoming_bytes > limit
+
 def dropbox_file_exists(path):
     """Returns True if a file already exists at the given Dropbox path."""
     try:
@@ -532,7 +663,7 @@ def write_long_video_row(author_name, game_name, part, yt_playlist, game_url, sy
     ws = get_worksheet(target_tab)
     row = find_target_row(ws)
     ws.batch_update([
-        {"range": f"A{row}", "values": [[game_name]]},
+        {"range": f"A{row}", "values": [[clean_game_name(game_name)]]},
         {"range": f"B{row}", "values": [[part]]},
         {"range": f"D{row}", "values": [[yt_playlist]]},
         {"range": f"E{row}", "values": [[game_url]]},
@@ -548,7 +679,7 @@ def write_shorts_row(author_name, game_name, part, yt_playlist, game_url, synops
     ws = get_worksheet(target_tab)
     row = find_target_row(ws)
     ws.batch_update([
-        {"range": f"A{row}", "values": [[game_name]]},
+        {"range": f"A{row}", "values": [[clean_game_name(game_name)]]},
         {"range": f"B{row}", "values": [[part]]},
         {"range": f"C{row}", "values": [[yt_playlist]]},
         {"range": f"D{row}", "values": [[game_url]]},
@@ -617,23 +748,43 @@ def upload_long(
         if save_size > 50 * 1024 * 1024:
             return T(lang, "m_save_size"), ""
 
-    # ---- Build the final filename: Author_Game_Part.ext ----
+    # ---- Build the final filename: Game_Part.ext (inside the Author's bucket) ----
     safe_author = sanitize_author_component(author_name)
     safe_game_part = sanitize_game_part_component(game_name, part)
-    if not safe_author or not safe_game_part:
+    if not safe_author or not safe_game_part or not clean_game_name(game_name):
         return T(lang, "m_invalid_chars"), ""
 
     # ---- Resolve the B2 bucket for this Author (one bucket per Author/channel) ----
-    author_bucket = get_author_bucket(safe_author)
+    try:
+        author_bucket = get_author_bucket(safe_author)
+    except B2KeyRestricted as e:
+        if png_is_temp:
+            try:
+                os.remove(png_path)
+            except OSError:
+                pass
+        return T(lang, "m_key_restricted", a=e.allowed, b=safe_author), ""
     if author_bucket is None:
         return T(lang, "m_no_bucket", b=safe_author), ""
 
-    existing_files = b2_existing_filenames(author_bucket)
+    existing_files, used_bytes = b2_bucket_contents(author_bucket)
 
-    base_name = f"{safe_author}_{safe_game_part}"
+    base_name = safe_game_part              # file names: Game_Part only (the bucket is already the author's)
     mp4_name = f"Non-Shorts/{base_name}.mp4"
     png_name = f"Non-Shorts/{base_name}.png"
 
+    # ---- Cloud storage limit: what is already there + what this upload adds ----
+    incoming = ((mp4_size if mp4_name not in existing_files else 0) +
+                (os.path.getsize(png_path) if png_name not in existing_files else 0))
+    if storage_would_overflow(safe_author, used_bytes, incoming):
+        if png_is_temp:
+            try:
+                os.remove(png_path)
+            except OSError:
+                pass
+        return T(lang, "m_storage_full"), ""
+    added_bytes = 0
+
     uploaded = []
     already_exists = []
     errors = []
@@ -644,6 +795,7 @@ def upload_long(
         try:
             author_bucket.upload_local_file(mp4.name, mp4_name)
             uploaded.append(f"MP4 ({mp4_name})")
+            added_bytes += mp4_size
         except Exception as e:
             if png_is_temp:
                 try:
@@ -658,6 +810,7 @@ def upload_long(
         try:
             author_bucket.upload_local_file(png_path, png_name, content_type="image/png")
             uploaded.append(f"PNG ({png_name})")
+            added_bytes += os.path.getsize(png_path)
         except Exception as e:
             errors.append(f"PNG ({png_name}) - {e}")
     if png_is_temp:
@@ -665,6 +818,8 @@ def upload_long(
             os.remove(png_path)
         except OSError:
             pass
+    if added_bytes:
+        report_storage_used(safe_author, used_bytes + added_bytes)
 
     share_url = ""
     save_label = T(lang, "f_save")
@@ -731,25 +886,35 @@ def upload_shorts(author_name, insta, youtube, tiktok, game_name, part, yt_playl
         if file_size > 100 * 1024 * 1024:
             return T(lang, "m_short_size", n=name), ""
 
-    # ---- Build the final filenames: Author_Game_Part_<PLATFORM>.mp4 ----
+    # ---- Build the final filenames: Game_Part_<PLATFORM>.mp4 (inside the Author's bucket) ----
     safe_author = sanitize_author_component(author_name)
     safe_game_part = sanitize_game_part_component(game_name, part)
-    if not safe_author or not safe_game_part:
+    if not safe_author or not safe_game_part or not clean_game_name(game_name):
         return T(lang, "m_invalid_chars"), ""
 
     # ---- Resolve the B2 bucket for this Author (one bucket per Author/channel) ----
-    author_bucket = get_author_bucket(safe_author)
+    try:
+        author_bucket = get_author_bucket(safe_author)
+    except B2KeyRestricted as e:
+        return T(lang, "m_key_restricted", a=e.allowed, b=safe_author), ""
     if author_bucket is None:
         return T(lang, "m_no_bucket", b=safe_author), ""
 
-    existing_files = b2_existing_filenames(author_bucket)
+    existing_files, used_bytes = b2_bucket_contents(author_bucket)
 
-    base_name = f"{safe_author}_{safe_game_part}"
+    base_name = safe_game_part              # file names: Game_Part only (the bucket is already the author's)
     remote_names = {
         name: f"Shorts/{base_name}_{name}.mp4"
         for name in files
     }
 
+    # ---- Cloud storage limit: what is already there + what this upload adds ----
+    incoming = sum(os.path.getsize(file.name) for name, file in files.items()
+                   if remote_names[name] not in existing_files)
+    if storage_would_overflow(safe_author, used_bytes, incoming):
+        return T(lang, "m_storage_full"), ""
+    added_bytes = 0
+
     uploaded = []
     already_exists = []
     errors = []
@@ -761,8 +926,11 @@ def upload_shorts(author_name, insta, youtube, tiktok, game_name, part, yt_playl
             try:
                 author_bucket.upload_local_file(file.name, remote_name)
                 uploaded.append(f"{name} ({remote_name})")
+                added_bytes += os.path.getsize(file.name)
             except Exception as e:
                 errors.append(f"{name} ({remote_name}) - {e}")
+    if added_bytes:
+        report_storage_used(safe_author, used_bytes + added_bytes)
 
     message_parts = _summary(lang, uploaded, already_exists, errors)
     try:
@@ -791,6 +959,7 @@ def router(
             T(lang, "m_files_wait"),
             "",
             gr.update(visible=False),
+            gr.update(visible=True),
         )
 
     if mode == "Long":
@@ -810,10 +979,20 @@ def router(
     return (
         message,
         url,
-        gr.update(visible=bool(url))
+        gr.update(visible=bool(url)),
+        gr.update(visible=True),
     )
 
 
+def router_safe(*args):
+    """router, but an unexpected error still ends the upload with a message (and unlocks the page)."""
+    try:
+        return router(*args)
+    except Exception as e:
+        traceback.print_exc()
+        return (f"⚠ {type(e).__name__}: {e}", "", gr.update(visible=False), gr.update(visible=True))
+
+
 # ============================================================
 # THEME — dark editor look (same as the other apps)
 # ============================================================
@@ -1169,7 +1348,8 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
             elem_id="upload_btn"
         )
 
-    with gr.Group(elem_classes=["section-card"]):
+    # Result: hidden until an upload finishes (success or a message to read)
+    with gr.Group(elem_classes=["section-card"], visible=False) as result_group:
         sec_result_md = gr.Markdown(T(L0, "sec_result"))
         output = gr.Textbox(
             label=T(L0, "status"),
@@ -1226,14 +1406,16 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
             return (
                 gr.update(visible=True),   # long
                 gr.update(visible=False),  # shorts
-                gr.update(visible=False)   # share link (reset on mode change)
+                gr.update(visible=False),  # share link (reset on mode change)
+                gr.update(visible=False),  # result
             )
 
         else:  # Shorts
             return (
                 gr.update(visible=False),
                 gr.update(visible=True),
-                gr.update(visible=False)
+                gr.update(visible=False),
+                gr.update(visible=False),
             )
 
     mode.change(
@@ -1242,7 +1424,8 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
         outputs=[
             long_col,
             shorts_col,
-            share_col
+            share_col,
+            result_group,
         ]
     ).then(
         # Switching mode changes which files are actually required, so re-lock/
@@ -1297,6 +1480,7 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
             gr.update(visible=False),  # shorts_col
             gr.update(visible=False),  # share_col
             gr.update(interactive=False, value=T(lang, "upload_waiting")),  # upload_btn
+            gr.update(visible=False),  # result_group
         )
 
     refresh_all_btn.click(
@@ -1329,13 +1513,20 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
             shorts_col,
             share_col,
             upload_btn,
+            result_group,
         ],
         js="(lang) => { window.scrollTo({ top: 0, behavior: 'smooth' }); return lang; }",
     )
 
-    # Upload
+    # Upload: hide the old result and lock the button while it uploads; result appears at the end
     upload_btn.click(
-        fn=router,
+        fn=lambda lang: (gr.update(visible=False),
+                         gr.update(interactive=False, value=T(lang if lang in LANG_CODES else DEFAULT_LANG, "uploading"))),
+        inputs=[lang_dd],
+        outputs=[result_group, upload_btn],
+        show_progress="hidden",
+    ).then(
+        fn=router_safe,
         inputs=[
             mode, author_name,
             mp4_long, png_long, save_long,
@@ -1348,8 +1539,14 @@ with gr.Blocks(**BLOCKS_KWARGS) as app:
         outputs=[
             output,
             share_url,
-            share_col
+            share_col,
+            result_group,
         ]
+    ).then(
+        fn=refresh_upload_button,
+        inputs=file_inputs,
+        outputs=upload_btn,
+        show_progress="hidden",
     )
 
     # ------------------------------------------------------------