Update app.py

app.py

@@ -4,10 +4,12 @@ import tempfile
 import json
 import re
 import subprocess
+import time
+import uuid
 import UnityPy
 from UnityPy.enums import CompressionFlags
-from fastapi import FastAPI, UploadFile, File
-from fastapi.responses import FileResponse
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks
+from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from typing import Optional
 
@@ -21,8 +23,96 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Arka plandaki görevleri takip edeceğimiz hafıza sözlüğü
+jobs = {}
+
+def process_repack(job_id: str, asset_path: str, zip_path: str, original_filename: str):
+    try:
+        jobs[job_id] = {"status": "processing", "progress": 5, "message": "Oyun dosyaları çözümleniyor..."}
+        env = UnityPy.load(asset_path)
+        
+        filename_to_translations = {}
+        with zipfile.ZipFile(zip_path, 'r') as zipf:
+            for file_info in zipf.infolist():
+                filename = file_info.filename
+                if "__MACOSX" in filename or filename.split("/")[-1].startswith("._"): continue
+                if filename.endswith(".json"):
+                    try:
+                        content = zipf.read(filename)
+                        filename_to_translations[filename.split("/")[-1]] = json.loads(content.decode('utf-8'))
+                    except json.JSONDecodeError: pass
+
+        total_objects = len(env.objects)
+        processed = 0
+        start_time = time.time()
+
+        for obj in env.objects:
+            processed += 1
+            # Her 50 objede bir hızı ölç ve ETA (Kalan Süre) hesapla
+            if processed % 50 == 0:
+                elapsed = time.time() - start_time
+                rate = processed / elapsed if elapsed > 0 else 1
+                remaining_seconds = int((total_objects - processed) / rate)
+                prog = 5 + int((processed / total_objects) * 45) # İlk aşama %5 ile %50 arası sürer
+                
+                jobs[job_id].update({
+                    "progress": prog,
+                    "message": f"Diyaloglar yamalanıyor... (Kalan Süre: ~{remaining_seconds} saniye)"
+                })
+
+            if obj.type.name in ["TextAsset", "MonoBehaviour"]:
+                asset_name = getattr(obj.assets_file, 'name', 'assets')
+                asset_name = "".join([c if c.isalnum() else "_" for c in asset_name])
+                obj_name = f"{asset_name}_{obj.type.name}_{obj.path_id}"
+                target_filename = f"{obj_name}_raw.json"
+                
+                if target_filename in filename_to_translations:
+                    translations = filename_to_translations[target_filename]
+                    if obj.type.name == "MonoBehaviour":
+                        raw_data = obj.get_raw_data()
+                        patched_data = bytearray(raw_data)
+                        for orig_str, trans_str in translations.items():
+                            if orig_str == trans_str: continue
+                            orig_bytes = orig_str.encode('utf-8')
+                            orig_pad = (4 - (len(orig_bytes) % 4)) % 4
+                            orig_block = len(orig_bytes).to_bytes(4, 'little') + orig_bytes + (b'\x00' * orig_pad)
+                            trans_bytes = trans_str.encode('utf-8')
+                            trans_pad = (4 - (len(trans_bytes) % 4)) % 4
+                            trans_block = len(trans_bytes).to_bytes(4, 'little') + trans_bytes + (b'\x00' * trans_pad)
+                            patched_data = patched_data.replace(orig_block, trans_block)
+                        obj.set_raw_data(bytes(patched_data))
+
+        # En ağır kısma geçiliyor: Orijinal boyuta sıkıştırma (LZMA)
+        jobs[job_id].update({
+            "progress": 60, 
+            "message": "Orijinal boyuta (LZMA) sıkıştırılıyor. Sunucu hızına göre 1-3 dakika sürebilir, bağlantınız kopmayacak..."
+        })
+        
+        output_path = os.path.join(tempfile.gettempdir(), f"repacked_{job_id}_{original_filename}")
+        with open(output_path, "wb") as f:
+            try:
+                # 300 MB'ı 20 MB'a düşüren asıl kod:
+                f.write(env.file.save(packer=CompressionFlags.LZMA))
+            except Exception:
+                f.write(env.file.save())
+
+        jobs[job_id].update({
+            "status": "completed",
+            "progress": 100,
+            "message": "İşlem %100 Tamamlandı! Dosya İndiriliyor...",
+            "file_path": output_path,
+            "filename": original_filename
+        })
+
+    except Exception as e:
+        jobs[job_id].update({"status": "error", "message": f"Kritik Hata: {str(e)}"})
+
+
+# --------- YENİ API UÇ NOKTALARI (ENDPOINTS) ---------
+
 @app.post("/generate_dll")
 async def generate_dll(binary_file: UploadFile = File(...), metadata_file: UploadFile = File(...)):
+    # Bu kısmı dokunmadık, aynı duruyor
     temp_dir = tempfile.mkdtemp()
     binary_path = os.path.join(temp_dir, binary_file.filename)
     metadata_path = os.path.join(temp_dir, metadata_file.filename)
@@ -40,109 +130,74 @@ async def generate_dll(binary_file: UploadFile = File(...), metadata_file: Uploa
 
 @app.post("/extract")
 async def extract_dialogues(file: UploadFile = File(...), assembly_file: Optional[UploadFile] = File(None)):
+    # Bu kısmı dokunmadık, aynı duruyor
     temp_dir = tempfile.mkdtemp()
     asset_path = os.path.join(temp_dir, file.filename)
     with open(asset_path, "wb") as f: f.write(await file.read())
-        
     env = UnityPy.load(asset_path)
     zip_filename = os.path.join(temp_dir, f"{file.filename}_dialogues.zip")
-    extracted_count = 0
-    
     with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
         for obj in env.objects:
             if obj.type.name in ["TextAsset", "MonoBehaviour"]:
                 asset_name = getattr(obj.assets_file, 'name', 'assets')
                 asset_name = "".join([c if c.isalnum() else "_" for c in asset_name])
                 obj_name = f"{asset_name}_{obj.type.name}_{obj.path_id}"
-                
                 if obj.type.name == "MonoBehaviour":
                     raw_data = obj.get_raw_data()
                     found_strings = {}
                     i = 28
-                    
                     while i <= len(raw_data) - 4:
                         length = int.from_bytes(raw_data[i:i+4], 'little')
                         if 2 <= length <= 5000 and (i + 4 + length) <= len(raw_data):
                             str_bytes = raw_data[i+4 : i+4+length]
                             pad_len = (4 - (length % 4)) % 4
-                            
                             if (i + 4 + length + pad_len) <= len(raw_data):
                                 padding = raw_data[i+4+length : i+4+length+pad_len]
                                 if all(b == 0 for b in padding):
                                     try:
                                         text = str_bytes.decode('utf-8')
-                                        if len(text.strip()) > 1 and any(c.isalpha() for c in text):
-                                            found_strings[text] = text
+                                        if len(text.strip()) > 1 and any(c.isalpha() for c in text): found_strings[text] = text
                                         i += 4 + length + pad_len
                                         continue
-                                    except UnicodeDecodeError:
-                                        pass
+                                    except UnicodeDecodeError: pass
                         i += 4
-                    
-                    if found_strings:
-                        zipf.writestr(f"{obj_name}_raw.json", json.dumps(found_strings, indent=4, ensure_ascii=False).encode('utf-8'))
-                        extracted_count += 1
-                        
+                    if found_strings: zipf.writestr(f"{obj_name}_raw.json", json.dumps(found_strings, indent=4, ensure_ascii=False).encode('utf-8'))
                 elif obj.type.name == "TextAsset":
                     try:
                         content = obj.read().text.encode('utf-8')
                         zipf.writestr(f"{obj_name}.txt", content)
-                        extracted_count += 1
                     except: pass
-
     return FileResponse(zip_filename, media_type="application/zip", filename=f"{file.filename}_dialogues.zip")
 
-@app.post("/repack")
-async def repack_dialogues(asset_file: UploadFile = File(...), mod_zip: UploadFile = File(...)):
+# ARKA PLAN GÖREVİ BAŞLATICISI
+@app.post("/repack_async")
+async def repack_async(background_tasks: BackgroundTasks, asset_file: UploadFile = File(...), mod_zip: UploadFile = File(...)):
+    job_id = str(uuid.uuid4())
     temp_dir = tempfile.mkdtemp()
     asset_path = os.path.join(temp_dir, asset_file.filename)
     zip_path = os.path.join(temp_dir, mod_zip.filename)
+    
+    # Dosyaları hızlıca diske al ve isteği hemen geri döndür ki 60 saniye sorunu yaşanmasın
     with open(asset_path, "wb") as f: f.write(await asset_file.read())
     with open(zip_path, "wb") as f: f.write(await mod_zip.read())
-
-    env = UnityPy.load(asset_path)
     
-    filename_to_translations = {}
-    with zipfile.ZipFile(zip_path, 'r') as zipf:
-        for file_info in zipf.infolist():
-            filename = file_info.filename
-            if "__MACOSX" in filename or filename.split("/")[-1].startswith("._"):
-                continue
-            if filename.endswith(".json"):
-                try:
-                    content = zipf.read(filename)
-                    filename_to_translations[filename.split("/")[-1]] = json.loads(content.decode('utf-8'))
-                except json.JSONDecodeError: pass
-
-    for obj in env.objects:
-        if obj.type.name in ["TextAsset", "MonoBehaviour"]:
-            asset_name = getattr(obj.assets_file, 'name', 'assets')
-            asset_name = "".join([c if c.isalnum() else "_" for c in asset_name])
-            obj_name = f"{asset_name}_{obj.type.name}_{obj.path_id}"
-            target_filename = f"{obj_name}_raw.json"
-            
-            if target_filename in filename_to_translations:
-                translations = filename_to_translations[target_filename]
-                if obj.type.name == "MonoBehaviour":
-                    raw_data = obj.get_raw_data()
-                    patched_data = bytearray(raw_data)
-                    for orig_str, trans_str in translations.items():
-                        if orig_str == trans_str: continue
-                        orig_bytes = orig_str.encode('utf-8')
-                        orig_pad = (4 - (len(orig_bytes) % 4)) % 4
-                        orig_block = len(orig_bytes).to_bytes(4, 'little') + orig_bytes + (b'\x00' * orig_pad)
-                        trans_bytes = trans_str.encode('utf-8')
-                        trans_pad = (4 - (len(trans_bytes) % 4)) % 4
-                        trans_block = len(trans_bytes).to_bytes(4, 'little') + trans_bytes + (b'\x00' * trans_pad)
-                        patched_data = patched_data.replace(orig_block, trans_block)
-                    obj.set_raw_data(bytes(patched_data))
-
-    output_path = os.path.join(temp_dir, f"repacked_{asset_file.filename}")
-    with open(output_path, "wb") as f: 
-        try:
-            # YENİLİK: Dosyayı ışık hızında LZ4 ile sıkıştırarak RAM dostu hale getir
-            f.write(env.file.save(packer=CompressionFlags.LZ4))
-        except Exception:
-            f.write(env.file.save())
-            
-    return FileResponse(output_path, media_type="application/octet-stream", filename=asset_file.filename)
+    # Gerçek işi arka plandaki isimsiz bir hayalete devret
+    background_tasks.add_task(process_repack, job_id, asset_path, zip_path, asset_file.filename)
+    jobs[job_id] = {"status": "queued", "progress": 0, "message": "İşlem sıraya alındı, başlıyor..."}
+    
+    return {"job_id": job_id}
+
+# DURUM KONTROLCÜSÜ (Yüzde ve Süre Buradan Okunur)
+@app.get("/status/{job_id}")
+async def get_status(job_id: str):
+    if job_id not in jobs:
+        return JSONResponse(status_code=404, content={"error": "Görev bulunamadı"})
+    return jobs[job_id]
+
+# İNDİRME UÇ NOKTASI
+@app.get("/download/{job_id}")
+async def download_file(job_id: str):
+    job = jobs.get(job_id)
+    if not job or job.get("status") != "completed":
+        return JSONResponse(status_code=400, content={"error": "Dosya henüz hazır değil"})
+    return FileResponse(job["file_path"], media_type="application/octet-stream", filename=job["filename"])