alchemist-nrel 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

api/services/session_store.py

@@ -2,7 +2,7 @@
 Session Store - Session management with disk persistence.
 
 Stores OptimizationSession instances with TTL and automatic cleanup.
-Sessions are persisted to disk to survive server restarts.
+Sessions are persisted to disk as JSON to survive server restarts.
 """
 
 from typing import Dict, Optional
@@ -10,8 +10,19 @@ from datetime import datetime, timedelta
 import uuid
 from alchemist_core.session import OptimizationSession
 import logging
-import pickle
+import json
+import tempfile
 from pathlib import Path
+import threading
+
+# TODO: Consider migrating per-session `threading.Lock()` to an async-compatible
+# `anyio.Lock()` (or `asyncio.Lock`) for cleaner async endpoint integration.
+#
+# Rationale / next steps:
+# - Many API endpoints are `async def` and blocking the event loop with
+#   `threading.Lock().acquire()` is undesirable.
+# - A migration plan is in `memory/SESSION_LOCKING_ASYNC_PLAN.md` describing
+#   how to transition to `anyio.Lock()` and update handlers to use `async with`.
 
 logger = logging.getLogger(__name__)
 
@@ -41,17 +52,42 @@ class SessionStore:
     
     def _get_session_file(self, session_id: str) -> Path:
         """Get path to session file."""
-        return self.persist_dir / f"{session_id}.pkl"
+        return self.persist_dir / f"{session_id}.json"
     
     def _save_to_disk(self, session_id: str):
-        """Save session to disk."""
+        """Save session to disk as JSON."""
         if not self.persist_dir:
             return
         
         try:
             session_file = self._get_session_file(session_id)
-            with open(session_file, 'wb') as f:
-                pickle.dump(self._sessions[session_id], f)
+            session_data = self._sessions[session_id]
+            
+            # Create a temporary file for the session
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                session_data["session"].save_session(tmp.name)
+                temp_path = tmp.name
+            
+            # Store metadata alongside session
+            metadata = {
+                "created_at": session_data["created_at"].isoformat(),
+                "last_accessed": session_data["last_accessed"].isoformat(),
+                "expires_at": session_data["expires_at"].isoformat()
+            }
+            
+            # Load session JSON and add metadata
+            with open(temp_path, 'r') as f:
+                session_json = json.load(f)
+            
+            session_json["_session_store_metadata"] = metadata
+            
+            # Write combined data
+            with open(session_file, 'w') as f:
+                json.dump(session_json, f, indent=2)
+            
+            # Clean up temp file
+            Path(temp_path).unlink()
+            
         except Exception as e:
             logger.error(f"Failed to save session {session_id}: {e}")
     
@@ -61,19 +97,39 @@ class SessionStore:
             return
         
         loaded_count = 0
-        for session_file in self.persist_dir.glob("*.pkl"):
+        for session_file in self.persist_dir.glob("*.json"):
             try:
-                with open(session_file, 'rb') as f:
-                    session_data = pickle.load(f)
-                    session_id = session_file.stem
-                    
-                    # Check if expired
-                    if datetime.now() > session_data["expires_at"]:
+                with open(session_file, 'r') as f:
+                    session_json = json.load(f)
+                
+                # Extract metadata
+                metadata = session_json.pop("_session_store_metadata", {})
+                
+                # Check if expired
+                if metadata:
+                    expires_at = datetime.fromisoformat(metadata["expires_at"])
+                    if datetime.now() > expires_at:
                         session_file.unlink()  # Delete expired session file
                         continue
-                    
-                    self._sessions[session_id] = session_data
-                    loaded_count += 1
+                
+                # Write session data to temp file and load
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                    json.dump(session_json, tmp, indent=2)
+                    temp_path = tmp.name
+                
+                # Load without retraining by default during startup
+                session = OptimizationSession.load_session(temp_path, retrain_on_load=False)
+                Path(temp_path).unlink()
+                session_id = session_file.stem
+                self._sessions[session_id] = {
+                    "session": session,
+                    "created_at": datetime.fromisoformat(metadata.get("created_at", datetime.now().isoformat())),
+                    "last_accessed": datetime.fromisoformat(metadata.get("last_accessed", datetime.now().isoformat())),
+                    "expires_at": datetime.fromisoformat(metadata.get("expires_at", (datetime.now() + self.default_ttl).isoformat())),
+                    "lock": threading.Lock()
+                }
+                loaded_count += 1
+                
             except Exception as e:
                 logger.error(f"Failed to load session from {session_file}: {e}")
         
@@ -92,7 +148,7 @@ class SessionStore:
         except Exception as e:
             logger.error(f"Failed to delete session file {session_id}: {e}")
     
-    def create(self) -> str:
+    def create(self, name: Optional[str] = None, description: Optional[str] = None, tags: Optional[list] = None) -> str:
         """
         Create a new session.
         
@@ -101,12 +157,28 @@ class SessionStore:
         """
         session_id = str(uuid.uuid4())
         session = OptimizationSession()
-        
+        # Ensure session metadata matches store id
+        try:
+            session.metadata.session_id = session_id
+        except Exception:
+            pass
+        # Populate optional metadata
+        if name:
+            session.metadata.name = name
+        if description:
+            session.metadata.description = description
+        if tags:
+            try:
+                session.metadata.tags = tags
+            except Exception:
+                pass
+
         self._sessions[session_id] = {
             "session": session,
             "created_at": datetime.now(),
             "last_accessed": datetime.now(),
-            "expires_at": datetime.now() + self.default_ttl
+            "expires_at": datetime.now() + self.default_ttl,
+            "lock": threading.Lock()
         }
         
         # Persist to disk
@@ -133,20 +205,31 @@ class SessionStore:
             return None
         
         session_data = self._sessions[session_id]
-        
-        # Check if expired
-        if datetime.now() > session_data["expires_at"]:
-            logger.info(f"Session {session_id} expired, removing")
-            del self._sessions[session_id]
-            return None
-        
-        # Update last accessed time
-        session_data["last_accessed"] = datetime.now()
-        
-        # Save updated access time to disk
-        self._save_to_disk(session_id)
-        
-        return session_data["session"]
+        lock = session_data.get("lock")
+        if lock:
+            with lock:
+                # Check if expired
+                if datetime.now() > session_data["expires_at"]:
+                    logger.info(f"Session {session_id} expired, removing")
+                    del self._sessions[session_id]
+                    return None
+
+                # Update last accessed time
+                session_data["last_accessed"] = datetime.now()
+
+                # Save updated access time to disk
+                self._save_to_disk(session_id)
+
+                return session_data["session"]
+        else:
+            # Fallback (no lock present)
+            if datetime.now() > session_data["expires_at"]:
+                logger.info(f"Session {session_id} expired, removing")
+                del self._sessions[session_id]
+                return None
+            session_data["last_accessed"] = datetime.now()
+            self._save_to_disk(session_id)
+            return session_data["session"]
     
     def delete(self, session_id: str) -> bool:
         """
@@ -159,8 +242,14 @@ class SessionStore:
             True if deleted, False if not found
         """
         if session_id in self._sessions:
-            del self._sessions[session_id]
-            self._delete_from_disk(session_id)
+            lock = self._sessions[session_id].get("lock")
+            if lock:
+                with lock:
+                    del self._sessions[session_id]
+                    self._delete_from_disk(session_id)
+            else:
+                del self._sessions[session_id]
+                self._delete_from_disk(session_id)
             logger.info(f"Deleted session {session_id}")
             return True
         return False
@@ -204,10 +293,17 @@ class SessionStore:
         """
         if session_id not in self._sessions:
             return False
-        
-        extension = timedelta(hours=hours) if hours else self.default_ttl
-        self._sessions[session_id]["expires_at"] = datetime.now() + extension
-        self._save_to_disk(session_id)
+        lock = self._sessions[session_id].get("lock")
+        if lock:
+            with lock:
+                extension = timedelta(hours=hours) if hours else self.default_ttl
+                self._sessions[session_id]["expires_at"] = datetime.now() + extension
+                self._save_to_disk(session_id)
+        else:
+            extension = timedelta(hours=hours) if hours else self.default_ttl
+            self._sessions[session_id]["expires_at"] = datetime.now() + extension
+            self._save_to_disk(session_id)
+
         logger.info(f"Extended TTL for session {session_id}")
         return True
     
@@ -234,49 +330,109 @@ class SessionStore:
         self._cleanup_expired()
         return list(self._sessions.keys())
     
-    def export_session(self, session_id: str) -> Optional[bytes]:
+    def export_session(self, session_id: str) -> Optional[str]:
         """
-        Export a session as bytes for download.
+        Export a session as JSON string for download.
         
         Args:
             session_id: Session identifier
             
         Returns:
-            Pickled session data or None if not found
+            JSON string of session data or None if not found
         """
         if session_id not in self._sessions:
             return None
-        
+
         try:
-            return pickle.dumps(self._sessions[session_id])
+            lock = self._sessions[session_id].get("lock")
+            if lock:
+                with lock:
+                    # Create temporary file
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                        self._sessions[session_id]["session"].save_session(tmp.name)
+                        temp_path = tmp.name
+
+                    # Read the JSON content
+                    with open(temp_path, 'r') as f:
+                        json_content = f.read()
+
+                    # Clean up temp file
+                    Path(temp_path).unlink()
+                    return json_content
+            else:
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                    self._sessions[session_id]["session"].save_session(tmp.name)
+                    temp_path = tmp.name
+
+                with open(temp_path, 'r') as f:
+                    json_content = f.read()
+
+                Path(temp_path).unlink()
+                return json_content
         except Exception as e:
             logger.error(f"Failed to export session {session_id}: {e}")
             return None
+
+    def persist_session_to_disk(self, session_id: str) -> bool:
+        """
+        Persist the in-memory session to disk (overwrite existing persisted file).
+
+        Returns True on success, False otherwise.
+        """
+        if session_id not in self._sessions:
+            return False
+        try:
+            lock = self._sessions[session_id].get('lock')
+            if lock:
+                with lock:
+                    self._save_to_disk(session_id)
+            else:
+                self._save_to_disk(session_id)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to persist session {session_id}: {e}")
+            return False
     
-    def import_session(self, session_data: bytes, session_id: Optional[str] = None) -> Optional[str]:
+    def import_session(self, session_data: str, session_id: Optional[str] = None) -> Optional[str]:
         """
-        Import a session from bytes.
+        Import a session from JSON string.
         
         Args:
-            session_data: Pickled session data
+            session_data: JSON string of session data
             session_id: Optional custom session ID (generates new one if None)
             
         Returns:
             Session ID or None if import failed
         """
         try:
-            imported_data = pickle.loads(session_data)
+            # Write JSON to temp file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                tmp.write(session_data)
+                temp_path = tmp.name
+            
+            # Load session without automatic retrain
+            session = OptimizationSession.load_session(temp_path, retrain_on_load=False)
+            Path(temp_path).unlink()
             
             # Generate new session ID if not provided
             if not session_id:
                 session_id = str(uuid.uuid4())
+
+            # Ensure session metadata session_id matches store id
+            try:
+                session.metadata.session_id = session_id
+            except Exception:
+                pass
+
+            # Store session with metadata and lock
+            self._sessions[session_id] = {
+                "session": session,
+                "created_at": datetime.now(),
+                "last_accessed": datetime.now(),
+                "expires_at": datetime.now() + self.default_ttl,
+                "lock": threading.Lock()
+            }
             
-            # Update timestamps
-            imported_data["last_accessed"] = datetime.now()
-            imported_data["expires_at"] = datetime.now() + self.default_ttl
-            
-            # Store session
-            self._sessions[session_id] = imported_data
             self._save_to_disk(session_id)
             
             logger.info(f"Imported session {session_id}")

api/static/assets/api-vcoXEqyq.js

@@ -0,0 +1 @@
+async function i(t,n,o=!1){const s={...n},e=await fetch(`/api/v1/sessions/${t}/experiments?auto_train=${o}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(s)});if(!e.ok)throw new Error(`Add experiment failed: ${e.statusText}`);return e.json()}export{i as addExperiment};