Update app.py

app.py

@@ -2,12 +2,9 @@ import streamlit as st
 import os
 import json
 import time
-import subprocess
 import random
-import string
-import tempfile
-import shutil
-import mimetypes
+import datetime
+import subprocess
 
 BASE_FOLDER = "uploaded_files"
 CATEGORIES = ["AVATAR WORLD", "BLOX FRUITS", "TOCA LIFE"]
@@ -34,11 +31,11 @@ st.markdown("""
     </style>
 """, unsafe_allow_html=True)
 
-# Cria as pastas se não existirem
+# Cria pastas
 for cat in CATEGORIES:
     os.makedirs(os.path.join(BASE_FOLDER, cat), exist_ok=True)
 
-# Carrega dados de expiração
+# Carrega expirações
 if os.path.exists(EXPIRATION_FILE):
     with open(EXPIRATION_FILE, "r") as f:
         expirations = json.load(f)
@@ -47,13 +44,11 @@ else:
 
 st.title("📂 File Manager por Categoria")
 
-# --- Funções auxiliares ---
+# --- Função remover expirados ---
 def remove_expired_files():
-    """Remove arquivos expirados automaticamente"""
     changed = False
     now = time.time()
     expired_files = []
-
     for file_full, expire_time in list(expirations.items()):
         cat, file = file_full.split("|||")
         file_path = os.path.join(BASE_FOLDER, cat, file)
@@ -62,82 +57,72 @@ def remove_expired_files():
                 os.remove(file_path)
                 expired_files.append(file_full)
                 changed = True
-
     for file_full in expired_files:
         expirations.pop(file_full)
-
     if changed:
         with open(EXPIRATION_FILE, "w") as f:
             json.dump(expirations, f)
 
-def random_string(length=12):
-    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
-
-def process_video(file_path, hard_mode=False):
-    """Processa vídeo removendo metadados e mascarando vestígios do ffmpeg"""
-    temp_fd, temp_out = tempfile.mkstemp(suffix=".mp4")
-    os.close(temp_fd)
-
-    if not hard_mode:
-        shutil.copy(file_path, temp_out)
-        return temp_out
-
-    # Randomizações técnicas
-    crf = str(random.randint(18, 26))  # qualidade variável
-    bitrate = f"{random.randint(96, 192)}k"
-    fps = f"{random.uniform(29.5, 30.5):.2f}"
-    brand = random.choice(["isom", "iso2", "mp42", "avc1", "dash", "iso3"])
-    compressor = random_string(random.randint(6, 12))
-    encoder_name = random_string(random.randint(6, 14))
-
-    # Metadados falsos
-    meta = {
-        "title": random_string(random.randint(8, 20)),
-        "comment": random_string(random.randint(8, 20)),
-        "description": random_string(random.randint(8, 20)),
-        "artist": random_string(random.randint(8, 20)),
-        "album": random_string(random.randint(8, 20)),
-        "genre": random_string(random.randint(5, 15)),
-        "publisher": random_string(random.randint(5, 15)),
-        "encoded_by": random_string(random.randint(5, 15)),
-        "location": random_string(random.randint(5, 15)),
-        "encoder": encoder_name
-    }
+remove_expired_files()
 
-    cmd_ffmpeg = [
-        "ffmpeg", "-y", "-i", file_path,
-        "-map", "0:v", "-map", "0:a?",
-        "-map_metadata", "-1",
-        "-c:v", "libx264", "-preset", "fast", "-crf", crf,
-        "-c:a", "aac", "-b:a", bitrate,
-        "-r", fps,
-        "-movflags", "use_metadata_tags+faststart",
-        "-brand", brand,
-        "-metadata", f"encoder={encoder_name}",
-        "-metadata", f"CompressorName={compressor}",
-        "-fflags", "+bitexact",
-        "-flags", "+bitexact",
+# --- Função aleatorizar metadados com ffmpeg ---
+def randomize_video_metadata(input_path, output_path, progress_placeholder):
+    major_brands = ["isom", "mp42", "iso5", "avc1"]
+    compatible_sets = [
+        ["isom", "iso2", "avc1", "mp41"],
+        ["mp42", "isom", "avc1"],
+        ["iso5", "mp41", "isom"],
+        ["iso2", "mp42", "isom"],
     ]
-    for k, v in meta.items():
-        cmd_ffmpeg += ["-metadata", f"{k}={v}"]
-
-    cmd_ffmpeg.append(temp_out)
-    subprocess.run(cmd_ffmpeg, check=True)
-
-    return temp_out
+    major = random.choice(major_brands)
+    compatible = ",".join(random.choice(compatible_sets))
+
+    # Gera datas aleatórias
+    start_date = datetime.datetime.now() - datetime.timedelta(days=180)
+    random_date = start_date + datetime.timedelta(days=random.randint(0, 180),
+                                                  seconds=random.randint(0, 86400))
+    date_str = random_date.strftime("%Y-%m-%d %H:%M:%S")
+
+    def randstr(n=12): 
+        return ''.join(random.choices("abcdefghijklmnopqrstuvwxyz0123456789", k=n))
+
+    metadata = {
+        "title": randstr(8),
+        "artist": randstr(10),
+        "album": randstr(10),
+        "comment": randstr(15),
+        "description": randstr(12),
+        "genre": randstr(8),
+        "publisher": randstr(10),
+        "encoded_by": randstr(10),
+        "creation_time": date_str,
+        "major_brand": major,
+        "compatible_brands": compatible,
+    }
 
-# --- Apagar arquivos vencidos ao iniciar ---
-remove_expired_files()
+    # Monta comando ffmpeg
+    cmd = ["ffmpeg", "-i", input_path, "-map_metadata", "-1"]
+    for k, v in metadata.items():
+        cmd += ["-metadata", f"{k}={v}"]
+
+    # Mantém qualidade alta
+    cmd += ["-c:v", "libx264", "-preset", "fast", "-crf", "18",
+            "-c:a", "aac", "-b:a", "192k", output_path]
+
+    # Executa com barra de progresso
+    progress = 0
+    with subprocess.Popen(cmd, stderr=subprocess.PIPE, universal_newlines=True) as proc:
+        for line in proc.stderr:
+            if "time=" in line:
+                progress = min(progress + 5, 100)  # fake progress
+                progress_placeholder.progress(progress)
+        proc.wait()
+    progress_placeholder.progress(100)
 
 # --- Upload ---
 st.header("📤 Upload de Arquivos")
-st.subheader("Selecione uma categoria:")
-
 categoria = st.radio("Categoria:", CATEGORIES, index=None)
-hard_mode = st.checkbox("Ativar randomização HARD (vídeos apenas)")
-
-if "last_upload" not in st.session_state:
-    st.session_state.last_upload = None
+aleatorizar = st.checkbox("🔀 Aleatorizar metadados de vídeos")
 
 if categoria:
     uploaded_files = st.file_uploader(
@@ -149,77 +134,56 @@ if categoria:
 
     if uploaded_files:
         for uploaded_file in uploaded_files:
-            if st.session_state.last_upload == uploaded_file.name:
-                continue  
-
             folder = os.path.join(BASE_FOLDER, categoria)
-            os.makedirs(folder, exist_ok=True)
-
-            mime, _ = mimetypes.guess_type(uploaded_file.name)
-            is_video = mime and mime.startswith("video")
-
-            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp:
-                tmp.write(uploaded_file.read())
-                tmp_path = tmp.name
-
-            if is_video and hard_mode:
-                final_tmp = process_video(tmp_path, hard_mode=True)
-            else:
-                final_tmp = tmp_path
+            file_path = os.path.join(folder, uploaded_file.name)
 
-            if hard_mode and is_video:
-                new_name = random_string(16) + ".mp4"
-            else:
-                new_name = uploaded_file.name
+            with open(file_path, "wb") as f:
+                f.write(uploaded_file.read())
 
-            file_path = os.path.join(folder, new_name)
-            shutil.move(final_tmp, file_path)
+            # Se for vídeo e checkbox ativo → processa metadados
+            if aleatorizar and uploaded_file.type == "video/mp4":
+                progress_placeholder = st.empty()
+                st.info(f"🔄 Processando metadados de {uploaded_file.name}...")
+                randomized_path = os.path.join(folder, f"rnd_{uploaded_file.name}")
+                randomize_video_metadata(file_path, randomized_path, progress_placeholder)
+                os.remove(file_path)  # remove original
+                os.rename(randomized_path, file_path)
+                st.success(f"✅ {uploaded_file.name} processado com metadados aleatórios!")
 
             if auto_delete:
-                key = f"{categoria}|||{new_name}"
+                key = f"{categoria}|||{uploaded_file.name}"
                 expirations[key] = time.time() + 24 * 60 * 60
                 with open(EXPIRATION_FILE, "w") as f:
                     json.dump(expirations, f)
 
-            st.session_state.last_upload = uploaded_file.name
-            st.success(f"Arquivo '{new_name}' enviado com sucesso!")
+        st.success("Arquivos enviados com sucesso!")
+        st.rerun()
 
-# --- Lista de Arquivos agrupada por pasta ---
+# --- Lista de Arquivos ---
 st.header("📄 Arquivos Disponíveis")
-
 for categoria in CATEGORIES:
     folder = os.path.join(BASE_FOLDER, categoria)
     files = os.listdir(folder)
-
     st.subheader(f"📁 {categoria}")
-
     if not files:
         st.info("Nenhum arquivo na categoria.")
     else:
         for file in files:
             st.markdown(f"<div class='file-box'>", unsafe_allow_html=True)
             st.markdown(f"<div class='file-name'>{file}</div>", unsafe_allow_html=True)
-
             key = f"{categoria}|||{file}"
-
             expira = expirations.get(key)
             if expira:
                 restante = int(expira - time.time())
                 if restante > 0:
-                    restante_horas = restante // 3600
-                    restante_min = (restante % 3600) // 60
-                    st.markdown(
-                        f"<div class='expire-text'>⏳ Expira em {restante_horas}h {restante_min}min</div>",
-                        unsafe_allow_html=True)
-                else:
-                    st.markdown("<div class='expire-text'>⚠ Expiração iminente</div>", unsafe_allow_html=True)
+                    h = restante // 3600
+                    m = (restante % 3600) // 60
+                    st.markdown(f"<div class='expire-text'>⏳ Expira em {h}h {m}min</div>", unsafe_allow_html=True)
 
             col1, col2, col3 = st.columns(3)
-
             with col1:
                 with open(os.path.join(folder, file), "rb") as f_obj:
                     st.download_button("⬇ Download", f_obj, file_name=file, key=f"down_{categoria}_{file}")
-
             with col2:
                 if st.button("🗑 Excluir", key=f"delete_{categoria}_{file}"):
                     os.remove(os.path.join(folder, file))
@@ -227,7 +191,7 @@ for categoria in CATEGORIES:
                     with open(EXPIRATION_FILE, "w") as f:
                         json.dump(expirations, f)
                     st.success(f"Arquivo '{file}' excluído.")
-
+                    st.rerun()
             with col3:
                 with open(os.path.join(folder, file), "rb") as f_obj:
                     if st.download_button("⬇ Baixar & Apagar", f_obj, file_name=file, key=f"download_delete_{categoria}_{file}"):
@@ -236,5 +200,5 @@ for categoria in CATEGORIES:
                         with open(EXPIRATION_FILE, "w") as f:
                             json.dump(expirations, f)
                         st.success(f"Arquivo '{file}' baixado e removido.")
-
+                        st.rerun()
             st.markdown("</div>", unsafe_allow_html=True)