Update app.py

app.py

@@ -8,6 +8,26 @@ from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_openai import OpenAI
 from typing import Optional, Type
 from pydantic import Field
+import logging
+import sys
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Custom StreamHandler to capture logs for Streamlit
+class StreamlitHandler(logging.StreamHandler):
+    def __init__(self):
+        logging.StreamHandler.__init__(self)
+        self.logs = []
+    
+    def emit(self, record):
+        msg = self.format(record)
+        self.logs.append(msg)
+
+# Initialize the custom handler
+streamlit_handler = StreamlitHandler()
+logger.addHandler(streamlit_handler)
 
 class SearchTool(BaseTool):
     name: str = "Search"
@@ -17,146 +37,142 @@ class SearchTool(BaseTool):
     
     def _run(self, query: str) -> str:
         """Execute the search tool"""
-        return self.search.run(query)
+        logger.info(f"Searching for: {query}")
+        result = self.search.run(query)
+        logger.info(f"Search completed. Result length: {len(result)}")
+        return result
         
     def _arun(self, query: str) -> str:
         """Async implementation"""
         raise NotImplementedError("Async not implemented")
 
-# Rest of the code remains the same...
+# Sample quotes database
+SPIRITUAL_QUOTES = [
+    {
+        "text": "Be the change you wish to see in the world.",
+        "author": "Mahatma Gandhi",
+        "tradition": "Hinduism"
+    },
+    {
+        "text": "The journey of a thousand miles begins with one step.",
+        "author": "Lao Tzu",
+        "tradition": "Taoism"
+    }
+]
 
-def setup_api_keys():
-    """Setup API keys from Hugging Face Spaces secrets"""
-    try:
-        if 'OPENAI_API_KEY' in st.secrets:
-            os.environ['OPENAI_API_KEY'] = st.secrets['OPENAI_API_KEY']
-            return True
-        else:
-            st.error("OpenAI API key not found in secrets!")
-            return False
-    except Exception as e:
-        st.error(f"Error setting up API keys: {str(e)}")
-        return False
+def generate_image_prompt(quote, author, tradition):
+    """Generate a detailed prompt for image creation"""
+    logger.info(f"Generating image prompt for quote by {author}")
+    return f"Create a serene, spiritual image that represents: '{quote}' - From {tradition} tradition. Style: Minimalistic, inspirational, Instagram-worthy."
 
-def initialize_agents():
-    """Initialize CrewAI agents with proper API key handling"""
-    if not os.environ.get('OPENAI_API_KEY'):
-        return None
-    
-    search_tool = SearchTool()
-    llm = OpenAI(temperature=0.7)
-    
-    quote_curator = Agent(
-        role='Quote Curator',
-        goal='Select meaningful spiritual quotes and validate their authenticity',
-        backstory="""You are an expert in world philosophies and spiritual traditions.""",
-        tools=[search_tool],
-        llm=llm,
-        verbose=True
-    )
-    
-    content_creator = Agent(
-        role='Content Creator',
-        goal='Create engaging visual descriptions for spiritual quotes',
-        backstory="""You are a creative content specialist.""",
-        tools=[search_tool],
-        llm=llm,
-        verbose=True
-    )
-    
-    content_validator = Agent(
-        role='Content Validator',
-        goal='Ensure content aligns with spiritual traditions',
-        backstory="""You are an expert in multiple spiritual traditions.""",
-        tools=[search_tool],
-        llm=llm,
-        verbose=True
-    )
-    
-    return quote_curator, content_creator, content_validator
+def select_background_music(tradition):
+    """Select appropriate background music based on tradition"""
+    logger.info(f"Selecting music for {tradition} tradition")
+    music_mapping = {
+        "Hinduism": "indian_flute.mp3",
+        "Buddhism": "tibetan_bells.mp3",
+        "Taoism": "chinese_zither.mp3",
+        "default": "meditation_ambient.mp3"
+    }
+    return music_mapping.get(tradition, music_mapping["default"])
 
 def main():
-    st.set_page_config(
-        page_title="Spiritual Content Generator",
-        page_icon="🕉️",
-        layout="wide"
-    )
-    
-    # Setup API keys at startup
-    if not setup_api_keys():
-        st.warning("""
-        Please set up the OpenAI API key in your Hugging Face Space:
-        1. Go to your Space Settings
-        2. Click on 'Secrets'
-        3. Add OPENAI_API_KEY
-        """)
-        st.stop()
+    st.set_page_config(page_title="Spiritual Content Generator", layout="wide")
     
-    # Initialize session state
-    if 'generated_content' not in st.session_state:
-        st.session_state.generated_content = None
-    if 'generation_history' not in st.session_state:
-        st.session_state.generation_history = []
+    # Initialize session state for logs
+    if 'logs' not in st.session_state:
+        st.session_state.logs = []
     
-    # Header
-    st.title("🕉️ Spiritual Content Generator")
-    st.markdown("""
-    Generate inspiring spiritual content combining quotes and insights from various philosophical traditions.
-    """)
+    # Tabs
+    tab1, tab2, tab3 = st.tabs(["Content Generator", "Debug Logs", "Settings"])
     
-    # Sidebar
-    with st.sidebar:
-        st.header("Controls")
-        if st.button("Generate New Content"):
-            with st.spinner("Initializing agents..."):
-                agents = initialize_agents()
-                
-                if agents:
-                    quote_curator, content_creator, content_validator = agents
-                    
+    with tab1:
+        st.title("🕉️ Spiritual Content Generator")
+        
+        # Content Generation Area
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.header("Generated Content")
+            if st.button("Generate New Content"):
+                with st.spinner("Generating content..."):
                     try:
-                        with st.spinner("Generating content..."):
-                            crew = Crew(
-                                agents=[quote_curator, content_creator, content_validator],
-                                tasks=[
-                                    Task(
-                                        description="Select and validate a spiritual quote.",
-                                        agent=quote_curator
-                                    ),
-                                    Task(
-                                        description="Create a visual description for the quote.",
-                                        agent=content_creator
-                                    ),
-                                    Task(
-                                        description="Validate the content's appropriateness.",
-                                        agent=content_validator
-                                    )
-                                ]
-                            )
-                            
-                            result = crew.kickoff()
-                            st.session_state.generated_content = result
-                            st.session_state.generation_history.append({
-                                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                                'content': result
-                            })
-                            
+                        # Log the start of generation
+                        logger.info("Starting content generation process")
+                        
+                        # 1. Select a quote
+                        quote = SPIRITUAL_QUOTES[0]  # For demo, using first quote
+                        logger.info(f"Selected quote: {quote['text']}")
+                        
+                        # 2. Generate image prompt
+                        image_prompt = generate_image_prompt(
+                            quote['text'], 
+                            quote['author'], 
+                            quote['tradition']
+                        )
+                        
+                        # 3. Select background music
+                        music = select_background_music(quote['tradition'])
+                        
+                        # 4. Combine everything
+                        content_package = {
+                            "quote": quote,
+                            "image_prompt": image_prompt,
+                            "background_music": music,
+                            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        }
+                        
+                        # Store in session state
+                        st.session_state.current_content = content_package
+                        logger.info("Content package generated successfully")
+                        
+                        # Display the generated content
+                        st.success("Content generated successfully!")
+                        st.json(content_package)
+                        
                     except Exception as e:
-                        st.error(f"Error during content generation: {str(e)}")
-    
-    # Main content area
-    col1, col2 = st.columns([2, 1])
+                        logger.error(f"Error during generation: {str(e)}")
+                        st.error(f"Error generating content: {str(e)}")
+        
+        with col2:
+            st.header("Preview")
+            st.info("Image preview will appear here")
+            st.audio("sample_music.mp3", format='audio/mp3')
     
-    with col1:
-        st.header("Latest Generated Content")
-        if st.session_state.generated_content:
-            st.json(st.session_state.generated_content)
+    with tab2:
+        st.header("Debug Logs")
+        st.text("Recent activity logs:")
+        
+        # Display logs
+        for log in streamlit_handler.logs:
+            if "ERROR" in log:
+                st.error(log)
+            elif "WARNING" in log:
+                st.warning(log)
+            else:
+                st.text(log)
+        
+        if st.button("Clear Logs"):
+            streamlit_handler.logs = []
     
-    with col2:
-        st.header("Generation History")
-        for entry in reversed(st.session_state.generation_history):
-            with st.expander(f"Generated at {entry['timestamp']}"):
-                st.json(entry['content'])
+    with tab3:
+        st.header("Settings")
+        st.subheader("API Configuration")
+        
+        # API key status
+        if 'OPENAI_API_KEY' in st.secrets:
+            st.success("OpenAI API key is configured")
+        else:
+            st.error("OpenAI API key is missing")
+        
+        # Image Generation settings
+        st.subheader("Image Generation")
+        st.selectbox("Image Style", ["Minimalistic", "Abstract", "Nature-inspired", "Sacred Geometry"])
+        
+        # Music settings
+        st.subheader("Music Settings")
+        st.checkbox("Enable background music", value=True)
+        st.slider("Music Volume", 0, 100, 50)
 
 if __name__ == "__main__":
     main()