Update app.py

app.py

@@ -6,14 +6,17 @@
 import streamlit as st
 import os
 import json
+import uuid
+
 from multi_agent_book_workflow import BookWritingOrchestrator
+from persistence_manager import HuggingFacePersistenceManager, check_huggingface_storage
 
 class BookWritingApp:
     def __init__(self):
         """
         Initialize the Streamlit application for book writing
         
-        Manages session state for the entire book writing project
+        Manages session state, persistence, and API resilience
         """
         # Set page configuration
         st.set_page_config(
@@ -22,217 +25,194 @@ class BookWritingApp:
             layout="wide"
         )
         
-        # Initialize session state
-        if 'project_orchestrator' not in st.session_state:
-            st.session_state.project_orchestrator = None
+        # Initialize persistence manager
+        self.persistence_manager = HuggingFacePersistenceManager()
         
-        if 'book_concept' not in st.session_state:
-            st.session_state.book_concept = None
+        # Verify storage capabilities
+        self._verify_storage()
         
-        # Track generated chapters
-        if 'generated_chapters' not in st.session_state:
-            st.session_state.generated_chapters = {}
+        # Initialize session state
+        self._initialize_session_state()
         
-        # Track project metadata
-        if 'project_metadata' not in st.session_state:
-            st.session_state.project_metadata = {
-                'title': 'Untitled Project',
-                'genre': 'Unspecified',
-                'total_chapters': 0
-            }
+        # Set up resilient API handling
+        self._setup_resilient_api_handler()
 
-    def render_book_generation_interface(self):
+    def _verify_storage(self):
         """
-        Comprehensive interface for book generation with progress tracking
+        Verify Hugging Face storage capabilities
         """
-        # Tabs for different aspects of book writing
-        tab1, tab2, tab3 = st.tabs([
-            "Book Concept", 
-            "Chapter Generation", 
-            "Book Progress"
-        ])
+        storage_check = check_huggingface_storage()
         
-        with tab1:
-            self._render_concept_development()
+        # Display warnings if storage is not fully accessible
+        if not storage_check['data_dir_exists']:
+            st.error("Persistent storage directory not found. Some features may be limited.")
         
-        with tab2:
-            self._render_chapter_generation()
+        if not storage_check['data_dir_writable']:
+            st.warning("Cannot write to persistent storage. Data may not be saved.")
         
-        with tab3:
-            self._render_book_progress()
+        # Optional: Display free space
+        free_space_mb = storage_check['free_space'] / (1024 * 1024)
+        st.sidebar.info(f"Available Storage: {free_space_mb:.2f} MB")
 
-    def _render_concept_development(self):
+    def _initialize_session_state(self):
         """
-        Render the book concept development interface
+        Initialize and manage Streamlit session state
         """
-        st.header("📘 Book Concept Development")
+        # Project tracking
+        if 'active_project_id' not in st.session_state:
+            st.session_state.active_project_id = None
+        
+        # Restore last active project if exists
+        if st.session_state.active_project_id:
+            self._load_project(st.session_state.active_project_id)
+        
+        # Ensure core session state variables exist
+        session_defaults = {
+            'project_orchestrator': None,
+            'book_concept': None,
+            'generated_chapters': {},
+            'project_metadata': {
+                'title': 'Untitled Project',
+                'genre': 'Unspecified',
+                'total_chapters': 0
+            }
+        }
         
-        # Initial concept input
-        initial_concept = st.text_area(
-            "Describe Your Book Idea", 
-            height=200, 
-            placeholder="Enter a comprehensive description of your book concept..."
-        )
+        for key, default in session_defaults.items():
+            if key not in st.session_state:
+                st.session_state[key] = default
+
+    def _load_project(self, project_id):
+        """
+        Load a project from persistent storage
         
-        if st.button("Generate Book Concept"):
-            if not st.session_state.project_orchestrator:
-                st.session_state.project_orchestrator = BookWritingOrchestrator()
+        Args:
+            project_id (str): Unique identifier for the project
+        """
+        try:
+            loaded_project = self.persistence_manager.load_project(project_id)
             
-            with st.spinner("Developing Book Concept..."):
-                try:
-                    book_concept = st.session_state.project_orchestrator.generate_book_concept(
-                        initial_concept
-                    )
-                    st.session_state.book_concept = book_concept
-                    
-                    # Update project metadata
-                    st.session_state.project_metadata.update({
-                        'title': book_concept.get('title', 'Untitled Project'),
-                        'genre': book_concept.get('genre', 'Unspecified')
-                    })
-                    
-                    # Display Concept Details
-                    st.subheader("Generated Book Concept")
-                    st.json(book_concept)
+            if loaded_project:
+                # Update session state with loaded project
+                st.session_state.active_project_id = project_id
+                st.session_state.book_concept = loaded_project.get('book_concept')
+                st.session_state.generated_chapters = loaded_project.get('chapters', {})
+                st.session_state.project_metadata = {
+                    'title': loaded_project.get('title', 'Untitled Project'),
+                    'genre': loaded_project.get('genre', 'Unspecified'),
+                    'total_chapters': loaded_project.get('total_chapters', 0)
+                }
                 
-                except Exception as e:
-                    st.error(f"Error generating book concept: {e}")
+                st.success(f"Loaded project: {loaded_project.get('title', 'Untitled')}")
+            else:
+                st.warning("Could not load project.")
+        
+        except Exception as e:
+            st.error(f"Error loading project: {e}")
 
-    def _render_chapter_generation(self):
+    def _setup_resilient_api_handler(self):
         """
-        Render the chapter generation interface with progress tracking
+        Set up resilient API handling for different language models
         """
-        st.header("✍️ Chapter Generation")
-        
-        # Check if book concept exists
-        if not st.session_state.book_concept:
-            st.warning("Please generate a book concept first.")
-            return
-        
-        # Chapter generation controls
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Chapter number selection
-            max_chapters = 20  # Can be adjusted
-            chapter_number = st.number_input(
-                "Select Chapter to Generate", 
-                min_value=1, 
-                max_value=max_chapters, 
-                value=len(st.session_state.generated_chapters) + 1
-            )
-        
-        with col2:
-            # Total chapters planning
-            total_chapters = st.number_input(
-                "Total Planned Chapters", 
-                min_value=1, 
-                max_value=max_chapters, 
-                value=st.session_state.project_metadata.get('total_chapters', 10)
-            )
-            st.session_state.project_metadata['total_chapters'] = total_chapters
-        
-        # Generate Chapter Button
-        if st.button("Generate Chapter"):
-            with st.spinner(f"Generating Chapter {chapter_number}..."):
-                try:
-                    # Generate chapter content
-                    chapter_content = st.session_state.project_orchestrator.generate_chapter_content(
-                        st.session_state.book_concept, 
-                        chapter_number
-                    )
-                    
-                    # Store generated chapter
-                    st.session_state.generated_chapters[chapter_number] = {
-                        'content': chapter_content,
-                        'status': 'Generated'
-                    }
-                    
-                    # Display Chapter Content
-                    st.subheader(f"Chapter {chapter_number}")
-                    st.write(chapter_content)
-                    
-                    # Optional: Edit Chapter
-                    edited_content = st.text_area(
-                        "Edit Chapter Content", 
-                        value=chapter_content, 
-                        height=400
-                    )
-                    
-                    # Save edited content
-                    if st.button(f"Save Chapter {chapter_number}"):
-                        st.session_state.generated_chapters[chapter_number]['content'] = edited_content
-                        st.success(f"Chapter {chapter_number} saved!")
-                
-                except Exception as e:
-                    st.error(f"Error generating chapter: {e}")
+        # Initialize with primary and fallback models from workflow
+        if not st.session_state.project_orchestrator:
+            st.session_state.project_orchestrator = BookWritingOrchestrator()
+        
+        openai_model = st.session_state.project_orchestrator.openai_llm
+        anthropic_model = st.session_state.project_orchestrator.anthropic_llm
+        
+        # Create resilient handler (complete implementation needed)
+        from persistence_manager import ResiliентAPIHandler
+        self.resilient_handler = ResiliентAPIHandler(
+            primary_model=openai_model, 
+            fallback_model=anthropic_model
+        )
 
-    def _render_book_progress(self):
+    def _save_current_project(self):
         """
-        Render a comprehensive view of book writing progress
+        Save the current project to persistent storage
         """
-        st.header("📊 Book Writing Progress")
-        
-        # Project Metadata
-        st.subheader("Project Overview")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.metric("Book Title", st.session_state.project_metadata.get('title', 'Untitled'))
-            st.metric("Genre", st.session_state.project_metadata.get('genre', 'Unspecified'))
-        
-        with col2:
-            total_chapters = st.session_state.project_metadata.get('total_chapters', 0)
-            generated_chapters = len(st.session_state.generated_chapters)
+        try:
+            # Prepare project data for saving
+            project_data = {
+                'project_id': st.session_state.active_project_id or str(uuid.uuid4()),
+                'title': st.session_state.project_metadata.get('title', 'Untitled Project'),
+                'genre': st.session_state.project_metadata.get('genre', 'Unspecified'),
+                'book_concept': st.session_state.book_concept,
+                'chapters': st.session_state.generated_chapters,
+                'total_chapters': st.session_state.project_metadata.get('total_chapters', 0)
+            }
+            
+            # Save project
+            project_id = self.persistence_manager.save_project(project_data)
             
-            st.metric("Total Planned Chapters", total_chapters)
-            st.metric("Chapters Generated", generated_chapters)
+            # Update active project ID
+            st.session_state.active_project_id = project_id
             
-            # Progress Bar
-            progress = generated_chapters / total_chapters if total_chapters > 0 else 0
-            st.progress(progress)
-        
-        # Chapter Navigation and Details
-        st.subheader("Generated Chapters")
-        
-        # Create tabs for each generated chapter
-        if st.session_state.generated_chapters:
-            chapter_tabs = st.tabs([
-                f"Chapter {ch_num}" for ch_num in sorted(st.session_state.generated_chapters.keys())
-            ])
+            st.success(f"Project saved with ID: {project_id}")
+        
+        except Exception as e:
+            st.error(f"Error saving project: {e}")
+
+    def render_project_management(self):
+        """
+        Render project management interface
+        """
+        st.sidebar.header("Project Management")
+        
+        # New Project Button
+        if st.sidebar.button("Start New Project"):
+            # Reset session state
+            st.session_state.active_project_id = None
+            st.session_state.book_concept = None
+            st.session_state.generated_chapters = {}
+            st.session_state.project_metadata = {
+                'title': 'Untitled Project',
+                'genre': 'Unspecified',
+                'total_chapters': 0
+            }
+            st.experimental_rerun()
+        
+        # Load Project
+        project_list = self.persistence_manager.list_projects()
+        if project_list:
+            selected_project = st.sidebar.selectbox(
+                "Load Existing Project",
+                [p['title'] for p in project_list],
+                index=None,
+                placeholder="Select a project..."
+            )
             
-            for i, ch_num in enumerate(sorted(st.session_state.generated_chapters.keys())):
-                with chapter_tabs[i]:
-                    chapter_data = st.session_state.generated_chapters[ch_num]
-                    st.write(chapter_data['content'])
-                    
-                    # Chapter status and actions
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        status = st.selectbox(
-                            "Chapter Status", 
-                            ["Generated", "In Review", "Completed"],
-                            key=f"status_{ch_num}"
-                        )
-                    
-                    with col2:
-                        if st.button(f"Export Chapter {ch_num}"):
-                            # Export chapter functionality
-                            with open(f"chapter_{ch_num}.txt", "w") as f:
-                                f.write(chapter_data['content'])
-                            st.success(f"Chapter {ch_num} exported!")
-        else:
-            st.info("No chapters generated yet. Start writing your book!")
+            if selected_project:
+                # Find project ID
+                project_id = next(
+                    p['project_id'] for p in project_list 
+                    if p['title'] == selected_project
+                )
+                
+                # Load project
+                if st.sidebar.button("Load Selected Project"):
+                    self._load_project(project_id)
+        
+        # Save Current Project
+        if st.sidebar.button("Save Current Project"):
+            self._save_current_project()
 
     def run(self):
         """
-        Run the Streamlit application
+        Run the main Streamlit application
         """
-        # Main title
-        st.title("🚀 AI-Powered Book Writing Assistant")
+        # Render project management sidebar
+        self.render_project_management()
+        
+        # Main application content (placeholder)
+        st.title("🚀 AI Book Writing Assistant")
         
-        # Render the comprehensive book generation interface
-        self.render_book_generation_interface()
+        # TODO: Add main application workflow
+        # This would include:
+        # 1. Book concept development
+        # 2. Chapter generation
+        # 3. Project progress tracking
 
 def main():
     # Initialize and run the application