kunthawat/ALwrity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b21cbb68da820a8d6353e17fd90e8311e1257f40
ALwrity/lib/alwrity_ui/seo_tools_dashboard.py
ajaysi b21cbb68da Added new features to the project
2025-06-30 07:49:48 +05:30

706 lines
27 KiB
Python
Raw Blame History

import streamlit as st
from loguru import logger
from typing import List, Dict, Any, Callable
# Import existing tools
from lib.ai_seo_tools.seo_structured_data import ai_structured_data
from lib.ai_seo_tools.content_title_generator import ai_title_generator
from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
from lib.ai_seo_tools.image_alt_text_generator import alt_text_gen
from lib.ai_seo_tools.opengraph_generator import og_tag_generator
from lib.ai_seo_tools.optimize_images_for_upload import main_img_optimizer
from lib.ai_seo_tools.google_pagespeed_insights import google_pagespeed_insights
from lib.ai_seo_tools.on_page_seo_analyzer import analyze_onpage_seo
from lib.ai_seo_tools.weburl_seo_checker import url_seo_checker
from lib.ai_marketing_tools.ai_backlinker.backlinking_ui_streamlit import backlinking_ui
from lib.ai_seo_tools.content_gap_analysis.ui import ContentGapAnalysisUI
from lib.ai_seo_tools.content_gap_analysis.enhanced_ui import render_enhanced_content_gap_analysis
from lib.ai_seo_tools.content_calendar.ui.dashboard import ContentCalendarDashboard
from lib.ai_seo_tools.technical_seo_crawler import render_technical_seo_crawler
# Import additional tools
from lib.ai_seo_tools.twitter_tags_generator import display_app as twitter_tags_app
from lib.ai_seo_tools.sitemap_analysis import main as sitemap_analyzer
from lib.ai_seo_tools.textstaty import analyze_text as readability_analyzer
from lib.ai_seo_tools.wordcloud import generate_wordcloud
# Import new enterprise tools
from ..ai_seo_tools.google_search_console_integration import render_gsc_integration
from ..ai_seo_tools.ai_content_strategy import render_ai_content_strategy
from ..ai_seo_tools.enterprise_seo_suite import render_enterprise_seo_suite
from lib.alwrity_ui.dashboard_styles import apply_dashboard_style, render_dashboard_header, render_category_header, render_card
# ============================================================================
# TOOL CONFIGURATION FUNCTIONS
# ============================================================================
def get_enterprise_tools_config() -> List[Dict[str, Any]]:
"""Get configuration for enterprise tools."""
return [
{
'name': '🎯 Enterprise SEO Suite',
'description': 'Unified command center for comprehensive SEO management with AI-powered workflows',
'function': render_enterprise_seo_suite,
'features': ['Complete SEO audit workflows', 'AI-powered recommendations', 'Strategic planning', 'Performance tracking']
},
{
'name': '📊 Google Search Console Intelligence',
'description': 'AI-powered insights from Google Search Console data with content recommendations',
'function': render_gsc_integration,
'features': ['GSC data analysis', 'Content opportunities', 'Performance insights', 'Strategic recommendations']
},
{
'name': '🧠 AI Content Strategy Generator',
'description': 'Generate comprehensive content strategies using AI market intelligence',
'function': render_ai_content_strategy,
'features': ['Content pillar development', 'Topic cluster strategy', 'Content calendar planning', 'Distribution strategy']
}
]
def get_analytics_tools_config() -> List[Dict[str, Any]]:
"""Get configuration for analytics tools."""
return [
{
'name': '📊 Google Search Console Intelligence',
'description': 'Deep analysis of GSC data with AI-powered content recommendations',
'function': render_gsc_integration,
'category': 'Search Analytics'
},
{
'name': '🔍 Enhanced Content Gap Analysis',
'description': 'Advanced competitor content analysis with AI insights',
'function': lambda: render_enhanced_content_gap_analysis(),
'category': 'Competitive Intelligence'
},
{
'name': '📈 SEO Performance Tracker',
'description': 'Track and analyze SEO performance with trend analysis',
'function': lambda: st.info("SEO Performance Tracker - Coming soon with advanced metrics"),
'category': 'Performance Analytics'
}
]
def get_technical_tools_config() -> List[Dict[str, Any]]:
"""Get configuration for technical SEO tools."""
return [
{
'name': '🔍 Technical SEO Crawler',
'description': 'Comprehensive site-wide technical SEO analysis',
'function': lambda: render_technical_seo_crawler(),
'priority': 'High'
},
{
'name': '📱 Mobile SEO Analyzer',
'description': 'Mobile-specific SEO analysis and optimization',
'function': lambda: st.info("Mobile SEO Analyzer - Advanced mobile optimization coming soon"),
'priority': 'Medium'
},
{
'name': '⚡ Core Web Vitals Optimizer',
'description': 'Analyze and optimize Core Web Vitals performance',
'function': lambda: st.info("Core Web Vitals Optimizer - Performance optimization coming soon"),
'priority': 'High'
},
{
'name': '🗺️ XML Sitemap Generator',
'description': 'Generate and optimize XML sitemaps',
'function': lambda: st.info("XML Sitemap Generator - Coming soon"),
'priority': 'Medium'
}
]
def get_content_tools_config() -> List[Dict[str, Any]]:
"""Get configuration for content and strategy tools."""
return [
{
'name': '🧠 AI Content Strategy Generator',
'description': 'Comprehensive content strategy with AI market intelligence',
'function': render_ai_content_strategy,
'type': 'Enterprise'
},
{
'name': '📅 Content Calendar Planner',
'description': 'AI-powered content calendar with SEO optimization',
'function': lambda: render_content_calendar(),
'type': 'Professional'
},
{
'name': '🎯 Topic Cluster Generator',
'description': 'Generate SEO topic clusters for content dominance',
'function': lambda: st.info("Topic Cluster Generator - Advanced clustering coming soon"),
'type': 'Professional'
},
{
'name': '📊 Content Performance Analyzer',
'description': 'Analyze content performance and optimization opportunities',
'function': lambda: st.info("Content Performance Analyzer - Coming soon"),
'type': 'Standard'
}
]
def get_basic_tools_config() -> List[Dict[str, Any]]:
"""Get configuration for basic SEO tools."""
return [
{
'name': '📝 Meta Description Generator',
'description': 'Generate SEO-optimized meta descriptions',
'function': lambda: metadesc_generator_main(),
'category': 'Metadata'
},
{
'name': '🎯 Content Title Generator',
'description': 'Create compelling, SEO-friendly titles',
'function': lambda: ai_title_generator(),
'category': 'Content'
},
{
'name': '🔗 OpenGraph Generator',
'description': 'Generate social media OpenGraph tags',
'function': lambda: og_tag_generator(),
'category': 'Social'
},
{
'name': '🖼️ Image Alt Text Generator',
'description': 'Generate SEO-friendly image alt text',
'function': lambda: alt_text_gen(),
'category': 'Images'
},
{
'name': '📋 Schema Markup Generator',
'description': 'Generate structured data markup',
'function': lambda: ai_structured_data(),
'category': 'Technical'
},
{
'name': '🔍 On-Page SEO Analyzer',
'description': 'Comprehensive on-page SEO analysis',
'function': lambda: analyze_onpage_seo(),
'category': 'Analysis'
},
{
'name': '🌐 URL SEO Checker',
'description': 'Quick SEO check for any URL',
'function': lambda: url_seo_checker(),
'category': 'Analysis'
}
]
def get_tool_functions_mapping() -> Dict[str, Callable]:
"""Get mapping of tool names to their functions for URL routing."""
return {
# Core content tools
"structured_data": ai_structured_data,
"blog_title": ai_title_generator,
"meta_description": metadesc_generator_main,
"alt_text": alt_text_gen,
"opengraph": og_tag_generator,
"image_optimizer": main_img_optimizer,
# Technical analysis tools
"technical_seo_crawler": render_technical_seo_crawler,
"pagespeed": google_pagespeed_insights,
"onpage_seo": analyze_onpage_seo,
"url_checker": url_seo_checker,
"sitemap_analysis": sitemap_analyzer,
# Social media tools
"twitter_tags": render_twitter_tags,
# Content analysis tools
"readability_analyzer": render_readability_analyzer,
"wordcloud_generator": render_wordcloud_generator,
# Advanced tools
"backlinking": backlinking_ui,
"content_gap_analysis": render_content_gap_analysis,
"enhanced_content_gap_analysis": render_enhanced_content_gap_analysis_ui,
"content_calendar": render_content_calendar,
# Tool combinations for workflow efficiency
"content_optimization": lambda: run_tool_combination([
ai_title_generator,
metadesc_generator_main,
ai_structured_data
], "Content Optimization Suite"),
"technical_audit": lambda: run_tool_combination([
google_pagespeed_insights,
analyze_onpage_seo,
url_seo_checker
], "Technical SEO Audit"),
"image_optimization": lambda: run_tool_combination([
alt_text_gen,
main_img_optimizer
], "Image Optimization Suite"),
"social_optimization": lambda: run_tool_combination([
og_tag_generator,
render_twitter_tags
], "Social Media Optimization")
}
# ============================================================================
# INDIVIDUAL TOOL RENDERING FUNCTIONS
# ============================================================================
def render_content_gap_analysis():
"""Render the content gap analysis workflow interface."""
ui = ContentGapAnalysisUI()
ui.run()
def render_enhanced_content_gap_analysis_ui():
"""Render the enhanced content gap analysis with advertools integration."""
render_enhanced_content_gap_analysis()
def render_content_calendar():
"""Render the content calendar dashboard with proper error handling."""
import logging
import sys
# Configure logging
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.StreamHandler(sys.stdout),
logging.FileHandler('content_calendar.log', mode='a')
]
)
calendar_logger = logging.getLogger('content_calendar')
try:
calendar_logger.info("Initializing Content Calendar Dashboard")
dashboard = ContentCalendarDashboard()
calendar_logger.info("Rendering Content Calendar Dashboard")
dashboard.render()
calendar_logger.info("Content Calendar Dashboard rendered successfully")
except Exception as e:
calendar_logger.error(f"Error rendering content calendar: {str(e)}", exc_info=True)
st.error(f"An error occurred while loading the content calendar: {str(e)}")
def render_twitter_tags():
"""Render the Twitter tags generator."""
twitter_tags_app()
def render_readability_analyzer():
"""Render the text readability analyzer."""
st.title("📖 Text Readability Analyzer")
st.write("Making Your Content Easy to Read")
text_input = st.text_area("Paste your text here:", height=200)
if st.button("Analyze Readability"):
if text_input.strip():
_display_readability_metrics(text_input)
_display_readability_recommendations()
else:
st.error("Please enter text to analyze.")
def _display_readability_metrics(text: str):
"""Display readability metrics for the given text."""
from textstat import textstat
metrics = {
"Flesch Reading Ease": textstat.flesch_reading_ease(text),
"Flesch-Kincaid Grade Level": textstat.flesch_kincaid_grade(text),
"Gunning Fog Index": textstat.gunning_fog(text),
"SMOG Index": textstat.smog_index(text),
"Automated Readability Index": textstat.automated_readability_index(text),
"Coleman-Liau Index": textstat.coleman_liau_index(text),
"Linsear Write Formula": textstat.linsear_write_formula(text),
"Dale-Chall Readability Score": textstat.dale_chall_readability_score(text),
"Readability Consensus": textstat.readability_consensus(text)
}
st.subheader("Text Analysis Results")
for metric, value in metrics.items():
st.metric(metric, f"{value:.2f}")
def _display_readability_recommendations():
"""Display readability recommendations."""
st.subheader("Key Takeaways:")
st.markdown("""
* **Don't Be Afraid to Simplify!** Often, simpler language makes content more impactful and easier to digest.
* **Aim for a Reading Level Appropriate for Your Audience:** Consider the education level, background, and familiarity of your readers.
* **Use Short Sentences:** This makes your content more scannable and easier to read.
* **Write for Everyone:** Accessibility should always be a priority. When in doubt, aim for clear, concise language!
""")
def render_wordcloud_generator():
"""Render the word cloud generator."""
st.title("☁️ Word Cloud Generator")
st.write("Visualize the most important words in your content")
text_input = st.text_area("Enter your text:", height=200)
if st.button("Generate Word Cloud"):
if text_input.strip():
_generate_and_display_wordcloud(text_input)
_display_text_statistics(text_input)
else:
st.error("Please enter text to generate a word cloud.")
def _generate_and_display_wordcloud(text: str):
"""Generate and display word cloud for the given text."""
from wordcloud import WordCloud
import matplotlib.pyplot as plt
# Create and generate a word cloud image
wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)
# Display the word cloud
st.subheader("Word Cloud Visualization")
fig, ax = plt.subplots(figsize=(10, 5))
ax.imshow(wordcloud, interpolation='bilinear')
ax.axis('off')
st.pyplot(fig)
def _display_text_statistics(text: str):
"""Display basic text statistics."""
st.subheader("Text Statistics")
words = text.split()
unique_words = set(words)
st.metric("Total Words", len(words))
st.metric("Unique Words", len(unique_words))
# ============================================================================
# TAB RENDERING FUNCTIONS
# ============================================================================
def render_enterprise_tab():
"""Render the Enterprise Suite tab."""
st.header("🏢 Enterprise SEO Command Center")
st.markdown("**Unified SEO management for enterprise-level optimization**")
enterprise_tools = get_enterprise_tools_config()
# Display enterprise tools
for tool in enterprise_tools:
_render_enterprise_tool_card(tool)
# Render selected enterprise tool
_render_selected_enterprise_tool(enterprise_tools)
def _render_enterprise_tool_card(tool: Dict[str, Any]):
"""Render an individual enterprise tool card."""
with st.expander(f"{tool['name']} - {tool['description']}", expanded=False):
col1, col2 = st.columns([2, 1])
with col1:
st.markdown("**Key Features:**")
for feature in tool['features']:
st.write(f"• {feature}")
with col2:
if st.button(f"Launch {tool['name'].split()[1]}", key=f"enterprise_{tool['name']}", use_container_width=True):
st.session_state.selected_enterprise_tool = tool['name']
tool['function']()
def _render_selected_enterprise_tool(enterprise_tools: List[Dict[str, Any]]):
"""Render the selected enterprise tool if any."""
if 'selected_enterprise_tool' in st.session_state:
selected_tool = next((tool for tool in enterprise_tools if tool['name'] == st.session_state.selected_enterprise_tool), None)
if selected_tool:
st.markdown("---")
selected_tool['function']()
def render_analytics_tab():
"""Render the Analytics & Intelligence tab."""
st.header("📊 Analytics & Intelligence")
st.markdown("**Advanced analytics and competitive intelligence tools**")
analytics_tools = get_analytics_tools_config()
# Group tools by category
categories = _group_tools_by_category(analytics_tools)
for category, tools in categories.items():
st.subheader(f"📊 {category}")
for tool in tools:
_render_analytics_tool_row(tool)
def _group_tools_by_category(tools: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
"""Group tools by their category."""
categories = {}
for tool in tools:
category = tool['category']
if category not in categories:
categories[category] = []
categories[category].append(tool)
return categories
def _render_analytics_tool_row(tool: Dict[str, Any]):
"""Render an analytics tool row."""
col1, col2 = st.columns([3, 1])
with col1:
st.markdown(f"**{tool['name']}**")
st.write(tool['description'])
with col2:
if st.button("Launch", key=f"analytics_{tool['name']}", use_container_width=True):
tool['function']()
def render_technical_tab():
"""Render the Technical SEO tab."""
st.header("🔧 Technical SEO")
st.markdown("**Advanced technical SEO analysis and optimization tools**")
technical_tools = get_technical_tools_config()
# Display technical tools with priority indicators
for tool in technical_tools:
_render_technical_tool_row(tool)
def _render_technical_tool_row(tool: Dict[str, Any]):
"""Render a technical tool row with priority indicator."""
priority_color = "🔴" if tool['priority'] == 'High' else "🟡"
col1, col2, col3 = st.columns([2, 1, 1])
with col1:
st.markdown(f"**{tool['name']}** {priority_color}")
st.write(tool['description'])
with col2:
st.write(f"**Priority:** {tool['priority']}")
with col3:
if st.button("Launch", key=f"technical_{tool['name']}", use_container_width=True):
tool['function']()
def render_content_tab():
"""Render the Content & Strategy tab."""
st.header("📝 Content & Strategy")
st.markdown("**AI-powered content creation and strategy tools**")
content_tools = get_content_tools_config()
# Group by tool type
tool_types = _group_tools_by_type(content_tools)
for tool_type, tools in tool_types.items():
_render_content_tool_section(tool_type, tools)
def _group_tools_by_type(tools: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
"""Group tools by their type."""
tool_types = {}
for tool in tools:
tool_type = tool['type']
if tool_type not in tool_types:
tool_types[tool_type] = []
tool_types[tool_type].append(tool)
return tool_types
def _render_content_tool_section(tool_type: str, tools: List[Dict[str, Any]]):
"""Render a content tool section."""
type_color = {"Enterprise": "🏢", "Professional": "💼", "Standard": "📋"}
st.subheader(f"{type_color.get(tool_type, '📋')} {tool_type} Tools")
for tool in tools:
col1, col2 = st.columns([3, 1])
with col1:
st.markdown(f"**{tool['name']}**")
st.write(tool['description'])
with col2:
if st.button("Launch", key=f"content_{tool['name']}", use_container_width=True):
tool['function']()
def render_basic_tools_tab():
"""Render the Basic Tools tab."""
st.header("🎯 Basic SEO Tools")
st.markdown("**Essential SEO tools for quick optimization tasks**")
basic_tools = get_basic_tools_config()
# Group basic tools by category
basic_categories = _group_tools_by_category(basic_tools)
# Display in columns for better layout
_render_basic_tools_in_columns(basic_categories)
def _render_basic_tools_in_columns(basic_categories: Dict[str, List[Dict[str, Any]]]):
"""Render basic tools in two columns."""
col1, col2 = st.columns(2)
categories_list = list(basic_categories.items())
mid_point = len(categories_list) // 2
with col1:
for category, tools in categories_list[:mid_point]:
_render_basic_tool_category(category, tools)
with col2:
for category, tools in categories_list[mid_point:]:
_render_basic_tool_category(category, tools)
def _render_basic_tool_category(category: str, tools: List[Dict[str, Any]]):
"""Render a basic tool category."""
st.subheader(f"📂 {category}")
for tool in tools:
if st.button(f"{tool['name']}", key=f"basic_{tool['name']}", use_container_width=True):
tool['function']()
st.caption(tool['description'])
st.markdown("---")
def render_enterprise_features_footer():
"""Render the enterprise features footer."""
st.markdown("---")
st.markdown("### 🚀 Enterprise SEO Features")
col1, col2, col3 = st.columns(3)
with col1:
st.info("""
**🏢 Enterprise Suite**
- Unified SEO workflows
- AI-powered insights
- Strategic planning
- Performance tracking
""")
with col2:
st.info("""
**📊 Advanced Analytics**
- GSC integration
- Competitive intelligence
- Content gap analysis
- Performance insights
""")
with col3:
st.info("""
**🧠 AI Strategy**
- Content strategy generation
- Topic cluster planning
- Distribution optimization
- Market intelligence
""")
# ============================================================================
# MAIN DASHBOARD FUNCTIONS
# ============================================================================
def render_seo_tools_dashboard():
"""Render comprehensive SEO tools dashboard with enterprise features."""
st.title("🚀 Alwrity AI SEO Tools")
st.markdown("**Enterprise-level SEO tools powered by artificial intelligence**")
# Create tabs for different tool categories
tab1, tab2, tab3, tab4, tab5 = st.tabs([
"🏢 Enterprise Suite",
"📊 Analytics & Intelligence",
"🔧 Technical SEO",
"📝 Content & Strategy",
"🎯 Basic Tools"
])
with tab1:
render_enterprise_tab()
with tab2:
render_analytics_tab()
with tab3:
render_technical_tab()
with tab4:
render_content_tab()
with tab5:
render_basic_tools_tab()
# Add footer with enterprise features highlight
render_enterprise_features_footer()
def ai_seo_tools():
"""Main entry point for SEO tools dashboard with premium glassmorphic design."""
logger.info("Starting SEO Tools Dashboard")
# Apply common dashboard styling
apply_dashboard_style()
# Check if a specific tool is selected
selected_tool = st.query_params.get("tool")
if selected_tool:
_handle_selected_tool(selected_tool)
else:
# Show the dashboard if no tool is selected
render_seo_tools_dashboard()
def _handle_selected_tool(selected_tool: str):
"""Handle rendering of a specific selected tool."""
tool_functions = get_tool_functions_mapping()
if selected_tool in tool_functions:
# Clear any existing content
st.empty()
# Execute the selected tool's function
tool_functions[selected_tool]()
else:
st.error(f"Tool '{selected_tool}' is not available or under development.")
st.info("Please select a different tool from the dashboard.")
render_seo_tools_dashboard()
def run_tool_combination(tools: List[Callable], combination_name: str):
"""Run a combination of tools and provide cross-tool analysis."""
st.markdown(f"# {combination_name}")
st.markdown("Comprehensive SEO analysis workflow")
# Create tabs for each tool in the combination
tab_names = _generate_tab_names(tools)
tabs = st.tabs(tab_names)
# Run each tool in its own tab
_execute_tools_in_tabs(tabs, tools)
# Add cross-tool analysis section
_render_analysis_summary()
def _generate_tab_names(tools: List[Callable]) -> List[str]:
"""Generate tab names for tool combination."""
tab_names = []
for i, tool in enumerate(tools):
if hasattr(tool, '__name__'):
tab_names.append(tool.__name__.replace('_', ' ').title())
else:
tab_names.append(f"Step {i+1}")
return tab_names
def _execute_tools_in_tabs(tabs: List, tools: List[Callable]):
"""Execute tools in their respective tabs."""
for tab, tool in zip(tabs, tools):
with tab:
try:
tool()
except Exception as e:
st.error(f"Error running tool: {str(e)}")
logger.error(f"Error in tool combination: {str(e)}")
def _render_analysis_summary():
"""Render the analysis summary section."""
with st.expander("📊 Analysis Summary", expanded=True):
st.markdown("""
### Key Recommendations:
1. **Content Optimization**: Ensure your titles and meta descriptions are keyword-optimized
2. **Technical Performance**: Address any speed or technical issues identified
3. **Structured Data**: Implement schema markup for better search visibility
4. **Social Optimization**: Optimize social sharing tags for better engagement
### Next Steps:
- Implement the recommendations from each tool
- Monitor your rankings and traffic after changes
- Regularly audit your content using these tools
""")
# Add export functionality placeholder
if st.button("📥 Export Analysis Report", use_container_width=True):
st.info("Export functionality is being developed. Save your results manually for now.")
Reference in New Issue View Git Blame Copy Permalink