Upload folder using huggingface_hub

app.py

@@ -8,98 +8,9 @@ import importlib.util
 from dotenv import load_dotenv
 load_dotenv()
 
-def ensure_root_directories(main_workspace: Path) -> None:
-    """Create required root-level folders and subfolders before any symlinks.
-
-    Folders: Generated/, static/{css,js,images}/, view_session/
-    Also drops a .gitkeep in each to ensure they can be tracked in a repo.
-    """
-    print("🏗️  Creating root-level directories (before symlinking)...")
-    required = [
-        main_workspace / "Generated",
-        main_workspace / "static",
-        main_workspace / "static" / "css",
-        main_workspace / "static" / "js",
-        main_workspace / "static" / "images",
-    main_workspace / "view_session",
-    ]
-
-    for d in required:
-        try:
-            # If a symlink exists at the path, replace it with a real directory
-            if d.is_symlink():
-                try:
-                    d.unlink()
-                    print(f"🔁 Replaced symlink with real directory: {d}")
-                except Exception as e:
-                    print(f"⚠️  Could not remove symlink {d}: {e}")
-            # Ensure directory exists
-            d.mkdir(parents=True, exist_ok=True)
-            try:
-                d.chmod(0o755)
-            except Exception:
-                pass
-            # Add README.md so directories are tracked per current .gitignore rules
-            try:
-                readme = d / "README.md"
-                if not readme.exists():
-                    rel = d.relative_to(main_workspace)
-                    readme.write_text(f"# {rel}\n\nPlaceholder to ensure this directory is tracked.\n")
-            except Exception:
-                pass
-            print(f"✅ Ensured directory: {d}")
-        except Exception as e:
-            print(f"⚠️  Warning: could not ensure {d}: {e}")
-
-def ensure_view_session_points_to_generated(main_workspace: Path) -> None:
-    """Ensure root-level view_session is a symlink to Generated (so UI views read from Generated)."""
-    vs = main_workspace / "view_session"
-    gen = main_workspace / "Generated"
-    try:
-        gen.mkdir(parents=True, exist_ok=True)
-        if vs.exists() or vs.is_symlink():
-            try:
-                if vs.is_symlink() and vs.resolve() == gen.resolve():
-                    print(f"🔗 Root symlink already set: {vs} -> {gen}")
-                    return
-            except Exception:
-                pass
-            if vs.is_symlink():
-                vs.unlink()
-            elif vs.is_dir():
-                # migrate contents into Generated
-                for item in vs.iterdir():
-                    dest = gen / item.name
-                    try:
-                        if item.is_dir():
-                            if dest.exists():
-                                for sub in item.iterdir():
-                                    sub.rename(dest / sub.name)
-                                item.rmdir()
-                            else:
-                                item.rename(dest)
-                        else:
-                            if dest.exists():
-                                dest.unlink()
-                            item.rename(dest)
-                    except Exception as me:
-                        print(f"⚠️  Root migration warning for {item}: {me}")
-                try:
-                    vs.rmdir()
-                except Exception:
-                    pass
-            else:
-                vs.unlink()
-        # create symlink view_session -> Generated
-        vs.symlink_to(gen, target_is_directory=True)
-        print(f"🔗 Root linked {vs} -> {gen}")
-    except Exception as e:
-        print(f"⚠️  Could not link root view_session to Generated: {e}")
-
 def create_symlinks_to_real_folders(cache_dir):
     """Create symbolic links in cache directory to real folders in main workspace."""
-    # Use the directory containing this script as root workspace
-    main_workspace = Path(__file__).parent.resolve()
+    main_workspace = Path("/Users/data/SGS-1")
     
     # Define the folders that need symbolic links
     folders_to_link = ["Generated", "static", "view_session"]
@@ -108,58 +19,24 @@ def create_symlinks_to_real_folders(cache_dir):
     
     for folder_name in folders_to_link:
         # Real folder path in main workspace
-        # Map view_session to Generated so the UI reads sessions from Generated
-        real_folder = (main_workspace / "Generated") if folder_name == "view_session" else (main_workspace / folder_name)
+        real_folder = main_workspace / folder_name
         # Symbolic link path in cache
         link_path = cache_dir / folder_name
         
         try:
-            # Ensure real folder exists (defensive)
-            real_folder.mkdir(parents=True, exist_ok=True)
-
-            # If an entry exists at the link path, handle safely
+            # Remove existing file/folder/link if it exists
             if link_path.exists() or link_path.is_symlink():
                 if link_path.is_symlink():
-                    try:
-                        # If already correct, keep it
-                        if link_path.resolve() == real_folder.resolve():
-                            print(f"✅ Symlink already set: {link_path} -> {real_folder}")
-                            continue
-                    except Exception:
-                        pass
                     link_path.unlink()
                 elif link_path.is_dir():
-                    # Migrate existing contents to the real folder before replacing
-                    for item in link_path.iterdir():
-                        dest = real_folder / item.name
-                        try:
-                            if item.is_dir():
-                                if dest.exists():
-                                    # Merge directories
-                                    for sub in item.iterdir():
-                                        sub.rename(dest / sub.name)
-                                    item.rmdir()
-                                else:
-                                    item.rename(dest)
-                            else:
-                                if dest.exists():
-                                    dest.unlink()
-                                item.rename(dest)
-                        except Exception as me:
-                            print(f"⚠️  Migration warning for {item}: {me}")
-                    # Remove the now-empty directory
-                    try:
-                        link_path.rmdir()
-                    except Exception:
-                        pass
+                    shutil.rmtree(link_path)
                 else:
-                    # Regular file – remove so we can place a symlink
                     link_path.unlink()
-
+            
             # Create symbolic link
             link_path.symlink_to(real_folder, target_is_directory=True)
             print(f"✅ Created symlink: {link_path} -> {real_folder}")
-
+            
         except Exception as e:
             print(f"⚠️  Warning: Could not create symlink for {folder_name}: {e}")
             # Fallback: create empty directory
@@ -169,32 +46,6 @@ def create_symlinks_to_real_folders(cache_dir):
     print("🎯 All symbolic links are ready!")
     return True
 
-def verify_cache_symlink(cache_dir: Path, name: str, root_dir: Path) -> bool:
-    """Verify a specific symlink in cache points to the corresponding root dir and is writable."""
-    link = cache_dir / name
-    target = root_dir / name
-    try:
-        if not link.exists():
-            print(f"❌ Missing link/path in cache: {link}")
-            return False
-        if not link.is_symlink():
-            print(f"⚠️  Cache path is not a symlink (still usable): {link}")
-        else:
-            if link.resolve() != target.resolve():
-                print(f"⚠️  Symlink target mismatch: {link.resolve()} != {target}")
-            else:
-                print(f"🔗 Verified symlink: {link} -> {target}")
-        # Write/read test
-        tf = link / ".__verify__"
-        tf.write_text("ok")
-        assert (target / ".__verify__").read_text() == "ok"
-        tf.unlink(missing_ok=True)
-        print(f"✅ Write/Read OK via cache link: {link}")
-        return True
-    except Exception as e:
-        print(f"❌ Verification failed for {link}: {e}")
-        return False
-
 def modify_byteplus_for_directories(cache_dir):
     """Modify the BytePlus app to ensure proper directory handling."""
     app_file = cache_dir / "app.py"
@@ -386,6 +237,28 @@ def download_space(cache_dir):
     token = os.environ.get("HF_TOKEN")
     repo_id = os.environ.get("REPO_ID")
     
+    if not token or not repo_id:
+        print("❌ HF_TOKEN or REPO_ID not found in environment variables")
+        return False
+    
+    try:
+        print(f"📥 Downloading BytePlus space: {repo_id}")
+        snapshot_download(
+            repo_id=repo_id,
+            repo_type="space",
+            local_dir=cache_dir,
+            token=token
+        )
+        print("✅ Successfully downloaded BytePlus space")
+        return True
+    except Exception as e:
+        print(f"❌ Error downloading space: {e}")
+        return False
+def download_space(cache_dir):
+    """Download the BytePlus space from HuggingFace."""
+    token = os.environ.get("HF_TOKEN")
+    repo_id = os.environ.get("REPO_ID")
+    
     if not token or not repo_id:
         print("❌ HF_TOKEN or REPO_ID not found in environment variables")
         return False
@@ -478,17 +351,11 @@ def load_app(cache_dir):
     )
 
 if __name__ == "__main__":
-    print("🚀 Setting up BytePlus Image Generation Studio with root directories + symlinks...")
+    print("🚀 Setting up BytePlus Image Generation Studio with symbolic links...")
     
     # Setup cache directory
     cache_dir = setup_cache_directory()
     print(f"📁 Cache directory: {cache_dir}")
-
-    # Ensure root directories exist first (as requested)
-    root = Path(__file__).parent.resolve()
-    ensure_root_directories(root)
-    # Ensure view_session at root points to Generated for History/View/ZIP
-    ensure_view_session_points_to_generated(root)
     
     # Download the space
     if download_space(cache_dir):