Update app.py

app.py

@@ -6,64 +6,76 @@ from huggingface_hub import hf_hub_download, upload_file, HfApi
 app = Flask(__name__)
 
 # CONFIGURATION
-# Format: "username/dataset-name"
-DATASET_REPO_ = "YOUR_USERNAME/memvid-storage" 
 FILENAME = "knowledge.mv2"
 HF_TOKEN = os.environ.get("HF_TOKEN")
+DATASET_NAME = "memvid-storage" # Just the name, we will append username dynamically
 
-# Global DB reference
+# Global variables
 db = None
 DB_PATH = os.path.abspath(FILENAME)
+DATASET_REPO_ID = None # Will be set during initialization
+
+def get_repo_id():
+    """Helper to dynamically resolve 'username/dataset_name'"""
+    global DATASET_REPO_ID
+    if DATASET_REPO_ID:
+        return DATASET_REPO_ID
+    
+    if HF_TOKEN:
+        try:
+            api = HfApi(token=HF_TOKEN)
+            username = api.whoami()['name']
+            DATASET_REPO_ID = f"{username}/{DATASET_NAME}"
+            return DATASET_REPO_ID
+        except Exception as e:
+            print(f"⚠️ Error getting username: {e}")
+            return None
+    return None
 
 def init_db():
     """
-    1. Try to download existing DB from HF Hub.
-    2. If not found, create a new one locally.
-    3. Load Memvid.
+    1. Ensure Dataset Exists.
+    2. Try to download existing DB.
+    3. Initialize Memvid.
     """
-    global db
+    global db, DATASET_REPO_ID
     
-    # 1. Try to sync from Hub
-    if HF_TOKEN:
+    repo_id = get_repo_id()
+    
+    # 1. Sync / Setup Cloud Storage
+    if HF_TOKEN and repo_id:
+        print(f"🔄 Checking cloud storage at {repo_id}...")
         api = HfApi(token=HF_TOKEN)
-        username = api.whoami()['name']
-        print(username)
-        DATASET_REPO_ID = DATASET_REPO_.replace("YOUR_USERNAME", username)
-        print(f"🔄 Attempting to download {FILENAME} from {DATASET_REPO_ID}...")
+        
         try:
-            # This downloads the file to the local cache and returns the path
-            # We copy it or link it to our working dir if needed, but usually 
-            # we just want it in the current directory for Memvid to write to.
+            # Create the repo if it doesn't exist (Fixes your 404 error)
+            api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
             
-            # Check if file exists in repo first
-
-            files = api.list_repo_files(repo_id=DATASET_REPO_ID, repo_type="dataset")
+            # Check for file existence
+            files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
             
             if FILENAME in files:
                 downloaded_path = hf_hub_download(
-                    repo_id=DATASET_REPO_ID,
+                    repo_id=repo_id,
                     filename=FILENAME,
                     repo_type="dataset",
                     token=HF_TOKEN,
-                    local_dir=".", # Download to current directory
-                    local_dir_use_symlinks=False # We need the actual file to write to it
+                    local_dir=".", 
+                    local_dir_use_symlinks=False
                 )
                 print(f"✅ Downloaded database to {downloaded_path}")
             else:
-                print("⚠️ Database file not found in repo. Creating new one.")
+                print("⚠️ Database file not found in repo. A new one will be created and synced.")
+                
         except Exception as e:
-            print(f"⚠️ Could not download from Hub (might be first run): {e}")
+            print(f"⚠️ Cloud sync warning: {e}")
 
-    # 2. Open or Create Memvid
+    # 2. Initialize Memvid (Fixes 'no attribute create' error)
     try:
-        # Memvid 2.0 pattern:
-        # If file exists, open it. If not, create it.
-        if os.path.exists(DB_PATH):
-            db = Memvid.open(DB_PATH)
-            print(f"📂 Memvid opened at {DB_PATH}")
-        else:
-            db = Memvid.create(DB_PATH)
-            print(f"✨ New Memvid created at {DB_PATH}")
+        # In Python SDKs, the constructor usually handles Open OR Create.
+        # If the file exists, it opens it. If not, it creates it.
+        db = Memvid(DB_PATH)
+        print(f"✨ Memvid initialized at {DB_PATH}")
             
     except Exception as e:
         print(f"❌ CRITICAL ERROR initializing Memvid: {e}")
@@ -71,8 +83,10 @@ def init_db():
 
 def sync_to_hub():
     """Uploads the local .mv2 file back to Hugging Face"""
-    if not HF_TOKEN:
-        print("⚠️ No HF_TOKEN found. Skipping sync.")
+    repo_id = get_repo_id()
+    
+    if not HF_TOKEN or not repo_id:
+        print("⚠️ No HF_TOKEN or Repo ID found. Skipping sync.")
         return
 
     try:
@@ -80,7 +94,7 @@ def sync_to_hub():
         upload_file(
             path_or_fileobj=DB_PATH,
             path_in_repo=FILENAME,
-            repo_id=DATASET_REPO_ID,
+            repo_id=repo_id,
             repo_type="dataset",
             token=HF_TOKEN,
             commit_message="Memvid: Auto-save memory update"
@@ -100,25 +114,20 @@ def index():
 def add_memory():
     global db
     if not db:
-        # Try to re-init if it failed before
         init_db()
         if not db:
             return jsonify({"error": "Database could not be initialized. Check logs."}), 500
 
     content = request.form.get('content')
-    tags = request.form.get('tags', '') # Not used in basic put, but good for expansion
-
+    
     if not content:
         return jsonify({"error": "No content provided"}), 400
 
     try:
         # Add the memory
-        # Note: Check if your SDK version requires explicit transaction/commit
-        # Some versions use db.put(content), others db.add(content)
         db.put(content) 
         
-        # IMPORTANT: Force a commit/flush to disk before uploading
-        # If the SDK has a .commit() or .flush(), call it here.
+        # Force commit if method exists (SDK dependent)
         if hasattr(db, 'commit'):
             db.commit()
 
@@ -142,12 +151,10 @@ def search_memory():
         # Search
         results = db.search(query, top_k=5)
         
-        # Transform results based on SDK object structure
         formatted_results = []
         for hit in results:
             formatted_results.append({
                 "text": hit.text, 
-                # "score": hit.score # Uncomment if available
             })
             
         return jsonify({"success": True, "results": formatted_results})