Update app.py

app.py

@@ -220,211 +220,211 @@ class GEOSEOApp:
                 st.error(f"An error occurred: {str(e)}")
     
     def render_content_enhancement_tab(self):
-    """Render Content Enhancement tab"""
-    st.header("🔧 Content Enhancement")
-    st.markdown("Analyze and optimize your content for better AI/LLM performance.")
+        """Render Content Enhancement tab"""
+        st.header("🔧 Content Enhancement")
+        st.markdown("Analyze and optimize your content for better AI/LLM performance.")
     
-    # Content input
-    input_text = st.text_area(
-        "Enter content to analyze and enhance:", 
-        height=200, 
-        key="enhancement_input"
-    )
+         # Content input
+        input_text = st.text_area(
+             "Enter content to analyze and enhance:", 
+              height=200, 
+              key="enhancement_input"
+         )
     
-    # Analysis options
-    col1, col2 = st.columns(2)
-    with col1:
-        analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
-    with col2:
-        include_keywords = st.checkbox("Include keyword suggestions", value=True)
+       # Analysis options
+        col1, col2 = st.columns(2)
+        with col1:
+             analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
+        with col2:
+             include_keywords = st.checkbox("Include keyword suggestions", value=True)
     
-    # Submit button
-    if st.button("🔧 Analyze & Enhance", key="enhancement_submit"):
-        if not input_text.strip():
-            st.warning("Please enter some content to analyze.")
-            return
-        
-        try:
-            with st.spinner("Analyzing content..."):
+       # Submit button
+        if st.button("🔧 Analyze & Enhance", key="enhancement_submit"):
+            if not input_text.strip():
+                st.warning("Please enter some content to analyze.")
+                return
+        
+            try:
+                with st.spinner("Analyzing content..."):
                 # Run content analysis and optimization
-                result = self.content_optimizer.optimize_content(
-                    input_text,
-                    analyze_only=analyze_only,
-                    include_keywords=include_keywords
-                )
+                    result = self.content_optimizer.optimize_content(
+                        input_text,
+                        analyze_only=analyze_only,
+                        include_keywords=include_keywords
+                       )
             
-            if result.get("error"):
-                st.error(f"Analysis failed: {result['error']}")
-                return
+                if result.get("error"):
+                    st.error(f"Analysis failed: {result['error']}")
+                    return
             
-            # Display results
-            if analyze_only:
-                st.success("Content analysis completed successfully!")  
-                st.markdown("### 📊 Analysis Results")
+                # Display results
+                if analyze_only:
+                    st.success("Content analysis completed successfully!")  
+                    st.markdown("### 📊 Analysis Results")
             
-                # Show scores
-                scores = result.get("scores", {})
-                if scores:
-                    col1, col2, col3 = st.columns(3)
-
-                    with col1:
-                        clarity = scores.get("clarity", 0)
-                        st.metric("Clarity", f"{clarity}/10")
-
-                    with col2:
-                        structure = scores.get("structuredness", 0)
-                        st.metric("Structure", f"{structure}/10")
-
-                    with col3:
-                        answerability = scores.get("answerability", 0)
-                        st.metric("Answerability", f"{answerability}/10")
-
-            # Show keywords
-            keywords = result.get("keywords", [])
-            if keywords:
-                st.markdown("#### 🔑 Key Terms")
-                st.write(", ".join(keywords))
+                    # Show scores
+                    scores = result.get("scores", {})
+                    if scores:
+                        col1, col2, col3 = st.columns(3)
+
+                        with col1:
+                              clarity = scores.get("clarity", 0)
+                              st.metric("Clarity", f"{clarity}/10")
+
+                        with col2:
+                              structure = scores.get("structuredness", 0)
+                              st.metric("Structure", f"{structure}/10")
+
+                        with col3:
+                             answerability = scores.get("answerability", 0)
+                             st.metric("Answerability", f"{answerability}/10")
+
+                # Show keywords
+                keywords = result.get("keywords", [])
+                if keywords:
+                    st.markdown("#### 🔑 Key Terms")
+                    st.write(", ".join(keywords))
             
-            # Show optimized content
-            optimized_text = result.get("optimized_text", "")
-            if optimized_text:
-                st.markdown("#### ✨ Optimized Content")
-                st.text_area(
-                    "Enhanced version:", 
-                    value=optimized_text, 
-                    height=200, 
-                    key="optimized_output"
-                )
-
-            # ✅ Optional RAG-based Q&A on the analyzed content
-            st.markdown("### 💬 Ask a question about the analyzed content:")
-            user_query = st.text_input("Enter your question:", key="enhancement_q")
-
-            if user_query:
-                from langchain.docstore.document import Document
-                new_doc = Document(page_content=optimized_text or input_text)
-                vectorstore = create_vectorstore_from_text([new_doc], self.embeddings)
-                st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
-
-                result = st.session_state.rag_chain.invoke({"question": user_query})
-                st.success("Answer:")
-                st.write(result["result"])
+                # Show optimized content
+                optimized_text = result.get("optimized_text", "")
+                if optimized_text:
+                    st.markdown("#### ✨ Optimized Content")
+                    st.text_area(
+                        "Enhanced version:", 
+                         value=optimized_text, 
+                         height=200, 
+                         key="optimized_output"
+                      )   
+
+                # ✅ Optional RAG-based Q&A on the analyzed content
+                st.markdown("### 💬 Ask a question about the analyzed content:")
+                user_query = st.text_input("Enter your question:", key="enhancement_q")
+
+                if user_query:
+                    from langchain.docstore.document import Document
+                    new_doc = Document(page_content=optimized_text or input_text)
+                    vectorstore = create_vectorstore_from_text([new_doc], self.embeddings)
+                    st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
 
-            # Export option
-            if st.button("📥 Export Results"):
-                export_data = self.result_exporter.export_enhancement_results(result)
-                st.download_button(
-                    label="Download Analysis Report",
-                    data=json.dumps(export_data, indent=2),
-                    file_name=f"content_analysis_{int(time.time())}.json",
-                    mime="application/json"
-                )
+                    result = st.session_state.rag_chain.invoke({"question": user_query})
+                    st.success("Answer:")
+                    st.write(result["result"])
+
+                # Export option
+                if st.button("📥 Export Results"):
+                     export_data = self.result_exporter.export_enhancement_results(result)
+                     st.download_button(
+                          label="Download Analysis Report",
+                          data=json.dumps(export_data, indent=2),
+                          file_name=f"content_analysis_{int(time.time())}.json",
+                          mime="application/json"
+                      )
         
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
+            except Exception as e:
+                  st.error(f"An error occurred: {str(e)}")
 
     
    def render_website_analysis_tab(self):
-    """Render Website GEO Analysis tab"""
-    st.header("🌐 Website GEO Analysis")
-    st.markdown("Analyze websites for Generative Engine Optimization (GEO) performance.")
+        """Render Website GEO Analysis tab"""
+        st.header("🌐 Website GEO Analysis")
+        st.markdown("Analyze websites for Generative Engine Optimization (GEO) performance.")
     
-    # URL input
-    col1, col2 = st.columns([3, 1])
-    with col1:
-        website_url = st.text_input("Enter website URL:", placeholder="https://example.com")
-    with col2:
-        max_pages = st.selectbox("Pages to analyze:", [1, 3, 5], index=0)
+        # URL input
+        col1, col2 = st.columns([3, 1])
+        with col1:
+              website_url = st.text_input("Enter website URL:", placeholder="https://example.com")
+        with col2:
+             max_pages = st.selectbox("Pages to analyze:", [1, 3, 5], index=0)
     
-    # Analysis options
-    col1, col2 = st.columns(2)
-    with col1:
-        include_subpages = st.checkbox("Include subpages", value=False)
-    with col2:
-        detailed_analysis = st.checkbox("Detailed analysis", value=True)
+        # Analysis options
+        col1, col2 = st.columns(2)
+        with col1:
+            include_subpages = st.checkbox("Include subpages", value=False)
+        with col2:
+            detailed_analysis = st.checkbox("Detailed analysis", value=True)
     
-    # Submit button
-    if st.button("🌐 Analyze Website", key="website_analyze"):
-        if not website_url.strip():
-            st.warning("Please enter a website URL.")
-            return
-        
-        try:
-            # Normalize URL
-            if not website_url.startswith(('http://', 'https://')):
-                website_url = 'https://' + website_url
+        # Submit button
+        if st.button("🌐 Analyze Website", key="website_analyze"):
+            if not website_url.strip():
+                st.warning("Please enter a website URL.")
+                return
+        
+            try:
+                # Normalize URL
+                if not website_url.startswith(('http://', 'https://')):
+                    website_url = 'https://' + website_url
             
-            with st.spinner(f"Analyzing website: {website_url}"):
-                # Parse website content
-                pages_data = self.webpage_parser.parse_website(
-                    website_url, 
-                    max_pages=max_pages,
-                    include_subpages=include_subpages
-                )
+                with st.spinner(f"Analyzing website: {website_url}"):
+                     # Parse website content
+                     pages_data = self.webpage_parser.parse_website(
+                         website_url, 
+                         max_pages=max_pages,
+                         include_subpages=include_subpages
+                      )
                 
-                if not pages_data:
-                    st.error("Could not extract content from the website.")
-                    return
+                    if not pages_data:
+                        st.error("Could not extract content from the website.")
+                         return
                 
-                st.success(f"Successfully extracted content from {len(pages_data)} page(s)")
+                    st.success(f"Successfully extracted content from {len(pages_data)} page(s)")
             
-            # Analyze GEO scores
-            with st.spinner("Calculating GEO scores..."):
-                geo_results = []
-                for i, page_data in enumerate(pages_data):
-                    with st.spinner(f"Analyzing page {i+1}/{len(pages_data)}..."):
-                        analysis = self.geo_scorer.analyze_page_geo(
-                            page_data['content'],
-                            page_data['title'],
-                            detailed=detailed_analysis
-                        )
+                # Analyze GEO scores
+                 with st.spinner("Calculating GEO scores..."):
+                    geo_results = []
+                    for i, page_data in enumerate(pages_data):
+                        with st.spinner(f"Analyzing page {i+1}/{len(pages_data)}..."):
+                             analysis = self.geo_scorer.analyze_page_geo(
+                                page_data['content'],
+                                page_data['title'],
+                                detailed=detailed_analysis
+                             )
                         
-                        if not analysis.get('error'):
-                            analysis['page_data'] = page_data
-                            geo_results.append(analysis)
-                        else:
-                            st.warning(f"Could not analyze page {i+1}: {analysis['error']}")
+                            if not analysis.get('error'):
+                                analysis['page_data'] = page_data
+                                geo_results.append(analysis)
+                            else:
+                                st.warning(f"Could not analyze page {i+1}: {analysis['error']}")
             
-            if not geo_results:
-                st.error("Could not analyze any pages from the website.")
-                return
+               if not geo_results:
+                    st.error("Could not analyze any pages from the website.")
+                    return
 
-            # Combine all page content for RAG
-            combined_content = "\n\n".join([page['content'] for page in pages_data])
-            from langchain.docstore.document import Document
-            doc = Document(page_content=combined_content)
+                # Combine all page content for RAG
+                combined_content = "\n\n".join([page['content'] for page in pages_data])
+                from langchain.docstore.document import Document
+                doc = Document(page_content=combined_content)
 
-            vectorstore = create_vectorstore_from_text([doc], self.embeddings)
-            st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
+                vectorstore = create_vectorstore_from_text([doc], self.embeddings)
+                st.session_state.rag_chain = create_rag_chain(self.llm, vectorstore)
 
-            # RAG-based Q&A
-            st.markdown("### 💬 Ask a question about the website:")
-            user_query = st.text_input("Ask here:", key="website_q")
+                # RAG-based Q&A
+                st.markdown("### 💬 Ask a question about the website:")
+                user_query = st.text_input("Ask here:", key="website_q")
 
-            if user_query:
-                result = st.session_state.rag_chain.invoke({"question": user_query})
-                st.success("Answer:")
-                st.write(result["result"])
+                if user_query:
+                     result = st.session_state.rag_chain.invoke({"question": user_query})
+                     st.success("Answer:")
+                     st.write(result["result"])
 
-            # Display results
-            self.display_geo_results(geo_results, website_url)
+                # Display results
+                self.display_geo_results(geo_results, website_url)
             
-            # Export functionality
-            st.markdown("### 📥 Export Results")
-            if st.button("📊 Generate Full Report"):
-                report_data = self.result_exporter.export_geo_results(
-                    geo_results, 
-                    website_url
-                )
-                st.download_button(
-                    label="Download GEO Report",
-                    data=json.dumps(report_data, indent=2),
-                    file_name=f"geo_analysis_{website_url.replace('https://', '').replace('/', '_')}.json",
-                    mime="application/json"
-                )
-        
-        except Exception as e:
-            st.error(f"An error occurred during website analysis: {str(e)}")
+                # Export functionality
+                st.markdown("### 📥 Export Results")
+                if st.button("📊 Generate Full Report"):
+                     report_data = self.result_exporter.export_geo_results(
+                           geo_results, 
+                           website_url
+                      )
+                    st.download_button(
+                        label="Download GEO Report",
+                        data=json.dumps(report_data, indent=2),
+                        file_name=f"geo_analysis_{website_url.replace('https://', '').replace('/', '_')}.json",
+                        mime="application/json"
+                     )
+        
+            except Exception as e:
+                 st.error(f"An error occurred during website analysis: {str(e)}")
 
     def render_multilingual_tab(self):
         st.markdown("### 🌍 Multilingual Translator")