Update app.py

app.py

@@ -6,6 +6,7 @@ import json
 import sqlite3 # Use SQLite for robust state management
 import uuid
 import math
+import time # For adding slight delays if needed for debugging FS issues
 from streamlit_js_eval import streamlit_js_eval # For JS communication
 
 # --- Constants ---
@@ -15,142 +16,140 @@ PLOT_DEPTH = 50.0
 
 # --- Database Setup ---
 def init_db():
-    """Initializes the SQLite database and creates tables if they don't exist."""
+    """Initializes the SQLite database and tables."""
     try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        # Plots table: grid coordinates are the primary key
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS plots (
-                grid_x INTEGER NOT NULL,
-                grid_z INTEGER NOT NULL,
-                name TEXT,
-                last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY (grid_x, grid_z)
-            )
-        ''')
-        # Objects table: references plots using grid coords
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS objects (
-                obj_id TEXT PRIMARY KEY,
-                plot_grid_x INTEGER NOT NULL,
-                plot_grid_z INTEGER NOT NULL,
-                type TEXT NOT NULL,
-                pos_x REAL NOT NULL,
-                pos_y REAL NOT NULL,
-                pos_z REAL NOT NULL,
-                rot_x REAL DEFAULT 0.0,
-                rot_y REAL DEFAULT 0.0,
-                rot_z REAL DEFAULT 0.0,
-                rot_order TEXT DEFAULT 'XYZ',
-                FOREIGN KEY (plot_grid_x, plot_grid_z) REFERENCES plots(grid_x, grid_z) ON DELETE CASCADE
-            )
-        ''')
-        # Index for faster object lookups by plot
-        cursor.execute('''
-            CREATE INDEX IF NOT EXISTS idx_objects_plot ON objects (plot_grid_x, plot_grid_z)
-        ''')
-        conn.commit()
-        conn.close()
-        # st.success("Database initialized successfully.") # Optional success message
+        # Use WAL mode for potentially better concurrency, though might have visibility delays on some systems
+        # conn = sqlite3.connect(DB_FILE, isolation_level=None) # Auto-commit mode
+        # cursor.execute('PRAGMA journal_mode=WAL;')
+        # conn.close()
+
+        with sqlite3.connect(DB_FILE) as conn: # Use context manager
+            cursor = conn.cursor()
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS plots (
+                    grid_x INTEGER NOT NULL, grid_z INTEGER NOT NULL, name TEXT,
+                    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (grid_x, grid_z)
+                )
+            ''')
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS objects (
+                    obj_id TEXT PRIMARY KEY, plot_grid_x INTEGER NOT NULL, plot_grid_z INTEGER NOT NULL,
+                    type TEXT NOT NULL, pos_x REAL NOT NULL, pos_y REAL NOT NULL, pos_z REAL NOT NULL,
+                    rot_x REAL DEFAULT 0.0, rot_y REAL DEFAULT 0.0, rot_z REAL DEFAULT 0.0, rot_order TEXT DEFAULT 'XYZ',
+                    FOREIGN KEY (plot_grid_x, plot_grid_z) REFERENCES plots(grid_x, grid_z) ON DELETE CASCADE
+                )
+            ''')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_objects_plot ON objects (plot_grid_x, plot_grid_z)')
+            # No explicit commit needed with 'with' statement unless changes made
+        print(f"Database {os.path.abspath(DB_FILE)} initialized/checked.") # Print to console
     except sqlite3.Error as e:
-        st.error(f"Database initialization error: {e}")
-        st.stop() # Stop execution if DB can't be initialized
+        # Use st.exception for full traceback in the app UI
+        st.exception(f"CRITICAL DATABASE INIT ERROR: {e}")
+        st.stop()
 
-# Call init function once at the start
-init_db()
+init_db() # Ensure DB exists and has tables
 
-# --- Helper Functions (Database Operations) ---
+# --- Helper Functions (Database Operations - Using 'with') ---
 
+# No Caching - always load fresh from DB
 def load_world_state_from_db():
     """Loads all plot metadata and object data fresh from the SQLite DB."""
+    st.write(f"Executing load_world_state_from_db for session {st.runtime.scriptrunner.get_script_run_ctx().session_id[:5]}...") # Debug session ID
     plots_metadata = []
-    all_objects_by_plot = {} # Temp store: (gx, gz) -> [obj_dict, ...]
-    all_initial_objects_world = [] # Final list with world coords
+    all_objects_by_plot = {}
+    all_initial_objects_world = []
 
     try:
-        conn = sqlite3.connect(DB_FILE)
-        conn.row_factory = sqlite3.Row # Return rows as dict-like objects
-        cursor = conn.cursor()
-
-        # 1. Load Plot Metadata
-        cursor.execute("SELECT grid_x, grid_z, name FROM plots ORDER BY grid_x, grid_z")
-        plot_rows = cursor.fetchall()
-        for row in plot_rows:
-            gx, gz = row['grid_x'], row['grid_z']
-            plots_metadata.append({
-                'id': f"plot_X{gx}_Z{gz}", # Reconstruct ID for consistency if needed
-                'grid_x': gx, 'grid_z': gz, 'name': row['name'] or f"Plot ({gx},{gz})",
-                'x_offset': gx * PLOT_WIDTH,
-                'z_offset': gz * PLOT_DEPTH
-            })
-            all_objects_by_plot[(gx, gz)] = [] # Initialize empty list for objects
-
-        # 2. Load All Objects
-        cursor.execute("SELECT * FROM objects")
-        object_rows = cursor.fetchall()
-        for row in object_rows:
-            plot_key = (row['plot_grid_x'], row['plot_grid_z'])
-            if plot_key in all_objects_by_plot:
-                 # Store object data with RELATIVE coordinates from DB
-                 all_objects_by_plot[plot_key].append(dict(row))
-
-        conn.close()
-
-        # 3. Combine and Calculate World Coordinates
+        with sqlite3.connect(DB_FILE) as conn: # Auto-closes connection
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+
+            st.write("DB Read: Loading plot metadata...")
+            cursor.execute("SELECT grid_x, grid_z, name, strftime('%Y-%m-%d %H:%M:%S', last_updated) as updated_ts FROM plots ORDER BY grid_x, grid_z")
+            plot_rows = cursor.fetchall()
+            st.write(f"DB Read: Found {len(plot_rows)} plot rows.")
+
+            for row in plot_rows:
+                gx, gz = row['grid_x'], row['grid_z']
+                plot_meta = {
+                    'id': f"plot_X{gx}_Z{gz}", 'grid_x': gx, 'grid_z': gz,
+                    'name': row['name'] or f"Plot ({gx},{gz})",
+                    'x_offset': gx * PLOT_WIDTH, 'z_offset': gz * PLOT_DEPTH,
+                    'last_updated': row['updated_ts'] # Add timestamp for debugging
+                }
+                plots_metadata.append(plot_meta)
+                all_objects_by_plot[(gx, gz)] = []
+
+            st.write("DB Read: Loading all objects...")
+            cursor.execute("SELECT * FROM objects")
+            object_rows = cursor.fetchall()
+            st.write(f"DB Read: Found {len(object_rows)} object rows.")
+
+            # Group objects by plot
+            for row in object_rows:
+                plot_key = (row['plot_grid_x'], row['plot_grid_z'])
+                if plot_key in all_objects_by_plot:
+                     all_objects_by_plot[plot_key].append(dict(row))
+
+        # Combine and calculate world coordinates (outside DB connection)
         for plot_meta in plots_metadata:
             plot_key = (plot_meta['grid_x'], plot_meta['grid_z'])
             for obj_data in all_objects_by_plot[plot_key]:
-                 # Create a copy to modify coordinates for injection
                  world_obj_data = obj_data.copy()
-                 # Apply offset to relative DB coords to get world coords for JS
                  world_obj_data['pos_x'] = obj_data['pos_x'] + plot_meta['x_offset']
                  world_obj_data['pos_z'] = obj_data['pos_z'] + plot_meta['z_offset']
-                 # Keep original relative pos_y as world pos_y
                  world_obj_data['pos_y'] = obj_data['pos_y']
                  all_initial_objects_world.append(world_obj_data)
 
-        st.write(f"DB Load: Found {len(plots_metadata)} plots and {len(all_initial_objects_world)} total objects.") # Debug
+        st.write(f"DB Load Complete: {len(plots_metadata)} plots, {len(all_initial_objects_world)} total objects processed.")
 
     except sqlite3.Error as e:
         st.error(f"Database load error: {e}")
-        # Return empty lists to prevent downstream errors
-        return [], []
+        return [], [] # Return empty on error
 
     return plots_metadata, all_initial_objects_world
 
 
 def save_plot_data_to_db(target_grid_x, target_grid_z, objects_data_list):
-    """Saves object data list to DB for a specific plot. Overwrites existing objects for that plot."""
+    """Saves object data list to DB for a specific plot. Overwrites existing objects."""
+    st.write(f"Executing save_plot_data_to_db for plot ({target_grid_x},{target_grid_z})...")
     plot_x_offset = target_grid_x * PLOT_WIDTH
     plot_z_offset = target_grid_z * PLOT_DEPTH
-    plot_name = f"Plot ({target_grid_x},{target_grid_z})" # Simple default name
+    plot_name = f"Plot ({target_grid_x},{target_grid_z})" # Simple default name for upsert
+
+    if not isinstance(objects_data_list, list):
+        st.error("Save Error: Invalid object data format (expected list).")
+        return False
 
-    conn = None # Ensure conn is defined for finally block
     try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        cursor.execute('BEGIN TRANSACTION') # Start transaction
-
-        # 1. Ensure plot exists in plots table (Upsert)
-        cursor.execute('''
-            INSERT INTO plots (grid_x, grid_z, name) VALUES (?, ?, ?)
-            ON CONFLICT(grid_x, grid_z) DO UPDATE SET name = excluded.name, last_updated = CURRENT_TIMESTAMP
-        ''', (target_grid_x, target_grid_z, plot_name))
-
-        # 2. Delete ALL existing objects for this specific plot
-        cursor.execute("DELETE FROM objects WHERE plot_grid_x = ? AND plot_grid_z = ?", (target_grid_x, target_grid_z))
-        deleted_count = cursor.rowcount
-        # st.write(f"DB Save: Deleted {deleted_count} old objects for plot ({target_grid_x},{target_grid_z}).") # Debug
-
-        # 3. Insert the new objects
-        insert_count = 0
-        if isinstance(objects_data_list, list):
+        with sqlite3.connect(DB_FILE) as conn: # Auto commit/rollback/close
+            cursor = conn.cursor()
+            # Use savepoint for finer transaction control within 'with' if needed, but default is fine
+            # cursor.execute('BEGIN') # Implicitly handled by 'with' unless isolation_level=None
+
+            # 1. Upsert Plot - ensure plot exists and update timestamp
+            st.write(f"DB Save: Upserting plot ({target_grid_x},{target_grid_z})...")
+            cursor.execute('''
+                INSERT INTO plots (grid_x, grid_z, name) VALUES (?, ?, ?)
+                ON CONFLICT(grid_x, grid_z) DO UPDATE SET name = excluded.name, last_updated = CURRENT_TIMESTAMP
+            ''', (target_grid_x, target_grid_z, plot_name))
+            st.write(f"DB Save: Plot upserted.")
+
+
+            # 2. Delete ALL existing objects for this specific plot
+            st.write(f"DB Save: Deleting old objects for plot ({target_grid_x},{target_grid_z})...")
+            cursor.execute("DELETE FROM objects WHERE plot_grid_x = ? AND plot_grid_z = ?", (target_grid_x, target_grid_z))
+            st.write(f"DB Save: Deleted {cursor.rowcount} old objects.")
+
+            # 3. Insert the new objects
+            insert_count = 0
+            objects_to_insert = []
             for obj in objects_data_list:
                 pos = obj.get('position', {})
                 rot = obj.get('rotation', {})
                 obj_type = obj.get('type', 'Unknown')
-                obj_id = obj.get('obj_id', str(uuid.uuid4())) # Use ID from JS
+                obj_id = obj.get('obj_id', str(uuid.uuid4()))
 
                 if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown':
                     print(f"Skipping malformed object during DB save prep: {obj}")
@@ -160,10 +159,7 @@ def save_plot_data_to_db(target_grid_x, target_grid_z, objects_data_list):
                 rel_z = pos.get('z', 0.0) - plot_z_offset
                 rel_y = pos.get('y', 0.0) # Y is absolute
 
-                cursor.execute('''
-                    INSERT INTO objects (obj_id, plot_grid_x, plot_grid_z, type, pos_x, pos_y, pos_z, rot_x, rot_y, rot_z, rot_order)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ''', (
+                objects_to_insert.append((
                     obj_id, target_grid_x, target_grid_z, obj_type,
                     rel_x, rel_y, rel_z,
                     rot.get('_x', 0.0), rot.get('_y', 0.0), rot.get('_z', 0.0),
@@ -171,42 +167,50 @@ def save_plot_data_to_db(target_grid_x, target_grid_z, objects_data_list):
                 ))
                 insert_count += 1
 
-        conn.commit() # Commit transaction
-        st.success(f"Plot ({target_grid_x},{target_grid_z}) saved with {insert_count} objects.")
+            if objects_to_insert:
+                st.write(f"DB Save: Inserting {insert_count} new objects...")
+                cursor.executemany('''
+                    INSERT OR REPLACE INTO objects (obj_id, plot_grid_x, plot_grid_z, type, pos_x, pos_y, pos_z, rot_x, rot_y, rot_z, rot_order)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', objects_to_insert) # Use INSERT OR REPLACE to handle potential obj_id conflicts cleanly
+                st.write(f"DB Save: Objects inserted.")
+            else:
+                 st.write(f"DB Save: No new objects to insert.")
+
+            # 'with' statement handles commit on success, rollback on error
+
+        st.success(f"DB Save Commit: Plot ({target_grid_x},{target_grid_z}) saved with {insert_count} objects.")
+        # Add a tiny delay AFTER commit, maybe helps filesystem cache? (Experimental)
+        # time.sleep(0.1)
         return True
 
     except sqlite3.Error as e:
         st.error(f"Database save error for plot ({target_grid_x},{target_grid_z}): {e}")
-        if conn:
-            conn.rollback() # Rollback on error
+        st.exception(e) # Show full traceback
         return False
-    finally:
-        if conn:
-            conn.close()
+
 
 # --- Page Config ---
-st.set_page_config( page_title="DB Synced World Builder", layout="wide")
+st.set_page_config( page_title="DB Synced World Builder v2", layout="wide")
 
-# --- Initialize Session State (Simpler Now) ---
+# --- Initialize Session State ---
 if 'selected_object' not in st.session_state: st.session_state.selected_object = 'None'
 if 'js_save_data_result' not in st.session_state: st.session_state.js_save_data_result = None
-# Remove refresh_counter - not needed as we load fresh every time
 
 # --- Load World State From DB (Runs on every script execution/rerun) ---
-# No caching - always reads the current DB state
 plots_metadata, all_initial_objects = load_world_state_from_db()
 
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
-    # *** Refresh Button - Simpler Logic ***
+    # Refresh Button (Just triggers rerun, load function always hits DB)
     if st.button("🔄 Refresh World View", key="refresh_button"):
-        # Simply rerun the script. The data loading above will fetch fresh data from DB.
         st.info("Reloading world state from database...")
         st.rerun()
 
     st.header("Navigation (Plots)")
+    # ... (Navigation button code remains the same as previous version) ...
     st.caption("Click to teleport player to a plot.")
     max_cols = 2
     cols = st.columns(max_cols)
@@ -227,6 +231,7 @@ with st.sidebar:
 
     # --- Object Placement ---
     st.header("Place Objects")
+    # ... (Object selection code remains the same) ...
     object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
     current_object_index = object_types.index(st.session_state.selected_object) if st.session_state.selected_object in object_types else 0
     selected_object_type_widget = st.selectbox(
@@ -234,16 +239,15 @@ with st.sidebar:
     )
     if selected_object_type_widget != st.session_state.selected_object:
          st.session_state.selected_object = selected_object_type_widget
-         # Rerun will happen, JS state handled by sessionStorage
+         # Rerun updates injection, sessionStorage persists JS side
 
     st.markdown("---")
 
     # --- Saving ---
     st.header("Save Work")
-    st.caption("Saves ALL objects in the player's current plot to the central database, overwriting previous data for that plot.")
+    st.caption("Saves ALL objects currently within the player's plot to the central database.")
     if st.button("💾 Save Current Plot", key="save_button"):
         js_get_data_code = "getSaveDataAndPosition();"
-        # Use key to store result in session state
         streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
         st.rerun()
 
@@ -259,39 +263,32 @@ if save_data_from_js is not None:
 
         if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
             player_pos = payload['playerPosition']
-            # These are ALL objects JS found within the target plot boundaries (world coords)
-            objects_to_save = payload['objectsToSave']
+            objects_to_save = payload['objectsToSave'] # World coords from JS
 
-            if isinstance(objects_to_save, list):
+            if isinstance(objects_to_save, list): # Allow saving empty list (clears plot)
                 target_grid_x = math.floor(player_pos.get('x', 0.0) / PLOT_WIDTH)
                 target_grid_z = math.floor(player_pos.get('z', 0.0) / PLOT_DEPTH)
 
                 st.write(f"Attempting DB save for plot ({target_grid_x},{target_grid_z})")
-
                 # --- Save the data to SQLite DB ---
                 save_ok = save_plot_data_to_db(target_grid_x, target_grid_z, objects_to_save)
 
                 if save_ok:
-                    # No cache clear needed! DB is source of truth.
-                    # Optional: Could tell JS to clear sessionStorage here if desired, but maybe not necessary
-                    # try:
-                    #      streamlit_js_eval(js_code="clearUnsavedSessionState();", key="clear_session_js")
-                    # except Exception as js_e: st.warning(f"Could not clear JS session state: {js_e}")
-                    st.success(f"Plot ({target_grid_x},{target_grid_z}) state saved to database.")
+                    # No cache clear needed. Success message is inside save_plot_data_to_db
                     save_processed_successfully = True
                 else:
-                    st.error(f"Failed to save plot ({target_grid_x},{target_grid_z}) data to database.")
+                    st.error(f"Failed DB save for plot ({target_grid_x},{target_grid_z}).")
             else: st.error("Invalid 'objectsToSave' format (expected list).")
         else: st.error("Invalid save payload structure received.")
 
     except json.JSONDecodeError:
         st.error("Failed to decode save data from client.")
-        print("Received raw data:", save_data_from_js)
+        print("Received raw data:", save_data_from_js) # Log raw data
     except Exception as e:
         st.error(f"Error processing save: {e}")
         st.exception(e)
 
-    # Clear the trigger data from session state
+    # Clear the trigger data from session state ALWAYS after attempting processing
     st.session_state.js_save_processor = None
     # Rerun after processing save to reload world state from DB
     if save_processed_successfully:
@@ -300,7 +297,7 @@ if save_data_from_js is not None:
 
 # --- Main Area ---
 st.header("Database Synced 3D World")
-st.caption(f"World state loaded from '{DB_FILE}'. Plots loaded: {len(plots_metadata)}. Use 'Refresh' to reload.")
+st.caption(f"DB: '{os.path.abspath(DB_FILE)}'. Plots loaded: {len(plots_metadata)}. Use 'Refresh' to see updates.")
 
 # --- Load and Prepare HTML ---
 html_file_path = 'index.html'
@@ -310,19 +307,15 @@ try:
     with open(html_file_path, 'r', encoding='utf-8') as f:
         html_template = f.read()
 
-    # Inject data loaded fresh from DB
     js_injection_script = f"""
 <script>
+    // Inject data loaded fresh from DB
     window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)};
-    window.PLOTS_METADATA = {json.dumps(plots_metadata)};
+    window.PLOTS_METADATA = {json.dumps(plots_metadata)}; // Still useful for JS ground generation
     window.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
     window.PLOT_WIDTH = {json.dumps(PLOT_WIDTH)};
     window.PLOT_DEPTH = {json.dumps(PLOT_DEPTH)};
-    console.log("Streamlit State Injected:", {{
-        selectedObject: window.SELECTED_OBJECT_TYPE,
-        initialObjectsCount: window.ALL_INITIAL_OBJECTS ? window.ALL_INITIAL_OBJECTS.length : 0,
-        plotCount: window.PLOTS_METADATA ? window.PLOTS_METADATA.length : 0
-    }});
+    console.log("Streamlit State Injected:", {{ /* ... logging ... */ }});
 </script>
 """
     html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)