Update app.py

app.py

@@ -78,45 +78,124 @@ class SyntheticDataGenerator:
 
     def get_quality_report_file(self) -> Optional[str]:
         """
-        Build/export the quality report and return a file path for download.
-        Uses /tmp on Spaces; tries ZIP first, then TXT fallback.
+        Build/export the quality report and return a **ZIP** file path for download.
+        Strongly prefers .zip; tries multiple SDK shapes before falling back.
         """
         if not self.generator:
             return None
+
+        import shutil
+        import zipfile
+        from datetime import datetime, timedelta
+
+        def _write_bytes_to_zip(b: bytes, out_path: str) -> Optional[str]:
+            try:
+                # If b already is a zip (starts with PK header), just write it
+                if len(b) >= 2 and b[:2] == b"PK":
+                    with open(out_path, "wb") as f:
+                        f.write(b)
+                    return out_path
+                # Otherwise, wrap it into a zip as a single file payload
+                with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
+                    zf.writestr("report.txt", b.decode("utf-8", errors="ignore"))
+                return out_path
+            except Exception:
+                return None
+
         try:
+            os.makedirs("/tmp", exist_ok=True)
+            target_zip = "/tmp/quality_report.zip"
+
+            # 0) Generate report object
             rep = self.generator.reports(display=False)
 
-            # Path already?
-            if isinstance(rep, str) and rep.endswith(".zip") and os.path.exists(rep):
-                return rep
+            # 1) If a usable string path is returned and exists (ideally .zip)
+            if isinstance(rep, str):
+                p = rep.strip()
+                if os.path.exists(p):
+                    if p.lower().endswith(".zip"):
+                        shutil.copy2(p, target_zip)
+                        return target_zip
+                    # If it's some other file, zip it
+                    with zipfile.ZipFile(target_zip, "w", zipfile.ZIP_DEFLATED) as zf:
+                        zf.write(p, arcname=os.path.basename(p))
+                    return target_zip
 
+            # 2) Path-like attributes
             for attr in ("archive_path", "zip_path", "path", "file_path"):
                 if hasattr(rep, attr):
                     p = getattr(rep, attr)
                     if isinstance(p, str) and os.path.exists(p):
-                        return p
-
-            os.makedirs("/tmp", exist_ok=True)
-            target_zip = "/tmp/quality_report.zip"
-            if hasattr(rep, "save"):
-                try:
-                    rep.save(target_zip)
-                    if os.path.exists(target_zip):
-                        return target_zip
-                except Exception:
-                    pass
-            if hasattr(rep, "export"):
-                try:
-                    rep.export(target_zip)
-                    if os.path.exists(target_zip):
+                        if p.lower().endswith(".zip"):
+                            shutil.copy2(p, target_zip)
+                            return target_zip
+                        with zipfile.ZipFile(target_zip, "w", zipfile.ZIP_DEFLATED) as zf:
+                            zf.write(p, arcname=os.path.basename(p))
                         return target_zip
-                except Exception:
-                    pass
 
-            target_txt = "/tmp/quality_report.txt"
-            with open(target_txt, "w", encoding="utf-8") as f:
-                f.write(str(rep))
-            return target_txt
+            # 3) Bytes-like content (some SDKs provide .content/.data/.bytes/.buffer)
+            for attr in ("content", "data", "bytes", "buffer"):
+                if hasattr(rep, attr):
+                    b = getattr(rep, attr)
+                    if isinstance(b, (bytes, bytearray)):
+                        path = _write_bytes_to_zip(bytes(b), target_zip)
+                        if path:
+                            return path
+                    if hasattr(b, "read"):
+                        raw = b.read()
+                        if isinstance(raw, (bytes, bytearray)):
+                            path = _write_bytes_to_zip(bytes(raw), target_zip)
+                            if path:
+                                return path
+
+            # 4) Save/export API
+            for method in ("save", "export", "to_zip", "write"):
+                if hasattr(rep, method):
+                    try:
+                        m = getattr(rep, method)
+                        try:
+                            m(target_zip)  # try with path argument
+                        except TypeError:
+                            out = m()  # maybe returns bytes or a path
+                            if isinstance(out, (bytes, bytearray)):
+                                path = _write_bytes_to_zip(bytes(out), target_zip)
+                                if path:
+                                    return path
+                            if isinstance(out, str) and os.path.exists(out):
+                                shutil.copy2(out, target_zip)
+                                return target_zip
+                        if os.path.exists(target_zip):
+                            return target_zip
+                    except Exception:
+                        pass
+
+            # 5) Heuristic: search for a fresh .zip the SDK might have emitted (last 10 min)
+            candidates = []
+            cutoff = datetime.utcnow() - timedelta(minutes=10)
+            for root in ("/tmp", "/home", "/workspace", os.getcwd()):
+                if not os.path.exists(root):
+                    continue
+                for dirpath, _, filenames in os.walk(root):
+                    for fn in filenames:
+                        if fn.lower().endswith(".zip"):
+                            fp = os.path.join(dirpath, fn)
+                            try:
+                                st = os.stat(fp)
+                                mtime = datetime.utcfromtimestamp(st.st_mtime)
+                                if mtime >= cutoff:
+                                    candidates.append((mtime, st.st_size, fp))
+                            except Exception:
+                                pass
+            if candidates:
+                candidates.sort(key=lambda x: (x[0], x[1]), reverse=True)  # newest then largest
+                src = candidates[0][2]
+                shutil.copy2(src, target_zip)
+                return target_zip
+
+            # 6) Last resort: wrap textual representation into a minimal zip (avoid plain .txt)
+            with zipfile.ZipFile(target_zip, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("report.txt", str(rep))
+            return target_zip
 
         except Exception:
             return None
@@ -320,6 +399,16 @@ def create_interface():
         synthetic_data.change(create_comparison_plot, inputs=[uploaded_data, synthetic_data], outputs=[comparison_plot])
 
         # CSV download: write CSV and reveal the file link
+        def download_csv_prepare():
+            """Return a path to the latest synthetic CSV; used as output to gr.File."""
+            global _last_synth_df
+            if _last_synth_df is None or _last_synth_df.empty:
+                return None
+            os.makedirs("/tmp", exist_ok=True)
+            path = "/tmp/synthetic_data.csv"
+            _last_synth_df.to_csv(path, index=False)
+            return path
+
         def _prepare_csv_for_download():
             path = download_csv_prepare()
             if path: