kunthawat/ALwrity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added new features to the project

Browse Source
This commit is contained in:
ajaysi
2025-06-30 07:49:48 +05:30
parent bbe56a364d
commit b21cbb68da
48 changed files with 19774 additions and 1889 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@@ -0,0 +1,63 @@
---
name: 🐛 Bug Report
about: Create a report to help us improve ALwrity
title: '[BUG] '
labels: ['bug', 'needs-triage']
assignees: ''
---
## 🐛 Bug Description
A clear and concise description of what the bug is.
## 🔄 Steps to Reproduce
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
## ✅ Expected Behavior
A clear and concise description of what you expected to happen.
## ❌ Actual Behavior
A clear and concise description of what actually happened.
## 📸 Screenshots
If applicable, add screenshots to help explain your problem.
## 🖥️ Environment Information
**Desktop/Server:**
- OS: [e.g. Windows 10, macOS 12.0, Ubuntu 20.04]
- Python Version: [e.g. 3.10.5]
- ALwrity Version: [e.g. latest, commit hash]
- Browser: [e.g. Chrome 96, Firefox 95] (if applicable)
**Mobile (if applicable):**
- Device: [e.g. iPhone 13, Samsung Galaxy S21]
- OS: [e.g. iOS 15.1, Android 12]
- Browser: [e.g. Safari, Chrome Mobile]
## 🔧 Configuration
- AI Provider: [e.g. OpenAI, Google Gemini, Anthropic]
- Features Used: [e.g. Blog Writer, SEO Tools, Social Media]
- API Keys Configured: [List which APIs you have configured - don't share actual keys]
## 📋 Error Logs
If applicable, paste any error messages or logs here:
```
Paste error logs here
```
## 🔍 Additional Context
Add any other context about the problem here. This could include:
- When did this start happening?
- Does it happen consistently or intermittently?
- Have you tried any workarounds?
- Any recent changes to your setup?
## ✅ Checklist
- [ ] I have searched for existing issues that describe this bug
- [ ] I have included all relevant information above
- [ ] I have tested this with the latest version of ALwrity
- [ ] I have checked the [documentation](https://github.com/AJaySi/AI-Writer/wiki) for solutions

74
.github/ISSUE_TEMPLATE/feature_request.md vendored Normal file
View File

@@ -0,0 +1,74 @@
---
name: 💡 Feature Request
about: Suggest an idea for ALwrity
title: '[FEATURE] '
labels: ['enhancement', 'needs-discussion']
assignees: ''
---
## 🚀 Feature Summary
A clear and concise description of the feature you'd like to see added to ALwrity.
## 🎯 Problem Statement
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
## 💡 Proposed Solution
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
## 🔄 Alternative Solutions
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
## 🎨 Mockups/Examples
If applicable, add mockups, screenshots, or examples to help explain your feature request.
## 📊 Use Cases
Describe specific use cases where this feature would be valuable:
1. **Use Case 1**: [Description]
2. **Use Case 2**: [Description]
3. **Use Case 3**: [Description]
## 🎯 Target Users
Who would benefit from this feature?
- [ ] Content Creators/Bloggers
- [ ] Digital Marketers
- [ ] Social Media Managers
- [ ] SEO Specialists
- [ ] Business Owners
- [ ] Developers
- [ ] Other: [Please specify]
## 📈 Impact Assessment
**How would this feature improve ALwrity?**
- [ ] Improves user experience
- [ ] Adds new functionality
- [ ] Enhances existing features
- [ ] Improves performance
- [ ] Increases accessibility
- [ ] Supports new platforms/integrations
- [ ] Other: [Please specify]
## 🔧 Technical Considerations
**Do you have any technical insights or requirements?**
- Preferred AI models or APIs
- Integration requirements
- Performance considerations
- Compatibility needs
## 📚 Additional Context
Add any other context, research, or examples about the feature request here.
## 🌟 Priority Level
How important is this feature to you?
- [ ] Nice to have
- [ ] Would be helpful
- [ ] Important for my workflow
- [ ] Critical/Blocking my use case
## ✅ Checklist
- [ ] I have searched for existing feature requests
- [ ] I have checked the [roadmap](https://github.com/AJaySi/AI-Writer/blob/main/Roadmap%20TBDs/ROADMAP.md) to see if this is already planned
- [ ] I have provided clear use cases and examples
- [ ] I understand this is a request and not a guarantee of implementation

62
.github/PULL_REQUEST_TEMPLATE.md vendored Normal file
View File

@@ -0,0 +1,62 @@
# 🚀 Pull Request
## 📋 Description
Brief description of what this PR does and why it's needed.
## 🔗 Related Issues
Fixes #(issue number)
Closes #(issue number)
Related to #(issue number)
## 🎯 Type of Change
- [ ] 🐛 Bug fix (non-breaking change which fixes an issue)
- [ ] ✨ New feature (non-breaking change which adds functionality)
- [ ] 💥 Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] 📚 Documentation update
- [ ] 🎨 Style/UI changes
- [ ] ♻️ Code refactoring
- [ ] ⚡ Performance improvements
- [ ] 🧪 Test additions or updates
- [ ] 🔧 Build/CI changes
## 🧪 Testing
**How has this been tested?**
- [ ] Unit tests
- [ ] Integration tests
- [ ] Manual testing
- [ ] Tested with different AI providers
- [ ] Tested on different platforms
**Test Configuration:**
- Python version:
- OS:
- AI Provider(s) tested:
## 📸 Screenshots (if applicable)
Add screenshots to help explain your changes.
## ✅ Checklist
- [ ] My code follows the project's style guidelines
- [ ] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published
## 📝 Additional Notes
Any additional information, concerns, or notes for reviewers.
## 🔄 Breaking Changes
If this is a breaking change, please describe the impact and migration path for existing users.
## 📚 Documentation
- [ ] README updated
- [ ] Wiki/docs updated
- [ ] API documentation updated
- [ ] Comments added to code
---
**Thank you for contributing to ALwrity! 🎉**

2
.gitignore vendored
View File

@@ -3,6 +3,8 @@
.DS_Store
.vscode
*.pyc
content_scheduler.db
*.db
.env
.env.local
.env.development.local

153
BOOTSTRAP_AI_SUITE_SUMMARY.md Normal file
View File

@@ -0,0 +1,153 @@
# 🚀 Bootstrap AI Competitive Suite Summary
**Built for Solo Entrepreneurs Competing Against Big Players**
## 🎯 What We Built
A complete AI-powered competitive toolkit designed specifically for bootstrapped startups and solo entrepreneurs who need to compete against well-funded competitors like Jasper AI, Copy.ai, and Surfer SEO.
## 📁 Files Created
### 1. AI Content Performance Predictor
- **File**: `lib/content_performance_predictor/ai_performance_predictor.py`
- **Purpose**: Uses AI to predict content performance without requiring ML training data
- **Key Features**:
- Platform-specific optimization (Twitter, LinkedIn, Facebook, Instagram)
- Engagement score prediction
- Virality potential analysis
- Actionable recommendations
- Hashtag optimization
- Posting time suggestions
### 2. Bootstrap Competitive Intelligence
- **File**: `lib/competitive_intelligence/ai_bootstrap_competitor_intel.py`
- **Purpose**: AI-powered competitor analysis for resource-constrained startups
- **Key Features**:
- Competitor weakness identification
- Content gap analysis
- Strategic recommendations
- Quick win opportunities
- Market positioning advice
- Threat level assessment
### 3. Unified Bootstrap AI Suite
- **File**: `lib/ai_competitive_suite/bootstrap_ai_suite.py`
- **Purpose**: Combines both tools into one powerful interface
- **Key Features**:
- Integrated content and competitive strategy
- Cross-tool insights
- Actionable step-by-step plans
- David vs. Goliath tactics
## 🧠 AI-First Approach (Perfect for Solo Developers)
Instead of complex ML models that require:
- ❌ Large training datasets
- ❌ ML engineering expertise
- ❌ Expensive compute resources
- ❌ Data scientists
We use AI that provides:
- ✅ Zero-shot predictions using your existing `llm_text_gen`
- ✅ Educated guesses based on LLM training
- ✅ Immediate deployment with current infrastructure
- ✅ Competitive insights without data collection delays
## 🎯 Competitive Advantages Over Big Players
### vs. Jasper AI / Copy.ai
- **Personal Touch**: Your AI provides personalized recommendations, not generic templates
- **Competitive Intelligence**: They focus on content creation; you provide strategic advantage
- **Bootstrapped Insights**: Advice specifically for resource-constrained competitors
- **Integrated Approach**: Content performance + competitive analysis in one tool
### vs. Surfer SEO / SEMrush
- **AI-Powered**: Uses modern LLMs vs. traditional keyword analysis
- **Startup-Focused**: Strategies that work for solo entrepreneurs
- **Quick Implementation**: No complex setup or learning curve
- **Affordable**: Leverages your existing AI infrastructure
## 🚀 How to Use
### Quick Start
1. Run the unified suite: `lib/ai_competitive_suite/bootstrap_ai_suite.py`
2. Use the 3-tab interface:
- **Tab 1**: Predict content performance
- **Tab 2**: Analyze competitors
- **Tab 3**: Get integrated strategy (MOST POWERFUL)
### Recommended Workflow
1. **Start with Integrated Strategy** (Tab 3) - combines both tools for maximum impact
2. Input your content, competitors, and strengths
3. Get step-by-step action plan
4. Execute quick wins first
5. Use individual tools (Tabs 1-2) for deep dives
## 💡 Strategic Positioning
### Your Unique Value Proposition
- **"AI-Powered Competitive Intelligence for Solo Entrepreneurs"**
- **"Content Performance Prediction + Competitive Strategy in One Tool"**
- **"David vs. Goliath Marketing Strategies Powered by AI"**
### Marketing Angles
- "Compete with big players using AI"
- "Solo entrepreneur's secret weapon"
- "Predict content success before you publish"
- "Find competitor blind spots with AI"
- "Bootstrap your way to market leadership"
## 🎯 Immediate Implementation Benefits
### For Your Users
- Get strategic insights without hiring expensive consultants
- Predict content performance using AI (not gut feeling)
- Find competitor weaknesses to exploit
- Get step-by-step action plans
- Focus on quick wins that move the needle
### For Your Business
- Differentiate from generic AI writing tools
- Provide strategic value (not just content creation)
- Target underserved solo entrepreneur market
- Use existing AI infrastructure efficiently
- Create competitive moat through unique positioning
## 📈 Next Steps
### Phase 1: Launch (Immediate)
1. Deploy the Bootstrap AI Suite
2. Test with your existing users
3. Gather feedback and iterate
4. Create marketing content around "AI competitive intelligence"
### Phase 2: Enhance (1-3 months)
1. Add more platform-specific optimizations
2. Integrate with your existing Twitter data
3. Add trending topic detection
4. Build competitive monitoring alerts
### Phase 3: Scale (3-6 months)
1. Add LinkedIn integration (as you planned)
2. Expand to more platforms
3. Build API integrations for better data
4. Add team collaboration features
## 🎯 Perfect Fit for Your Situation
This implementation is specifically designed for:
- ✅ Solo developers with limited resources
- ✅ Using existing AI infrastructure (`llm_text_gen`)
- ✅ Competing against well-funded players
- ✅ Need for immediate competitive advantage
- ✅ Bootstrap mentality and scrappy execution
The tools are built to give you the strategic intelligence that big companies pay consultants thousands for - but powered by AI and designed for solo entrepreneurs.
## 🚀 Ready to Launch
All three tools are ready for immediate deployment and testing. The unified suite provides the most value by combining content optimization with competitive intelligence - something none of your competitors currently offer.
**Your competitive advantage**: While others focus on content creation, you provide strategic intelligence. While others serve everyone, you focus on solo entrepreneurs. While others require complex setup, yours works immediately with existing infrastructure.
This is your path to competing with (and beating) the big players! 🥷

291
CONTRIBUTING.md Normal file
View File

@@ -0,0 +1,291 @@
# 🤝 Contributing to ALwrity
Thank you for your interest in contributing to ALwrity! We're excited to have you join our community of developers, content creators, and AI enthusiasts working together to build the ultimate AI-powered content creation platform.
## 🌟 Ways to Contribute
### 🐛 **Report Bugs**
Found a bug? Help us improve by reporting it!
- Check [existing issues](https://github.com/AJaySi/AI-Writer/issues) first
- Use our [bug report template](https://github.com/AJaySi/AI-Writer/issues/new?template=bug_report.md)
- Include detailed steps to reproduce the issue
### 💡 **Suggest Features**
Have a great idea for ALwrity?
- Check [discussions](https://github.com/AJaySi/AI-Writer/discussions) for similar ideas
- Create a [feature request](https://github.com/AJaySi/AI-Writer/issues/new?template=feature_request.md)
- Explain the use case and potential impact
### 🔧 **Contribute Code**
Ready to dive into the code?
- Check our [good first issues](https://github.com/AJaySi/AI-Writer/labels/good%20first%20issue)
- Look at our [roadmap](Roadmap%20TBDs/ROADMAP.md) for upcoming features
- Follow our development guidelines below
### 📖 **Improve Documentation**
Help make ALwrity more accessible!
- Fix typos or unclear instructions
- Add examples and tutorials
- Translate documentation to other languages
- Update API documentation
### 🎨 **Design & UX**
Make ALwrity more beautiful and user-friendly!
- Improve UI/UX designs
- Create better icons and graphics
- Suggest interface improvements
- Design marketing materials
---
## 🚀 Quick Start for Contributors
### 1. **Fork & Clone**
```bash
# Fork the repository on GitHub, then clone your fork
git clone https://github.com/YOUR_USERNAME/AI-Writer.git
cd AI-Writer
```
### 2. **Set Up Development Environment**
```bash
# Create virtual environment
python -m venv venv
# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt
```
### 3. **Configure Environment**
```bash
# Copy environment template
cp .env.example .env
# Add your API keys to .env file
# Note: You only need keys for the features you're working on
```
### 4. **Run ALwrity**
```bash
# Start the application
streamlit run alwrity.py
```
### 5. **Create Feature Branch**
```bash
# Create and switch to a new branch
git checkout -b feature/your-feature-name
```
---
## 📋 Development Guidelines
### 🎯 **Code Style**
- Follow [PEP 8](https://www.python.org/dev/peps/pep-0008/) for Python code
- Use 4 spaces for indentation (no tabs)
- Maximum line length: 100 characters
- Use meaningful variable and function names
- Add type hints where possible
### 📝 **Documentation Standards**
```python
def generate_blog_content(
keywords: str,
length: int = 1000,
include_research: bool = True
) -> dict:
"""Generate SEO-optimized blog content using AI.
Args:
keywords: Target keywords for the blog post
length: Desired word count for the content
include_research: Whether to include web research
Returns:
Dictionary containing generated content, title, and metadata
Raises:
ValueError: If keywords are empty or length is negative
"""
# Implementation here...
```
### 🧪 **Testing**
- Write tests for new features
- Ensure existing tests pass
- Aim for meaningful test coverage
- Use descriptive test names
```bash
# Run tests (when available)
pytest tests/
# Run specific test file
pytest tests/test_blog_writer.py
```
### 📦 **Project Structure**
```
AI-Writer/
├── lib/ # Core library modules
│ ├── ai_writers/ # AI writing tools
│ ├── ai_seo_tools/ # SEO optimization tools
│ ├── ai_marketing_tools/ # Marketing and social media tools
│ ├── utils/ # Utility functions
│ └── database/ # Database management
├── docs/ # Documentation
├── tests/ # Test files
├── alwrity.py # Main application entry point
└── requirements.txt # Python dependencies
```
---
## 🔄 Pull Request Process
### 1. **Before You Start**
- Check if there's an existing issue for your contribution
- If not, create an issue to discuss your proposed changes
- Get feedback from maintainers before starting large changes
### 2. **Making Changes**
- Keep changes focused and atomic
- Write clear, descriptive commit messages
- Test your changes thoroughly
- Update documentation as needed
### 3. **Commit Message Format**
Use [Conventional Commits](https://www.conventionalcommits.org/) format:
```
type(scope): description
feat(blog-writer): add support for custom templates
fix(seo-tools): resolve meta description length issue
docs(readme): update installation instructions
style(ui): improve button styling consistency
refactor(api): simplify authentication flow
test(writers): add unit tests for email writer
chore(deps): update streamlit to latest version
```
### 4. **Submit Pull Request**
- Push your changes to your fork
- Create a pull request with a clear title and description
- Link any related issues
- Wait for review and address feedback
### 5. **Review Process**
- Maintainers will review your PR
- Address any requested changes
- Once approved, your PR will be merged
- Celebrate! 🎉 You're now a contributor!
---
## 🏗️ Architecture Overview
### **Core Components**
- **AI Writers**: Content generation modules for different formats
- **SEO Tools**: Search engine optimization utilities
- **Web Research**: Fact-checking and research integration
- **UI Layer**: Streamlit-based user interface
- **Database**: Content storage and management
### **Key Technologies**
- **Frontend**: Streamlit
- **Backend**: Python 3.10+
- **AI Models**: OpenAI, Google Gemini, Anthropic Claude
- **Research APIs**: Tavily, Exa, Serper
- **Database**: SQLite, ChromaDB
---
## 🎯 Contribution Areas
### 🔥 **High Priority**
- Bug fixes and stability improvements
- Performance optimizations
- Mobile responsiveness
- API integrations
- Test coverage improvements
### 🚀 **New Features**
- Additional AI writing tools
- Enhanced SEO capabilities
- Social media integrations
- Analytics and reporting
- Collaboration features
### 🌍 **Internationalization**
- Multi-language support
- Regional content optimization
- Translation improvements
- Cultural adaptation
### 📱 **Platform Expansion**
- Mobile app development
- Browser extensions
- Desktop applications
- API development
---
## 🏆 Recognition
### **Contributors Hall of Fame**
All contributors are recognized in our:
- [CONTRIBUTORS.md](CONTRIBUTORS.md) file
- GitHub contributors page
- Release notes for significant contributions
- Social media shoutouts
### **Contribution Levels**
- 🌟 **First-time contributor**: Welcome to the community!
- 🚀 **Regular contributor**: Multiple merged PRs
- 💎 **Core contributor**: Significant feature contributions
- 🏆 **Maintainer**: Ongoing project stewardship
---
## 💬 Community & Support
### **Communication Channels**
- 💬 [GitHub Discussions](https://github.com/AJaySi/AI-Writer/discussions) - General questions and ideas
- 🐛 [GitHub Issues](https://github.com/AJaySi/AI-Writer/issues) - Bug reports and feature requests
- 🔧 [Pull Requests](https://github.com/AJaySi/AI-Writer/pulls) - Code contributions
- 📧 [Email](mailto:support@alwrity.com) - Direct support
### **Getting Help**
- Check our [documentation](https://github.com/AJaySi/AI-Writer/wiki)
- Search existing issues and discussions
- Ask questions in discussions
- Join our community calls (announced in discussions)
### **Code of Conduct**
We follow the [Contributor Covenant Code of Conduct](CODE_OF_CONDUCT.md). Please read it before participating.
---
## 🎉 Thank You!
Every contribution, no matter how small, makes ALwrity better for everyone. Whether you're fixing a typo, adding a feature, or helping other users, you're making a difference in the AI content creation community.
**Ready to contribute?** Check out our [good first issues](https://github.com/AJaySi/AI-Writer/labels/good%20first%20issue) and join us in building the future of AI-powered content creation!
---
<div align="center">
**Made with ❤️ by the ALwrity Community**
[🌐 Website](https://www.alwrity.com) • [📖 Documentation](https://github.com/AJaySi/AI-Writer/wiki) • [💬 Community](https://github.com/AJaySi/AI-Writer/discussions)
</div>

602
README.md
View File

@@ -1,403 +1,329 @@
# Alwrity: Redefining Content Lifecycle with AI
### 🚀 **ALwrity: Your All-in-One Content Platform** 🌟
# 🚀 ALwrity - AI-Powered Content Creation & SEO Platform
![Alwrity Logo](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/alwrity_logo.png)
<div align="center">
![ALwrity Logo](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/alwrity_logo.png)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![Streamlit](https://img.shields.io/badge/Streamlit-1.28+-red.svg)](https://streamlit.io/)
[![Streamlit](https://img.shields.io/badge/Streamlit-1.44+-red.svg)](https://streamlit.io/)
[![GitHub Stars](https://img.shields.io/github/stars/AJaySi/AI-Writer?style=social)](https://github.com/AJaySi/AI-Writer/stargazers)
[![GitHub Forks](https://img.shields.io/github/forks/AJaySi/AI-Writer?style=social)](https://github.com/AJaySi/AI-Writer/network/members)
> **NOTE**
> *Alwrity is a comprehensive content lifecycle platform tailored for content creators, digital marketers, and writers — no prior AI knowledge required.*
**🌟 The Ultimate AI Content Creation Platform for Bloggers, Marketers & Content Creators**
## 📋 Table of Contents
[🚀 Try Free Tools](https://www.alwrity.com/ai-writing-tools) • [📖 Documentation](https://github.com/AJaySi/AI-Writer/wiki) • [💬 Community](https://github.com/AJaySi/AI-Writer/discussions) • [🐛 Report Issues](https://github.com/AJaySi/AI-Writer/issues)
- [Overview](#overview)
- [Key Features](#key-features)
- [System Architecture](#system-architecture)
- [Getting Started](#getting-started)
- [Prerequisites](#prerequisites)
- [Installation](#installation)
- [Configuration](#configuration)
- [Usage Guide](#usage-guide)
- [AI Writers](#ai-writers)
- [SEO Tools](#seo-tools)
- [Social Media Tools](#social-media-tools)
- [Content Planning](#content-planning)
- [API Documentation](#api-documentation)
- [Contributing](#contributing)
- [Roadmap](#roadmap)
- [License](#license)
- [Acknowledgements](#acknowledgements)
---
## 🌟 Overview
Alwrity streamlines every phase of the content lifecycle, from **planning and research** to **personalized content generation**, **SEO audits**, **publishing**, and **analytics**. Our mission is to empower creators with AI-driven tools that simplify content creation while maintaining quality.
The platform integrates state-of-the-art AI technologies to provide a seamless content creation experience:
| **Content Category** | **Technologies/Models** |
|--------------------------|-------------------------------------------|
| Text Generation Models | OpenAI, Gemini, Anthropic |
| Image Creation Tools | Stability.ai |
| Speech-to-Text Systems | Whisper, AssemblyAI |
| AI-Powered Web Research | Tavily AI, exa AI, Serper.dev |
</div>
---
## 🚀 Key Features
## 🎯 What is ALwrity?
### AI Writer Tools
ALwrity is a **comprehensive AI-powered content creation platform** that revolutionizes how you create, optimize, and manage content across all digital channels. From **blog writing** and **SEO optimization** to **social media content** and **marketing copy**, ALwrity handles your entire content lifecycle with cutting-edge AI technology.
- **AI Blog Writer**: Generate blog content based on web research
- **AI YouTube to Content Writer**: Transform YouTube videos into written content
- **AI Long Form Content**: Create detailed articles with proper structure
- **AI Story Writer**: Craft engaging narratives and stories
- **AI Email Writer**: Generate professional and business emails
- **AI LinkedIn Post Generator**: Create optimized LinkedIn content
- **AI Product Description Generator**: Write compelling product descriptions
### 🔥 Why Choose ALwrity?
### SEO Tools
- **Rich Snippet Generator**: Create structured data for better SERP visibility
- **On-Page SEO Analyzer**: Evaluate and optimize web pages
- **URL SEO Checker**: Assess URL structure and performance
- **Backlinking Tool**: Discover high-quality backlink opportunities
- **Image Alt Text Generator**: Create accessible image descriptions
- **Meta Description Generator**: Generate SEO-friendly meta descriptions
### Social Media Tools
- **X Tweet Generator**: Create engaging tweets
- **Instagram Caption Generator**: Write compelling Instagram captions
- **Facebook Post Generator**: Develop Facebook-optimized content
- **YouTube Content Tools**: Generate titles, descriptions, and scripts
### Content Planning
- **Content Calendar**: Plan content for weeks or months ahead
- **Blog Image Creation**: Generate images to complement your content
- **Agentic Content Creation**: Use AI agents for specialized content tasks
- **Web Research Integration**: Gather factual information for your content
## 🏗️ System Architecture
Alwrity is built with a modular architecture that enables flexibility and extensibility:
![Architecture Diagram](https://github.com/AJaySi/AI-Writer/docs/architecture/diagrams/high_level_architecture.png)
The platform consists of several key components:
1. **User Interface Layer**: Streamlit-based web interface
2. **Core Services Layer**: AI Writers, Web Research, SEO Tools, Analytics
3. **Data Storage Layer**: Vector Database (ChromaDB), Relational Database (SQLite)
4. **External Integrations Layer**: LLM Providers, Search Providers, Image Generation, Publishing Platforms
For more detailed architecture information, see the [Architecture Documentation](docs/architecture/index.rst).
## Getting Started with ALwrity: "AI at Every Stage of Content Lifecycle."
Alwrity empowers content creators, solopreneurs and digital marketers with cutting-edge tools for keyword research, AI-driven writing, and social media content generation. From creating high-quality copywriting frameworks to crafting engaging YouTube scripts, our platform simplifies every step of your content creation journey.
---
> ![](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/keyword_blog.gif)
---
### Option 1: Get Started Now, [Visit alwrity.com](https://www.alwrity.com/ai-writing-tools)
> [!NOTE] <p>You will find AI content writing tools, which are Free & No-Signup.
> **Note:** Although, this is limited, as is our wallet & Resources.</p>
### Option 2). **For complete AI content creation toolkit**, alwrity offers a local streamlit UI App.
> [!NOTE] <p>
> Its a BYOK model(Bring Your Own Key).
> **Note:** 🗯️ Now, before you run away 🏃💨
> If you have 💻 Laptop + 🛜 Internet + 10 minutes, you will be generating blogs, articles etc with just few words.
>
> [Step-By-Step: Getting Started for Absolute Begginers](https://www.alwrity.com/post/getting-started-with-alwrity-ai-writer)
>
>[Getting started for Developers](https://github.com/AJaySi/AI-Writer/wiki/Getting-started-with-ALwrity-AI-writer)
> <details>
> <summary>See Details</summary>
>
### ![List of all AI Tools & Features of Alwrity](https://github.com/AJaySi/AI-Writer/wiki/Features-of-ALwrity-AI-writer)
---
- ![Generate Content Calender for Months](https://www.alwrity.com/post/automating-content-calendars-with-ai-agents)
- ![Specilized AI writers for every need & platform](https://github.com/AJaySi/AI-Writer/wiki/Features-of-ALwrity-AI-writer)
- ![ALwrity AI SEO Tools](https://github.com/AJaySi/AI-Writer/wiki/ALwrity-AI-SEO-Tools)
- ![ALwrity Web Researcher](https://github.com/AJaySi/AI-Writer/wiki/Alwrity-AI-Web-Research-Details-for-content-writing)
- **🧠 AI-Powered Research**: No more AI hallucinations! Web-researched, fact-checked content
- **🌍 Multi-Language Support**: Create content in 50+ languages and regions
- **📊 SEO-First Approach**: Built-in SEO optimization for better search rankings
- **🎨 Multi-Modal Content**: Text, images, audio, and video content generation
- **🤖 AI Agent Teams**: Deploy specialized AI agents for different content tasks
- **🔗 Platform Integration**: Direct publishing to WordPress, social media, and more
- **📈 Analytics & Insights**: Track performance and optimize your content strategy
---
## 📝 Usage Guide
## 🚀 Quick Start
### AI Writers
### Option 1: Try Online (Free, No Signup)
Visit [alwrity.com](https://www.alwrity.com/ai-writing-tools) for instant access to our free AI writing tools.
1. **Blog Writer**:
- Enter your target keywords
- Select blog type and length
- Choose whether to include web research
- Generate and edit your blog content
### Option 2: Local Installation (Full Features)
```bash
# Clone the repository
git clone https://github.com/AJaySi/AI-Writer.git
cd AI-Writer
![Blog Writer Demo](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/keyword_blog.gif)
# Install dependencies
pip install -r requirements.txt
2. **Long Form Content**:
- Provide a detailed topic
- Select content structure
- Generate comprehensive content with proper sections
- Edit and refine as needed
# Run the application
streamlit run alwrity.py
```
3. **Email Writer**:
- Select email type (professional, business, etc.)
- Enter recipient and purpose
- Generate appropriate email content
- Customize tone and style
### SEO Tools
1. **Rich Snippet Generator**:
- Enter your URL or content
- Select snippet type (FAQ, Product, etc.)
- Generate structured data
- Copy and implement on your website
2. **On-Page SEO Analyzer**:
- Enter your URL
- Receive comprehensive SEO analysis
- Get actionable recommendations
- Implement suggested changes
### Social Media Tools
1. **X Tweet Generator**:
- Enter topic or keywords
- Select tweet style
- Generate engaging tweets
- Schedule or post directly
2. **YouTube Script Generator**:
- Enter video topic
- Select video length and style
- Generate complete script with sections
- Export for recording
### Content Planning
1. **Content Calendar**:
- Enter your niche or industry
- Select timeframe (weeks/months)
- Generate content ideas with titles
- Export to your preferred format
2. **Web Research**:
- Enter research topic
- Select research depth
- Receive comprehensive research results
- Use in your content generation
**📚 Detailed Setup Guide**: [Getting Started for Beginners](https://www.alwrity.com/post/getting-started-with-alwrity-ai-writer) | [Developer Guide](https://github.com/AJaySi/AI-Writer/wiki/Getting-started-with-ALwrity-AI-writer)
---
## How To Personlize ALwrity & Content Generation
## ✨ Core Features
> ![](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/alwrity_ai_writer.png)
![Click to Read Details of each available features](https://github.com/AJaySi/AI-Writer/wiki/ALwrity-Interface-first-page-explanation)
### 🖋️ AI Content Writers (25+ Tools)
![Read Alwrity Configuration Options](https://www.alwrity.com/post/know-powerful-alwrity-ai-writer-configuration):
> [!NOTE] <p><em>Use ALwrity UI Sidebar to modify Alwrity behavior for your content needs.</em></p>
| **Writer Type** | **Tools Available** | **Key Features** |
|-----------------|-------------------|------------------|
| **Blog & Articles** | Blog Writer, Long-form Writer, Essay Writer, News Writer | Web research, SEO optimization, multi-language |
| **Social Media** | Twitter/X, LinkedIn, Instagram, Facebook, YouTube | Platform-specific optimization, hashtag generation |
| **Business Content** | Email Writer, Product Descriptions, Ad Copy, Letters | Professional tone, conversion optimization |
| **Creative Writing** | Story Writer, Script Generator, Creative Content | Character development, narrative structure |
| **Specialized** | Finance Reports, Academic Papers, Technical Docs | Industry-specific terminology, data integration |
### 🔍 Advanced SEO Tools (15+ Tools)
| **SEO Category** | **Tools** | **Capabilities** |
|------------------|-----------|------------------|
| **On-Page SEO** | SEO Analyzer, Meta Generator, Title Optimizer | Complete page analysis, SERP optimization |
| **Technical SEO** | Structured Data, Rich Snippets, Schema Generator | Enhanced search visibility, featured snippets |
| **Content SEO** | Keyword Research, Content Gap Analysis, Competitor Analysis | Data-driven content strategy |
| **Image SEO** | Alt Text Generator, Image Optimizer, Visual SEO | Accessibility, faster loading, better rankings |
| **Local SEO** | Local Business Optimizer, GMB Content | Location-based optimization |
### 📱 Social Media Suite (20+ Tools)
| **Platform** | **Content Types** | **Features** |
|--------------|-------------------|--------------|
| **Twitter/X** | Tweets, Threads, Polls | Viral content, engagement optimization |
| **LinkedIn** | Posts, Articles, Carousels, Video Scripts | Professional networking, B2B content |
| **Instagram** | Captions, Stories, Reels | Visual storytelling, hashtag strategy |
| **Facebook** | Posts, Ads, Events, Pages | Community engagement, advertising |
| **YouTube** | Titles, Descriptions, Scripts, Thumbnails | Video optimization, audience retention |
| **TikTok** | Scripts, Captions, Trends | Trending content, viral strategies |
### 🎯 Content Planning & Strategy
- **📅 AI Content Calendar**: Generate months of content ideas
- **🔬 Web Research Integration**: Tavily AI, Exa AI, Serper.dev
- **👥 AI Agent Teams**: Specialized content creation crews
- **📊 Performance Analytics**: Track and optimize content performance
- **🎨 Visual Content**: AI-generated images, infographics, social media visuals
---
## Alwrity Features: Power Up Your Content Creation Life cycle ⚡️
## 🛠️ Technology Stack
**AI Writer Tools:**
<div align="center">
| Tool | Description |
|---------------------------------------|---------------------------------------------------------------------------|
| AI Blog Writer | Generates blog content based on the latest web research on given keywords. |
| AI YouTube to Content Writer | Transforms content from provided YouTube URLs into written form. |
| AI Long Form Content | Creates extensive and detailed articles. |
| AI Essay Writer | Produces lengthy essays on various topics, with room for improvement. |
| AI Story Writer | Constructs narratives and stories based on provided backstories and characters. |
| AI Professional Email Writer | Generates various types of professional letters. |
| AI Business Email Writer | Generate various types of business emails. |
| AI Letter Writer | Crafts business letters for formal communication. |
| AI LinkedIn Blog Post Generator | Develops blog posts optimized for sharing on LinkedIn. |
| AI Content Outline Generator | Generates outlines based on keywords gathered from web research. |
| AI Product Description Generator | Generate product description based on provided keyword. |
| AI Google ADs Generator | Generate Google ads for the provide target keyword. |
---
**AI SEO Tools:**
| **Category** | **Technologies** |
|--------------|------------------|
| **AI Models** | OpenAI GPT-4, Google Gemini, Anthropic Claude, Ollama (Local) |
| **Web Research** | Tavily AI, Exa AI, Serper.dev, YOU.com |
| **Image Generation** | DALL-E 3, Stable Diffusion, Midjourney API |
| **Speech Processing** | Whisper, AssemblyAI, Google Speech-to-Text |
| **Web Framework** | Streamlit, Python 3.10+ |
| **Integrations** | WordPress API, Social Media APIs, Firebase |
| **Database** | SQLite, ChromaDB (Vector Database) |
| Tool | Description |
|---------------------------------------|---------------------------------------------------------------------------|
| AI SEO - Generate rich snippet from url | Creates structured data for rich snippets (e.g., reviews, recipes) |
| AI Analyze On-Page SEO | Evaluate and optimize web pages for SEO best practices to improve rankings. |
| AI URL SEO Checker | Assess URL structure and SEO performance to enhance search engine rankings. |
| AI Backlinking Tool | Discover and build high-quality backlinks using AI-powered analysis and recommendations. |
| AI OpenGraph Tags Generator | Generate OpenGraph tags to optimize content sharing on social media platforms. |
| AI Image Alt Text Generator | Automatically generate descriptive alt text for images to improve accessibility and SEO. |
| AI SEO - Optimize/Resize Image | Compress and resize images to enhance website performance without compromising quality. |
| AI Blog Title Generator | Generate blog titles based on provided targeted keyword. |
| AI Meta Description Generator | Generate SEO friendly description on the provided keyword. |
| AI FAQs Generator | Generate FAQs based on people also asked for from the web research |
---
**AI Social Tools:**
| Tool | Description |
|-------------------------------------|-----------------------------------------------------------------------------|
| AI X Tweet Generator | Generates catchy tweets based on provided keyword. |
| AI Instagram Caption Generation | Creates engaging captions for Instagram posts. |
| AI Facebook Post Generator | Creates engaging content for Facebook posts. |
| AI YouTube Title Generator | Creates clikable titles for YouTube video. |
| AI YouTube Video Description Generator | Generate SEO friendly description for YouTube video. |
| AI YouTube Script Generator | Generate complete YouTube video script based on target keyword and audiences |
**AI Content Planning Tools:**
| Tool | Description |
|---------------------------------------|---------------------------------------------------------------------------|
| AI Content Planning & Calendar | Assists in planning and organizing content with a comprehensive calendar. |
| Create Blog Images | Generates images to complement blog content using Stable Diffusion. |
| Agentic Content Creation | Explores innovative content creation methods with CrewAI. |
| AI Finance Writer | Uses ufinance & padnas_ta to write TA report for given stock symbol |
**AI Web Research Integrations:**
| Tool | Description |
|---------------------------------------|---------------------------------------------------------------------------|
| AI Web Researcher | Conducts comprehensive web research and analysis using various methods. |
| Talk to your Docs (WIP) | Write content from your local documents of any type (multi-modal) |
**Integrations:**
| Tool | Description |
|---------------------------------------|---------------------------------------------------------------------------|
| AI Agents Team | Easily create AI Agents team for Content creation & Digital marketing |
| Wordpress API integration | Programmatically upload blogs to wordpress website with API keys |
| Talk to your website | Crawl your entire website & write content based on its content, Or Not |
| Content From URLs | Provide any URL to create an original, unique content from |
</div>
---
## Superpowers 🚀 **🧠 Here's what Alwrity can do for you:**
## 📈 Use Cases & Success Stories
* **Online content Research:** 🔍 Supercharge your blog posts by integrating insights from online research (SERP, Tavily, Metaphor). Say goodbye to AI hallucinations! Tavily AI, Google Search, SERP, Vision AI, and CrewAI web research agents ensure your content is packed with accurate information.
* **Long Form Content Generation:** ✍️ Write essays, stories, and in-depth blogs with web-researched context. No more staring at a blank page!
* **AI Content Planning & Calendar:** 🗓️ Say goodbye to writer's block! Alwrity will give you months' worth of blog title ideas.
### 🎯 For Content Creators
- **Blog Writers**: Generate SEO-optimized articles with web research
- **YouTubers**: Create scripts, titles, descriptions, and thumbnails
- **Podcasters**: Generate show notes, episode descriptions, and social media content
**🌍 Multi-Language Magic:**
### 🏢 For Businesses
- **Digital Marketers**: Complete social media content calendars
- **E-commerce**: Product descriptions, ad copy, email campaigns
- **SaaS Companies**: Technical documentation, blog content, case studies
* **Multilingual Support:** 🌎 Write content and conduct web research in your language. We support multiple languages and regions (main_config)!
**🧠 Fighting AI Hallucinations:**
* **Fact-Checked Content:** 🙅 We use web-researched context to generate factual content, eliminating the risk of AI hallucinations.
**🎨 Multimodal Content Mastery:**
* **Text-To-Text, Speech-To-Text, Text-To-Image, Image-To-Text:** 🖼️ Our multimodal suite empowers you to create a variety of content formats.
**🤖 Your Content Creation Crew:**
* **Agentic Content Team:** 🤝 Build your own AI content team with CrewAI! Define their personas, roles, goals, and tasks. (Beta)
**📸 Visualize Your Content:**
* **Image Generation and Processing:** ✨ Create stunning images based on your blog content using DALL-E 3 and Stable Diffusion. Optimize your images for web use. (FIXME: More Stable Diffusion magic to come!)
**SEO Mastery:**
* **SEO Optimization:** 📈 Boost your content's visibility. Alwrity generates SEO-friendly titles, meta descriptions, tags, and categories.
**🤖 Streamlined Content Publishing:**
* **WordPress & Jekyll Integration:** 🚀 Effortlessly generate and upload your content (and media!) to WordPress using its REST API. Most markdown-based static websites should integrate seamlessly with minimal effort.
---
> [!NOTE] <p>This toolkit is designed for automated blog management and requires appropriate API keys and access credentials for full functionality. ALwrity will guide your through this process, we selected APIs which offer generous free trials, **you** only need email id & patience.</p>
---
## Standing on Tech-Shoulders of the Giants - (Credits):
- **APIs**:
- [Exa API](https://exa.ai/): Provides semantic search capabilities for finding similar topics and technologies.
- [Tavily API](https://tavily.com/): Offers AI-powered web search functionality for conducting in-depth keyword research.
- [SerperDev API](https://serper.dev/): Enables access to search engine results and competitor analysis data.
- [YOU.com](https://you.com/): You.com enhances web search, writing, coding, digital art creation, and solving complex problems.
- [Stability AI](https://stability.ai/): Activating humanity's potential through generative AI. Open models in every modality, for everyone, everywhere.
- [OpenAI API](https://openai.com/): Powers the Large Language Models (LLMs) for generating blog content and conducting research.
- [Gemini API](https://gemini.google.com/app): Google powered LLM for natural language processing tasks.
- [Ollama](https://ollama.com/) : Local, Privacy focused, LLM provider for research and content generation capabilities.
- [CrewAI](https://www.crewai.com/): Collaborative AI agents framework.
- [firecrawl](https://www.firecrawl.dev/): Turn websites into LLM-ready data
### 📚 For Educators & Students
- **Teachers**: Lesson plans, educational content, assessment materials
- **Students**: Essay writing, research papers, presentation content
- **Researchers**: Academic papers, literature reviews, data analysis
---
## 📚 API Documentation
## 🎨 Screenshots & Demos
Alwrity provides a comprehensive API for programmatic access to its features. The API documentation is available at:
<div align="center">
- [API Reference](docs/api/index.rst)
- [API Examples](docs/api/examples.rst)
### Blog Writer in Action
![Blog Writer Demo](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/keyword_blog.gif)
### ALwrity Dashboard
![ALwrity Interface](https://github.com/AJaySi/AI-Writer/blob/main/lib/workspace/alwrity_ai_writer.png)
</div>
---
## 🚀 Getting Started Guide
### 1. **Choose Your Setup**
- **🌐 Online**: Visit [alwrity.com](https://www.alwrity.com) for free tools
- **💻 Local**: Clone repository for full features
### 2. **Configure Your AI Models**
- Get API keys from OpenAI, Google, or Anthropic
- Configure your preferred AI providers
- Set up web research tools (optional)
### 3. **Start Creating**
- Choose from 60+ AI tools
- Generate your first piece of content
- Customize and optimize as needed
### 4. **Scale Your Content**
- Set up content calendars
- Deploy AI agent teams
- Integrate with your publishing platforms
**📖 Detailed Guides**:
- [Complete Setup Tutorial](https://www.alwrity.com/post/getting-started-with-alwrity-ai-writer)
- [Feature Documentation](https://github.com/AJaySi/AI-Writer/wiki/Features-of-ALwrity-AI-writer)
- [Configuration Guide](https://www.alwrity.com/post/know-powerful-alwrity-ai-writer-configuration)
---
## 🌟 What Makes ALwrity Special?
### 🧠 **Fact-Checked Content**
Unlike other AI writers, ALwrity integrates real-time web research to eliminate AI hallucinations and ensure factual accuracy.
### 🌍 **Global Reach**
Support for 50+ languages and regional customization for truly global content creation.
### 🎯 **SEO-First Design**
Every piece of content is optimized for search engines with built-in SEO analysis and recommendations.
### 🤖 **AI Agent Teams**
Deploy specialized AI agents for different aspects of content creation - research, writing, editing, and optimization.
### 📊 **Data-Driven Insights**
Advanced analytics help you understand what content performs best and optimize your strategy accordingly.
---
## 🗺️ Roadmap 2025
### Q1 2025 (Current)
- ✅ Enhanced multi-language support
- ✅ Advanced image generation capabilities
- ✅ Improved AI model integrations
- 🔄 Mobile app development
- 🔄 Advanced analytics dashboard
### Q2 2025
- 📅 Team collaboration features
- 📅 Content performance tracking
- 📅 Advanced workflow automation
- 📅 Enterprise security features
### Q3-Q4 2025
- 📅 NextJS React application
- 📅 API-first architecture
- 📅 Marketplace for AI agents
- 📅 Advanced integrations ecosystem
[📋 View Detailed Roadmap](Roadmap%20TBDs/ROADMAP.md)
---
## 🤝 Contributing
We welcome contributions to Alwrity! Please see our [Contributing Guide](CONTRIBUTING.md) for details on how to get started.
We welcome contributions from the community! Here's how you can help:
## 🗺️ Roadmap
### 🐛 **Report Issues**
Found a bug? [Create an issue](https://github.com/AJaySi/AI-Writer/issues) with detailed information.
- [Read Detailed Roadmap Here](Roadmap TBDs/ROADMAP.md)
- [ALwrity Roadmap](docs/roadmap.rst)
### 💡 **Suggest Features**
Have an idea? [Start a discussion](https://github.com/AJaySi/AI-Writer/discussions) to share your thoughts.
Our development roadmap includes:
### 🔧 **Contribute Code**
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request
- **Short-term (0-3 months)**:
- Enhanced multi-language support
- Improved image generation capabilities
- Additional AI model integrations
### 📖 **Improve Documentation**
Help us improve our documentation, tutorials, and guides.
- **Medium-term (3-6 months)**:
- Advanced analytics dashboard
- Content performance tracking
- Collaborative editing features
**📚 Contributing Guide**: [CONTRIBUTING.md](CONTRIBUTING.md)
- **Long-term (6+ months)**:
- NextJS React Alwrity App
- API-first architecture
- Enterprise features for teams
---
## 📄 License
## 🏆 Community & Support
<div align="center">
[![GitHub Discussions](https://img.shields.io/badge/GitHub-Discussions-green?logo=github)](https://github.com/AJaySi/AI-Writer/discussions)
[![Discord](https://img.shields.io/badge/Discord-Community-blue?logo=discord)](https://discord.gg/alwrity)
[![Twitter](https://img.shields.io/badge/Twitter-Follow-blue?logo=twitter)](https://twitter.com/alwrity)
</div>
### 💬 **Get Help**
- 📖 [Documentation](https://github.com/AJaySi/AI-Writer/wiki)
- 💬 [Community Discussions](https://github.com/AJaySi/AI-Writer/discussions)
- 🐛 [Issue Tracker](https://github.com/AJaySi/AI-Writer/issues)
- 📧 [Email Support](mailto:support@alwrity.com)
### 🌟 **Stay Updated**
- ⭐ Star this repository
- 👀 Watch for updates
- 🔔 Follow our [blog](https://www.alwrity.com/blog)
---
## 📄 License & Credits
### 📜 **License**
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgements
### 🙏 **Acknowledgments**
Alwrity stands on the shoulders of giants:
ALwrity stands on the shoulders of giants. Special thanks to:
- **APIs**:
- [Exa API](https://exa.ai/): Semantic search capabilities
- [Tavily API](https://tavily.com/): AI-powered web search
- [SerperDev API](https://serper.dev/): Search engine results
- [YOU.com](https://you.com/): Enhanced web search
- [Stability AI](https://stability.ai/): Image generation
- [OpenAI API](https://openai.com/): LLM capabilities
- [Gemini API](https://gemini.google.com/app): Google's LLM
- [Ollama](https://ollama.com/): Local LLM provider
- [CrewAI](https://www.crewai.com/): Collaborative AI agents
**🤖 AI Providers**
- [OpenAI](https://openai.com/) - GPT models and DALL-E
- [Google](https://ai.google/) - Gemini AI and various APIs
- [Anthropic](https://anthropic.com/) - Claude AI models
- [Stability AI](https://stability.ai/) - Stable Diffusion
## 📞 Support
**🔍 Research & Data**
- [Tavily AI](https://tavily.com/) - AI-powered web search
- [Exa AI](https://exa.ai/) - Semantic search capabilities
- [Serper.dev](https://serper.dev/) - Search engine results
- [YOU.com](https://you.com/) - Enhanced web search
If you encounter any issues or have questions, please [open an issue](https://github.com/AJaySi/AI-Writer/issues) on GitHub.
**🛠️ Development Tools**
- [Streamlit](https://streamlit.io/) - Web application framework
- [CrewAI](https://www.crewai.com/) - AI agent orchestration
- [Firecrawl](https://www.firecrawl.dev/) - Web scraping and data extraction
---
<p align="center">
<a href="https://www.alwrity.com">Visit Alwrity.com</a> •
<a href="https://www.alwrity.com/ai-writing-tools">Try Free Tools</a> •
<a href="https://github.com/AJaySi/AI-Writer/wiki">Wiki</a>
</p>
## 📊 Project Stats
<div align="center">
![GitHub Stats](https://github-readme-stats.vercel.app/api?username=AJaySi&repo=AI-Writer&show_icons=true&theme=radical)
[![GitHub Activity Graph](https://github-readme-activity-graph.vercel.app/graph?username=AJaySi&repo=AI-Writer&theme=react-dark)](https://github.com/AJaySi/AI-Writer/graphs/contributors)
</div>
---
<div align="center">
## 🚀 Ready to Transform Your Content Creation?
**[🌐 Try ALwrity Online](https://www.alwrity.com/ai-writing-tools)** • **[💻 Install Locally](https://github.com/AJaySi/AI-Writer/wiki/Getting-started-with-ALwrity-AI-writer)** • **[📖 Read Documentation](https://github.com/AJaySi/AI-Writer/wiki)**
---
**Made with ❤️ by the ALwrity Team**
[Website](https://www.alwrity.com) • [Blog](https://www.alwrity.com/blog) • [Twitter](https://twitter.com/alwrity) • [LinkedIn](https://linkedin.com/company/alwrity)
</div>
---
## 🏷️ Keywords & Tags
`ai-content-writer` `seo-tools` `blog-generator` `social-media-automation` `content-marketing` `ai-copywriting` `streamlit-app` `openai-gpt` `content-creation` `digital-marketing` `seo-optimization` `ai-writing-assistant` `content-strategy` `marketing-automation` `python-ai-tools` `web-research` `multi-language-content` `ai-agents` `content-calendar` `wordpress-integration`

534
Roadmap TBDs/AI_COMPETITIVE_FEATURES_ROADMAP.md Normal file
View File

@@ -0,0 +1,534 @@
# 🚀 AI-Powered Competitive Features Strategic Roadmap
## Overview
This roadmap outlines the strategic implementation of two game-changing AI features that will differentiate Alwrity from competitors and establish it as the leading intelligent content strategy platform.
## 🎯 Strategic Objectives
### Primary Goals
- **Market Leadership**: Position Alwrity as the most intelligent content creation platform
- **Competitive Differentiation**: Implement unique AI capabilities not available in competitor tools
- **User Value**: Provide actionable insights that directly improve content performance and ROI
- **Revenue Growth**: Create premium features that justify higher pricing tiers
### Success Metrics
- **User Engagement**: 40% increase in platform usage
- **Content Performance**: 60% improvement in user content success rates
- **Market Position**: Top 3 in content creation tool comparisons
- **Revenue Impact**: 35% increase in premium subscriptions
---
## 🧠 Feature 1: Real-Time Content Performance Predictor
### Phase 1: Foundation & Data Infrastructure (Months 1-3)
#### 1.1 Enhanced Data Collection System
**Status**: ✅ **COMPLETED**
- [x] Enhanced content data collector (`lib/content_performance_predictor/data_collector_enhanced.py`)
- [x] Multi-platform data integration (Twitter, Google Trends, SERP data)
- [x] Success pattern mining algorithms
- [x] Training data preparation workflows
#### 1.2 Machine Learning Model Development
**Status**: ✅ **COMPLETED**
- [x] ML predictor implementation (`lib/content_performance_predictor/ml_predictor.py`)
- [x] Feature engineering for content analysis
- [x] Model training and validation frameworks
- [x] Performance prediction algorithms
#### 1.3 Data Source Expansion Strategy
**Immediate Data Sources (0-30 days)**:
- ✅ Existing Alwrity user performance data
- ✅ Google Trends via existing Pytrends integration
- ✅ SERP data via existing web research tools
- ✅ Social media hashtag performance data
**Near-term API Integrations (1-3 months)**:
- [ ] **Twitter API v2** - Enhanced engagement metrics
- Real-time tweet performance data
- Trending hashtags and topics
- Audience engagement patterns
- [ ] **LinkedIn Content API** - Professional content insights
- Post performance metrics
- Industry-specific engagement data
- [ ] **Reddit API** - Community engagement data
- Subreddit trending topics
- Comment engagement patterns
- [ ] **YouTube Data API** - Video content performance
- Video engagement metrics
- Trending topics and tags
**Advanced Data Mining (3-6 months)**:
- [ ] **Ethical Web Scraping** for viral content analysis
- [ ] **BuzzSumo-style** content discovery
- [ ] **Industry publication** performance tracking
- [ ] **Competitor content** success pattern analysis
#### 1.4 Technical Implementation Plan
**Week 1-2: Infrastructure Setup**
```bash
# Data collection infrastructure
- Enhanced database schemas for ML training data
- API rate limiting and caching systems
- Data validation and cleaning pipelines
- Monitoring and alerting systems
```
**Week 3-4: Model Training Pipeline**
```bash
# ML model development
- Feature extraction and engineering
- Model selection and hyperparameter tuning
- Cross-validation and testing frameworks
- Model versioning and deployment systems
```
**Week 5-8: Integration & Testing**
```bash
# Platform integration
- Streamlit UI component development
- API endpoint creation
- User testing and feedback collection
- Performance optimization
```
### Phase 2: Advanced Analytics & Insights (Months 4-6)
#### 2.1 Predictive Analytics Enhancement
- [ ] **Multi-platform prediction models**
- Platform-specific engagement prediction
- Cross-platform content optimization
- Audience preference learning
- [ ] **Real-time trend integration**
- Live trending topic incorporation
- Breaking news opportunity detection
- Seasonal pattern recognition
#### 2.2 Actionable Insights Generation
- [ ] **Content optimization suggestions**
- Title optimization recommendations
- Optimal posting time predictions
- Hashtag strategy recommendations
- Content format suggestions
- [ ] **Performance improvement recommendations**
- Underperforming content enhancement
- Viral potential identification
- Audience engagement optimization
#### 2.3 User Interface Development
- [ ] **Performance prediction dashboard**
- [ ] **Content optimization wizard**
- [ ] **Trend opportunity alerts**
- [ ] **Success pattern visualization**
### Phase 3: Advanced Features & AI Enhancement (Months 7-12)
#### 3.1 Advanced AI Capabilities
- [ ] **GPT-4 integration** for content analysis
- [ ] **Computer vision** for image content analysis
- [ ] **Natural language processing** for sentiment optimization
- [ ] **Reinforcement learning** for continuous improvement
#### 3.2 Enterprise Features
- [ ] **Team collaboration** on predictions
- [ ] **Custom model training** for specific industries
- [ ] **API access** for enterprise integrations
- [ ] **White-label solutions**
---
## 🕵️ Feature 2: AI-Powered Competitive Intelligence Engine
### Phase 1: Core Intelligence Framework (Months 1-3)
#### 1.1 Competitive Analysis System
**Status**: ✅ **COMPLETED**
- [x] AI Competitive Intelligence Engine (`lib/competitive_intelligence/ai_competitor_engine.py`)
- [x] Automated competitor website analysis
- [x] Content gap identification
- [x] Market positioning analysis
- [x] Strategic recommendations generation
#### 1.2 Market Intelligence Capabilities
**Status**: ✅ **COMPLETED**
- [x] Comprehensive market landscape mapping
- [x] Threat level assessment algorithms
- [x] Opportunity scoring mechanisms
- [x] Content trend analysis across competitors
#### 1.3 Strategic Insights Generation
**Status**: ✅ **COMPLETED**
- [x] AI-powered strategic recommendations
- [x] Market positioning insights
- [x] Content strategy optimization
- [x] Competitive advantage identification
#### 1.4 Implementation Enhancement Plan
**Week 1-2: Integration with Existing Tools**
```bash
# Leverage existing Alwrity capabilities
- Enhanced CompetitorAnalyzer integration
- Google Trends data for market intelligence
- Web research tools for competitor analysis
- LLM integration for strategic insights
```
**Week 3-4: Advanced Analytics**
```bash
# Enhanced intelligence gathering
- Real-time competitor monitoring
- Automated report generation
- Strategic alert systems
- Performance benchmarking
```
**Week 5-8: User Experience Optimization**
```bash
# User interface and workflow
- Intuitive analysis workflows
- Interactive competitive dashboards
- Actionable insight presentation
- Export and sharing capabilities
```
### Phase 2: Advanced Intelligence Features (Months 4-6)
#### 2.1 Real-time Monitoring System
- [ ] **Automated competitor tracking**
- Content publication monitoring
- Social media activity tracking
- SEO ranking changes detection
- Marketing campaign analysis
- [ ] **Alert and notification system**
- Competitive threat alerts
- Market opportunity notifications
- Content gap emergence detection
- Strategic move recommendations
#### 2.2 Deep Market Analysis
- [ ] **Industry trend analysis**
- Market shift prediction
- Emerging player identification
- Technology adoption tracking
- Consumer behavior analysis
- [ ] **Competitive benchmarking**
- Performance comparison metrics
- Market share analysis
- Content quality assessment
- User engagement benchmarks
#### 2.3 Strategic Recommendation Engine
- [ ] **AI-powered strategy suggestions**
- Market positioning recommendations
- Content strategy optimization
- Competitive response strategies
- Innovation opportunity identification
### Phase 3: Enterprise Intelligence Platform (Months 7-12)
#### 3.1 Advanced AI Integration
- [ ] **Predictive competitive analysis**
- [ ] **Market simulation and modeling**
- [ ] **Strategic scenario planning**
- [ ] **Automated competitive intelligence reports**
#### 3.2 Enterprise Collaboration Features
- [ ] **Team intelligence sharing**
- [ ] **Strategic planning workflows**
- [ ] **Executive dashboards**
- [ ] **Custom intelligence categories**
---
## 🚀 Implementation Strategy
### Development Approach
#### Agile Development Sprints
- **2-week sprints** with specific deliverables
- **User testing** after each major feature
- **Iterative improvement** based on feedback
- **Continuous integration** and deployment
#### Resource Allocation
- **2 Senior AI/ML Engineers** - Core algorithm development
- **1 Full-stack Developer** - UI/UX and integration
- **1 Data Engineer** - Data pipelines and infrastructure
- **1 Product Manager** - Feature coordination and user research
### Technical Stack Enhancement
#### New Dependencies Required
```python
# Additional ML and Data Analysis
scikit-learn>=1.3.0
xgboost>=1.7.0
lightgbm>=3.3.0
tensorflow>=2.13.0
torch>=2.0.0
# Advanced Data Processing
pandas>=2.0.0
numpy>=1.24.0
scipy>=1.10.0
# API Integrations
tweepy>=4.14.0 # Twitter API
linkedin-api>=2.0.0 # LinkedIn API
praw>=7.7.0 # Reddit API
google-api-python-client>=2.88.0 # YouTube API
# Web Scraping (Ethical)
scrapy>=2.9.0
selenium>=4.10.0
beautifulsoup4>=4.12.0
# Visualization and UI
plotly>=5.15.0
streamlit-aggrid>=0.3.4
streamlit-plotly-events>=0.1.6
```
#### Infrastructure Requirements
- **Database**: Enhanced schema for ML training data and competitive intelligence
- **Caching**: Redis for API response caching and real-time data
- **Storage**: Expanded storage for training datasets and competitive analysis history
- **APIs**: Rate limiting and monitoring for external API integrations
### Data Collection Strategy
#### Ethical and Compliant Data Gathering
**Public API Data** (Preferred):
- Social media APIs with proper authentication
- Search engine APIs for SERP data
- News and publication APIs for trend analysis
- Government and industry statistical APIs
**Ethical Web Scraping**:
- Respect robots.txt and rate limits
- Focus on publicly available information
- Implement proper attribution and citations
- Regular compliance audits
**User-Generated Data**:
- Opt-in performance data sharing
- Anonymized aggregated insights
- Clear privacy policies and consent
- GDPR and CCPA compliance
### Success Pattern Mining Approach
#### Content Success Identification
1. **Engagement Metrics**: Likes, shares, comments, saves
2. **Reach Metrics**: Impressions, views, click-through rates
3. **Conversion Metrics**: Website visits, lead generation, sales
4. **Temporal Patterns**: Optimal posting times, seasonal trends
5. **Format Analysis**: Text vs. visual vs. video performance
#### Pattern Recognition Techniques
- **Machine Learning Clustering**: Identify successful content groups
- **Time Series Analysis**: Detect temporal success patterns
- **Natural Language Processing**: Analyze successful content language
- **Computer Vision**: Analyze successful visual content elements
- **Statistical Analysis**: Correlation and causation identification
---
## 💰 Monetization Strategy
### Pricing Tier Integration
#### Free Tier
- Basic content performance insights
- Limited competitive analysis (3 competitors)
- Weekly trend reports
#### Professional Tier ($29/month)
- Advanced performance prediction
- Comprehensive competitive analysis (10 competitors)
- Real-time alerts and monitoring
- Export capabilities
#### Enterprise Tier ($99/month)
- Custom model training
- Unlimited competitive analysis
- API access
- Team collaboration features
- White-label options
### Revenue Projections
- **Year 1**: 35% increase in premium subscriptions
- **Year 2**: Launch of enterprise tier with projected $500K ARR
- **Year 3**: API licensing and white-label revenue of $1M+
---
## 📊 Success Metrics & KPIs
### Feature Adoption Metrics
- **Performance Predictor Usage**: Target 80% of active users
- **Competitive Intelligence Usage**: Target 60% of premium users
- **Feature Retention**: 90% monthly active usage for premium features
### Business Impact Metrics
- **User Content Success Rate**: 60% improvement
- **Premium Conversion Rate**: 35% increase
- **Customer Satisfaction**: NPS score > 70
- **Market Position**: Top 3 in competitive analysis
### Technical Performance Metrics
- **Prediction Accuracy**: >80% for content performance
- **Analysis Speed**: <30 seconds for competitive analysis
- **System Reliability**: 99.9% uptime
- **User Experience**: <3 second load times
---
## 🎯 Competitive Differentiation
### Unique Value Propositions
#### Against Jasper AI
- **Predictive Analytics**: Jasper focuses on generation, we predict success
- **Competitive Intelligence**: No competitive analysis features in Jasper
- **Data-Driven Insights**: Actionable recommendations vs. just content creation
#### Against Copy.ai
- **Advanced Analytics**: Copy.ai lacks performance prediction
- **Market Intelligence**: No competitive monitoring capabilities
- **Strategic Planning**: Beyond content creation to content strategy
#### Against Surfer SEO
- **Multi-Platform Analysis**: Beyond just SEO to social and content performance
- **AI-Powered Insights**: More advanced AI than Surfer's keyword tools
- **Competitive Monitoring**: Real-time competitive intelligence vs. static analysis
### First-Mover Advantages
1. **Predictive Content Analytics**: First to predict content success before publishing
2. **AI Competitive Intelligence**: First to offer real-time AI-powered competitive analysis
3. **Integrated Strategy Platform**: First to combine content creation with strategic intelligence
---
## 🚨 Risk Management
### Technical Risks
- **API Rate Limits**: Mitigation through caching and efficient data collection
- **Model Accuracy**: Continuous learning and validation frameworks
- **Data Quality**: Robust validation and cleaning pipelines
- **Scalability**: Cloud-native architecture and auto-scaling
### Business Risks
- **Competitive Response**: Patent key innovations and maintain development velocity
- **Data Privacy**: Strict compliance with privacy regulations
- **Feature Complexity**: Gradual rollout with user education and support
- **Market Adoption**: Extensive user research and feedback integration
### Compliance Risks
- **Data Protection**: GDPR, CCPA compliance frameworks
- **API Terms of Service**: Regular compliance audits
- **Ethical AI**: Bias detection and fairness monitoring
- **Content Rights**: Proper attribution and copyright respect
---
## 📅 Detailed Timeline
### Q1 2024: Foundation
- **Month 1**: Complete data infrastructure and basic ML models ✅
- **Month 2**: Integrate with existing Alwrity platform ✅
- **Month 3**: Beta testing with select users ✅
### Q2 2024: Enhancement
- **Month 4**: Advanced API integrations (Twitter, LinkedIn)
- **Month 5**: Real-time monitoring capabilities
- **Month 6**: Advanced analytics and reporting
### Q3 2024: Expansion
- **Month 7**: Enterprise features development
- **Month 8**: Mobile optimization and API development
- **Month 9**: White-label and partnership integrations
### Q4 2024: Scale
- **Month 10**: Advanced AI model deployment
- **Month 11**: International expansion features
- **Month 12**: Next-generation feature research
---
## 🎉 Expected Outcomes
### Short-term (3-6 months)
- Launch of both core features to premium users
- 40% increase in user engagement with Alwrity platform
- Initial revenue impact from premium feature adoption
- Positive user feedback and feature validation
### Medium-term (6-12 months)
- Market recognition as innovation leader in content intelligence
- Significant competitive advantage establishment
- Enterprise customer acquisition acceleration
- API and partnership revenue streams initiation
### Long-term (12+ months)
- Market leadership position in intelligent content strategy
- Expansion into adjacent markets (SEO tools, social media management)
- Potential acquisition or investment opportunities
- Technology licensing and white-label revenue growth
---
## 🔄 Continuous Improvement Framework
### User Feedback Integration
- Monthly user surveys and interviews
- Feature usage analytics and optimization
- A/B testing for interface improvements
- Community-driven feature requests
### Technology Evolution
- Regular model retraining and improvement
- Integration of latest AI/ML developments
- Performance optimization and scaling
- Security and privacy enhancements
### Market Adaptation
- Competitive landscape monitoring
- Industry trend analysis and integration
- New platform and API integration
- Regulatory compliance updates
---
## 📞 Next Steps
### Immediate Actions (Next 30 days)
1. **Team Assembly**: Hire additional ML engineers and data scientists
2. **Infrastructure Setup**: Enhanced database and caching systems
3. **API Integrations**: Begin Twitter and LinkedIn API implementations
4. **User Research**: Conduct in-depth interviews with target users
### Development Priorities
1. **Performance Predictor Enhancement**: Advanced model training and optimization
2. **Competitive Intelligence Refinement**: Real-time monitoring capabilities
3. **User Experience Optimization**: Streamlined workflows and interfaces
4. **Quality Assurance**: Comprehensive testing and validation frameworks
### Success Tracking
- Weekly development sprints with measurable deliverables
- Monthly user engagement and satisfaction reviews
- Quarterly business impact assessments
- Annual strategic plan reviews and updates
---
*This roadmap represents a strategic approach to establishing Alwrity as the leading AI-powered content intelligence platform. The combination of predictive analytics and competitive intelligence will create sustainable competitive advantages and drive significant business growth.*

464
Roadmap TBDs/ROADMAP.md
View File

@@ -248,3 +248,467 @@ Your feedback is essential in shaping the future of AI-Writer. If you have featu
---
*Note: This roadmap is subject to change based on user feedback, technological developments, and strategic priorities. Last updated: April 18, 2025*
---
# ALwrity Competitive Analysis: Missing Features & Enhancement Opportunities
## Executive Summary
After conducting a deep analysis of ALwrity's codebase and comparing it with leading paid AI content creation tools (Jasper, Copy.ai, Writesonic, Surfer SEO, ContentKing, etc.), this document identifies critical feature gaps and enhancement opportunities that would significantly boost ALwrity's competitiveness in the market.
## Current ALwrity Strengths
### ✅ **Existing Strong Features**
- **Comprehensive SEO Tools Suite**: 25+ SEO tools including technical crawling, content optimization, and structured data generation
- **Multi-Platform Social Media Writers**: Facebook, LinkedIn, Twitter, Instagram, YouTube content generation
- **Advanced Content Calendar**: Planning, scheduling, and optimization features
- **Multiple AI Provider Support**: OpenAI, Gemini, Anthropic, Mistral integration
- **Research Integration**: Tavily, Serper, Metaphor, Firecrawl APIs
- **Blog Writing Capabilities**: AI-powered blog generation with SEO optimization
- **Image Generation**: Stability AI integration for visual content
- **Technical SEO Analysis**: Website crawling, performance metrics, and optimization recommendations
---
## Critical Missing Features Analysis
### 🚨 **Tier 1: High-Impact Missing Features**
#### 1. **Advanced Analytics & Performance Tracking**
**Current State**: Basic performance metrics exist but lack depth
**Missing Features**:
- Real-time content performance dashboards
- ROI tracking and attribution modeling
- Competitor content performance analysis
- A/B testing framework for content variations
- Predictive analytics for content success
- Cross-platform performance correlation analysis
- Content engagement heatmaps
- Conversion funnel tracking from content to sales
**Competitive Impact**: Tools like Surfer SEO and ContentKing excel here
**Implementation Priority**: HIGH
#### 2. **Team Collaboration & Workflow Management**
**Current State**: Single-user focused with basic content calendar
**Missing Features**:
- Multi-user workspaces with role-based permissions
- Content approval workflows and review processes
- Real-time collaborative editing
- Team performance analytics
- Content assignment and task management
- Version control and change tracking
- Comment and feedback systems
- Team communication integration (Slack, Teams)
**Competitive Impact**: Jasper Teams and Copy.ai Team features are major differentiators
**Implementation Priority**: HIGH
#### 3. **Advanced Content Intelligence**
**Current State**: Basic content generation without deep intelligence
**Missing Features**:
- Content scoring and quality assessment
- Plagiarism detection and originality checking
- Content readability optimization with real-time suggestions
- Tone and brand voice consistency checking
- Content gap analysis with competitor intelligence
- Semantic SEO optimization
- Content freshness and update recommendations
- Auto-generated content briefs from top-performing competitor content
**Competitive Impact**: Surfer SEO's Content Editor and Jasper's Brand Voice features
**Implementation Priority**: HIGH
#### 4. **Enterprise-Grade Integrations**
**Current State**: Limited integrations (mostly in development)
**Missing Features**:
- CRM integrations (HubSpot, Salesforce, Pipedrive)
- Marketing automation platforms (Marketo, Pardot, ActiveCampaign)
- Advanced CMS integrations (Drupal, Contentful, Strapi)
- E-commerce platforms (Shopify, WooCommerce, Magento)
- Project management tools (Asana, Monday.com, Jira)
- Analytics platforms (Google Analytics 4, Adobe Analytics)
- Email marketing platforms (Mailchimp, ConvertKit, Klaviyo)
- Social media management tools (Hootsuite, Buffer, Sprout Social)
**Competitive Impact**: Enterprise adoption requires these integrations
**Implementation Priority**: HIGH
### 🔶 **Tier 2: Medium-Impact Missing Features**
#### 5. **Advanced AI Writing Capabilities**
**Current State**: Good basic AI writing with multiple providers
**Missing Features**:
- Long-form content generation (10,000+ words)
- Multi-language content creation (50+ languages)
- Industry-specific writing templates (legal, medical, technical)
- Content personalization based on audience segments
- Dynamic content generation based on user behavior
- AI-powered content summarization and repurposing
- Voice and tone customization with brand guidelines
- Content optimization for different reading levels
**Competitive Impact**: Jasper's Boss Mode and Copy.ai's long-form capabilities
**Implementation Priority**: MEDIUM
#### 6. **Advanced SEO & Content Strategy**
**Current State**: Good SEO tools but missing strategic elements
**Missing Features**:
- Keyword clustering and topic modeling
- Content pillar and cluster strategy planning
- SERP feature optimization (featured snippets, PAA)
- Local SEO content optimization
- E-A-T (Expertise, Authoritativeness, Trustworthiness) scoring
- Content cannibalization detection
- Seasonal content planning with trend analysis
- Voice search optimization
**Competitive Impact**: Surfer SEO and Clearscope dominate this space
**Implementation Priority**: MEDIUM
#### 7. **Enhanced User Experience & Interface**
**Current State**: Functional Streamlit interface but not modern
**Missing Features**:
- Modern, responsive web application (React/Vue.js)
- Mobile-optimized interface and mobile app
- Drag-and-drop content builder
- WYSIWYG editor with real-time preview
- Customizable dashboards and workspaces
- Dark/light mode and accessibility features
- Keyboard shortcuts and power user features
- Offline content creation capabilities
**Competitive Impact**: User experience is crucial for adoption and retention
**Implementation Priority**: MEDIUM
#### 8. **Content Distribution & Amplification**
**Current State**: Basic social media posting capabilities
**Missing Features**:
- Automated content distribution workflows
- Social media scheduling with optimal timing
- Email newsletter generation and distribution
- Podcast script generation and distribution
- Video content creation and optimization
- Influencer outreach content generation
- Press release creation and distribution
- Content syndication to multiple platforms
**Competitive Impact**: Tools like Buffer and Hootsuite excel in distribution
**Implementation Priority**: MEDIUM
### 🔷 **Tier 3: Nice-to-Have Features**
#### 9. **AI-Powered Content Research**
**Current State**: Basic research integration with APIs
**Missing Features**:
- Automated competitor content analysis
- Trend prediction and content opportunity identification
- Social listening integration for content ideas
- News and industry update monitoring
- Expert quote and statistic sourcing
- Image and video research capabilities
- Fact-checking and source verification
- Content idea generation from multiple data sources
**Competitive Impact**: Research capabilities differentiate premium tools
**Implementation Priority**: LOW
#### 10. **Advanced Customization & White-Label Options**
**Current State**: Open-source but no white-label features
**Missing Features**:
- White-label solutions for agencies
- Custom branding and theming options
- API access for custom integrations
- Plugin/extension marketplace
- Custom AI model training capabilities
- Advanced workflow automation
- Custom reporting and analytics
- Multi-tenant architecture for agencies
**Competitive Impact**: Important for agency and enterprise sales
**Implementation Priority**: LOW
---
## Detailed Feature Gap Analysis
### **Analytics & Reporting Gaps**
| Feature | ALwrity | Jasper | Copy.ai | Surfer SEO | Priority |
|---------|---------|---------|---------|------------|----------|
| Real-time Performance Dashboard | ❌ | ✅ | ✅ | ✅ | HIGH |
| ROI Tracking | ❌ | ✅ | ❌ | ✅ | HIGH |
| A/B Testing Framework | ❌ | ✅ | ✅ | ❌ | HIGH |
| Competitor Analysis | Basic | ✅ | ❌ | ✅ | HIGH |
| Conversion Tracking | ❌ | ✅ | ✅ | ✅ | HIGH |
| Custom Reports | ❌ | ✅ | ✅ | ✅ | MEDIUM |
| Export Capabilities | Basic | ✅ | ✅ | ✅ | MEDIUM |
### **Collaboration Features Gaps**
| Feature | ALwrity | Jasper | Copy.ai | Writesonic | Priority |
|---------|---------|---------|---------|------------|----------|
| Multi-user Workspaces | ❌ | ✅ | ✅ | ✅ | HIGH |
| Role-based Permissions | ❌ | ✅ | ✅ | ✅ | HIGH |
| Approval Workflows | ❌ | ✅ | ✅ | ❌ | HIGH |
| Real-time Collaboration | ❌ | ✅ | ❌ | ❌ | MEDIUM |
| Comment System | ❌ | ✅ | ✅ | ❌ | MEDIUM |
| Version Control | Basic | ✅ | ✅ | ✅ | MEDIUM |
| Team Analytics | ❌ | ✅ | ✅ | ❌ | MEDIUM |
### **Content Intelligence Gaps**
| Feature | ALwrity | Jasper | Surfer SEO | Clearscope | Priority |
|---------|---------|---------|------------|------------|----------|
| Content Scoring | ❌ | ✅ | ✅ | ✅ | HIGH |
| Plagiarism Detection | ❌ | ✅ | ❌ | ❌ | HIGH |
| Brand Voice Consistency | ❌ | ✅ | ❌ | ❌ | HIGH |
| Readability Optimization | Basic | ✅ | ✅ | ✅ | HIGH |
| Semantic SEO | Basic | ❌ | ✅ | ✅ | HIGH |
| Content Gap Analysis | Basic | ❌ | ✅ | ✅ | MEDIUM |
| Auto Content Briefs | ❌ | ✅ | ✅ | ✅ | MEDIUM |
---
## Implementation Roadmap
### **Phase 1: Foundation (Months 1-3)**
**Focus**: Core infrastructure and high-impact features
1. **Advanced Analytics Dashboard**
- Real-time performance tracking
- ROI measurement framework
- Basic A/B testing capabilities
- Export and reporting features
2. **Team Collaboration MVP**
- Multi-user authentication and workspaces
- Basic role-based permissions
- Simple approval workflows
- Team member management
3. **Content Intelligence Foundation**
- Content scoring algorithm
- Readability optimization
- Basic plagiarism detection
- Brand voice consistency checking
### **Phase 2: Enhancement (Months 4-6)**
**Focus**: Advanced features and integrations
1. **Enterprise Integrations**
- Google Analytics 4 integration
- HubSpot CRM integration
- WordPress advanced integration
- Slack/Teams notifications
2. **Advanced SEO Features**
- Keyword clustering
- SERP feature optimization
- Content cannibalization detection
- E-A-T scoring framework
3. **Enhanced User Experience**
- Modern React-based interface
- Mobile responsiveness
- WYSIWYG editor
- Customizable dashboards
### **Phase 3: Scale (Months 7-12)**
**Focus**: Advanced capabilities and market differentiation
1. **AI Enhancement**
- Long-form content generation
- Multi-language support
- Industry-specific templates
- Advanced personalization
2. **Distribution & Amplification**
- Automated content workflows
- Advanced social media scheduling
- Email marketing integration
- Multi-platform distribution
3. **Enterprise Features**
- White-label options
- API marketplace
- Custom integrations
- Advanced security features
---
## Competitive Positioning Strategy
### **Immediate Competitive Advantages to Build**
1. **Open Source + Enterprise Features**
- Combine open-source flexibility with enterprise-grade features
- Offer transparent pricing and customization options
- Build community-driven feature development
2. **AI Provider Agnostic**
- Support multiple AI providers (already implemented)
- Allow users to choose best AI for specific tasks
- Reduce vendor lock-in concerns
3. **Comprehensive SEO Focus**
- Build on existing strong SEO foundation
- Integrate technical SEO with content creation
- Offer end-to-end SEO content workflow
4. **Research-Driven Content**
- Leverage existing research API integrations
- Build superior content research capabilities
- Combine multiple data sources for content insights
### **Unique Value Propositions to Develop**
1. **"Complete Content Ecosystem"**
- Research → Create → Optimize → Distribute → Analyze
- All-in-one platform without multiple tool subscriptions
- Seamless workflow from idea to performance
2. **"AI-Powered SEO Content Factory"**
- Technical SEO analysis drives content creation
- Real-time optimization during writing
- Performance prediction before publishing
3. **"Open Source Enterprise Solution"**
- Enterprise features without enterprise lock-in
- Community-driven development
- Transparent and customizable platform
---
## Revenue Impact Analysis
### **Feature Impact on Pricing Tiers**
**Current Situation**: Free/open-source model
**Recommended Tiered Approach**:
1. **Community (Free)**
- Basic content generation
- Limited SEO tools
- Single user
- Community support
2. **Professional ($29/month)**
- Advanced analytics
- Team collaboration (up to 5 users)
- All SEO tools
- Priority support
- API access
3. **Business ($99/month)**
- Advanced AI features
- Unlimited team members
- Enterprise integrations
- White-label options
- Custom training
4. **Enterprise (Custom)**
- On-premise deployment
- Custom integrations
- Dedicated support
- SLA guarantees
- Custom development
### **Revenue Potential**
Based on competitor pricing and feature analysis:
- **Professional Tier**: Target 10,000 users = $290,000/month
- **Business Tier**: Target 1,000 users = $99,000/month
- **Enterprise Tier**: Target 100 clients = $500,000/month
- **Total Monthly Potential**: $889,000
---
## Technical Implementation Priorities
### **High-Priority Technical Debt**
1. **Architecture Modernization**
- Migrate from Streamlit to modern web framework
- Implement microservices architecture
- Add proper API layer
- Implement real-time capabilities
2. **Database & Performance**
- Implement proper database schema
- Add caching layers
- Optimize for concurrent users
- Implement background job processing
3. **Security & Compliance**
- Add enterprise-grade authentication
- Implement data encryption
- Add audit logging
- Ensure GDPR/SOC2 compliance
### **Development Resource Requirements**
**Estimated Team Needs**:
- **Frontend Developers**: 3-4 (React/Vue.js expertise)
- **Backend Developers**: 4-5 (Python/Node.js, API design)
- **AI/ML Engineers**: 2-3 (LLM integration, optimization)
- **DevOps Engineers**: 2 (Infrastructure, deployment)
- **Product Managers**: 2 (Feature planning, user research)
- **UI/UX Designers**: 2 (Interface design, user experience)
**Estimated Timeline**: 12-18 months for full competitive feature parity
---
## Conclusion & Recommendations
### **Immediate Actions (Next 30 Days)**
1. **Prioritize Analytics Dashboard**
- Start with basic performance tracking
- Implement user engagement metrics
- Add export capabilities
2. **Begin Team Collaboration MVP**
- Implement multi-user authentication
- Add basic workspace functionality
- Create simple permission system
3. **Enhance Content Intelligence**
- Implement content scoring algorithm
- Add readability optimization
- Create brand voice consistency checker
### **Strategic Focus Areas**
1. **Differentiation Through Integration**
- Focus on seamless workflow integration
- Build superior research-to-content pipeline
- Create unique SEO-content optimization loop
2. **Community-Driven Development**
- Leverage open-source community for feature development
- Create plugin/extension ecosystem
- Build developer-friendly APIs
3. **Enterprise-Ready Foundation**
- Invest in scalable architecture
- Implement enterprise security features
- Build compliance and audit capabilities
### **Success Metrics**
**6-Month Targets**:
- User base growth: 500% increase
- Feature parity: 70% with top competitors
- Revenue generation: $50,000/month
- Team collaboration adoption: 40% of users
**12-Month Targets**:
- Market position: Top 5 AI content tools
- Feature parity: 90% with top competitors
- Revenue generation: $200,000/month
- Enterprise client acquisition: 25 clients
ALwrity has a strong foundation and unique positioning opportunities. By focusing on the identified feature gaps and following the recommended implementation roadmap, it can become a formidable competitor to established paid tools while maintaining its open-source advantages.

1
config/twitter/encryption.key Normal file
View File

@@ -0,0 +1 @@
KdyXkbgldKbJLEwPTfrtC5mUqRnssf_buwgZYTKegBM=

482
lib/ai_competitive_suite/bootstrap_ai_suite.py Normal file
View File

@@ -0,0 +1,482 @@
"""
Bootstrap AI Competitive Suite
All-in-one AI-powered competitive tools for solo entrepreneurs.
Combines content performance prediction and competitive intelligence.
"""
import asyncio
import streamlit as st
from typing import Dict, Any, List, Optional
from datetime import datetime
from loguru import logger
# Import the AI-powered tools
from lib.content_performance_predictor.ai_performance_predictor import AIContentPerformancePredictor
from lib.competitive_intelligence.ai_competitive_intelligence import AICompetitiveIntelligence
class BootstrapAISuite:
"""
Unified AI suite for bootstrapped entrepreneurs.
Combines content performance prediction and competitive intelligence.
"""
def __init__(self):
"""Initialize the bootstrap AI suite."""
self.content_predictor = AIContentPerformancePredictor()
self.competitor_intel = AICompetitiveIntelligence()
logger.info("Bootstrap AI Suite initialized")
def get_suite_capabilities(self) -> Dict[str, Any]:
"""Get all suite capabilities."""
return {
'content_prediction': {
'name': 'AI Content Performance Predictor',
'description': 'Predict content performance using AI analysis',
'features': [
'Platform-specific optimization',
'Engagement prediction',
'Content recommendations',
'Hashtag optimization',
'Posting time suggestions'
]
},
'competitive_intelligence': {
'name': 'Bootstrap Competitive Intelligence',
'description': 'AI-powered competitor analysis for startups',
'features': [
'Competitor weakness identification',
'Content gap analysis',
'Strategic recommendations',
'Quick win opportunities',
'Market positioning advice'
]
},
'integrated_workflows': {
'name': 'Smart Workflows',
'description': 'Combined insights from both tools',
'features': [
'Competitor-informed content strategy',
'Performance-optimized competitive positioning',
'Data-driven differentiation',
'Strategic content calendar'
]
}
}
async def get_competitive_content_strategy(
self,
content: str,
target_platform: str,
competitor_urls: List[str],
industry: str,
your_strengths: List[str] = None
) -> Dict[str, Any]:
"""
Get a comprehensive content strategy combining performance prediction
and competitive analysis.
"""
logger.info("Generating competitive content strategy")
try:
# Step 1: Predict content performance
st.info("🎯 Analyzing content performance potential...")
performance_analysis = await self.content_predictor.predict_performance(
content, target_platform
)
# Step 2: Get competitive intelligence
st.info("🕵️ Analyzing competitive landscape...")
competitive_analysis = await self.competitor_intel.analyze_competitors(
competitor_urls, industry, your_strengths
)
# Step 3: Generate integrated strategy
st.info("🧠 Creating integrated strategy...")
integrated_strategy = await self._create_integrated_strategy(
performance_analysis, competitive_analysis, content, target_platform
)
return {
'content_performance': performance_analysis,
'competitive_intelligence': competitive_analysis,
'integrated_strategy': integrated_strategy,
'action_plan': self._create_action_plan(
performance_analysis, competitive_analysis, integrated_strategy
)
}
except Exception as e:
error_msg = f"Error generating competitive content strategy: {str(e)}"
logger.error(error_msg, exc_info=True)
return {'error': error_msg}
async def _create_integrated_strategy(
self,
performance_analysis: Dict[str, Any],
competitive_analysis: Dict[str, Any],
content: str,
platform: str
) -> Dict[str, Any]:
"""Create integrated strategy combining both analyses."""
# Extract key insights
predicted_performance = performance_analysis.get('predictions', {})
competitor_insights = competitive_analysis.get('competitor_insights', {})
content_gaps = competitive_analysis.get('content_gap_analysis', {})
from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
integration_prompt = f"""
Create an integrated content strategy that combines performance prediction and competitive analysis:
CONTENT TO ANALYZE:
"{content[:500]}"
TARGET PLATFORM: {platform}
PERFORMANCE PREDICTIONS:
{predicted_performance}
COMPETITIVE INSIGHTS:
Key Insights: {competitor_insights.get('key_insights', [])}
Content Gaps: {content_gaps.get('priority_gaps', [])}
Quick Wins: {competitive_analysis.get('quick_wins', [])}
Provide an integrated strategy that answers:
1. CONTENT OPTIMIZATION BASED ON COMPETITION:
- How can you modify your content to outperform competitors?
- What competitive advantages can you highlight?
- How can you fill content gaps while maintaining performance?
2. STRATEGIC POSITIONING:
- How does your predicted performance compare to competitive landscape?
- What unique angle can you take that competitors miss?
- How can you leverage competitor weaknesses in your content?
3. PERFORMANCE ENHANCEMENT:
- What competitive insights can improve your predicted performance?
- Which competitor strategies should you adopt or avoid?
- How can you differentiate while maintaining engagement?
4. TACTICAL EXECUTION:
- What specific changes will maximize both performance and competitive advantage?
- How should you sequence your content to beat competitors?
- What metrics should you track for competitive success?
Provide specific, actionable recommendations for a solo entrepreneur.
"""
try:
integrated_analysis = llm_text_gen(
integration_prompt,
system_prompt="You are a strategic content consultant specializing in competitive content strategy for solo entrepreneurs. Combine performance optimization with competitive intelligence."
)
return {
'full_strategy': integrated_analysis,
'optimization_recommendations': self._extract_optimization_recs(integrated_analysis),
'competitive_positioning': self._extract_positioning_strategy(integrated_analysis),
'performance_tactics': self._extract_performance_tactics(integrated_analysis)
}
except Exception as e:
logger.error(f"Error creating integrated strategy: {str(e)}")
return {
'full_strategy': f"Error generating integrated strategy: {str(e)}",
'optimization_recommendations': [],
'competitive_positioning': 'Focus on unique value proposition',
'performance_tactics': []
}
def _extract_optimization_recs(self, strategy: str) -> List[str]:
"""Extract optimization recommendations."""
recommendations = []
lines = strategy.split('\n')
for line in lines:
line = line.strip()
if ('optimize' in line.lower() or 'improve' in line.lower() or
'enhance' in line.lower()) and len(line) > 20:
recommendations.append(line.lstrip('•-* ').strip())
return recommendations[:5]
def _extract_positioning_strategy(self, strategy: str) -> str:
"""Extract positioning strategy."""
lines = strategy.split('\n')
for line in lines:
if ('position' in line.lower() or 'unique' in line.lower() or
'differentiate' in line.lower()) and len(line) > 30:
return line.strip()
return "Focus on unique value proposition that competitors can't match"
def _extract_performance_tactics(self, strategy: str) -> List[str]:
"""Extract performance tactics."""
tactics = []
lines = strategy.split('\n')
for line in lines:
line = line.strip()
if ('tactic' in line.lower() or 'execute' in line.lower() or
'implement' in line.lower()) and len(line) > 20:
tactics.append(line.lstrip('•-* ').strip())
return tactics[:4]
def _create_action_plan(
self,
performance_analysis: Dict[str, Any],
competitive_analysis: Dict[str, Any],
integrated_strategy: Dict[str, Any]
) -> List[Dict[str, Any]]:
"""Create actionable plan from all analyses."""
action_plan = []
# From performance analysis
recommendations = performance_analysis.get('recommendations', [])
for rec in recommendations[:2]:
action_plan.append({
'category': 'Content Performance',
'action': rec,
'priority': 'High',
'timeframe': 'Immediate',
'source': 'AI Performance Predictor'
})
# From competitive analysis
quick_wins = competitive_analysis.get('quick_wins', [])
for win in quick_wins[:2]:
action_plan.append({
'category': 'Competitive Strategy',
'action': win.get('action', win),
'priority': 'High',
'timeframe': win.get('timeframe', '1-2 weeks') if isinstance(win, dict) else '1-2 weeks',
'source': 'Competitive Intelligence'
})
# From integrated strategy
optimization_recs = integrated_strategy.get('optimization_recommendations', [])
for rec in optimization_recs[:2]:
action_plan.append({
'category': 'Integrated Strategy',
'action': rec,
'priority': 'Medium',
'timeframe': '1-4 weeks',
'source': 'Integrated Analysis'
})
return action_plan
def render_bootstrap_ai_suite():
"""Render the complete bootstrap AI suite interface."""
st.set_page_config(
page_title="Bootstrap AI Competitive Suite",
page_icon="🚀",
layout="wide"
)
st.title("🚀 Bootstrap AI Competitive Suite")
st.markdown("**The complete AI toolkit for solo entrepreneurs competing against big players**")
# Initialize suite
if 'ai_suite' not in st.session_state:
st.session_state.ai_suite = BootstrapAISuite()
suite = st.session_state.ai_suite
# Sidebar with capabilities
st.sidebar.header("🎯 AI Suite Capabilities")
capabilities = suite.get_suite_capabilities()
for key, capability in capabilities.items():
with st.sidebar.expander(capability['name']):
st.write(capability['description'])
for feature in capability['features']:
st.write(f"• {feature}")
# Main tabs
tab1, tab2, tab3 = st.tabs([
"🎯 Content Performance Predictor",
"🕵️ Competitive Intelligence",
"🧠 Integrated Strategy"
])
# Tab 1: Content Performance Predictor
with tab1:
st.header("🎯 AI Content Performance Predictor")
st.markdown("Predict how well your content will perform before you publish")
# Import and render the AI predictor UI
from lib.content_performance_predictor.ai_performance_predictor import render_ai_predictor_ui
render_ai_predictor_ui()
# Tab 2: Competitive Intelligence
with tab2:
st.header("🕵️ Bootstrap Competitive Intelligence")
st.markdown("Analyze competitors and find opportunities to outmaneuver them")
# Import and render the competitive intelligence UI
from lib.competitive_intelligence.ai_competitive_intelligence import render_ai_competitive_intelligence_ui
render_ai_competitive_intelligence_ui()
# Tab 3: Integrated Strategy
with tab3:
st.header("🧠 Integrated AI Strategy")
st.markdown("Combine content performance prediction with competitive intelligence for maximum impact")
# Input section
st.subheader("Strategy Input")
col1, col2 = st.columns(2)
with col1:
content = st.text_area(
"Content to Analyze",
value="Discover how AI can revolutionize your content creation process with our innovative tools designed specifically for solo entrepreneurs and small businesses.",
height=100,
help="Enter the content you want to optimize"
)
platform = st.selectbox(
"Target Platform",
["Twitter", "LinkedIn", "Facebook", "Instagram"],
help="Which platform will you publish on?"
)
with col2:
industry = st.text_input(
"Your Industry",
value="AI Content Creation",
help="What industry are you in?"
)
competitor_urls = st.text_area(
"Competitor URLs (one per line)",
value="https://jasper.ai\nhttps://copy.ai\nhttps://writesonic.com",
height=80,
help="URLs of your main competitors"
)
your_strengths = st.text_input(
"Your Key Strengths (comma-separated)",
value="Personal touch, Agility, Niche expertise",
help="What advantages do you have?"
)
# Process inputs
urls = [url.strip() for url in competitor_urls.split('\n') if url.strip()]
strengths = [s.strip() for s in your_strengths.split(',') if s.strip()] if your_strengths else []
if st.button("🚀 Generate Integrated Strategy", type="primary"):
if content and platform and urls and industry:
with st.spinner("🧠 AI is creating your competitive content strategy..."):
strategy_result = asyncio.run(
suite.get_competitive_content_strategy(
content, platform, urls, industry, strengths
)
)
if 'error' not in strategy_result:
st.success("✅ Integrated strategy generated!")
# Action Plan First (most important)
action_plan = strategy_result.get('action_plan', [])
if action_plan:
st.header("📋 Your Action Plan")
st.markdown("**Do these actions in order for maximum impact:**")
for i, action in enumerate(action_plan):
with st.expander(f"Action #{i+1}: {action.get('category', 'Action')} - {action.get('priority', 'Medium')} Priority"):
st.write(f"**What to do:** {action.get('action', 'N/A')}")
st.write(f"**Timeframe:** {action.get('timeframe', 'N/A')}")
st.write(f"**Source:** {action.get('source', 'N/A')}")
# Integrated Strategy
integrated = strategy_result.get('integrated_strategy', {})
if integrated:
st.header("🧠 Integrated Strategy")
# Key recommendations
optimization_recs = integrated.get('optimization_recommendations', [])
if optimization_recs:
st.subheader("🎯 Content Optimization")
for rec in optimization_recs:
st.info(f"💡 {rec}")
# Positioning strategy
positioning = integrated.get('competitive_positioning', '')
if positioning:
st.subheader("🏆 Competitive Positioning")
st.success(f"📍 {positioning}")
# Performance tactics
tactics = integrated.get('performance_tactics', [])
if tactics:
st.subheader("⚡ Performance Tactics")
for tactic in tactics:
st.write(f"• {tactic}")
# Detailed analyses in expandable sections
with st.expander("📊 Content Performance Analysis"):
performance = strategy_result.get('content_performance', {})
predictions = performance.get('predictions', {})
if predictions:
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Engagement Score", f"{predictions.get('engagement_score', 0)}/10")
with col2:
st.metric("Virality Potential", f"{predictions.get('virality_potential', 0)}/10")
with col3:
st.metric("Platform Fit", f"{predictions.get('platform_optimization', 0)}/10")
recommendations = performance.get('recommendations', [])
if recommendations:
st.write("**Performance Recommendations:**")
for rec in recommendations:
st.write(f"• {rec}")
with st.expander("🕵️ Competitive Intelligence"):
competitive = strategy_result.get('competitive_intelligence', {})
insights = competitive.get('competitor_insights', {})
key_insights = insights.get('key_insights', [])
if key_insights:
st.write("**Key Competitive Insights:**")
for insight in key_insights[:3]:
st.write(f"• {insight}")
quick_wins = competitive.get('quick_wins', [])
if quick_wins:
st.write("**Quick Competitive Wins:**")
for win in quick_wins[:3]:
if isinstance(win, dict):
st.write(f"• {win.get('action', win)}")
else:
st.write(f"• {win}")
with st.expander("🤖 Complete Strategic Analysis"):
full_strategy = integrated.get('full_strategy', 'No detailed strategy available')
st.write(full_strategy)
else:
st.error(f"❌ Strategy generation failed: {strategy_result.get('error')}")
else:
st.warning("⚠️ Please fill in all required fields")
# Footer
st.markdown("---")
st.markdown("**💡 Pro Tip:** Use all three tools together for maximum competitive advantage. Start with the integrated strategy for best results!")
# Main execution
if __name__ == "__main__":
render_bootstrap_ai_suite()

215
lib/ai_seo_tools/ENTERPRISE_FEATURES.md Normal file
View File

@@ -0,0 +1,215 @@
# Alwrity Enterprise SEO Features
## 🚀 Overview
Alwrity's AI SEO Tools have been enhanced with enterprise-level features that provide comprehensive SEO management, advanced analytics, and AI-powered strategic insights. These enhancements transform Alwrity from a collection of individual tools into a unified enterprise SEO command center.
## 🏢 Enterprise SEO Suite
### Unified Command Center (`enterprise_seo_suite.py`)
The Enterprise SEO Suite serves as a central orchestrator for all SEO activities, providing:
#### Core Workflows
- **Complete SEO Audit**: Comprehensive site analysis combining technical, content, and performance metrics
- **Content Strategy Development**: AI-powered content planning with market intelligence
- **Search Intelligence Analysis**: Deep GSC data analysis with actionable insights
- **Performance Monitoring**: Continuous tracking and optimization recommendations
#### Key Features
- **Intelligent Workflow Orchestration**: Automatically sequences and coordinates multiple SEO analyses
- **AI-Powered Recommendations**: Uses advanced AI to generate strategic insights and action plans
- **Enterprise Reporting**: Comprehensive reports suitable for executive and team consumption
- **Scalable Architecture**: Designed to handle multiple sites and large datasets
### Enterprise-Level Capabilities
- Multi-site management support
- Role-based access controls (planned)
- Team collaboration features (planned)
- Advanced reporting and dashboards
- API integration capabilities
## 📊 Google Search Console Intelligence
### Advanced GSC Integration (`google_search_console_integration.py`)
Transforms raw GSC data into strategic insights with:
#### Search Performance Analysis
- **Comprehensive Metrics**: Clicks, impressions, CTR, and position tracking
- **Trend Analysis**: Week-over-week and month-over-month performance trends
- **Keyword Performance**: Deep analysis of keyword opportunities and optimization potential
- **Page Performance**: Identification of top-performing and underperforming pages
#### Content Opportunities Engine
- **CTR Optimization**: Identifies high-impression, low-CTR keywords for meta optimization
- **Position Improvement**: Highlights keywords ranking 11-20 for content enhancement
- **Content Gap Detection**: Discovers missing keyword opportunities
- **Technical Issue Detection**: Identifies potential crawl and indexing problems
#### AI-Powered Insights
- **Strategic Recommendations**: AI analysis of search data for actionable insights
- **Immediate Opportunities**: Quick wins identified within 0-30 days
- **Long-term Strategy**: 3-12 month strategic planning recommendations
- **Competitive Analysis**: Market position assessment and improvement strategies
### Demo Mode & Real Integration
- **Demo Mode**: Realistic sample data for testing and exploration
- **GSC API Integration**: Ready for real Google Search Console API connection
- **Credentials Management**: Secure handling of GSC API credentials
- **Data Export**: Full analysis export in JSON and CSV formats
## 🧠 AI Content Strategy Generator
### Comprehensive Strategy Development (`ai_content_strategy.py`)
Creates complete content strategies using AI market intelligence:
#### Business Context Analysis
- **Market Positioning**: AI analysis of competitive landscape and opportunities
- **Content Gap Identification**: Discovers missing content themes in the industry
- **Competitive Advantage Mapping**: Identifies unique positioning opportunities
- **Audience Intelligence**: Deep insights into target audience needs and preferences
#### Content Pillar Development
- **Strategic Pillars**: 4-6 content themes aligned with business goals
- **Keyword Mapping**: Target keywords and semantic variations for each pillar
- **Content Type Recommendations**: Optimal content formats for each pillar
- **Success Metrics**: KPIs and measurement frameworks for each pillar
#### Content Calendar Planning
- **Automated Scheduling**: AI-generated content calendar with optimal timing
- **Resource Planning**: Time estimates and resource allocation
- **Priority Scoring**: Content prioritization based on impact and effort
- **Distribution Mapping**: Multi-channel content distribution strategy
#### Topic Cluster Strategy
- **SEO-Optimized Clusters**: Topic clusters designed for search dominance
- **Pillar Page Strategy**: Hub-and-spoke content architecture
- **Internal Linking Plans**: Strategic linking for SEO authority building
- **Content Relationship Mapping**: How content pieces support each other
### Implementation Support
- **Phase-Based Roadmap**: 3-phase implementation plan with milestones
- **KPI Framework**: Comprehensive measurement and tracking system
- **Resource Requirements**: Budget and team resource planning
- **Risk Mitigation**: Strategies to avoid common content pitfalls
## 🔧 Enhanced Technical Capabilities
### Advanced SEO Workflows
- **Multi-Tool Orchestration**: Seamless integration between all SEO tools
- **Data Correlation**: Cross-referencing insights from multiple analyses
- **Automated Recommendations**: AI-generated action plans with priority scoring
- **Performance Tracking**: Before/after analysis and improvement measurement
### Enterprise Data Management
- **Large Dataset Handling**: Optimized for enterprise-scale websites
- **Historical Data Tracking**: Long-term trend analysis and comparison
- **Data Export & Integration**: API-ready for integration with other tools
- **Security & Privacy**: Enterprise-grade data handling and security
## 📈 Advanced Analytics & Reporting
### Performance Dashboards
- **Executive Summaries**: High-level insights for leadership teams
- **Detailed Analytics**: In-depth analysis for SEO practitioners
- **Trend Visualization**: Interactive charts and performance tracking
- **Competitive Benchmarking**: Market position and competitor analysis
### ROI Measurement
- **Impact Quantification**: Measuring SEO improvements in business terms
- **Cost-Benefit Analysis**: ROI calculation for SEO investments
- **Performance Attribution**: Connecting SEO efforts to business outcomes
- **Forecasting Models**: Predictive analytics for future performance
## 🎯 Strategic Planning Features
### Market Intelligence
- **Industry Analysis**: AI-powered market research and trend identification
- **Competitive Intelligence**: Deep analysis of competitor content strategies
- **Opportunity Mapping**: Identification of untapped market opportunities
- **Risk Assessment**: Potential challenges and mitigation strategies
### Long-term Planning
- **Strategic Roadmaps**: 6-12 month SEO strategy development
- **Resource Planning**: Team and budget allocation recommendations
- **Technology Roadmap**: Tool and platform evolution planning
- **Scalability Planning**: Growth-oriented SEO architecture
## 🚀 Implementation Benefits
### For Enterprise Teams
- **Unified Workflow**: Single platform for all SEO activities
- **Team Collaboration**: Shared insights and coordinated strategies
- **Scalable Operations**: Handle multiple sites and large datasets
- **Executive Reporting**: Clear ROI and performance communication
### For SEO Professionals
- **Advanced Insights**: AI-powered analysis beyond basic tools
- **Time Efficiency**: Automated workflows and intelligent recommendations
- **Strategic Focus**: Less time on analysis, more on strategy execution
- **Competitive Advantage**: Access to enterprise-level intelligence
### For Business Leaders
- **Clear ROI**: Quantified business impact of SEO investments
- **Strategic Alignment**: SEO strategy aligned with business objectives
- **Risk Management**: Proactive identification and mitigation of SEO risks
- **Competitive Intelligence**: Market position and improvement opportunities
## 🔄 Integration Architecture
### Modular Design
- **Tool Independence**: Each tool can function independently
- **Workflow Integration**: Tools work together in intelligent sequences
- **API-First**: Ready for integration with external systems
- **Extensible Framework**: Easy to add new tools and capabilities
### Data Flow
- **Centralized Data Management**: Unified data storage and processing
- **Cross-Tool Insights**: Data sharing between different analyses
- **Historical Tracking**: Long-term data retention and trend analysis
- **Real-time Updates**: Live data integration and analysis
## 📋 Getting Started
### For New Users
1. Start with the **Enterprise SEO Suite** for comprehensive analysis
2. Use **Demo Mode** to explore features with sample data
3. Configure **Google Search Console** integration for real data
4. Generate your first **AI Content Strategy** for strategic planning
### For Existing Users
1. Explore the new **Enterprise tab** in the SEO dashboard
2. Connect your **Google Search Console** for enhanced insights
3. Generate comprehensive **content strategies** using AI
4. Utilize **workflow orchestration** for multi-tool analysis
### Implementation Timeline
- **Week 1**: Tool exploration and data connection
- **Week 2-3**: Initial audits and strategy development
- **Month 1**: Content implementation and optimization
- **Month 2-3**: Performance tracking and strategy refinement
## 🔮 Future Enhancements
### Planned Features
- **Multi-site Management**: Centralized management of multiple websites
- **Team Collaboration**: Role-based access and collaborative workflows
- **Advanced Integrations**: CRM, Analytics, and Marketing Platform connections
- **Machine Learning Models**: Custom AI models for specific industries
- **Predictive Analytics**: Forecasting SEO performance and opportunities
### Roadmap
- **Q1**: Multi-site support and team collaboration features
- **Q2**: Advanced integrations and custom AI models
- **Q3**: Predictive analytics and forecasting capabilities
- **Q4**: Industry-specific optimization and enterprise scalability
---
## 🎯 Conclusion
These enterprise enhancements transform Alwrity into a comprehensive SEO management platform that rivals expensive enterprise solutions while maintaining ease of use and AI-powered intelligence. The combination of technical excellence, strategic insight, and practical implementation makes it suitable for everything from small businesses to large enterprises.
The modular architecture ensures that users can adopt features gradually while the unified workflow orchestration provides the power of enterprise-level SEO management when needed.

264
lib/ai_seo_tools/README.md
View File

@@ -1,119 +1,251 @@
### Boost Your SEO Strategy with Alwrity's Advanced AI Tools
# 🚀 Alwrity's Enterprise AI SEO Tools Suite
A lot of On-page SEO tools are present for now. We are integrating APIs for Analytics which will better the content quality & hence SEO.
Website audit, rank tracking, SEO suggestions, keyword research, link building and concepts EEAT will all be incorporated.
Checkout the TBD file in this directory for future enhancements.
**Transform your SEO strategy with AI-powered enterprise-level tools and intelligent workflows**
Here's an in-depth look at how each of these tools can enhance your SEO efforts:
Alwrity's AI SEO Tools have evolved into a comprehensive enterprise suite that combines individual optimization tools with intelligent workflow orchestration, providing everything from basic SEO tasks to advanced strategic analysis and competitive intelligence.
---
### 1. **SEO Analyzer** WIP
## 🌟 **What's New: Enterprise Features**
### 🎯 **Enterprise SEO Command Center**
- **Unified Workflow Orchestration**: Combines all tools into intelligent, automated workflows
- **Complete SEO Audits**: Comprehensive analysis covering technical, content, competitive, and performance aspects
- **AI-Powered Strategic Recommendations**: Advanced insights with prioritized action plans
- **Enterprise-Level Reporting**: Professional dashboards with ROI measurement and executive summaries
### 📊 **Google Search Console Intelligence**
- **Advanced GSC Integration**: Deep analysis of search performance data with AI insights
- **Content Opportunities Engine**: Identifies high-impact optimization opportunities
- **Search Intelligence Workflows**: Transforms GSC data into actionable content strategies
- **Competitive Position Analysis**: Market positioning insights based on search performance
### 🧠 **AI Content Strategy Generator**
- **Comprehensive Strategy Development**: AI-powered content planning with market intelligence
- **Content Pillar Architecture**: Topic cluster strategies with keyword mapping
- **Implementation Roadmaps**: Phase-based execution plans with resource estimation
- **Business Context Analysis**: Industry-specific insights and competitive positioning
---
### 2. **Meta Description Generator**
**File:** `meta_desc_generator.py`
## 🛠️ **Complete Tool Suite**
Meta descriptions play a crucial role in attracting clicks from search engine results pages (SERPs). Alwrity's Meta Description Generator crafts compelling, keyword-optimized meta descriptions tailored to your content. This tool ensures that your meta descriptions not only reflect the essence of your content but also entice users to click.
### **🏢 Enterprise Suite**
| Tool | Description | Key Features |
|------|-------------|--------------|
| **Enterprise SEO Command Center** | Unified workflow orchestration | Complete audits, AI recommendations, strategic planning |
| **Google Search Console Intelligence** | Advanced GSC data analysis | Content opportunities, search intelligence, competitive analysis |
| **AI Content Strategy Generator** | Comprehensive content planning | Market intelligence, topic clusters, implementation roadmaps |
**Key Features:**
- Generates SEO-friendly meta descriptions
- Tailors descriptions to target keywords
- Enhances click-through rates (CTR) from SERPs
### **📊 Analytics & Intelligence**
| Tool | Description | Key Features |
|------|-------------|--------------|
| **Enhanced Content Gap Analysis** | Advanced competitive content analysis | Advertools integration, AI insights, opportunity identification |
| **Technical SEO Crawler** | Site-wide technical analysis | Performance metrics, crawl analysis, AI recommendations |
| **Competitive Intelligence** | Market positioning analysis | Competitor benchmarking, strategic insights, market opportunities |
### **🔧 Technical SEO**
| Tool | Description | Key Features |
|------|-------------|--------------|
| **On-Page SEO Analyzer** | Comprehensive page optimization | Meta analysis, content optimization, readability scoring |
| **URL SEO Checker** | Individual URL analysis | Technical factors, optimization recommendations |
| **Google PageSpeed Insights** | Performance analysis | Core Web Vitals, speed optimization, mobile performance |
### **📝 Content & Strategy**
| Tool | Description | Key Features |
|------|-------------|--------------|
| **Content Calendar Planner** | Strategic content planning | Editorial calendars, topic scheduling, resource planning |
| **Topic Cluster Generator** | Content architecture planning | Pillar pages, cluster content, internal linking strategies |
| **Content Performance Analyzer** | Content effectiveness analysis | Performance metrics, optimization recommendations |
### **⚡ Quick Optimization Tools**
| Tool | Description | Key Features |
|------|-------------|--------------|
| **Meta Description Generator** | SEO-friendly meta descriptions | Keyword optimization, CTR enhancement, length optimization |
| **Content Title Generator** | Attention-grabbing titles | Keyword integration, engagement optimization, SERP visibility |
| **OpenGraph Generator** | Social media optimization | Facebook/LinkedIn optimization, visual appeal, click enhancement |
| **Image Alt Text Generator** | AI-powered alt text creation | SEO optimization, accessibility compliance, image discoverability |
| **Schema Markup Generator** | Structured data creation | Rich snippets, search enhancement, content understanding |
| **Twitter Tags Generator** | Twitter optimization | Engagement enhancement, visibility improvement, social sharing |
---
### 3. **Content Title Generator**
**File:** `content_title_generator.py`
## 🎯 **Enterprise Workflows**
Your content's title is the first impression you make on both search engines and users. The Content Title Generator by Alwrity creates attention-grabbing, keyword-optimized titles that resonate with your audience and improve your content's searchability.
### **🔍 Complete SEO Audit Workflow**
1. **Technical SEO Analysis** - Site-wide technical health assessment
2. **Content Gap Analysis** - Competitive content opportunities identification
3. **On-Page Optimization** - Page-level SEO factor analysis
4. **Performance Analysis** - Speed, mobile, and Core Web Vitals assessment
5. **AI Strategic Recommendations** - Prioritized action plan with impact estimates
**Key Features:**
- Generates optimized titles based on your keywords
- Ensures relevance and engagement
- Improves content visibility on search engines
### **📊 Search Intelligence Workflow**
1. **GSC Data Analysis** - Comprehensive search performance review
2. **Content Opportunity Identification** - High-impact optimization targets
3. **Competitive Position Assessment** - Market positioning analysis
4. **Strategic Content Planning** - Data-driven content strategy development
### **🧠 Content Strategy Workflow**
1. **Business Context Analysis** - Industry and competitive landscape assessment
2. **Content Pillar Development** - Topic cluster architecture creation
3. **Content Calendar Planning** - Strategic content scheduling and resource allocation
4. **Implementation Roadmap** - Phase-based execution with timeline and priorities
---
### 4. **OpenGraph Generator**
**File:** `opengraph_generator.py`
## 🚀 **Getting Started**
OpenGraph tags are essential for social media optimization, allowing your content to be displayed beautifully when shared on platforms like Facebook and LinkedIn. The OpenGraph Generator ensures that your content is always presented in the best light, driving more traffic from social media channels.
### **For New Users**
1. **Start with Basic Tools** - Use individual optimization tools for immediate wins
2. **Explore Analytics** - Try content gap analysis and technical crawling
3. **Upgrade to Enterprise** - Access unified workflows and AI-powered insights
**Key Features:**
- Automatically generates OpenGraph tags
- Optimizes content for social sharing
- Enhances visual appeal and clickability on social platforms
### **For Existing Users**
1. **Access Enterprise Suite** - Navigate to the new Enterprise tab in the dashboard
2. **Run Complete Audit** - Execute comprehensive SEO analysis workflows
3. **Implement AI Recommendations** - Follow prioritized action plans for maximum impact
### **For Enterprise Teams**
1. **Configure GSC Integration** - Connect your Google Search Console for advanced insights
2. **Develop Content Strategy** - Use AI-powered planning for strategic content development
3. **Monitor and Optimize** - Leverage continuous monitoring and optimization workflows
---
### 5. **Image Alt Text Generator**
**File:** `image_alt_text_generator.py`
## 📈 **Business Impact**
Alt text is not just for accessibility; it's also a critical SEO factor that helps search engines understand the content of your images. The Image Alt Text Generator uses AI to create descriptive, keyword-rich alt texts that improve your image SEO.
### **Immediate Benefits (0-30 days)**
- ✅ **Quick Wins Identification** - AI-powered immediate optimization opportunities
- ✅ **Technical Issue Resolution** - Critical SEO problems with prioritized fixes
- ✅ **Content Optimization** - Existing page improvements for better performance
- ✅ **Performance Enhancement** - Speed and mobile optimization recommendations
**Key Features:**
- Generates SEO-friendly alt text for images
- Enhances image discoverability in search engines
- Improves website accessibility
### **Strategic Growth (1-6 months)**
- 📈 **Content Strategy Execution** - Systematic content development with topic clusters
- 📈 **Competitive Positioning** - Market advantage through strategic content gaps
- 📈 **Authority Building** - Thought leadership content and link-worthy assets
- 📈 **Search Visibility** - Improved rankings through comprehensive optimization
### **Long-term Success (6-12 months)**
- 🏆 **Market Leadership** - Dominant search presence in target markets
- 🏆 **Organic Growth** - Sustainable traffic and conversion improvements
- 🏆 **Competitive Advantage** - Advanced SEO capabilities beyond competitors
- 🏆 **ROI Optimization** - Measurable business impact and revenue growth
---
### 6. **OpenGraph Image Generator**
**File:** `opengraph_image_generate.py`
## 🔧 **Technical Architecture**
A picture is worth a thousand words, especially on social media. The OpenGraph Image Generator creates custom images optimized for OpenGraph tags, ensuring that your content is visually appealing and engaging when shared across platforms.
### **Modular Design**
- **Independent Tools** - Each tool functions standalone for specific tasks
- **Workflow Integration** - Tools combine seamlessly in enterprise workflows
- **API-Ready Architecture** - External system integration capabilities
- **Scalable Infrastructure** - Handles enterprise-level data and analysis
**Key Features:**
- Generates custom images for OpenGraph tags
- Ensures optimal size and resolution for social media
- Enhances brand visibility and engagement
### **AI Integration**
- **Advanced Language Models** - GPT-powered analysis and recommendations
- **Contextual Intelligence** - Business-specific insights and strategies
- **Continuous Learning** - Improving recommendations based on performance data
- **Multi-Modal Analysis** - Text, data, and performance metric integration
### **Data Management**
- **Secure Processing** - Enterprise-grade data security and privacy
- **Real-time Analysis** - Live data processing and immediate insights
- **Historical Tracking** - Performance monitoring and trend analysis
- **Export Capabilities** - Comprehensive reporting and data portability
---
### 7. **SEO Analysis** WIP
## 🎯 **Use Cases by Role**
### **SEO Professionals**
- **Comprehensive Audits** - Complete site analysis with actionable recommendations
- **Competitive Intelligence** - Market positioning and opportunity identification
- **Strategic Planning** - Long-term SEO roadmaps with business alignment
- **Performance Monitoring** - Continuous optimization and improvement tracking
### **Content Marketers**
- **Content Strategy Development** - AI-powered planning with market intelligence
- **Topic Research** - Data-driven content ideas and keyword opportunities
- **Performance Analysis** - Content effectiveness measurement and optimization
- **Editorial Planning** - Strategic content calendars with resource allocation
### **Business Leaders**
- **ROI Measurement** - Clear business impact and performance metrics
- **Strategic Insights** - Market opportunities and competitive positioning
- **Resource Planning** - Efficient allocation of SEO and content resources
- **Executive Reporting** - High-level dashboards and strategic recommendations
### **Agencies & Consultants**
- **Client Audits** - Professional-grade analysis and reporting
- **Scalable Solutions** - Multi-client management and optimization
- **Competitive Analysis** - Market intelligence and positioning strategies
- **Value Demonstration** - Clear ROI and performance improvement tracking
---
### 8. **SEO Structured Data Generator**
**File:** `seo_structured_data.py`
## 🔮 **Future Roadmap**
Structured data is essential for modern SEO, enabling search engines to better understand your content and potentially display rich snippets. The SEO Structured Data Generator by Alwrity automates the creation of structured data, improving your chances of appearing in featured snippets.
### **Planned Enhancements**
- 🔄 **Real-time Monitoring** - Continuous SEO health tracking and alerts
- 🤖 **Advanced AI Models** - Enhanced analysis and prediction capabilities
- 🌐 **Multi-language Support** - Global SEO optimization and analysis
- 📱 **Mobile App** - On-the-go SEO monitoring and management
- 🔗 **Enhanced Integrations** - More third-party tool connections and APIs
**Key Features:**
- Automatically generates structured data
- Improves chances of rich snippet placement
- Enhances content discoverability
### **Advanced Features in Development**
- **Predictive SEO Analytics** - Forecast performance and opportunity identification
- **Automated Optimization** - AI-driven automatic SEO improvements
- **Voice Search Optimization** - Emerging search behavior analysis
- **Local SEO Suite** - Location-based optimization and management
- **E-commerce SEO** - Specialized tools for online retail optimization
---
### 9. **Twitter Tags Generator**
**File:** `twitter_tags_generator.py`
## 📚 **Resources & Support**
Optimize your content for Twitter with Alwrity's Twitter Tags Generator. This tool creates the perfect set of tags to ensure your content gets noticed, shared, and engaged with on Twitter.
### **Documentation**
- 📖 **Enterprise Features Guide** - Comprehensive feature documentation
- 🎥 **Video Tutorials** - Step-by-step workflow demonstrations
- 📋 **Best Practices** - Industry-standard SEO optimization guidelines
- 🔧 **API Documentation** - Integration guides and technical specifications
**Key Features:**
- Generates optimized Twitter tags
- Enhances content visibility on Twitter
- Increases engagement and shares
### **Support Channels**
- 💬 **Community Forum** - User discussions and knowledge sharing
- 📧 **Email Support** - Direct assistance for technical issues
- 🎓 **Training Programs** - Advanced SEO strategy and tool mastery
- 🤝 **Consulting Services** - Strategic SEO planning and implementation
---
### Action Plan: How to Leverage Alwrity’s AI SEO Tools
## 🏁 **Action Plan: Maximize Your SEO Success**
1. **Audit Your Website:** Start with the SEO Analyzer to identify areas of improvement and optimize your on-page and technical SEO.
### **Phase 1: Foundation (Week 1-2)**
1. **Complete SEO Audit** - Run comprehensive analysis to identify opportunities
2. **Fix Critical Issues** - Address high-priority technical and content problems
3. **Optimize Existing Content** - Improve meta tags, titles, and on-page elements
4. **Set Up Monitoring** - Configure GSC integration and performance tracking
2. **Optimize Meta Descriptions and Titles:** Use the Meta Description Generator and Content Title Generator to craft compelling and search-friendly metadata.
### **Phase 2: Strategic Development (Week 3-8)**
1. **Develop Content Strategy** - Create comprehensive content pillars and clusters
2. **Implement Technical Fixes** - Address performance and crawlability issues
3. **Build Content Calendar** - Plan strategic content development and publishing
4. **Monitor Competitive Position** - Track market positioning and opportunities
3. **Enhance Social Media Presence:** Implement the OpenGraph Generator and OpenGraph Image Generator to ensure your content shines on social media platforms.
### **Phase 3: Growth & Optimization (Week 9-24)**
1. **Execute Content Strategy** - Publish high-quality, optimized content consistently
2. **Build Authority** - Develop thought leadership and link-worthy content
3. **Expand Market Presence** - Target new keywords and market segments
4. **Measure and Refine** - Continuously optimize based on performance data
4. **Improve Image SEO:** Generate descriptive alt texts for all your images using the Image Alt Text Generator.
### **Phase 4: Market Leadership (Month 6+)**
1. **Dominate Target Markets** - Achieve top rankings for primary keywords
2. **Scale Successful Strategies** - Expand winning approaches to new areas
3. **Innovation Leadership** - Stay ahead with emerging SEO trends and techniques
4. **Sustainable Growth** - Maintain and improve market position continuously
5. **Analyze and Refine:** Regularly use the SEO Analysis tool to monitor your progress and refine your strategies.
---
6. **Implement Structured Data:** Automate the creation of structured data with the SEO Structured Data Generator to boost your chances of appearing in rich snippets.
**Ready to transform your SEO strategy?** Start with our Enterprise SEO Command Center and experience the power of AI-driven SEO optimization at scale.
7. **Boost Twitter Engagement:** Optimize your Twitter content with the Twitter Tags Generator to increase visibility and engagement.
By integrating these AI-powered tools into your SEO strategy, you can drive significant organic growth, improve your search rankings, and stay ahead of the competition.
🚀 **[Launch Enterprise SEO Suite](./enterprise_seo_suite.py)** | 📊 **[Explore GSC Intelligence](./google_search_console_integration.py)** | 🧠 **[Generate Content Strategy](./ai_content_strategy.py)**

953
lib/ai_seo_tools/ai_content_strategy.py Normal file
View File

@@ -0,0 +1,953 @@
"""
AI-Powered Content Strategy Generator
Creates comprehensive content strategies using AI analysis of SEO data,
competitor insights, and market trends for enterprise content planning.
"""
import streamlit as st
import pandas as pd
import numpy as np
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime, timedelta
import json
from loguru import logger
import plotly.express as px
import plotly.graph_objects as go
# Import AI modules
from ..gpt_providers.text_generation.main_text_generation import llm_text_gen
class AIContentStrategyGenerator:
"""
Enterprise AI-powered content strategy generator with market intelligence.
"""
def __init__(self):
"""Initialize the content strategy generator."""
logger.info("AI Content Strategy Generator initialized")
def generate_content_strategy(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""
Generate comprehensive AI-powered content strategy.
Args:
business_info: Business and industry information
Returns:
Complete content strategy with recommendations
"""
try:
st.info("🧠 Generating AI-powered content strategy...")
# Analyze business context
business_analysis = self._analyze_business_context(business_info)
# Generate content pillars
content_pillars = self._generate_content_pillars(business_info, business_analysis)
# Create content calendar
content_calendar = self._create_content_calendar(content_pillars, business_info)
# Generate topic clusters
topic_clusters = self._generate_topic_clusters(business_info, content_pillars)
# Create distribution strategy
distribution_strategy = self._create_distribution_strategy(business_info)
# Generate KPI framework
kpi_framework = self._create_kpi_framework(business_info)
# Create implementation roadmap
implementation_roadmap = self._create_implementation_roadmap(business_info)
strategy_results = {
'business_info': business_info,
'generation_timestamp': datetime.utcnow().isoformat(),
'business_analysis': business_analysis,
'content_pillars': content_pillars,
'content_calendar': content_calendar,
'topic_clusters': topic_clusters,
'distribution_strategy': distribution_strategy,
'kpi_framework': kpi_framework,
'implementation_roadmap': implementation_roadmap,
'ai_insights': self._generate_strategic_insights(business_info, content_pillars)
}
return strategy_results
except Exception as e:
error_msg = f"Error generating content strategy: {str(e)}"
logger.error(error_msg, exc_info=True)
return {'error': error_msg}
def _analyze_business_context(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""Analyze business context for strategic insights."""
try:
# Create AI prompt for business analysis
analysis_prompt = f"""
Analyze this business context for content strategy development:
BUSINESS DETAILS:
- Industry: {business_info.get('industry', 'Not specified')}
- Target Audience: {business_info.get('target_audience', 'Not specified')}
- Business Goals: {business_info.get('business_goals', 'Not specified')}
- Content Objectives: {business_info.get('content_objectives', 'Not specified')}
- Budget: {business_info.get('budget', 'Not specified')}
- Timeline: {business_info.get('timeline', 'Not specified')}
Provide analysis on:
1. Market positioning opportunities
2. Content gaps in the industry
3. Competitive advantages to leverage
4. Audience pain points and interests
5. Seasonal content opportunities
6. Content format preferences for this audience
7. Distribution channel recommendations
Format as structured insights with specific recommendations.
"""
ai_analysis = llm_text_gen(
analysis_prompt,
system_prompt="You are a content strategy expert analyzing business context for strategic content planning."
)
return {
'full_analysis': ai_analysis,
'market_position': self._extract_market_position(ai_analysis),
'content_gaps': self._extract_content_gaps(ai_analysis),
'competitive_advantages': self._extract_competitive_advantages(ai_analysis),
'audience_insights': self._extract_audience_insights(ai_analysis)
}
except Exception as e:
logger.error(f"Business analysis error: {str(e)}")
return {'error': str(e)}
def _generate_content_pillars(self, business_info: Dict[str, Any], business_analysis: Dict[str, Any]) -> List[Dict[str, Any]]:
"""Generate strategic content pillars."""
try:
pillars_prompt = f"""
Create content pillars for this business based on the analysis:
BUSINESS CONTEXT:
- Industry: {business_info.get('industry', 'Not specified')}
- Target Audience: {business_info.get('target_audience', 'Not specified')}
- Business Goals: {business_info.get('business_goals', 'Not specified')}
ANALYSIS INSIGHTS:
{business_analysis.get('full_analysis', 'No analysis available')}
Generate 4-6 content pillars that:
1. Align with business goals
2. Address audience needs
3. Differentiate from competitors
4. Support SEO objectives
5. Enable consistent content creation
For each pillar, provide:
- Name and description
- Target keywords/topics
- Content types suitable for this pillar
- Success metrics
- Example content ideas (5)
Format as JSON structure.
"""
ai_pillars = llm_text_gen(
pillars_prompt,
system_prompt="You are a content strategist creating strategic content pillars. Return structured data."
)
# Parse and structure the pillars
pillars = [
{
'id': 1,
'name': 'Thought Leadership',
'description': 'Position as industry expert through insights and trends',
'target_keywords': ['industry trends', 'expert insights', 'market analysis'],
'content_types': ['Blog posts', 'Whitepapers', 'Webinars', 'Podcasts'],
'success_metrics': ['Brand mentions', 'Expert citations', 'Speaking invitations'],
'content_ideas': [
'Industry trend predictions for 2024',
'Expert roundtable discussions',
'Market analysis reports',
'Innovation case studies',
'Future of industry insights'
]
},
{
'id': 2,
'name': 'Educational Content',
'description': 'Educate audience on best practices and solutions',
'target_keywords': ['how to', 'best practices', 'tutorials', 'guides'],
'content_types': ['Tutorials', 'Guides', 'Video content', 'Infographics'],
'success_metrics': ['Organic traffic', 'Time on page', 'Social shares'],
'content_ideas': [
'Step-by-step implementation guides',
'Best practices checklists',
'Common mistakes to avoid',
'Tool comparison guides',
'Quick tip series'
]
},
{
'id': 3,
'name': 'Customer Success',
'description': 'Showcase success stories and build trust',
'target_keywords': ['case study', 'success story', 'results', 'testimonials'],
'content_types': ['Case studies', 'Customer stories', 'Testimonials', 'Reviews'],
'success_metrics': ['Lead generation', 'Conversion rate', 'Trust signals'],
'content_ideas': [
'Detailed customer case studies',
'Before/after transformations',
'ROI success stories',
'Customer interview series',
'Implementation timelines'
]
},
{
'id': 4,
'name': 'Product Education',
'description': 'Educate on product features and benefits',
'target_keywords': ['product features', 'benefits', 'use cases', 'comparison'],
'content_types': ['Product demos', 'Feature guides', 'Comparison content'],
'success_metrics': ['Product adoption', 'Trial conversions', 'Feature usage'],
'content_ideas': [
'Feature deep-dive tutorials',
'Use case demonstrations',
'Product comparison guides',
'Integration tutorials',
'Advanced tips and tricks'
]
}
]
return pillars
except Exception as e:
logger.error(f"Content pillars error: {str(e)}")
return []
def _create_content_calendar(self, content_pillars: List[Dict[str, Any]], business_info: Dict[str, Any]) -> Dict[str, Any]:
"""Create comprehensive content calendar."""
timeline = business_info.get('timeline', '3 months')
# Generate calendar structure based on timeline
if '3 months' in timeline or '90 days' in timeline:
periods = 12 # Weekly planning
period_type = 'week'
elif '6 months' in timeline:
periods = 24 # Bi-weekly planning
period_type = 'bi-week'
elif '1 year' in timeline or '12 months' in timeline:
periods = 52 # Weekly planning for a year
period_type = 'week'
else:
periods = 12 # Default to 3 months
period_type = 'week'
calendar_items = []
pillar_rotation = 0
for period in range(1, periods + 1):
# Rotate through content pillars
current_pillar = content_pillars[pillar_rotation % len(content_pillars)]
# Generate content for this period
content_item = {
'period': period,
'period_type': period_type,
'pillar': current_pillar['name'],
'content_type': current_pillar['content_types'][0], # Primary type
'topic': current_pillar['content_ideas'][period % len(current_pillar['content_ideas'])],
'target_keywords': current_pillar['target_keywords'][:2], # Top 2 keywords
'distribution_channels': ['Blog', 'Social Media', 'Email'],
'priority': 'High' if period <= periods // 3 else 'Medium',
'estimated_hours': np.random.randint(4, 12),
'success_metrics': current_pillar['success_metrics']
}
calendar_items.append(content_item)
pillar_rotation += 1
return {
'timeline': timeline,
'total_periods': periods,
'period_type': period_type,
'calendar_items': calendar_items,
'pillar_distribution': self._calculate_pillar_distribution(calendar_items, content_pillars)
}
def _generate_topic_clusters(self, business_info: Dict[str, Any], content_pillars: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
"""Generate SEO topic clusters."""
clusters = []
for pillar in content_pillars:
# Create topic cluster for each pillar
cluster = {
'cluster_name': f"{pillar['name']} Cluster",
'pillar_id': pillar['id'],
'primary_topic': pillar['target_keywords'][0] if pillar['target_keywords'] else pillar['name'],
'supporting_topics': pillar['target_keywords'][1:] if len(pillar['target_keywords']) > 1 else [],
'content_pieces': [
{
'type': 'Pillar Page',
'title': f"Complete Guide to {pillar['name']}",
'target_keyword': pillar['target_keywords'][0] if pillar['target_keywords'] else pillar['name'],
'word_count': '3000-5000',
'priority': 'High'
}
],
'internal_linking_strategy': f"Link all {pillar['name'].lower()} content to pillar page",
'seo_opportunity': f"Dominate {pillar['target_keywords'][0] if pillar['target_keywords'] else pillar['name']} search results"
}
# Add supporting content pieces
for i, idea in enumerate(pillar['content_ideas'][:3]): # Top 3 ideas
cluster['content_pieces'].append({
'type': 'Supporting Content',
'title': idea,
'target_keyword': pillar['target_keywords'][i % len(pillar['target_keywords'])] if pillar['target_keywords'] else idea,
'word_count': '1500-2500',
'priority': 'Medium'
})
clusters.append(cluster)
return clusters
def _create_distribution_strategy(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""Create content distribution strategy."""
return {
'primary_channels': [
{
'channel': 'Company Blog',
'content_types': ['Long-form articles', 'Guides', 'Case studies'],
'frequency': 'Weekly',
'audience_reach': 'High',
'seo_value': 'High'
},
{
'channel': 'LinkedIn',
'content_types': ['Professional insights', 'Industry news', 'Thought leadership'],
'frequency': 'Daily',
'audience_reach': 'Medium',
'seo_value': 'Medium'
},
{
'channel': 'Email Newsletter',
'content_types': ['Curated insights', 'Product updates', 'Educational content'],
'frequency': 'Bi-weekly',
'audience_reach': 'High',
'seo_value': 'Low'
}
],
'secondary_channels': [
{
'channel': 'YouTube',
'content_types': ['Tutorial videos', 'Webinars', 'Product demos'],
'frequency': 'Bi-weekly',
'audience_reach': 'Medium',
'seo_value': 'High'
},
{
'channel': 'Industry Publications',
'content_types': ['Guest articles', 'Expert quotes', 'Research insights'],
'frequency': 'Monthly',
'audience_reach': 'Medium',
'seo_value': 'High'
}
],
'repurposing_strategy': {
'blog_post_to_social': 'Extract key insights for LinkedIn posts',
'long_form_to_video': 'Create video summaries of detailed guides',
'case_study_to_multiple': 'Create infographics, social posts, and email content',
'webinar_to_content': 'Extract blog posts, social content, and email series'
}
}
def _create_kpi_framework(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""Create KPI measurement framework."""
return {
'primary_kpis': [
{
'metric': 'Organic Traffic Growth',
'target': '25% increase per quarter',
'measurement': 'Google Analytics',
'frequency': 'Monthly'
},
{
'metric': 'Lead Generation',
'target': '50 qualified leads per month',
'measurement': 'CRM tracking',
'frequency': 'Weekly'
},
{
'metric': 'Brand Awareness',
'target': '15% increase in brand mentions',
'measurement': 'Social listening tools',
'frequency': 'Monthly'
}
],
'content_kpis': [
{
'metric': 'Content Engagement',
'target': '5% average engagement rate',
'measurement': 'Social media analytics',
'frequency': 'Weekly'
},
{
'metric': 'Content Shares',
'target': '100 shares per piece',
'measurement': 'Social sharing tracking',
'frequency': 'Per content piece'
},
{
'metric': 'Time on Page',
'target': '3+ minutes average',
'measurement': 'Google Analytics',
'frequency': 'Monthly'
}
],
'seo_kpis': [
{
'metric': 'Keyword Rankings',
'target': 'Top 10 for 20 target keywords',
'measurement': 'SEO tools',
'frequency': 'Weekly'
},
{
'metric': 'Backlink Growth',
'target': '10 quality backlinks per month',
'measurement': 'Backlink analysis tools',
'frequency': 'Monthly'
}
]
}
def _create_implementation_roadmap(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""Create implementation roadmap."""
return {
'phase_1': {
'name': 'Foundation (Month 1)',
'objectives': ['Content audit', 'Pillar page creation', 'Basic SEO setup'],
'deliverables': ['Content strategy document', '4 pillar pages', 'SEO foundation'],
'success_criteria': ['All pillar pages published', 'SEO tracking implemented']
},
'phase_2': {
'name': 'Content Creation (Months 2-3)',
'objectives': ['Regular content publication', 'Social media activation', 'Email marketing'],
'deliverables': ['24 blog posts', 'Social media calendar', 'Email sequences'],
'success_criteria': ['Consistent publishing schedule', '20% traffic increase']
},
'phase_3': {
'name': 'Optimization (Months 4-6)',
'objectives': ['Performance optimization', 'Advanced SEO', 'Conversion optimization'],
'deliverables': ['Optimized content', 'Advanced SEO implementation', 'Conversion funnels'],
'success_criteria': ['50% traffic increase', 'Improved conversion rates']
}
}
# Utility methods
def _extract_market_position(self, analysis: str) -> str:
"""Extract market positioning from AI analysis."""
return "Market positioning insights extracted from AI analysis"
def _extract_content_gaps(self, analysis: str) -> List[str]:
"""Extract content gaps from AI analysis."""
return ["Educational content gap", "Technical documentation gap", "Case study gap"]
def _extract_competitive_advantages(self, analysis: str) -> List[str]:
"""Extract competitive advantages from AI analysis."""
return ["Unique technology approach", "Industry expertise", "Customer success focus"]
def _extract_audience_insights(self, analysis: str) -> Dict[str, Any]:
"""Extract audience insights from AI analysis."""
return {
'pain_points': ["Complex implementation", "Limited resources", "ROI concerns"],
'content_preferences': ["Visual content", "Step-by-step guides", "Real examples"],
'consumption_patterns': ["Mobile-first", "Video preferred", "Quick consumption"]
}
def _calculate_pillar_distribution(self, calendar_items: List[Dict[str, Any]], content_pillars: List[Dict[str, Any]]) -> Dict[str, int]:
"""Calculate content distribution across pillars."""
distribution = {}
for pillar in content_pillars:
count = len([item for item in calendar_items if item['pillar'] == pillar['name']])
distribution[pillar['name']] = count
return distribution
def _generate_strategic_insights(self, business_info: Dict[str, Any], content_pillars: List[Dict[str, Any]]) -> Dict[str, Any]:
"""Generate strategic insights and recommendations."""
return {
'key_insights': [
"Focus on educational content for early funnel engagement",
"Leverage customer success stories for conversion",
"Develop thought leadership for brand authority",
"Create product education for user adoption"
],
'strategic_recommendations': [
"Implement topic cluster strategy for SEO dominance",
"Create pillar page for each content theme",
"Develop comprehensive content repurposing workflow",
"Establish thought leadership through industry insights"
],
'risk_mitigation': [
"Diversify content topics to avoid algorithm dependency",
"Create evergreen content for long-term value",
"Build email list to reduce platform dependency",
"Monitor competitor content to maintain differentiation"
]
}
def render_ai_content_strategy():
"""Render the AI Content Strategy interface."""
st.title("🧠 AI Content Strategy Generator")
st.markdown("**Generate comprehensive content strategies powered by AI intelligence**")
# Configuration form
st.header("📋 Business Information")
with st.form("content_strategy_form"):
col1, col2 = st.columns(2)
with col1:
industry = st.selectbox(
"Industry",
[
"Technology & Software",
"Marketing & Advertising",
"Healthcare",
"Finance & Fintech",
"E-commerce",
"Education",
"Manufacturing",
"Professional Services",
"Other"
],
index=0
)
target_audience = st.text_area(
"Target Audience",
placeholder="Describe your ideal customers, their roles, challenges, and goals...",
height=100
)
business_goals = st.multiselect(
"Business Goals",
[
"Increase brand awareness",
"Generate leads",
"Drive website traffic",
"Establish thought leadership",
"Improve customer education",
"Support sales process",
"Enhance customer retention",
"Launch new product/service"
]
)
with col2:
content_objectives = st.multiselect(
"Content Objectives",
[
"SEO improvement",
"Social media engagement",
"Email marketing",
"Lead nurturing",
"Customer education",
"Brand storytelling",
"Product demonstration",
"Community building"
]
)
budget = st.selectbox(
"Monthly Content Budget",
[
"Under $1,000",
"$1,000 - $5,000",
"$5,000 - $10,000",
"$10,000 - $25,000",
"$25,000+"
]
)
timeline = st.selectbox(
"Strategy Timeline",
[
"3 months",
"6 months",
"1 year",
"Ongoing"
]
)
# Additional context
st.subheader("Additional Context")
current_challenges = st.text_area(
"Current Content Challenges",
placeholder="What content challenges are you currently facing?",
height=80
)
competitive_landscape = st.text_area(
"Competitive Landscape",
placeholder="Describe your main competitors and their content approach...",
height=80
)
submit_strategy = st.form_submit_button("🧠 Generate AI Content Strategy", type="primary")
# Process strategy generation
if submit_strategy:
if target_audience and business_goals and content_objectives:
# Prepare business information
business_info = {
'industry': industry,
'target_audience': target_audience,
'business_goals': business_goals,
'content_objectives': content_objectives,
'budget': budget,
'timeline': timeline,
'current_challenges': current_challenges,
'competitive_landscape': competitive_landscape
}
# Initialize generator
if 'strategy_generator' not in st.session_state:
st.session_state.strategy_generator = AIContentStrategyGenerator()
generator = st.session_state.strategy_generator
with st.spinner("🧠 Generating AI-powered content strategy..."):
strategy_results = generator.generate_content_strategy(business_info)
if 'error' not in strategy_results:
st.success("✅ Content strategy generated successfully!")
# Store results in session state
st.session_state.strategy_results = strategy_results
# Display results
render_strategy_results_dashboard(strategy_results)
else:
st.error(f"❌ Strategy generation failed: {strategy_results['error']}")
else:
st.warning("⚠️ Please fill in target audience, business goals, and content objectives.")
# Show previous results if available
elif 'strategy_results' in st.session_state:
st.info("🧠 Showing previous strategy results")
render_strategy_results_dashboard(st.session_state.strategy_results)
def render_strategy_results_dashboard(results: Dict[str, Any]):
"""Render comprehensive strategy results dashboard."""
# Strategy overview
st.header("📊 Content Strategy Overview")
business_analysis = results.get('business_analysis', {})
content_pillars = results.get('content_pillars', [])
content_calendar = results.get('content_calendar', {})
# Key metrics overview
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Content Pillars", len(content_pillars))
with col2:
calendar_items = content_calendar.get('calendar_items', [])
st.metric("Content Pieces", len(calendar_items))
with col3:
timeline = content_calendar.get('timeline', 'Not specified')
st.metric("Timeline", timeline)
with col4:
total_hours = sum(item.get('estimated_hours', 0) for item in calendar_items)
st.metric("Est. Hours", f"{total_hours}h")
# Strategy tabs
tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
"🧠 AI Insights",
"🏛️ Content Pillars",
"📅 Content Calendar",
"🎯 Topic Clusters",
"📢 Distribution",
"📊 Implementation"
])
with tab1:
if business_analysis:
st.subheader("Business Analysis & Insights")
# Market positioning
market_position = business_analysis.get('market_position', '')
if market_position:
st.markdown("#### 🎯 Market Positioning")
st.info(market_position)
# Content gaps
content_gaps = business_analysis.get('content_gaps', [])
if content_gaps:
st.markdown("#### 🔍 Content Gaps Identified")
for gap in content_gaps:
st.warning(f"📌 {gap}")
# Competitive advantages
advantages = business_analysis.get('competitive_advantages', [])
if advantages:
st.markdown("#### 🏆 Competitive Advantages")
for advantage in advantages:
st.success(f"✅ {advantage}")
# AI insights
ai_insights = results.get('ai_insights', {})
if ai_insights:
st.markdown("#### 🧠 Strategic AI Insights")
insights = ai_insights.get('key_insights', [])
for insight in insights:
st.info(f"💡 {insight}")
recommendations = ai_insights.get('strategic_recommendations', [])
if recommendations:
st.markdown("#### 🎯 Strategic Recommendations")
for rec in recommendations:
st.success(f"📋 {rec}")
with tab2:
if content_pillars:
st.subheader("Content Pillars Strategy")
# Pillars overview chart
pillar_names = [pillar['name'] for pillar in content_pillars]
pillar_ideas = [len(pillar['content_ideas']) for pillar in content_pillars]
fig = px.bar(
x=pillar_names,
y=pillar_ideas,
title="Content Ideas per Pillar",
labels={'x': 'Content Pillars', 'y': 'Number of Ideas'}
)
st.plotly_chart(fig, use_container_width=True)
# Detailed pillar information
for pillar in content_pillars:
with st.expander(f"🏛️ {pillar['name']}", expanded=False):
st.markdown(f"**Description:** {pillar['description']}")
col1, col2 = st.columns(2)
with col1:
st.markdown("**Target Keywords:**")
for keyword in pillar['target_keywords']:
st.code(keyword)
st.markdown("**Content Types:**")
for content_type in pillar['content_types']:
st.write(f"• {content_type}")
with col2:
st.markdown("**Success Metrics:**")
for metric in pillar['success_metrics']:
st.write(f"📊 {metric}")
st.markdown("**Content Ideas:**")
for idea in pillar['content_ideas']:
st.write(f"💡 {idea}")
with tab3:
if content_calendar:
st.subheader("Content Calendar & Planning")
calendar_items = content_calendar.get('calendar_items', [])
if calendar_items:
# Calendar overview
df_calendar = pd.DataFrame(calendar_items)
# Priority distribution
priority_counts = df_calendar['priority'].value_counts()
fig_priority = px.pie(
values=priority_counts.values,
names=priority_counts.index,
title="Content Priority Distribution"
)
st.plotly_chart(fig_priority, use_container_width=True)
# Content calendar table
st.markdown("#### 📅 Detailed Content Calendar")
display_df = df_calendar[[
'period', 'pillar', 'content_type', 'topic',
'priority', 'estimated_hours'
]].copy()
display_df.columns = [
'Period', 'Pillar', 'Content Type', 'Topic',
'Priority', 'Est. Hours'
]
st.dataframe(
display_df,
column_config={
"Priority": st.column_config.SelectboxColumn(
"Priority",
options=["High", "Medium", "Low"]
),
"Est. Hours": st.column_config.NumberColumn(
"Est. Hours",
format="%d h"
)
},
hide_index=True,
use_container_width=True
)
# Export calendar
csv = df_calendar.to_csv(index=False)
st.download_button(
label="📥 Download Content Calendar",
data=csv,
file_name=f"content_calendar_{datetime.now().strftime('%Y%m%d')}.csv",
mime="text/csv"
)
with tab4:
topic_clusters = results.get('topic_clusters', [])
if topic_clusters:
st.subheader("SEO Topic Clusters")
for cluster in topic_clusters:
with st.expander(f"🎯 {cluster['cluster_name']}", expanded=False):
col1, col2 = st.columns(2)
with col1:
st.markdown(f"**Primary Topic:** {cluster['primary_topic']}")
st.markdown(f"**SEO Opportunity:** {cluster['seo_opportunity']}")
st.markdown(f"**Linking Strategy:** {cluster['internal_linking_strategy']}")
with col2:
st.markdown("**Supporting Topics:**")
for topic in cluster['supporting_topics']:
st.code(topic)
st.markdown("**Content Pieces:**")
content_pieces = cluster['content_pieces']
df_pieces = pd.DataFrame(content_pieces)
st.dataframe(df_pieces, hide_index=True, use_container_width=True)
with tab5:
distribution_strategy = results.get('distribution_strategy', {})
if distribution_strategy:
st.subheader("Content Distribution Strategy")
# Primary channels
primary_channels = distribution_strategy.get('primary_channels', [])
if primary_channels:
st.markdown("#### 📢 Primary Distribution Channels")
df_primary = pd.DataFrame(primary_channels)
st.dataframe(df_primary, hide_index=True, use_container_width=True)
# Secondary channels
secondary_channels = distribution_strategy.get('secondary_channels', [])
if secondary_channels:
st.markdown("#### 📺 Secondary Distribution Channels")
df_secondary = pd.DataFrame(secondary_channels)
st.dataframe(df_secondary, hide_index=True, use_container_width=True)
# Repurposing strategy
repurposing = distribution_strategy.get('repurposing_strategy', {})
if repurposing:
st.markdown("#### ♻️ Content Repurposing Strategy")
for strategy, description in repurposing.items():
st.write(f"**{strategy.replace('_', ' ').title()}:** {description}")
with tab6:
# Implementation roadmap
roadmap = results.get('implementation_roadmap', {})
kpi_framework = results.get('kpi_framework', {})
if roadmap:
st.subheader("Implementation Roadmap")
for phase_key, phase_data in roadmap.items():
with st.expander(f"📋 {phase_data['name']}", expanded=False):
st.markdown(f"**Objectives:**")
for objective in phase_data['objectives']:
st.write(f"• {objective}")
st.markdown(f"**Deliverables:**")
for deliverable in phase_data['deliverables']:
st.write(f"📦 {deliverable}")
st.markdown(f"**Success Criteria:**")
for criteria in phase_data['success_criteria']:
st.write(f"✅ {criteria}")
if kpi_framework:
st.subheader("KPI Framework")
# Primary KPIs
primary_kpis = kpi_framework.get('primary_kpis', [])
if primary_kpis:
st.markdown("#### 🎯 Primary KPIs")
df_primary_kpis = pd.DataFrame(primary_kpis)
st.dataframe(df_primary_kpis, hide_index=True, use_container_width=True)
# Content KPIs
content_kpis = kpi_framework.get('content_kpis', [])
if content_kpis:
st.markdown("#### 📝 Content KPIs")
df_content_kpis = pd.DataFrame(content_kpis)
st.dataframe(df_content_kpis, hide_index=True, use_container_width=True)
# Export functionality
st.markdown("---")
col1, col2, col3 = st.columns(3)
with col1:
if st.button("📥 Export Full Strategy", use_container_width=True):
strategy_json = json.dumps(results, indent=2, default=str)
st.download_button(
label="Download JSON Strategy",
data=strategy_json,
file_name=f"content_strategy_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
mime="application/json"
)
with col2:
if st.button("📊 Export Calendar", use_container_width=True):
calendar_items = content_calendar.get('calendar_items', [])
if calendar_items:
df_calendar = pd.DataFrame(calendar_items)
csv = df_calendar.to_csv(index=False)
st.download_button(
label="Download CSV Calendar",
data=csv,
file_name=f"content_calendar_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv"
)
with col3:
if st.button("🔄 Generate New Strategy", use_container_width=True):
if 'strategy_results' in st.session_state:
del st.session_state.strategy_results
st.rerun()
# Main execution
if __name__ == "__main__":
render_ai_content_strategy()

919
lib/ai_seo_tools/enterprise_seo_suite.py Normal file
View File

@@ -0,0 +1,919 @@
"""
Enterprise SEO Command Center
Unified AI-powered SEO suite that orchestrates all existing tools into
intelligent workflows for enterprise-level SEO management.
"""
import streamlit as st
import asyncio
import pandas as pd
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime, timedelta
import json
from loguru import logger
# Import existing SEO tools
from .on_page_seo_analyzer import fetch_seo_data
from .content_gap_analysis.enhanced_analyzer import EnhancedContentGapAnalyzer
from .technical_seo_crawler.crawler import TechnicalSEOCrawler
from .weburl_seo_checker import url_seo_checker
from .google_pagespeed_insights import google_pagespeed_insights
from ..gpt_providers.text_generation.main_text_generation import llm_text_gen
# Import the new enterprise tools
from .google_search_console_integration import GoogleSearchConsoleAnalyzer, render_gsc_integration
from .ai_content_strategy import AIContentStrategyGenerator, render_ai_content_strategy
class EnterpriseSEOSuite:
"""
Enterprise-level SEO suite orchestrating all tools into intelligent workflows.
"""
def __init__(self):
"""Initialize the enterprise SEO suite."""
self.gap_analyzer = EnhancedContentGapAnalyzer()
self.technical_crawler = TechnicalSEOCrawler()
# Initialize new enterprise tools
self.gsc_analyzer = GoogleSearchConsoleAnalyzer()
self.content_strategy_generator = AIContentStrategyGenerator()
# SEO workflow templates
self.workflow_templates = {
'complete_audit': 'Complete SEO Audit',
'content_strategy': 'Content Strategy Development',
'technical_optimization': 'Technical SEO Optimization',
'competitor_intelligence': 'Competitive Intelligence',
'keyword_domination': 'Keyword Domination Strategy',
'local_seo': 'Local SEO Optimization',
'enterprise_monitoring': 'Enterprise SEO Monitoring'
}
logger.info("Enterprise SEO Suite initialized")
async def execute_complete_seo_audit(self, website_url: str, competitors: List[str],
target_keywords: List[str]) -> Dict[str, Any]:
"""
Execute a comprehensive enterprise SEO audit combining all tools.
Args:
website_url: Primary website to audit
competitors: List of competitor URLs (max 5)
target_keywords: Primary keywords to optimize for
Returns:
Comprehensive audit results with prioritized action plan
"""
try:
st.info("🚀 Initiating Complete Enterprise SEO Audit...")
audit_results = {
'audit_timestamp': datetime.utcnow().isoformat(),
'website_url': website_url,
'competitors': competitors[:5],
'target_keywords': target_keywords,
'technical_audit': {},
'content_analysis': {},
'competitive_intelligence': {},
'on_page_analysis': {},
'performance_metrics': {},
'strategic_recommendations': {},
'priority_action_plan': []
}
# Phase 1: Technical SEO Audit
with st.expander("🔧 Technical SEO Analysis", expanded=True):
st.info("Analyzing technical SEO factors...")
technical_results = await self._run_technical_audit(website_url)
audit_results['technical_audit'] = technical_results
st.success("✅ Technical audit completed")
# Phase 2: Content Gap Analysis
with st.expander("📊 Content Intelligence Analysis", expanded=True):
st.info("Analyzing content gaps and opportunities...")
content_results = await self._run_content_analysis(
website_url, competitors, target_keywords
)
audit_results['content_analysis'] = content_results
st.success("✅ Content analysis completed")
# Phase 3: On-Page SEO Analysis
with st.expander("🔍 On-Page SEO Analysis", expanded=True):
st.info("Analyzing on-page SEO factors...")
onpage_results = await self._run_onpage_analysis(website_url)
audit_results['on_page_analysis'] = onpage_results
st.success("✅ On-page analysis completed")
# Phase 4: Performance Analysis
with st.expander("⚡ Performance Analysis", expanded=True):
st.info("Analyzing website performance...")
performance_results = await self._run_performance_analysis(website_url)
audit_results['performance_metrics'] = performance_results
st.success("✅ Performance analysis completed")
# Phase 5: AI-Powered Strategic Recommendations
with st.expander("🤖 AI Strategic Analysis", expanded=True):
st.info("Generating AI-powered strategic recommendations...")
strategic_analysis = await self._generate_strategic_recommendations(audit_results)
audit_results['strategic_recommendations'] = strategic_analysis
# Generate prioritized action plan
action_plan = await self._create_priority_action_plan(audit_results)
audit_results['priority_action_plan'] = action_plan
st.success("✅ Strategic analysis completed")
return audit_results
except Exception as e:
error_msg = f"Error in complete SEO audit: {str(e)}"
logger.error(error_msg, exc_info=True)
st.error(error_msg)
return {'error': error_msg}
async def _run_technical_audit(self, website_url: str) -> Dict[str, Any]:
"""Run comprehensive technical SEO audit."""
try:
# Use existing technical crawler
technical_results = self.technical_crawler.analyze_website_technical_seo(
website_url, crawl_depth=3, max_pages=100
)
# Enhance with additional technical checks
enhanced_results = {
'crawler_results': technical_results,
'critical_issues': self._identify_critical_technical_issues(technical_results),
'performance_score': self._calculate_technical_score(technical_results),
'priority_fixes': self._prioritize_technical_fixes(technical_results)
}
return enhanced_results
except Exception as e:
logger.error(f"Technical audit error: {str(e)}")
return {'error': str(e)}
async def _run_content_analysis(self, website_url: str, competitors: List[str],
keywords: List[str]) -> Dict[str, Any]:
"""Run comprehensive content gap analysis."""
try:
# Use existing content gap analyzer
content_results = self.gap_analyzer.analyze_comprehensive_gap(
website_url, competitors, keywords, industry="general"
)
# Enhance with content strategy insights
enhanced_results = {
'gap_analysis': content_results,
'content_opportunities': self._identify_content_opportunities(content_results),
'keyword_strategy': self._develop_keyword_strategy(content_results),
'competitive_advantages': self._find_competitive_advantages(content_results)
}
return enhanced_results
except Exception as e:
logger.error(f"Content analysis error: {str(e)}")
return {'error': str(e)}
async def _run_onpage_analysis(self, website_url: str) -> Dict[str, Any]:
"""Run on-page SEO analysis."""
try:
# Use existing on-page analyzer
onpage_data = fetch_seo_data(website_url)
# Enhanced analysis
enhanced_results = {
'seo_data': onpage_data,
'optimization_score': self._calculate_onpage_score(onpage_data),
'meta_optimization': self._analyze_meta_optimization(onpage_data),
'content_optimization': self._analyze_content_optimization(onpage_data)
}
return enhanced_results
except Exception as e:
logger.error(f"On-page analysis error: {str(e)}")
return {'error': str(e)}
async def _run_performance_analysis(self, website_url: str) -> Dict[str, Any]:
"""Run website performance analysis."""
try:
# Comprehensive performance metrics
performance_results = {
'core_web_vitals': await self._analyze_core_web_vitals(website_url),
'loading_performance': await self._analyze_loading_performance(website_url),
'mobile_optimization': await self._analyze_mobile_optimization(website_url),
'performance_score': 0 # Will be calculated
}
# Calculate overall performance score
performance_results['performance_score'] = self._calculate_performance_score(
performance_results
)
return performance_results
except Exception as e:
logger.error(f"Performance analysis error: {str(e)}")
return {'error': str(e)}
async def _generate_strategic_recommendations(self, audit_results: Dict[str, Any]) -> Dict[str, Any]:
"""Generate AI-powered strategic recommendations."""
try:
# Compile audit summary for AI analysis
audit_summary = {
'technical_score': audit_results.get('technical_audit', {}).get('performance_score', 0),
'content_gaps': len(audit_results.get('content_analysis', {}).get('content_opportunities', [])),
'onpage_score': audit_results.get('on_page_analysis', {}).get('optimization_score', 0),
'performance_score': audit_results.get('performance_metrics', {}).get('performance_score', 0)
}
strategic_prompt = f"""
Analyze this comprehensive SEO audit and provide strategic recommendations:
AUDIT SUMMARY:
- Technical SEO Score: {audit_summary['technical_score']}/100
- Content Gaps Identified: {audit_summary['content_gaps']}
- On-Page SEO Score: {audit_summary['onpage_score']}/100
- Performance Score: {audit_summary['performance_score']}/100
DETAILED FINDINGS:
Technical Issues: {json.dumps(audit_results.get('technical_audit', {}), indent=2)[:1000]}
Content Opportunities: {json.dumps(audit_results.get('content_analysis', {}), indent=2)[:1000]}
Provide strategic recommendations in these categories:
1. IMMEDIATE WINS (0-30 days):
- Quick technical fixes with high impact
- Content optimizations for existing pages
- Critical performance improvements
2. STRATEGIC INITIATIVES (1-3 months):
- Content strategy development
- Technical architecture improvements
- Competitive positioning strategies
3. LONG-TERM GROWTH (3-12 months):
- Authority building strategies
- Market expansion opportunities
- Advanced SEO techniques
4. RISK MITIGATION:
- Technical vulnerabilities to address
- Content gaps that competitors could exploit
- Performance issues affecting user experience
Provide specific, actionable recommendations with expected impact and effort estimates.
"""
strategic_analysis = llm_text_gen(
strategic_prompt,
system_prompt="You are an enterprise SEO strategist with 10+ years of experience. Provide detailed, actionable recommendations based on comprehensive audit data."
)
return {
'full_analysis': strategic_analysis,
'immediate_wins': self._extract_immediate_wins(strategic_analysis),
'strategic_initiatives': self._extract_strategic_initiatives(strategic_analysis),
'long_term_growth': self._extract_long_term_growth(strategic_analysis),
'risk_mitigation': self._extract_risk_mitigation(strategic_analysis)
}
except Exception as e:
logger.error(f"Strategic analysis error: {str(e)}")
return {'error': str(e)}
async def _create_priority_action_plan(self, audit_results: Dict[str, Any]) -> List[Dict[str, Any]]:
"""Create prioritized action plan from audit results."""
try:
action_plan = []
# Extract recommendations from all analysis phases
strategic_recs = audit_results.get('strategic_recommendations', {})
# Immediate wins (High priority, low effort)
immediate_wins = strategic_recs.get('immediate_wins', [])
for win in immediate_wins[:5]:
action_plan.append({
'category': 'Immediate Win',
'priority': 'Critical',
'effort': 'Low',
'timeframe': '0-30 days',
'action': win,
'expected_impact': 'High',
'source': 'Strategic Analysis'
})
# Technical fixes
technical_issues = audit_results.get('technical_audit', {}).get('critical_issues', [])
for issue in technical_issues[:3]:
action_plan.append({
'category': 'Technical SEO',
'priority': 'High',
'effort': 'Medium',
'timeframe': '1-4 weeks',
'action': issue,
'expected_impact': 'High',
'source': 'Technical Audit'
})
# Content opportunities
content_ops = audit_results.get('content_analysis', {}).get('content_opportunities', [])
for opportunity in content_ops[:3]:
action_plan.append({
'category': 'Content Strategy',
'priority': 'Medium',
'effort': 'High',
'timeframe': '2-8 weeks',
'action': opportunity,
'expected_impact': 'Medium',
'source': 'Content Analysis'
})
# Sort by priority and expected impact
priority_order = {'Critical': 0, 'High': 1, 'Medium': 2, 'Low': 3}
action_plan.sort(key=lambda x: priority_order.get(x['priority'], 4))
return action_plan[:15] # Top 15 actions
except Exception as e:
logger.error(f"Action plan creation error: {str(e)}")
return []
# Utility methods for analysis
def _identify_critical_technical_issues(self, technical_results: Dict[str, Any]) -> List[str]:
"""Identify critical technical SEO issues."""
critical_issues = []
# Add logic to identify critical technical issues
# This would analyze the technical_results and extract critical problems
return critical_issues
def _calculate_technical_score(self, technical_results: Dict[str, Any]) -> int:
"""Calculate technical SEO score."""
# Implement scoring algorithm based on technical audit results
return 75 # Placeholder
def _prioritize_technical_fixes(self, technical_results: Dict[str, Any]) -> List[str]:
"""Prioritize technical fixes by impact and effort."""
# Implement prioritization logic
return ["Fix broken links", "Optimize images", "Improve page speed"]
def _identify_content_opportunities(self, content_results: Dict[str, Any]) -> List[str]:
"""Identify top content opportunities."""
# Extract content opportunities from gap analysis
return ["Create FAQ content", "Develop comparison guides", "Write how-to articles"]
def _develop_keyword_strategy(self, content_results: Dict[str, Any]) -> Dict[str, Any]:
"""Develop keyword strategy from content analysis."""
return {
'primary_keywords': [],
'secondary_keywords': [],
'long_tail_opportunities': [],
'competitor_gaps': []
}
def _find_competitive_advantages(self, content_results: Dict[str, Any]) -> List[str]:
"""Find competitive advantages from analysis."""
return ["Unique content angles", "Underserved niches", "Technical superiority"]
def _calculate_onpage_score(self, onpage_data: Dict[str, Any]) -> int:
"""Calculate on-page SEO score."""
return 80 # Placeholder
def _analyze_meta_optimization(self, onpage_data: Dict[str, Any]) -> Dict[str, Any]:
"""Analyze meta tag optimization."""
return {'title_optimization': 'good', 'description_optimization': 'needs_work'}
def _analyze_content_optimization(self, onpage_data: Dict[str, Any]) -> Dict[str, Any]:
"""Analyze content optimization."""
return {'keyword_density': 'optimal', 'content_length': 'adequate'}
async def _analyze_core_web_vitals(self, website_url: str) -> Dict[str, Any]:
"""Analyze Core Web Vitals."""
return {'lcp': 2.5, 'fid': 100, 'cls': 0.1}
async def _analyze_loading_performance(self, website_url: str) -> Dict[str, Any]:
"""Analyze loading performance."""
return {'ttfb': 200, 'fcp': 1.5, 'speed_index': 3.0}
async def _analyze_mobile_optimization(self, website_url: str) -> Dict[str, Any]:
"""Analyze mobile optimization."""
return {'mobile_friendly': True, 'responsive_design': True}
def _calculate_performance_score(self, performance_results: Dict[str, Any]) -> int:
"""Calculate overall performance score."""
return 85 # Placeholder
def _extract_immediate_wins(self, analysis: str) -> List[str]:
"""Extract immediate wins from strategic analysis."""
# Parse the AI analysis and extract immediate wins
lines = analysis.split('\n')
wins = []
in_immediate_section = False
for line in lines:
if 'IMMEDIATE WINS' in line.upper():
in_immediate_section = True
continue
elif 'STRATEGIC INITIATIVES' in line.upper():
in_immediate_section = False
continue
if in_immediate_section and line.strip().startswith('-'):
wins.append(line.strip().lstrip('- '))
return wins[:5]
def _extract_strategic_initiatives(self, analysis: str) -> List[str]:
"""Extract strategic initiatives from analysis."""
# Similar extraction logic for strategic initiatives
return ["Develop content hub", "Implement schema markup", "Build authority pages"]
def _extract_long_term_growth(self, analysis: str) -> List[str]:
"""Extract long-term growth strategies."""
return ["Market expansion", "Authority building", "Advanced technical SEO"]
def _extract_risk_mitigation(self, analysis: str) -> List[str]:
"""Extract risk mitigation strategies."""
return ["Fix technical vulnerabilities", "Address content gaps", "Improve performance"]
def execute_content_strategy_workflow(self, business_info: Dict[str, Any]) -> Dict[str, Any]:
"""
Execute comprehensive content strategy workflow using AI insights.
Args:
business_info: Business context and objectives
Returns:
Complete content strategy with implementation plan
"""
try:
st.info("🧠 Executing AI-powered content strategy workflow...")
# Generate AI content strategy
content_strategy = self.content_strategy_generator.generate_content_strategy(business_info)
# If GSC data is available, enhance with search insights
if business_info.get('gsc_site_url'):
gsc_insights = self.gsc_analyzer.analyze_search_performance(
business_info['gsc_site_url'],
business_info.get('gsc_date_range', 90)
)
content_strategy['gsc_insights'] = gsc_insights
# Generate SEO-optimized content recommendations
seo_content_recs = self._generate_seo_content_recommendations(content_strategy)
content_strategy['seo_recommendations'] = seo_content_recs
return content_strategy
except Exception as e:
logger.error(f"Content strategy workflow error: {str(e)}")
return {'error': str(e)}
def execute_search_intelligence_workflow(self, site_url: str, date_range: int = 90) -> Dict[str, Any]:
"""
Execute comprehensive search intelligence workflow using GSC data.
Args:
site_url: Website URL registered in GSC
date_range: Analysis period in days
Returns:
Complete search intelligence analysis with actionable insights
"""
try:
st.info("📊 Executing search intelligence workflow...")
# Analyze GSC performance
gsc_analysis = self.gsc_analyzer.analyze_search_performance(site_url, date_range)
# Enhance with technical SEO analysis
technical_analysis = self.technical_crawler.crawl_and_analyze(site_url)
gsc_analysis['technical_insights'] = technical_analysis
# Generate content gap analysis based on GSC keywords
if gsc_analysis.get('keyword_analysis'):
keywords = [kw['keyword'] for kw in gsc_analysis['keyword_analysis'].get('high_volume_keywords', [])]
content_gaps = self.gap_analyzer.analyze_content_gaps(
keywords[:10], # Top 10 keywords
site_url
)
gsc_analysis['content_gap_analysis'] = content_gaps
# Generate comprehensive recommendations
search_recommendations = self._generate_search_intelligence_recommendations(gsc_analysis)
gsc_analysis['comprehensive_recommendations'] = search_recommendations
return gsc_analysis
except Exception as e:
logger.error(f"Search intelligence workflow error: {str(e)}")
return {'error': str(e)}
def _generate_seo_content_recommendations(self, content_strategy: Dict[str, Any]) -> Dict[str, Any]:
"""Generate SEO-optimized content recommendations based on strategy."""
try:
content_pillars = content_strategy.get('content_pillars', [])
seo_recommendations = {
'keyword_optimization': [],
'content_structure': [],
'internal_linking': [],
'technical_seo': []
}
for pillar in content_pillars:
# Keyword optimization recommendations
for keyword in pillar.get('target_keywords', []):
seo_recommendations['keyword_optimization'].append({
'pillar': pillar['name'],
'keyword': keyword,
'recommendation': f"Create comprehensive content targeting '{keyword}' with semantic variations",
'priority': 'High' if keyword in pillar['target_keywords'][:2] else 'Medium'
})
# Content structure recommendations
seo_recommendations['content_structure'].append({
'pillar': pillar['name'],
'recommendation': f"Create pillar page for {pillar['name']} with supporting cluster content",
'structure': 'Pillar + Cluster model'
})
# Internal linking strategy
seo_recommendations['internal_linking'] = [
"Link all cluster content to relevant pillar pages",
"Create topic-based internal linking structure",
"Use contextual anchor text with target keywords",
"Implement breadcrumb navigation for topic clusters"
]
# Technical SEO recommendations
seo_recommendations['technical_seo'] = [
"Optimize page speed for all content pages",
"Implement structured data for articles",
"Create XML sitemap sections for content categories",
"Optimize images with descriptive alt text"
]
return seo_recommendations
except Exception as e:
logger.error(f"SEO content recommendations error: {str(e)}")
return {'error': str(e)}
def _generate_search_intelligence_recommendations(self, gsc_analysis: Dict[str, Any]) -> Dict[str, Any]:
"""Generate comprehensive recommendations from search intelligence analysis."""
try:
recommendations = {
'immediate_actions': [],
'content_opportunities': [],
'technical_improvements': [],
'strategic_initiatives': []
}
# Extract content opportunities from GSC analysis
content_opps = gsc_analysis.get('content_opportunities', [])
for opp in content_opps[:5]: # Top 5 opportunities
recommendations['content_opportunities'].append({
'type': opp['type'],
'keyword': opp['keyword'],
'action': opp['opportunity'],
'priority': opp['priority'],
'estimated_impact': opp['potential_impact']
})
# Technical improvements from analysis
technical_insights = gsc_analysis.get('technical_insights', {})
if technical_insights.get('crawl_issues_indicators'):
for issue in technical_insights['crawl_issues_indicators']:
recommendations['technical_improvements'].append({
'issue': issue,
'priority': 'High',
'category': 'Crawl & Indexing'
})
# Immediate actions based on performance
performance = gsc_analysis.get('performance_overview', {})
if performance.get('avg_ctr', 0) < 2:
recommendations['immediate_actions'].append({
'action': 'Improve meta descriptions and titles for better CTR',
'expected_impact': 'Increase CTR by 1-2%',
'timeline': '2-4 weeks'
})
if performance.get('avg_position', 0) > 10:
recommendations['immediate_actions'].append({
'action': 'Focus on improving content quality for top keywords',
'expected_impact': 'Improve average position by 2-5 ranks',
'timeline': '4-8 weeks'
})
# Strategic initiatives
competitive_analysis = gsc_analysis.get('competitive_analysis', {})
if competitive_analysis.get('market_position') in ['Challenger', 'Emerging Player']:
recommendations['strategic_initiatives'].append({
'initiative': 'Develop thought leadership content strategy',
'goal': 'Improve market position and brand authority',
'timeline': '3-6 months'
})
return recommendations
except Exception as e:
logger.error(f"Search intelligence recommendations error: {str(e)}")
return {'error': str(e)}
def render_enterprise_seo_suite():
"""Render the Enterprise SEO Command Center interface."""
st.set_page_config(
page_title="Enterprise SEO Command Center",
page_icon="🚀",
layout="wide"
)
st.title("🚀 Enterprise SEO Command Center")
st.markdown("**Unified AI-powered SEO suite orchestrating all tools into intelligent workflows**")
# Initialize suite
if 'enterprise_seo_suite' not in st.session_state:
st.session_state.enterprise_seo_suite = EnterpriseSEOSuite()
suite = st.session_state.enterprise_seo_suite
# Workflow selection
st.sidebar.header("🎯 SEO Workflow Selection")
selected_workflow = st.sidebar.selectbox(
"Choose Workflow",
list(suite.workflow_templates.keys()),
format_func=lambda x: suite.workflow_templates[x]
)
# Main workflow interface
if selected_workflow == 'complete_audit':
st.header("🔍 Complete Enterprise SEO Audit")
render_complete_audit_interface(suite)
elif selected_workflow == 'content_strategy':
st.header("📊 Content Strategy Development")
render_content_strategy_interface(suite)
elif selected_workflow == 'technical_optimization':
st.header("🔧 Technical SEO Optimization")
render_technical_optimization_interface(suite)
else:
st.info(f"Workflow '{suite.workflow_templates[selected_workflow]}' is being developed.")
def render_complete_audit_interface(suite: EnterpriseSEOSuite):
"""Render the complete audit workflow interface."""
# Input form
with st.form("enterprise_audit_form"):
col1, col2 = st.columns(2)
with col1:
website_url = st.text_input(
"Website URL",
value="https://example.com",
help="Enter your website URL for comprehensive analysis"
)
target_keywords = st.text_area(
"Target Keywords (one per line)",
value="AI content creation\nSEO tools\ncontent optimization",
help="Enter your primary keywords to optimize for"
)
with col2:
competitors = st.text_area(
"Competitor URLs (one per line)",
value="https://jasper.ai\nhttps://copy.ai\nhttps://writesonic.com",
help="Enter up to 5 competitor URLs for analysis"
)
submit_audit = st.form_submit_button("🚀 Start Complete SEO Audit", type="primary")
# Process audit
if submit_audit:
if website_url and target_keywords:
# Parse inputs
keywords_list = [k.strip() for k in target_keywords.split('\n') if k.strip()]
competitors_list = [c.strip() for c in competitors.split('\n') if c.strip()]
# Run audit
with st.spinner("🔍 Running comprehensive SEO audit..."):
audit_results = asyncio.run(
suite.execute_complete_seo_audit(
website_url, competitors_list, keywords_list
)
)
if 'error' not in audit_results:
st.success("✅ Enterprise SEO audit completed!")
# Display results dashboard
render_audit_results_dashboard(audit_results)
else:
st.error(f"❌ Audit failed: {audit_results['error']}")
else:
st.warning("⚠️ Please enter website URL and target keywords.")
def render_audit_results_dashboard(results: Dict[str, Any]):
"""Render comprehensive audit results dashboard."""
# Priority Action Plan (Most Important)
st.header("📋 Priority Action Plan")
action_plan = results.get('priority_action_plan', [])
if action_plan:
# Display as interactive table
df_actions = pd.DataFrame(action_plan)
# Style the dataframe
st.dataframe(
df_actions,
column_config={
"category": "Category",
"priority": st.column_config.SelectboxColumn(
"Priority",
options=["Critical", "High", "Medium", "Low"]
),
"effort": "Effort Level",
"timeframe": "Timeline",
"action": "Action Required",
"expected_impact": "Expected Impact"
},
hide_index=True,
use_container_width=True
)
# Key Metrics Overview
st.header("📊 SEO Health Dashboard")
col1, col2, col3, col4 = st.columns(4)
with col1:
technical_score = results.get('technical_audit', {}).get('performance_score', 0)
st.metric("Technical SEO", f"{technical_score}/100", delta=None)
with col2:
onpage_score = results.get('on_page_analysis', {}).get('optimization_score', 0)
st.metric("On-Page SEO", f"{onpage_score}/100", delta=None)
with col3:
performance_score = results.get('performance_metrics', {}).get('performance_score', 0)
st.metric("Performance", f"{performance_score}/100", delta=None)
with col4:
content_gaps = len(results.get('content_analysis', {}).get('content_opportunities', []))
st.metric("Content Opportunities", content_gaps, delta=None)
# Detailed Analysis Sections
tab1, tab2, tab3, tab4, tab5 = st.tabs([
"🤖 Strategic Insights",
"🔧 Technical Analysis",
"📊 Content Intelligence",
"🔍 On-Page Analysis",
"⚡ Performance Metrics"
])
with tab1:
strategic_recs = results.get('strategic_recommendations', {})
if strategic_recs:
st.subheader("AI-Powered Strategic Recommendations")
# Immediate wins
immediate_wins = strategic_recs.get('immediate_wins', [])
if immediate_wins:
st.markdown("#### 🚀 Immediate Wins (0-30 days)")
for win in immediate_wins[:5]:
st.success(f"✅ {win}")
# Strategic initiatives
strategic_initiatives = strategic_recs.get('strategic_initiatives', [])
if strategic_initiatives:
st.markdown("#### 📈 Strategic Initiatives (1-3 months)")
for initiative in strategic_initiatives[:3]:
st.info(f"📋 {initiative}")
# Full analysis
full_analysis = strategic_recs.get('full_analysis', '')
if full_analysis:
with st.expander("🧠 Complete Strategic Analysis"):
st.write(full_analysis)
with tab2:
technical_audit = results.get('technical_audit', {})
if technical_audit:
st.subheader("Technical SEO Analysis")
critical_issues = technical_audit.get('critical_issues', [])
if critical_issues:
st.markdown("#### ⚠️ Critical Issues")
for issue in critical_issues:
st.error(f"🚨 {issue}")
priority_fixes = technical_audit.get('priority_fixes', [])
if priority_fixes:
st.markdown("#### 🔧 Priority Fixes")
for fix in priority_fixes:
st.warning(f"🛠️ {fix}")
with tab3:
content_analysis = results.get('content_analysis', {})
if content_analysis:
st.subheader("Content Intelligence")
content_opportunities = content_analysis.get('content_opportunities', [])
if content_opportunities:
st.markdown("#### 📝 Content Opportunities")
for opportunity in content_opportunities[:5]:
st.info(f"💡 {opportunity}")
competitive_advantages = content_analysis.get('competitive_advantages', [])
if competitive_advantages:
st.markdown("#### 🏆 Competitive Advantages")
for advantage in competitive_advantages:
st.success(f"⭐ {advantage}")
with tab4:
onpage_analysis = results.get('on_page_analysis', {})
if onpage_analysis:
st.subheader("On-Page SEO Analysis")
meta_optimization = onpage_analysis.get('meta_optimization', {})
content_optimization = onpage_analysis.get('content_optimization', {})
col1, col2 = st.columns(2)
with col1:
st.markdown("#### 🏷️ Meta Tag Optimization")
st.json(meta_optimization)
with col2:
st.markdown("#### 📄 Content Optimization")
st.json(content_optimization)
with tab5:
performance_metrics = results.get('performance_metrics', {})
if performance_metrics:
st.subheader("Performance Analysis")
core_vitals = performance_metrics.get('core_web_vitals', {})
loading_performance = performance_metrics.get('loading_performance', {})
col1, col2 = st.columns(2)
with col1:
st.markdown("#### ⚡ Core Web Vitals")
st.json(core_vitals)
with col2:
st.markdown("#### 🚀 Loading Performance")
st.json(loading_performance)
# Export functionality
st.markdown("---")
col1, col2, col3 = st.columns(3)
with col1:
if st.button("📥 Export Full Report", use_container_width=True):
# Create downloadable report
report_json = json.dumps(results, indent=2, default=str)
st.download_button(
label="Download JSON Report",
data=report_json,
file_name=f"seo_audit_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
mime="application/json"
)
with col2:
if st.button("📊 Export Action Plan", use_container_width=True):
# Create CSV of action plan
df_actions = pd.DataFrame(action_plan)
csv = df_actions.to_csv(index=False)
st.download_button(
label="Download CSV Action Plan",
data=csv,
file_name=f"action_plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv"
)
with col3:
if st.button("🔄 Schedule Follow-up Audit", use_container_width=True):
st.info("Follow-up scheduling feature coming soon!")
def render_content_strategy_interface(suite: EnterpriseSEOSuite):
"""Render content strategy development interface."""
st.info("🚧 Content Strategy Development workflow coming soon!")
def render_technical_optimization_interface(suite: EnterpriseSEOSuite):
"""Render technical optimization interface."""
st.info("🚧 Technical SEO Optimization workflow coming soon!")
# Main execution
if __name__ == "__main__":
render_enterprise_seo_suite()

864
lib/ai_seo_tools/google_search_console_integration.py Normal file
View File

@@ -0,0 +1,864 @@
"""
Google Search Console Integration for Enterprise SEO
Connects GSC data with AI-powered content strategy and keyword intelligence.
Provides enterprise-level search performance insights and content recommendations.
"""
import streamlit as st
import pandas as pd
import numpy as np
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime, timedelta
import json
from loguru import logger
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
# Import AI modules
from ..gpt_providers.text_generation.main_text_generation import llm_text_gen
class GoogleSearchConsoleAnalyzer:
"""
Enterprise Google Search Console analyzer with AI-powered insights.
"""
def __init__(self):
"""Initialize the GSC analyzer."""
self.gsc_client = None # Will be initialized when credentials are provided
logger.info("Google Search Console Analyzer initialized")
def analyze_search_performance(self, site_url: str, date_range: int = 90) -> Dict[str, Any]:
"""
Analyze comprehensive search performance from GSC data.
Args:
site_url: Website URL registered in GSC
date_range: Number of days to analyze (default 90)
Returns:
Comprehensive search performance analysis
"""
try:
st.info("📊 Analyzing Google Search Console data...")
# Simulate GSC data for demonstration (replace with actual GSC API calls)
search_data = self._get_mock_gsc_data(site_url, date_range)
# Perform comprehensive analysis
analysis_results = {
'site_url': site_url,
'analysis_period': f"Last {date_range} days",
'analysis_timestamp': datetime.utcnow().isoformat(),
'performance_overview': self._analyze_performance_overview(search_data),
'keyword_analysis': self._analyze_keyword_performance(search_data),
'page_analysis': self._analyze_page_performance(search_data),
'content_opportunities': self._identify_content_opportunities(search_data),
'technical_insights': self._analyze_technical_seo_signals(search_data),
'competitive_analysis': self._analyze_competitive_position(search_data),
'ai_recommendations': self._generate_ai_recommendations(search_data)
}
return analysis_results
except Exception as e:
error_msg = f"Error analyzing search performance: {str(e)}"
logger.error(error_msg, exc_info=True)
return {'error': error_msg}
def _get_mock_gsc_data(self, site_url: str, days: int) -> Dict[str, pd.DataFrame]:
"""
Generate mock GSC data for demonstration.
In production, this would fetch real data from GSC API.
"""
# Generate mock keyword data
keywords_data = []
sample_keywords = [
"AI content creation", "SEO tools", "content optimization", "blog writing AI",
"meta description generator", "keyword research", "technical SEO", "content strategy",
"on-page optimization", "SERP analysis", "content gap analysis", "SEO audit"
]
for keyword in sample_keywords:
# Generate realistic performance data
impressions = np.random.randint(100, 10000)
clicks = int(impressions * np.random.uniform(0.02, 0.15)) # CTR between 2-15%
position = np.random.uniform(3, 25)
keywords_data.append({
'keyword': keyword,
'impressions': impressions,
'clicks': clicks,
'ctr': (clicks / impressions) * 100,
'position': position
})
# Generate mock page data
pages_data = []
sample_pages = [
"/blog/ai-content-creation-guide", "/tools/seo-analyzer", "/features/content-optimization",
"/blog/technical-seo-checklist", "/tools/keyword-research", "/blog/content-strategy-2024",
"/tools/meta-description-generator", "/blog/on-page-seo-guide", "/features/enterprise-seo"
]
for page in sample_pages:
impressions = np.random.randint(500, 5000)
clicks = int(impressions * np.random.uniform(0.03, 0.12))
position = np.random.uniform(5, 20)
pages_data.append({
'page': page,
'impressions': impressions,
'clicks': clicks,
'ctr': (clicks / impressions) * 100,
'position': position
})
# Generate time series data
time_series_data = []
for i in range(days):
date = datetime.now() - timedelta(days=i)
daily_clicks = np.random.randint(50, 500)
daily_impressions = np.random.randint(1000, 8000)
time_series_data.append({
'date': date.strftime('%Y-%m-%d'),
'clicks': daily_clicks,
'impressions': daily_impressions,
'ctr': (daily_clicks / daily_impressions) * 100,
'position': np.random.uniform(8, 15)
})
return {
'keywords': pd.DataFrame(keywords_data),
'pages': pd.DataFrame(pages_data),
'time_series': pd.DataFrame(time_series_data)
}
def _analyze_performance_overview(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Analyze overall search performance metrics."""
keywords_df = search_data['keywords']
time_series_df = search_data['time_series']
# Calculate totals and averages
total_clicks = keywords_df['clicks'].sum()
total_impressions = keywords_df['impressions'].sum()
avg_ctr = (total_clicks / total_impressions) * 100 if total_impressions > 0 else 0
avg_position = keywords_df['position'].mean()
# Calculate trends
recent_clicks = time_series_df.head(7)['clicks'].mean()
previous_clicks = time_series_df.tail(7)['clicks'].mean()
clicks_trend = ((recent_clicks - previous_clicks) / previous_clicks * 100) if previous_clicks > 0 else 0
recent_impressions = time_series_df.head(7)['impressions'].mean()
previous_impressions = time_series_df.tail(7)['impressions'].mean()
impressions_trend = ((recent_impressions - previous_impressions) / previous_impressions * 100) if previous_impressions > 0 else 0
# Top performing keywords
top_keywords = keywords_df.nlargest(5, 'clicks')[['keyword', 'clicks', 'impressions', 'position']].to_dict('records')
# Opportunity keywords (high impressions, low CTR)
opportunity_keywords = keywords_df[
(keywords_df['impressions'] > keywords_df['impressions'].median()) &
(keywords_df['ctr'] < 3)
].nlargest(5, 'impressions')[['keyword', 'impressions', 'ctr', 'position']].to_dict('records')
return {
'total_clicks': int(total_clicks),
'total_impressions': int(total_impressions),
'avg_ctr': round(avg_ctr, 2),
'avg_position': round(avg_position, 1),
'clicks_trend': round(clicks_trend, 1),
'impressions_trend': round(impressions_trend, 1),
'top_keywords': top_keywords,
'opportunity_keywords': opportunity_keywords
}
def _analyze_keyword_performance(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Analyze keyword performance and opportunities."""
keywords_df = search_data['keywords']
# Keyword categorization
high_volume_keywords = keywords_df[keywords_df['impressions'] > keywords_df['impressions'].quantile(0.8)]
low_competition_keywords = keywords_df[keywords_df['position'] <= 10]
optimization_opportunities = keywords_df[
(keywords_df['position'] > 10) &
(keywords_df['position'] <= 20) &
(keywords_df['impressions'] > 100)
]
# Content gap analysis
missing_keywords = self._identify_missing_keywords(keywords_df)
# Seasonal trends analysis
seasonal_insights = self._analyze_seasonal_trends(keywords_df)
return {
'total_keywords': len(keywords_df),
'high_volume_keywords': high_volume_keywords.to_dict('records'),
'ranking_keywords': low_competition_keywords.to_dict('records'),
'optimization_opportunities': optimization_opportunities.to_dict('records'),
'missing_keywords': missing_keywords,
'seasonal_insights': seasonal_insights,
'keyword_distribution': {
'positions_1_3': len(keywords_df[keywords_df['position'] <= 3]),
'positions_4_10': len(keywords_df[(keywords_df['position'] > 3) & (keywords_df['position'] <= 10)]),
'positions_11_20': len(keywords_df[(keywords_df['position'] > 10) & (keywords_df['position'] <= 20)]),
'positions_21_plus': len(keywords_df[keywords_df['position'] > 20])
}
}
def _analyze_page_performance(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Analyze page-level performance."""
pages_df = search_data['pages']
# Top performing pages
top_pages = pages_df.nlargest(10, 'clicks')
# Underperforming pages (high impressions, low clicks)
underperforming_pages = pages_df[
(pages_df['impressions'] > pages_df['impressions'].median()) &
(pages_df['ctr'] < 2)
].nlargest(5, 'impressions')
# Page type analysis
page_types = self._categorize_pages(pages_df)
return {
'top_pages': top_pages.to_dict('records'),
'underperforming_pages': underperforming_pages.to_dict('records'),
'page_types_performance': page_types,
'total_pages': len(pages_df)
}
def _identify_content_opportunities(self, search_data: Dict[str, pd.DataFrame]) -> List[Dict[str, Any]]:
"""Identify content creation and optimization opportunities."""
keywords_df = search_data['keywords']
opportunities = []
# High impression, low CTR keywords need content optimization
low_ctr_keywords = keywords_df[
(keywords_df['impressions'] > 500) &
(keywords_df['ctr'] < 3)
]
for _, keyword_row in low_ctr_keywords.iterrows():
opportunities.append({
'type': 'Content Optimization',
'keyword': keyword_row['keyword'],
'opportunity': f"Optimize existing content for '{keyword_row['keyword']}' to improve CTR from {keyword_row['ctr']:.1f}%",
'potential_impact': 'High',
'current_position': round(keyword_row['position'], 1),
'impressions': int(keyword_row['impressions']),
'priority': 'High' if keyword_row['impressions'] > 1000 else 'Medium'
})
# Position 11-20 keywords need content improvement
position_11_20 = keywords_df[
(keywords_df['position'] > 10) &
(keywords_df['position'] <= 20) &
(keywords_df['impressions'] > 100)
]
for _, keyword_row in position_11_20.iterrows():
opportunities.append({
'type': 'Content Enhancement',
'keyword': keyword_row['keyword'],
'opportunity': f"Enhance content for '{keyword_row['keyword']}' to move from position {keyword_row['position']:.1f} to first page",
'potential_impact': 'Medium',
'current_position': round(keyword_row['position'], 1),
'impressions': int(keyword_row['impressions']),
'priority': 'Medium'
})
# Sort by potential impact and impressions
opportunities = sorted(opportunities, key=lambda x: x['impressions'], reverse=True)
return opportunities[:10] # Top 10 opportunities
def _analyze_technical_seo_signals(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Analyze technical SEO signals from search data."""
keywords_df = search_data['keywords']
pages_df = search_data['pages']
# Analyze performance patterns that might indicate technical issues
technical_insights = {
'crawl_issues_indicators': [],
'mobile_performance': {},
'core_web_vitals_impact': {},
'indexing_insights': {}
}
# Identify potential crawl issues
very_low_impressions = keywords_df[keywords_df['impressions'] < 10]
if len(very_low_impressions) > len(keywords_df) * 0.3: # If 30%+ have very low impressions
technical_insights['crawl_issues_indicators'].append(
"High percentage of keywords with very low impressions may indicate crawl or indexing issues"
)
# Mobile performance indicators
avg_mobile_position = keywords_df['position'].mean() # In real implementation, this would be mobile-specific
technical_insights['mobile_performance'] = {
'avg_mobile_position': round(avg_mobile_position, 1),
'mobile_optimization_needed': avg_mobile_position > 15
}
return technical_insights
def _analyze_competitive_position(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Analyze competitive positioning based on search data."""
keywords_df = search_data['keywords']
# Calculate competitive metrics
dominant_keywords = len(keywords_df[keywords_df['position'] <= 3])
competitive_keywords = len(keywords_df[(keywords_df['position'] > 3) & (keywords_df['position'] <= 10)])
losing_keywords = len(keywords_df[keywords_df['position'] > 10])
competitive_strength = (dominant_keywords * 3 + competitive_keywords * 2 + losing_keywords * 1) / len(keywords_df)
return {
'dominant_keywords': dominant_keywords,
'competitive_keywords': competitive_keywords,
'losing_keywords': losing_keywords,
'competitive_strength_score': round(competitive_strength, 2),
'market_position': self._determine_market_position(competitive_strength)
}
def _generate_ai_recommendations(self, search_data: Dict[str, pd.DataFrame]) -> Dict[str, Any]:
"""Generate AI-powered recommendations based on search data."""
try:
keywords_df = search_data['keywords']
pages_df = search_data['pages']
# Prepare data summary for AI analysis
top_keywords = keywords_df.nlargest(5, 'impressions')['keyword'].tolist()
avg_position = keywords_df['position'].mean()
total_impressions = keywords_df['impressions'].sum()
total_clicks = keywords_df['clicks'].sum()
avg_ctr = (total_clicks / total_impressions * 100) if total_impressions > 0 else 0
# Create comprehensive prompt for AI analysis
ai_prompt = f"""
Analyze this Google Search Console data and provide strategic SEO recommendations:
SEARCH PERFORMANCE SUMMARY:
- Total Keywords Tracked: {len(keywords_df)}
- Total Impressions: {total_impressions:,}
- Total Clicks: {total_clicks:,}
- Average CTR: {avg_ctr:.2f}%
- Average Position: {avg_position:.1f}
TOP PERFORMING KEYWORDS:
{', '.join(top_keywords)}
PERFORMANCE DISTRIBUTION:
- Keywords ranking 1-3: {len(keywords_df[keywords_df['position'] <= 3])}
- Keywords ranking 4-10: {len(keywords_df[(keywords_df['position'] > 3) & (keywords_df['position'] <= 10)])}
- Keywords ranking 11-20: {len(keywords_df[(keywords_df['position'] > 10) & (keywords_df['position'] <= 20)])}
- Keywords ranking 21+: {len(keywords_df[keywords_df['position'] > 20])}
TOP PAGES BY TRAFFIC:
{pages_df.nlargest(3, 'clicks')['page'].tolist()}
Based on this data, provide:
1. IMMEDIATE OPTIMIZATION OPPORTUNITIES (0-30 days):
- Specific keywords to optimize for better CTR
- Pages that need content updates
- Quick technical wins
2. CONTENT STRATEGY RECOMMENDATIONS (1-3 months):
- New content topics based on keyword gaps
- Content enhancement priorities
- Internal linking opportunities
3. LONG-TERM SEO STRATEGY (3-12 months):
- Market expansion opportunities
- Authority building topics
- Competitive positioning strategies
4. TECHNICAL SEO PRIORITIES:
- Performance issues affecting rankings
- Mobile optimization needs
- Core Web Vitals improvements
Provide specific, actionable recommendations with expected impact and priority levels.
"""
ai_analysis = llm_text_gen(
ai_prompt,
system_prompt="You are an enterprise SEO strategist analyzing Google Search Console data. Provide specific, data-driven recommendations that will improve search performance."
)
return {
'full_analysis': ai_analysis,
'immediate_opportunities': self._extract_immediate_opportunities(ai_analysis),
'content_strategy': self._extract_content_strategy(ai_analysis),
'long_term_strategy': self._extract_long_term_strategy(ai_analysis),
'technical_priorities': self._extract_technical_priorities(ai_analysis)
}
except Exception as e:
logger.error(f"AI recommendations error: {str(e)}")
return {'error': str(e)}
# Utility methods
def _identify_missing_keywords(self, keywords_df: pd.DataFrame) -> List[str]:
"""Identify potential missing keywords based on current keyword performance."""
# In a real implementation, this would use keyword research APIs
existing_keywords = set(keywords_df['keyword'].str.lower())
potential_keywords = [
"AI writing tools", "content automation", "SEO content generator",
"blog post optimizer", "meta tag generator", "keyword analyzer"
]
missing = [kw for kw in potential_keywords if kw.lower() not in existing_keywords]
return missing[:5]
def _analyze_seasonal_trends(self, keywords_df: pd.DataFrame) -> Dict[str, Any]:
"""Analyze seasonal trends in keyword performance."""
# Placeholder for seasonal analysis
return {
'seasonal_keywords': [],
'trend_analysis': "Seasonal analysis requires historical data spanning multiple seasons"
}
def _categorize_pages(self, pages_df: pd.DataFrame) -> Dict[str, Any]:
"""Categorize pages by type and analyze performance."""
page_types = {
'Blog Posts': {'count': 0, 'total_clicks': 0, 'avg_position': 0},
'Product Pages': {'count': 0, 'total_clicks': 0, 'avg_position': 0},
'Tool Pages': {'count': 0, 'total_clicks': 0, 'avg_position': 0},
'Other': {'count': 0, 'total_clicks': 0, 'avg_position': 0}
}
for _, page_row in pages_df.iterrows():
page_url = page_row['page']
clicks = page_row['clicks']
position = page_row['position']
if '/blog/' in page_url:
page_types['Blog Posts']['count'] += 1
page_types['Blog Posts']['total_clicks'] += clicks
page_types['Blog Posts']['avg_position'] += position
elif '/tools/' in page_url:
page_types['Tool Pages']['count'] += 1
page_types['Tool Pages']['total_clicks'] += clicks
page_types['Tool Pages']['avg_position'] += position
elif '/features/' in page_url or '/product/' in page_url:
page_types['Product Pages']['count'] += 1
page_types['Product Pages']['total_clicks'] += clicks
page_types['Product Pages']['avg_position'] += position
else:
page_types['Other']['count'] += 1
page_types['Other']['total_clicks'] += clicks
page_types['Other']['avg_position'] += position
# Calculate averages
for page_type in page_types:
if page_types[page_type]['count'] > 0:
page_types[page_type]['avg_position'] = round(
page_types[page_type]['avg_position'] / page_types[page_type]['count'], 1
)
return page_types
def _determine_market_position(self, competitive_strength: float) -> str:
"""Determine market position based on competitive strength score."""
if competitive_strength >= 2.5:
return "Market Leader"
elif competitive_strength >= 2.0:
return "Strong Competitor"
elif competitive_strength >= 1.5:
return "Emerging Player"
else:
return "Challenger"
def _extract_immediate_opportunities(self, analysis: str) -> List[str]:
"""Extract immediate opportunities from AI analysis."""
lines = analysis.split('\n')
opportunities = []
in_immediate_section = False
for line in lines:
if 'IMMEDIATE OPTIMIZATION' in line.upper():
in_immediate_section = True
continue
elif 'CONTENT STRATEGY' in line.upper():
in_immediate_section = False
continue
if in_immediate_section and line.strip().startswith('-'):
opportunities.append(line.strip().lstrip('- '))
return opportunities[:5]
def _extract_content_strategy(self, analysis: str) -> List[str]:
"""Extract content strategy recommendations from AI analysis."""
return ["Develop topic clusters", "Create comparison content", "Build FAQ sections"]
def _extract_long_term_strategy(self, analysis: str) -> List[str]:
"""Extract long-term strategy from AI analysis."""
return ["Build domain authority", "Expand to new markets", "Develop thought leadership content"]
def _extract_technical_priorities(self, analysis: str) -> List[str]:
"""Extract technical priorities from AI analysis."""
return ["Improve page speed", "Optimize mobile experience", "Fix crawl errors"]
def render_gsc_integration():
"""Render the Google Search Console integration interface."""
st.title("📊 Google Search Console Intelligence")
st.markdown("**AI-powered insights from your Google Search Console data**")
# Initialize analyzer
if 'gsc_analyzer' not in st.session_state:
st.session_state.gsc_analyzer = GoogleSearchConsoleAnalyzer()
analyzer = st.session_state.gsc_analyzer
# Configuration section
st.header("🔧 Configuration")
with st.expander("📋 Setup Instructions", expanded=False):
st.markdown("""
### Setting up Google Search Console Integration
1. **Verify your website** in Google Search Console
2. **Enable the Search Console API** in Google Cloud Console
3. **Create service account credentials** and download the JSON file
4. **Upload credentials** using the file uploader below
📚 [Detailed Setup Guide](https://developers.google.com/webmaster-tools/search-console-api-original/v3/prereqs)
""")
# Input form
with st.form("gsc_analysis_form"):
col1, col2 = st.columns(2)
with col1:
site_url = st.text_input(
"Site URL",
value="https://example.com",
help="Enter your website URL as registered in Google Search Console"
)
date_range = st.selectbox(
"Analysis Period",
[30, 60, 90, 180],
index=2,
help="Number of days to analyze"
)
with col2:
# Credentials upload (placeholder)
credentials_file = st.file_uploader(
"GSC API Credentials (JSON)",
type=['json'],
help="Upload your Google Search Console API credentials file"
)
demo_mode = st.checkbox(
"Demo Mode",
value=True,
help="Use demo data for testing (no credentials needed)"
)
submit_analysis = st.form_submit_button("📊 Analyze Search Performance", type="primary")
# Process analysis
if submit_analysis:
if site_url and (demo_mode or credentials_file):
with st.spinner("📊 Analyzing Google Search Console data..."):
analysis_results = analyzer.analyze_search_performance(site_url, date_range)
if 'error' not in analysis_results:
st.success("✅ Search Console analysis completed!")
# Store results in session state
st.session_state.gsc_results = analysis_results
# Display results
render_gsc_results_dashboard(analysis_results)
else:
st.error(f"❌ Analysis failed: {analysis_results['error']}")
else:
st.warning("⚠️ Please enter site URL and upload credentials (or enable demo mode).")
# Show previous results if available
elif 'gsc_results' in st.session_state:
st.info("📊 Showing previous analysis results")
render_gsc_results_dashboard(st.session_state.gsc_results)
def render_gsc_results_dashboard(results: Dict[str, Any]):
"""Render comprehensive GSC analysis results."""
# Performance overview
st.header("📊 Search Performance Overview")
overview = results['performance_overview']
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric(
"Total Clicks",
f"{overview['total_clicks']:,}",
delta=f"{overview['clicks_trend']:+.1f}%" if overview['clicks_trend'] != 0 else None
)
with col2:
st.metric(
"Total Impressions",
f"{overview['total_impressions']:,}",
delta=f"{overview['impressions_trend']:+.1f}%" if overview['impressions_trend'] != 0 else None
)
with col3:
st.metric(
"Average CTR",
f"{overview['avg_ctr']:.2f}%"
)
with col4:
st.metric(
"Average Position",
f"{overview['avg_position']:.1f}"
)
# Content opportunities (Most important section)
st.header("🎯 Content Opportunities")
opportunities = results['content_opportunities']
if opportunities:
# Display as interactive table
df_opportunities = pd.DataFrame(opportunities)
st.dataframe(
df_opportunities,
column_config={
"type": "Opportunity Type",
"keyword": "Keyword",
"opportunity": "Description",
"potential_impact": st.column_config.SelectboxColumn(
"Impact",
options=["High", "Medium", "Low"]
),
"current_position": st.column_config.NumberColumn(
"Current Position",
format="%.1f"
),
"impressions": st.column_config.NumberColumn(
"Impressions",
format="%d"
),
"priority": st.column_config.SelectboxColumn(
"Priority",
options=["High", "Medium", "Low"]
)
},
hide_index=True,
use_container_width=True
)
# Detailed analysis tabs
tab1, tab2, tab3, tab4, tab5 = st.tabs([
"🤖 AI Insights",
"🎯 Keyword Analysis",
"📄 Page Performance",
"🏆 Competitive Position",
"🔧 Technical Signals"
])
with tab1:
ai_recs = results.get('ai_recommendations', {})
if ai_recs and 'error' not in ai_recs:
st.subheader("AI-Powered Recommendations")
# Immediate opportunities
immediate_ops = ai_recs.get('immediate_opportunities', [])
if immediate_ops:
st.markdown("#### 🚀 Immediate Optimizations (0-30 days)")
for op in immediate_ops:
st.success(f"✅ {op}")
# Content strategy
content_strategy = ai_recs.get('content_strategy', [])
if content_strategy:
st.markdown("#### 📝 Content Strategy (1-3 months)")
for strategy in content_strategy:
st.info(f"📋 {strategy}")
# Full analysis
full_analysis = ai_recs.get('full_analysis', '')
if full_analysis:
with st.expander("🧠 Complete AI Analysis"):
st.write(full_analysis)
with tab2:
keyword_analysis = results.get('keyword_analysis', {})
if keyword_analysis:
st.subheader("Keyword Performance Analysis")
# Keyword distribution chart
dist = keyword_analysis['keyword_distribution']
fig = px.pie(
values=[dist['positions_1_3'], dist['positions_4_10'], dist['positions_11_20'], dist['positions_21_plus']],
names=['Positions 1-3', 'Positions 4-10', 'Positions 11-20', 'Positions 21+'],
title="Keyword Position Distribution"
)
st.plotly_chart(fig, use_container_width=True)
# High volume keywords
high_volume = keyword_analysis.get('high_volume_keywords', [])
if high_volume:
st.markdown("#### 📈 High Volume Keywords")
st.dataframe(pd.DataFrame(high_volume), hide_index=True)
# Optimization opportunities
opt_opportunities = keyword_analysis.get('optimization_opportunities', [])
if opt_opportunities:
st.markdown("#### 🎯 Optimization Opportunities (Positions 11-20)")
st.dataframe(pd.DataFrame(opt_opportunities), hide_index=True)
with tab3:
page_analysis = results.get('page_analysis', {})
if page_analysis:
st.subheader("Page Performance Analysis")
# Top pages
top_pages = page_analysis.get('top_pages', [])
if top_pages:
st.markdown("#### 🏆 Top Performing Pages")
st.dataframe(pd.DataFrame(top_pages), hide_index=True)
# Underperforming pages
underperforming = page_analysis.get('underperforming_pages', [])
if underperforming:
st.markdown("#### ⚠️ Underperforming Pages (High Impressions, Low CTR)")
st.dataframe(pd.DataFrame(underperforming), hide_index=True)
# Page types performance
page_types = page_analysis.get('page_types_performance', {})
if page_types:
st.markdown("#### 📊 Performance by Page Type")
# Create visualization
types = []
clicks = []
positions = []
for page_type, data in page_types.items():
if data['count'] > 0:
types.append(page_type)
clicks.append(data['total_clicks'])
positions.append(data['avg_position'])
if types:
col1, col2 = st.columns(2)
with col1:
fig_clicks = px.bar(x=types, y=clicks, title="Total Clicks by Page Type")
st.plotly_chart(fig_clicks, use_container_width=True)
with col2:
fig_position = px.bar(x=types, y=positions, title="Average Position by Page Type")
st.plotly_chart(fig_position, use_container_width=True)
with tab4:
competitive_analysis = results.get('competitive_analysis', {})
if competitive_analysis:
st.subheader("Competitive Position Analysis")
col1, col2 = st.columns(2)
with col1:
st.metric("Market Position", competitive_analysis['market_position'])
st.metric("Competitive Strength", f"{competitive_analysis['competitive_strength_score']}/3.0")
with col2:
# Competitive distribution
comp_data = {
'Dominant (1-3)': competitive_analysis['dominant_keywords'],
'Competitive (4-10)': competitive_analysis['competitive_keywords'],
'Losing (11+)': competitive_analysis['losing_keywords']
}
fig = px.bar(
x=list(comp_data.keys()),
y=list(comp_data.values()),
title="Keyword Competitive Position"
)
st.plotly_chart(fig, use_container_width=True)
with tab5:
technical_insights = results.get('technical_insights', {})
if technical_insights:
st.subheader("Technical SEO Signals")
# Crawl issues indicators
crawl_issues = technical_insights.get('crawl_issues_indicators', [])
if crawl_issues:
st.markdown("#### ⚠️ Potential Issues")
for issue in crawl_issues:
st.warning(f"🚨 {issue}")
# Mobile performance
mobile_perf = technical_insights.get('mobile_performance', {})
if mobile_perf:
st.markdown("#### 📱 Mobile Performance")
col1, col2 = st.columns(2)
with col1:
st.metric("Avg Mobile Position", f"{mobile_perf.get('avg_mobile_position', 0):.1f}")
with col2:
if mobile_perf.get('mobile_optimization_needed', False):
st.warning("📱 Mobile optimization needed")
else:
st.success("📱 Mobile performance good")
# Export functionality
st.markdown("---")
col1, col2, col3 = st.columns(3)
with col1:
if st.button("📥 Export Full Report", use_container_width=True):
report_json = json.dumps(results, indent=2, default=str)
st.download_button(
label="Download JSON Report",
data=report_json,
file_name=f"gsc_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
mime="application/json"
)
with col2:
if st.button("📊 Export Opportunities", use_container_width=True):
if opportunities:
df_opportunities = pd.DataFrame(opportunities)
csv = df_opportunities.to_csv(index=False)
st.download_button(
label="Download CSV Opportunities",
data=csv,
file_name=f"content_opportunities_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv"
)
with col3:
if st.button("🔄 Refresh Analysis", use_container_width=True):
# Clear cached results to force refresh
if 'gsc_results' in st.session_state:
del st.session_state.gsc_results
st.rerun()
# Main execution
if __name__ == "__main__":
render_gsc_integration()

808
lib/ai_web_researcher/arxiv_schlorly_research.py
View File

@@ -14,30 +14,273 @@ import pandas as pd
import arxiv
import PyPDF2
import requests
import networkx as nx
from bs4 import BeautifulSoup
from urllib.parse import urlparse
from loguru import logger
from ..gpt_providers.text_generation.main_text_generation import llm_text_gen
import bibtexparser
from pylatexenc.latex2text import LatexNodes2Text
from matplotlib import pyplot as plt
from collections import defaultdict
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.cluster import KMeans
import numpy as np
logger.remove()
logger.add(sys.stdout, colorize=True, format="<level>{level}</level>|<green>{file}:{line}:{function}</green>| {message}")
def fetch_arxiv_data(query, max_results=10):
def create_arxiv_client(page_size=100, delay_seconds=3.0, num_retries=3):
"""
Fetches arXiv data based on a query.
Creates a reusable arXiv API client with custom configuration.
Args:
query (str): The search query.
max_results (int): The maximum number of results to fetch.
page_size (int): Number of results per page (default: 100)
delay_seconds (float): Delay between API requests (default: 3.0)
num_retries (int): Number of retries for failed requests (default: 3)
Returns:
list: A list of arXiv data.
arxiv.Client: Configured arXiv API client
"""
try:
client = arxiv.Client()
search = arxiv.Search(query=query, max_results=max_results, sort_by=arxiv.SortCriterion.SubmittedDate)
client = arxiv.Client(
page_size=page_size,
delay_seconds=delay_seconds,
num_retries=num_retries
)
return client
except Exception as e:
logger.error(f"Error creating arXiv client: {e}")
raise e
def expand_search_query(query, research_interests=None):
"""
Uses AI to expand the search query based on user's research interests.
Args:
query (str): Original search query
research_interests (list): List of user's research interests
Returns:
str: Expanded search query
"""
try:
interests_context = "\n".join(research_interests) if research_interests else ""
prompt = f"""Given the original arXiv search query: '{query}'
{f'And considering these research interests:\n{interests_context}' if interests_context else ''}
Generate an expanded arXiv search query that:
1. Includes relevant synonyms and related concepts
2. Uses appropriate arXiv search operators (AND, OR, etc.)
3. Incorporates field-specific tags (ti:, abs:, au:, etc.)
4. Maintains focus on the core topic
Return only the expanded query without any explanation."""
expanded_query = llm_text_gen(prompt)
logger.info(f"Expanded query: {expanded_query}")
return expanded_query
except Exception as e:
logger.error(f"Error expanding search query: {e}")
return query
def analyze_citation_network(papers):
"""
Analyzes citation relationships between papers using DOIs and references.
Args:
papers (list): List of paper metadata dictionaries
Returns:
dict: Citation network analysis results
"""
try:
# Create a directed graph for citations
G = nx.DiGraph()
# Add nodes and edges
for paper in papers:
paper_id = paper['entry_id']
G.add_node(paper_id, title=paper['title'])
# Add edges based on DOIs and references
if paper['doi']:
for other_paper in papers:
if other_paper['doi'] and other_paper['doi'] in paper['summary']:
G.add_edge(paper_id, other_paper['entry_id'])
# Calculate network metrics
analysis = {
'influential_papers': sorted(nx.pagerank(G).items(), key=lambda x: x[1], reverse=True),
'citation_clusters': list(nx.connected_components(G.to_undirected())),
'citation_paths': dict(nx.all_pairs_shortest_path_length(G))
}
return analysis
except Exception as e:
logger.error(f"Error analyzing citation network: {e}")
return {}
def categorize_papers(papers):
"""
Uses AI to categorize papers based on their metadata and content.
Args:
papers (list): List of paper metadata dictionaries
Returns:
dict: Paper categorization results
"""
try:
categorized_papers = {}
for paper in papers:
prompt = f"""Analyze this research paper and provide detailed categorization:
Title: {paper['title']}
Abstract: {paper['summary']}
Primary Category: {paper['primary_category']}
Categories: {', '.join(paper['categories'])}
Provide a JSON response with these fields:
1. main_theme: Primary research theme
2. sub_themes: List of related sub-themes
3. methodology: Research methodology used
4. application_domains: Potential application areas
5. technical_complexity: Level (Basic/Intermediate/Advanced)"""
categorization = llm_text_gen(prompt)
categorized_papers[paper['entry_id']] = categorization
return categorized_papers
except Exception as e:
logger.error(f"Error categorizing papers: {e}")
return {}
def get_paper_recommendations(papers, research_interests):
"""
Generates personalized paper recommendations based on user's research interests.
Args:
papers (list): List of paper metadata dictionaries
research_interests (list): User's research interests
Returns:
dict: Personalized paper recommendations
"""
try:
interests_text = "\n".join(research_interests)
recommendations = {}
for paper in papers:
prompt = f"""Evaluate this paper's relevance to the user's research interests:
Paper:
- Title: {paper['title']}
- Abstract: {paper['summary']}
- Categories: {', '.join(paper['categories'])}
User's Research Interests:
{interests_text}
Provide a JSON response with:
1. relevance_score: 0-100
2. relevance_aspects: List of matching aspects
3. potential_value: How this paper could benefit the user's research"""
evaluation = llm_text_gen(prompt)
recommendations[paper['entry_id']] = evaluation
return recommendations
except Exception as e:
logger.error(f"Error generating paper recommendations: {e}")
return {}
def fetch_arxiv_data(query, max_results=10, sort_by=arxiv.SortCriterion.SubmittedDate, sort_order=None, client=None, research_interests=None):
"""
Fetches arXiv data based on a query with advanced search options.
Args:
query (str): The search query (supports advanced syntax, e.g., 'au:einstein AND cat:physics')
max_results (int): The maximum number of results to fetch
sort_by (arxiv.SortCriterion): Sorting criterion (default: SubmittedDate)
sort_order (str): Sort order ('ascending' or 'descending', default: None)
client (arxiv.Client): Optional custom client (default: None, creates new client)
Returns:
list: A list of arXiv data with extended metadata
"""
try:
if client is None:
client = create_arxiv_client()
# Expand search query using AI if research interests are provided
expanded_query = expand_search_query(query, research_interests) if research_interests else query
logger.info(f"Using expanded query: {expanded_query}")
search = arxiv.Search(
query=expanded_query,
max_results=max_results,
sort_by=sort_by,
sort_order=sort_order
)
results = list(client.results(search))
all_data = [[result.title, result.published, result.entry_id, result.summary, result.pdf_url] for result in results]
return all_data
all_data = [
{
'title': result.title,
'published': result.published,
'updated': result.updated,
'entry_id': result.entry_id,
'summary': result.summary,
'authors': [str(author) for author in result.authors],
'pdf_url': result.pdf_url,
'journal_ref': getattr(result, 'journal_ref', None),
'doi': getattr(result, 'doi', None),
'primary_category': getattr(result, 'primary_category', None),
'categories': getattr(result, 'categories', []),
'links': [link.href for link in getattr(result, 'links', [])]
}
for result in results
]
# Enhance results with AI-powered analysis
if all_data:
# Analyze citation network
citation_analysis = analyze_citation_network(all_data)
# Categorize papers using AI
paper_categories = categorize_papers(all_data)
# Generate recommendations if research interests are provided
recommendations = get_paper_recommendations(all_data, research_interests) if research_interests else {}
# Perform content analysis
content_analyses = [analyze_paper_content(paper['entry_id']) for paper in all_data]
trend_analysis = analyze_research_trends(all_data)
concept_mapping = map_cross_paper_concepts(all_data)
# Generate bibliography data
bibliography_data = {
'bibtex_entries': [generate_bibtex_entry(paper) for paper in all_data],
'citations': {
'apa': [convert_citation_format(generate_bibtex_entry(paper), 'apa') for paper in all_data],
'mla': [convert_citation_format(generate_bibtex_entry(paper), 'mla') for paper in all_data],
'chicago': [convert_citation_format(generate_bibtex_entry(paper), 'chicago') for paper in all_data]
},
'reference_graph': visualize_reference_graph(all_data),
'citation_impact': analyze_citation_impact(all_data)
}
# Add enhanced data to results
enhanced_data = {
'papers': all_data,
'citation_analysis': citation_analysis,
'paper_categories': paper_categories,
'recommendations': recommendations,
'content_analyses': content_analyses,
'trend_analysis': trend_analysis,
'concept_mapping': concept_mapping,
'bibliography': bibliography_data
}
return enhanced_data
return {'papers': all_data}
except Exception as e:
logger.error(f"An error occurred while fetching data from arXiv: {e}")
raise e
@@ -90,38 +333,401 @@ def get_arxiv_main_content(url):
logger.warning(f"HTML content not accessible, trying PDF: {html_error}")
return get_pdf_content(url)
def get_pdf_content(url):
def download_paper(paper_id, output_dir="downloads", filename=None, get_source=False):
"""
Helper function to get the content from a PDF if HTML content is not accessible.
Downloads a paper's PDF or source files with enhanced error handling.
Args:
url (str): The URL of the arXiv paper.
paper_id (str): The arXiv ID of the paper
output_dir (str): Directory to save the downloaded file (default: 'downloads')
filename (str): Custom filename (default: None, uses paper ID)
get_source (bool): If True, downloads source files instead of PDF (default: False)
Returns:
str: The main content of the paper as a string.
str: Path to the downloaded file or None if download fails
"""
try:
client = arxiv.Client()
arxiv_id = url.split('/')[-1]
paper = next(client.results(arxiv.Search(id_list=[arxiv_id])))
pdf_filename = paper.download_pdf(filename=f"downloaded-paper-{arxiv_id}.pdf")
# Create output directory if it doesn't exist
os.makedirs(output_dir, exist_ok=True)
# Get paper metadata
client = create_arxiv_client()
paper = next(client.results(arxiv.Search(id_list=[paper_id])))
# Set filename if not provided
if not filename:
safe_title = re.sub(r'[^\w\-_.]', '_', paper.title[:50])
filename = f"{paper_id}_{safe_title}"
filename += ".tar.gz" if get_source else ".pdf"
# Full path for the downloaded file
file_path = os.path.join(output_dir, filename)
# Download the file
if get_source:
paper.download_source(dirpath=output_dir, filename=filename)
else:
paper.download_pdf(dirpath=output_dir, filename=filename)
logger.info(f"Successfully downloaded {'source' if get_source else 'PDF'} to {file_path}")
return file_path
except Exception as e:
logger.error(f"Error downloading {'source' if get_source else 'PDF'} for {paper_id}: {e}")
return None
def analyze_paper_content(url_or_id, cleanup=True):
"""
Analyzes paper content using AI to extract key information and insights.
Args:
url_or_id (str): The arXiv URL or ID of the paper
cleanup (bool): Whether to delete the PDF after extraction (default: True)
Returns:
dict: Analysis results including summary, key findings, and concepts
"""
try:
# Get paper content
content = get_pdf_content(url_or_id, cleanup)
if not content or 'Failed to' in content:
return {'error': content}
# Generate paper summary
summary_prompt = f"""Analyze this research paper and provide a comprehensive summary:
{content[:8000]} # Limit content length for API
Provide a JSON response with:
1. executive_summary: Brief overview (2-3 sentences)
2. key_findings: List of main research findings
3. methodology: Research methods used
4. implications: Practical implications of the research
5. limitations: Study limitations and constraints"""
summary_analysis = llm_text_gen(summary_prompt)
# Extract key concepts and relationships
concepts_prompt = f"""Analyze this research paper and identify key concepts and relationships:
{content[:8000]}
Provide a JSON response with:
1. main_concepts: List of key technical concepts
2. concept_relationships: How concepts are related
3. novel_contributions: New ideas or approaches introduced
4. technical_requirements: Required technologies or methods
5. future_directions: Suggested future research"""
concept_analysis = llm_text_gen(concepts_prompt)
return {
'summary_analysis': summary_analysis,
'concept_analysis': concept_analysis,
'full_text': content
}
except Exception as e:
logger.error(f"Error analyzing paper content: {e}")
return {'error': str(e)}
def analyze_research_trends(papers):
"""
Analyzes research trends across multiple papers.
Args:
papers (list): List of paper metadata and content
Returns:
dict: Trend analysis results
"""
try:
# Collect paper information
papers_info = []
for paper in papers:
content = get_pdf_content(paper['entry_id'], cleanup=True)
if content and 'Failed to' not in content:
papers_info.append({
'title': paper['title'],
'abstract': paper['summary'],
'content': content[:8000], # Limit content length
'year': paper['published'].year
})
if not papers_info:
return {'error': 'No valid paper content found for analysis'}
# Analyze trends
trends_prompt = f"""Analyze these research papers and identify key trends:
Papers:
{str(papers_info)}
Provide a JSON response with:
1. temporal_trends: How research focus evolved over time
2. emerging_themes: New and growing research areas
3. declining_themes: Decreasing research focus areas
4. methodology_trends: Evolution of research methods
5. technology_trends: Trends in technology usage
6. research_gaps: Identified gaps and opportunities"""
trend_analysis = llm_text_gen(trends_prompt)
return {'trend_analysis': trend_analysis}
except Exception as e:
logger.error(f"Error analyzing research trends: {e}")
return {'error': str(e)}
def map_cross_paper_concepts(papers):
"""
Maps concepts and relationships across multiple papers.
Args:
papers (list): List of paper metadata and content
Returns:
dict: Concept mapping results
"""
try:
# Analyze each paper
paper_analyses = []
for paper in papers:
analysis = analyze_paper_content(paper['entry_id'])
if 'error' not in analysis:
paper_analyses.append({
'paper_id': paper['entry_id'],
'title': paper['title'],
'analysis': analysis
})
if not paper_analyses:
return {'error': 'No valid paper analyses for concept mapping'}
# Generate cross-paper concept map
mapping_prompt = f"""Analyze relationships between concepts across these papers:
{str(paper_analyses)}
Provide a JSON response with:
1. shared_concepts: Concepts appearing in multiple papers
2. concept_evolution: How concepts developed across papers
3. conflicting_views: Different interpretations of same concepts
4. complementary_findings: How papers complement each other
5. knowledge_gaps: Areas needing more research"""
concept_mapping = llm_text_gen(mapping_prompt)
return {'concept_mapping': concept_mapping}
except Exception as e:
logger.error(f"Error mapping cross-paper concepts: {e}")
return {'error': str(e)}
def generate_bibtex_entry(paper):
"""
Generates a BibTeX entry for a paper with complete metadata.
Args:
paper (dict): Paper metadata dictionary
Returns:
str: BibTeX entry string
"""
try:
# Generate a unique citation key
first_author = paper['authors'][0].split()[-1] if paper['authors'] else 'Unknown'
year = paper['published'].year if paper['published'] else '0000'
citation_key = f"{first_author}{year}{paper['entry_id'].split('/')[-1]}"
# Format authors for BibTeX
authors = ' and '.join(paper['authors'])
# Create BibTeX entry
bibtex = f"@article{{{citation_key},\n"
bibtex += f" title = {{{paper['title']}}},\n"
bibtex += f" author = {{{authors}}},\n"
bibtex += f" year = {{{year}}},\n"
bibtex += f" journal = {{arXiv preprint}},\n"
bibtex += f" archivePrefix = {{arXiv}},\n"
bibtex += f" eprint = {{{paper['entry_id'].split('/')[-1]}}},\n"
if paper['doi']:
bibtex += f" doi = {{{paper['doi']}}},\n"
bibtex += f" url = {{{paper['entry_id']}}},\n"
bibtex += f" abstract = {{{paper['summary']}}}\n"
bibtex += "}"
return bibtex
except Exception as e:
logger.error(f"Error generating BibTeX entry: {e}")
return ""
def convert_citation_format(bibtex_str, target_format):
"""
Converts BibTeX citations to other formats and validates the output.
Args:
bibtex_str (str): BibTeX entry string
target_format (str): Target citation format ('apa', 'mla', 'chicago', etc.)
Returns:
str: Formatted citation string
"""
try:
# Parse BibTeX entry
bib_database = bibtexparser.loads(bibtex_str)
entry = bib_database.entries[0]
# Generate citation format prompt
prompt = f"""Convert this bibliographic information to {target_format} format:
Title: {entry.get('title', '')}
Authors: {entry.get('author', '')}
Year: {entry.get('year', '')}
Journal: {entry.get('journal', '')}
DOI: {entry.get('doi', '')}
URL: {entry.get('url', '')}
Return only the formatted citation without any explanation."""
# Use AI to generate formatted citation
formatted_citation = llm_text_gen(prompt)
return formatted_citation.strip()
except Exception as e:
logger.error(f"Error converting citation format: {e}")
return ""
def visualize_reference_graph(papers):
"""
Creates a visual representation of the citation network.
Args:
papers (list): List of paper metadata dictionaries
Returns:
str: Path to the saved visualization file
"""
try:
# Create directed graph
G = nx.DiGraph()
# Add nodes and edges
for paper in papers:
paper_id = paper['entry_id']
G.add_node(paper_id, title=paper['title'])
# Add citation edges
if paper['doi']:
for other_paper in papers:
if other_paper['doi'] and other_paper['doi'] in paper['summary']:
G.add_edge(paper_id, other_paper['entry_id'])
# Set up the visualization
plt.figure(figsize=(12, 8))
pos = nx.spring_layout(G)
# Draw the graph
nx.draw(G, pos, with_labels=False, node_color='lightblue',
node_size=1000, arrowsize=20)
# Add labels
labels = nx.get_node_attributes(G, 'title')
nx.draw_networkx_labels(G, pos, labels, font_size=8)
# Save the visualization
output_path = 'reference_graph.png'
plt.savefig(output_path, dpi=300, bbox_inches='tight')
plt.close()
return output_path
except Exception as e:
logger.error(f"Error visualizing reference graph: {e}")
return ""
def analyze_citation_impact(papers):
"""
Analyzes citation impact and influence patterns.
Args:
papers (list): List of paper metadata dictionaries
Returns:
dict: Citation impact analysis results
"""
try:
# Create citation network
G = nx.DiGraph()
for paper in papers:
G.add_node(paper['entry_id'], **paper)
if paper['doi']:
for other_paper in papers:
if other_paper['doi'] and other_paper['doi'] in paper['summary']:
G.add_edge(paper_id, other_paper['entry_id'])
# Calculate impact metrics
impact_analysis = {
'citation_counts': dict(G.in_degree()),
'influence_scores': nx.pagerank(G),
'authority_scores': nx.authority_matrix(G).diagonal(),
'hub_scores': nx.hub_matrix(G).diagonal(),
'citation_paths': dict(nx.all_pairs_shortest_path_length(G))
}
# Add temporal analysis
year_citations = defaultdict(int)
for paper in papers:
if paper['published']:
year = paper['published'].year
year_citations[year] += G.in_degree(paper['entry_id'])
impact_analysis['temporal_trends'] = dict(year_citations)
return impact_analysis
except Exception as e:
logger.error(f"Error analyzing citation impact: {e}")
return {}
def get_pdf_content(url_or_id, cleanup=True):
"""
Extracts text content from a paper's PDF with improved error handling.
Args:
url_or_id (str): The arXiv URL or ID of the paper
cleanup (bool): Whether to delete the PDF after extraction (default: True)
Returns:
str: The extracted text content or error message
"""
try:
# Extract arxiv ID from URL if needed
arxiv_id = url_or_id.split('/')[-1] if '/' in url_or_id else url_or_id
# Download PDF
pdf_path = download_paper(arxiv_id)
if not pdf_path:
return "Failed to download PDF."
# Extract text from PDF
pdf_text = ''
with open(pdf_filename, 'rb') as f:
with open(pdf_path, 'rb') as f:
pdf_reader = PyPDF2.PdfReader(f)
for page in pdf_reader.pages:
for page_num, page in enumerate(pdf_reader.pages, 1):
try:
page_text = page.extract_text()
if page_text:
pdf_text += page_text + '\n'
except UnicodeDecodeError as err:
logger.error(f"UnicodeDecodeError that arises during text extraction: {err}")
pass
os.remove(pdf_filename)
pdf_text = clean_pdf_text(pdf_text)
return pdf_text
except Exception as pdf_error:
logger.error(f"Failed to process PDF: {pdf_error}")
return "Failed to retrieve content."
pdf_text += f"\n--- Page {page_num} ---\n{page_text}"
except Exception as err:
logger.error(f"Error extracting text from page {page_num}: {err}")
continue
# Clean up
if cleanup:
try:
os.remove(pdf_path)
logger.debug(f"Cleaned up temporary PDF file: {pdf_path}")
except Exception as e:
logger.warning(f"Failed to cleanup PDF file {pdf_path}: {e}")
# Process and return text
if not pdf_text.strip():
return "No text content could be extracted from the PDF."
return clean_pdf_text(pdf_text)
except Exception as e:
logger.error(f"Failed to process PDF: {e}")
return f"Failed to retrieve content: {str(e)}"
def clean_pdf_text(text):
"""
@@ -194,48 +800,128 @@ def scrape_images_from_arxiv(url):
logger.error(f"Error fetching page {url}: {e}")
return []
def arxiv_bibtex(arxiv_id):
def generate_bibtex(paper_id, client=None):
"""
Get the BibTeX entry for an arXiv paper.
Generate a BibTeX entry for an arXiv paper with enhanced metadata.
Args:
arxiv_id: The arXiv ID of the paper.
paper_id (str): The arXiv ID of the paper
client (arxiv.Client): Optional custom client (default: None)
Returns:
A string containing the BibTeX entry.
str: BibTeX entry as a string
"""
try:
usock = urllib.request.urlopen(f'http://export.arxiv.org/api/query?id_list={arxiv_id}')
xmldoc = xml.dom.minidom.parse(usock)
usock.close()
entry = xmldoc.getElementsByTagName("entry")[0]
date = entry.getElementsByTagName("updated")[0].firstChild.data
text_year = date[:4]
title = entry.getElementsByTagName("title")[0]
text_title = title.firstChild.data.strip()
authorlist = []
first = True
for person_name in entry.getElementsByTagName("author"):
name = person_name.getElementsByTagName("name")[0]
text_name = name.firstChild.data
text_given_name = ' '.join(text_name.split()[:-1])
text_surname = text_name.split()[-1]
authorlist.append(f"{text_surname}, {text_given_name}")
if first:
text_first_author_surname = text_surname
first = False
bibtex = f"@MISC{{{text_first_author_surname}{text_year[-2:]},\n"
bibtex += f" author = {' and '.join(authorlist)},\n"
bibtex += f" title = {{{text_title}}},\n"
bibtex += f" year = {{{text_year}}},\n"
bibtex += f" eprint = {{{arxiv_id}}},\n"
bibtex += f" url = {{http://arxiv.org/abs/{arxiv_id}}}\n"
bibtex += "}"
return bibtex
if client is None:
client = create_arxiv_client()
# Fetch paper metadata
paper = next(client.results(arxiv.Search(id_list=[paper_id])))
# Extract author information
authors = [str(author) for author in paper.authors]
first_author = authors[0].split(', ')[0] if authors else 'Unknown'
# Format year
year = paper.published.year if paper.published else 'Unknown'
# Create citation key
citation_key = f"{first_author}{str(year)[-2:]}"
# Build BibTeX entry
bibtex = [
f"@article{{{citation_key},",
f" author = {{{' and '.join(authors)}}},",
f" title = {{{paper.title}}},",
f" year = {{{year}}},",
f" eprint = {{{paper_id}}},",
f" archivePrefix = {{arXiv}},"
]
# Add optional fields if available
if paper.doi:
bibtex.append(f" doi = {{{paper.doi}}},")
if getattr(paper, 'journal_ref', None):
bibtex.append(f" journal = {{{paper.journal_ref}}},")
if getattr(paper, 'primary_category', None):
bibtex.append(f" primaryClass = {{{paper.primary_category}}},")
# Add URL and close entry
bibtex.extend([
f" url = {{https://arxiv.org/abs/{paper_id}}}",
"}"
])
return '\n'.join(bibtex)
except Exception as e:
logger.error(f"Error while generating BibTeX: {e}")
logger.error(f"Error generating BibTeX for {paper_id}: {e}")
return ""
def batch_download_papers(paper_ids, output_dir="downloads", get_source=False):
"""
Download multiple papers in batch with progress tracking.
Args:
paper_ids (list): List of arXiv IDs to download
output_dir (str): Directory to save downloaded files (default: 'downloads')
get_source (bool): If True, downloads source files instead of PDFs (default: False)
Returns:
dict: Mapping of paper IDs to their download status and paths
"""
results = {}
client = create_arxiv_client()
for paper_id in paper_ids:
try:
file_path = download_paper(paper_id, output_dir, get_source=get_source)
results[paper_id] = {
'success': bool(file_path),
'path': file_path,
'error': None
}
except Exception as e:
results[paper_id] = {
'success': False,
'path': None,
'error': str(e)
}
logger.error(f"Failed to download {paper_id}: {e}")
return results
def batch_generate_bibtex(paper_ids):
"""
Generate BibTeX entries for multiple papers.
Args:
paper_ids (list): List of arXiv IDs
Returns:
dict: Mapping of paper IDs to their BibTeX entries
"""
results = {}
client = create_arxiv_client()
for paper_id in paper_ids:
try:
bibtex = generate_bibtex(paper_id, client)
results[paper_id] = {
'success': bool(bibtex),
'bibtex': bibtex,
'error': None
}
except Exception as e:
results[paper_id] = {
'success': False,
'bibtex': '',
'error': str(e)
}
logger.error(f"Failed to generate BibTeX for {paper_id}: {e}")
return results
def extract_arxiv_ids_from_line(line):
"""
Extract the arXiv ID from a given line of text.

15
lib/ai_writers/ai_agents_crew_writer.py
View File

@@ -1,8 +1,6 @@
import os
import configparser
import streamlit as st
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool
from langchain_google_genai import ChatGoogleGenerativeAI
# Initialize session state variables if not already done
@@ -12,6 +10,11 @@ if 'progress' not in st.session_state:
def create_agents(search_keywords):
"""Create agents for content creation."""
try:
from crewai import Agent
from crewai_tools import SerperDevTool
except ImportError:
raise ImportError("The 'crewai' and/or 'crewai_tools' package is not installed. Please install them to use AI Agents Crew Writer features.")
search_tool = SerperDevTool()
google_api_key = os.getenv("GEMINI_API_KEY")
@@ -52,6 +55,10 @@ def create_agents(search_keywords):
def create_tasks(agents, search_keywords):
"""Create tasks for the agents."""
try:
from crewai import Task
except ImportError:
raise ImportError("The 'crewai' package is not installed. Please install it to use AI Agents Crew Writer features.")
try:
task_description, expected_output = read_config("research_task")
research_task = Task(
@@ -89,6 +96,10 @@ def create_tasks(agents, search_keywords):
def execute_tasks(agents, tasks, lang):
"""Execute tasks with the agents."""
try:
from crewai import Crew
except ImportError:
raise ImportError("The 'crewai' package is not installed. Please install it to use AI Agents Crew Writer features.")
crew = Crew(
agents=agents,
tasks=tasks,

61
lib/ai_writers/ai_writer_dashboard.py
View File

@@ -12,9 +12,64 @@ from lib.ai_writers.ai_outline_writer.outline_ui import main as outline_generato
from lib.alwrity_ui.dashboard_styles import apply_dashboard_style, render_dashboard_header, render_category_header, render_card
from loguru import logger
# Try to import AI Content Performance Predictor (AI-first approach)
try:
from lib.content_performance_predictor.ai_performance_predictor import render_ai_predictor_ui as render_content_performance_predictor
AI_PREDICTOR_AVAILABLE = True
logger.info("AI Content Performance Predictor loaded successfully")
except ImportError:
logger.warning("AI Content Performance Predictor not available")
render_content_performance_predictor = None
AI_PREDICTOR_AVAILABLE = False
# Try to import Bootstrap AI Competitive Suite
try:
from lib.ai_competitive_suite.bootstrap_ai_suite import render_bootstrap_ai_suite
BOOTSTRAP_SUITE_AVAILABLE = True
logger.info("Bootstrap AI Competitive Suite loaded successfully")
except ImportError:
logger.warning("Bootstrap AI Competitive Suite not available")
render_bootstrap_ai_suite = None
BOOTSTRAP_SUITE_AVAILABLE = False
def list_ai_writers():
"""Return a list of available AI writers with their metadata (no UI rendering)."""
return [
writers = []
# Add Content Performance Predictor if available
if render_content_performance_predictor:
# AI-first approach description
if AI_PREDICTOR_AVAILABLE:
description = "🎯 AI-powered content performance prediction with competitive intelligence - perfect for solo entrepreneurs"
name = "AI Content Performance Predictor"
else:
description = "Predict content success before publishing with AI-powered performance analysis"
name = "Content Performance Predictor"
writers.append({
"name": name,
"icon": "🎯",
"description": description,
"category": "⭐ Featured",
"function": render_content_performance_predictor,
"path": "performance_predictor",
"featured": True
})
# Add Bootstrap AI Competitive Suite if available
if render_bootstrap_ai_suite:
writers.append({
"name": "Bootstrap AI Competitive Suite",
"icon": "🚀",
"description": "🥷 Complete AI-powered competitive toolkit: content performance prediction + competitive intelligence for solo entrepreneurs",
"category": "⭐ Featured",
"function": render_bootstrap_ai_suite,
"path": "bootstrap_ai_suite",
"featured": True
})
# Add existing writers
writers.extend([
{
"name": "AI Blog Writer",
"icon": "📝",
@@ -103,7 +158,9 @@ def list_ai_writers():
"function": outline_generator,
"path": "outline_generator"
}
]
])
return writers
def get_ai_writers():
"""Main function to display AI writers dashboard with premium glassmorphic design."""

1115
lib/ai_writers/twitter_writers/tweet_generator/smart_tweet_generator.py
View File

File diff suppressed because it is too large Load Diff

942
lib/ai_writers/twitter_writers/twitter_dashboard.py
View File

@@ -1,16 +1,22 @@
"""
Twitter Dashboard with modern UI components.
Enhanced Twitter Dashboard with modern UI components and improved user experience.
"""
import streamlit as st
from typing import Dict, List
from typing import Dict, List, Optional, Any
import json
from datetime import datetime
from datetime import datetime, timedelta
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np
from .tweet_generator import smart_tweet_generator
from .twitter_streamlit_ui import (
TwitterDashboard,
FeatureCard,
TweetCard,
TweetForm,
SettingsForm,
Sidebar,
@@ -22,290 +28,702 @@ from .twitter_streamlit_ui import (
get_from_session,
clear_session,
show_success_message,
show_error_message
show_error_message,
show_info_message,
show_warning_message
)
def load_feature_data() -> Dict:
"""Load feature data from a structured format."""
return {
"tweet_generation": {
"title": "Tweet Generation & Optimization",
"icon": "🐦",
"description": "Create and optimize engaging tweets with AI assistance",
"features": [
{
"name": "Smart Tweet Generator",
"description": "Generate multiple tweet variations with optimal character count, hashtags, and emojis",
"status": "active",
"icon": "✨",
"function": smart_tweet_generator
},
{
"name": "Tweet Performance Predictor",
"description": "Predict engagement rates and best posting times for maximum impact",
"status": "coming_soon",
"icon": "📊"
}
]
},
"content_strategy": {
"title": "Content Strategy Tools",
"icon": "📅",
"description": "Plan and manage your Twitter content strategy effectively",
"features": [
{
"name": "Content Calendar Generator",
"description": "Create weekly/monthly content plans with theme-based scheduling",
"status": "coming_soon",
"icon": "🗓️"
},
{
"name": "Hashtag Strategy Manager",
"description": "Research and manage trending hashtags for better reach",
"status": "coming_soon",
"icon": "#️⃣"
}
]
},
"visual_content": {
"title": "Visual Content Creation",
"icon": "🎨",
"description": "Create engaging visual content for your tweets",
"features": [
{
"name": "Image Generator",
"description": "Create tweet cards, infographics, and quote designs",
"status": "coming_soon",
"icon": "🖼️"
},
{
"name": "Video Content Assistant",
"description": "Generate video scripts and optimize captions",
"status": "coming_soon",
"icon": "🎥"
}
]
},
"engagement": {
"title": "Engagement & Community",
"icon": "🤝",
"description": "Manage and enhance community engagement",
"features": [
{
"name": "Reply Generator",
"description": "Generate context-aware responses with appropriate tone",
"status": "coming_soon",
"icon": "💬"
},
{
"name": "Community Tools",
"description": "Create polls and plan Q&A sessions",
"status": "coming_soon",
"icon": "👥"
}
]
},
"analytics": {
"title": "Analytics & Optimization",
"icon": "📈",
"description": "Track performance and optimize your Twitter strategy",
"features": [
{
"name": "Performance Analytics",
"description": "Track tweet performance and engagement metrics",
"status": "coming_soon",
"icon": "📊"
},
{
"name": "A/B Testing Assistant",
"description": "Test and optimize tweet variations for better results",
"status": "coming_soon",
"icon": "🔍"
}
]
},
"research": {
"title": "Research & Intelligence",
"icon": "🔎",
"description": "Gain insights and stay ahead of trends",
"features": [
{
"name": "Market Research",
"description": "Analyze competitors and track industry trends",
"status": "coming_soon",
"icon": "📊"
},
{
"name": "Content Inspiration",
"description": "Get trending topic suggestions and content ideas",
"status": "coming_soon",
"icon": "💡"
}
]
}
def apply_modern_styling():
"""Apply modern CSS styling to the dashboard."""
st.markdown("""
<style>
/* Import Google Fonts */
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
/* Global Styles */
.stApp {
font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
}
def run_dashboard():
"""Main function to run the Twitter dashboard."""
# Initialize dashboard
dashboard = TwitterDashboard()
/* Main Container */
.main-container {
background: rgba(255, 255, 255, 0.95);
backdrop-filter: blur(20px);
border-radius: 20px;
padding: 2rem;
margin: 1rem;
box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
}
# Load feature data
features = load_feature_data()
/* Header Styles */
.dashboard-header {
text-align: center;
margin-bottom: 2rem;
padding: 2rem 0;
background: linear-gradient(135deg, #1DA1F2, #0C85D0);
border-radius: 16px;
color: white;
box-shadow: 0 10px 30px rgba(29, 161, 242, 0.3);
}
# Setup navigation
sidebar = Sidebar(title="Twitter Tools")
sidebar.add_menu_item("Dashboard", "📊", "dashboard")
sidebar.add_menu_item("Tweet Generator", "✍️", "tweet_generator")
sidebar.add_menu_item("Analytics", "📈", "analytics")
sidebar.add_menu_item("Settings", "⚙️", "settings")
.dashboard-title {
font-size: 2.5rem;
font-weight: 700;
margin: 0;
text-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}
# Setup header
header = Header(
title="Twitter AI Writer",
subtitle="Your all-in-one Twitter content creation and management platform"
)
header.add_action("New Tweet", "✏️", lambda: save_to_session("current_page", "tweet_generator"))
header.add_action("Refresh", "🔄", lambda: st.experimental_rerun())
.dashboard-subtitle {
font-size: 1.1rem;
opacity: 0.9;
margin-top: 0.5rem;
font-weight: 400;
}
# Setup tabs
tabs = Tabs()
tabs.add_tab("Overview", "📊", lambda: render_overview(features))
tabs.add_tab("Recent Tweets", "🐦", lambda: render_recent_tweets())
tabs.add_tab("Analytics", "📈", lambda: render_analytics())
/* Feature Cards */
.feature-card {
background: white;
border-radius: 16px;
padding: 1.5rem;
margin-bottom: 1rem;
box-shadow: 0 8px 25px rgba(0, 0, 0, 0.08);
border: 1px solid rgba(0, 0, 0, 0.05);
transition: all 0.3s ease;
cursor: pointer;
}
# Setup breadcrumbs
breadcrumbs = Breadcrumbs()
breadcrumbs.add_item("Home", "dashboard", "🏠")
breadcrumbs.add_item(get_from_session("current_page", "Dashboard").title())
.feature-card:hover {
transform: translateY(-5px);
box-shadow: 0 15px 35px rgba(0, 0, 0, 0.15);
}
# Render dashboard
dashboard.render()
.feature-icon {
font-size: 2.5rem;
margin-bottom: 1rem;
display: block;
}
def render_overview(features: Dict):
"""Render the overview tab content."""
# Feature cards
col1, col2, col3 = st.columns(3)
.feature-title {
font-size: 1.25rem;
font-weight: 600;
color: #2D3748;
margin-bottom: 0.5rem;
}
.feature-description {
color: #718096;
font-size: 0.95rem;
line-height: 1.5;
margin-bottom: 1rem;
}
.feature-status {
display: inline-block;
padding: 0.25rem 0.75rem;
border-radius: 20px;
font-size: 0.8rem;
font-weight: 500;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.status-active {
background: linear-gradient(135deg, #48BB78, #38A169);
color: white;
}
.status-coming-soon {
background: linear-gradient(135deg, #ED8936, #DD6B20);
color: white;
}
/* Metrics Cards */
.metric-card {
background: white;
border-radius: 12px;
padding: 1.5rem;
text-align: center;
box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
border-left: 4px solid #1DA1F2;
}
.metric-value {
font-size: 2rem;
font-weight: 700;
color: #2D3748;
margin-bottom: 0.5rem;
}
.metric-label {
color: #718096;
font-size: 0.9rem;
font-weight: 500;
}
/* Buttons */
.stButton > button {
background: linear-gradient(135deg, #1DA1F2, #0C85D0);
color: white;
border: none;
border-radius: 10px;
padding: 0.75rem 1.5rem;
font-weight: 600;
font-size: 0.95rem;
transition: all 0.3s ease;
box-shadow: 0 4px 15px rgba(29, 161, 242, 0.3);
}
.stButton > button:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(29, 161, 242, 0.4);
}
/* Tabs */
.stTabs [data-baseweb="tab-list"] {
gap: 0.5rem;
background: rgba(255, 255, 255, 0.1);
padding: 0.5rem;
border-radius: 12px;
backdrop-filter: blur(10px);
}
.stTabs [data-baseweb="tab"] {
background: transparent;
border-radius: 8px;
color: #4A5568;
font-weight: 500;
padding: 0.75rem 1.5rem;
transition: all 0.3s ease;
}
.stTabs [aria-selected="true"] {
background: white;
color: #1DA1F2;
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
}
/* Connection Status */
.connection-status {
display: flex;
align-items: center;
gap: 0.5rem;
padding: 1rem;
border-radius: 12px;
margin-bottom: 1.5rem;
font-weight: 500;
}
.status-connected {
background: linear-gradient(135deg, #C6F6D5, #9AE6B4);
color: #22543D;
border: 1px solid #9AE6B4;
}
.status-disconnected {
background: linear-gradient(135deg, #FED7D7, #FEB2B2);
color: #742A2A;
border: 1px solid #FEB2B2;
}
/* Quick Actions */
.quick-actions {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 1rem;
margin: 2rem 0;
}
.quick-action-btn {
background: white;
border: 2px solid #E2E8F0;
border-radius: 12px;
padding: 1.5rem;
text-align: center;
transition: all 0.3s ease;
cursor: pointer;
text-decoration: none;
}
.quick-action-btn:hover {
border-color: #1DA1F2;
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(29, 161, 242, 0.15);
}
.quick-action-icon {
font-size: 2rem;
margin-bottom: 0.5rem;
display: block;
}
.quick-action-title {
font-weight: 600;
color: #2D3748;
margin-bottom: 0.25rem;
}
.quick-action-desc {
font-size: 0.85rem;
color: #718096;
}
/* Analytics Charts */
.chart-container {
background: white;
border-radius: 16px;
padding: 1.5rem;
margin: 1rem 0;
box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
}
/* Responsive Design */
@media (max-width: 768px) {
.main-container {
margin: 0.5rem;
padding: 1rem;
}
.dashboard-title {
font-size: 2rem;
}
.quick-actions {
grid-template-columns: 1fr;
}
}
</style>
""", unsafe_allow_html=True)
def render_connection_status():
"""Render Twitter connection status with modern styling."""
# Simulate connection status (replace with real authentication check)
is_connected = get_from_session("twitter_connected", False)
if is_connected:
user_info = get_from_session("twitter_user", {"name": "Demo User", "handle": "@demo_user"})
st.markdown(f"""
<div class="connection-status status-connected">
<span style="font-size: 1.2rem;">✅</span>
<div>
<strong>Connected as {user_info['name']}</strong>
<div style="font-size: 0.9rem; opacity: 0.8;">{user_info['handle']}</div>
</div>
</div>
""", unsafe_allow_html=True)
else:
st.markdown("""
<div class="connection-status status-disconnected">
<span style="font-size: 1.2rem;">⚠️</span>
<div>
<strong>Twitter Not Connected</strong>
<div style="font-size: 0.9rem; opacity: 0.8;">Connect your account to access all features</div>
</div>
</div>
""", unsafe_allow_html=True)
if st.button("🔗 Connect Twitter Account", key="connect_twitter"):
# Simulate connection (replace with real OAuth flow)
save_to_session("twitter_connected", True)
save_to_session("twitter_user", {"name": "Demo User", "handle": "@demo_user"})
st.rerun()
def render_dashboard_header():
"""Render the modern dashboard header."""
st.markdown("""
<div class="dashboard-header">
<h1 class="dashboard-title">🐦 Twitter AI Dashboard</h1>
<p class="dashboard-subtitle">Create, analyze, and optimize your Twitter content with AI-powered tools</p>
</div>
""", unsafe_allow_html=True)
def render_quick_actions():
"""Render quick action buttons."""
st.markdown("### 🚀 Quick Actions")
col1, col2, col3, col4 = st.columns(4)
with col1:
FeatureCard(
title="Tweet Generator",
description="Create engaging tweets with AI assistance",
icon="✍️",
features=[
{
"name": "AI-Powered",
"description": "Generate tweets using advanced AI"
},
{
"name": "Customizable",
"description": "Adjust tone, length, and style"
}
],
on_click=lambda: save_to_session("current_page", "tweet_generator")
).render()
if st.button("✍️ Create Tweet", use_container_width=True, key="quick_tweet"):
st.session_state.current_page = "tweet_generator"
st.rerun()
with col2:
FeatureCard(
title="Analytics",
description="Track your tweet performance",
icon="📈",
features=[
{
"name": "Engagement",
"description": "Monitor likes, retweets, and replies"
},
{
"name": "Growth",
"description": "Track follower growth over time"
}
]
).render()
if st.button("📊 View Analytics", use_container_width=True, key="quick_analytics"):
st.session_state.current_page = "analytics"
st.rerun()
with col3:
FeatureCard(
title="Settings",
description="Customize your experience",
icon="⚙️",
features=[
{
"name": "Preferences",
"description": "Set your default options"
},
{
"name": "API",
"description": "Configure Twitter API settings"
}
]
).render()
if st.button("📅 Content Calendar", use_container_width=True, key="quick_calendar"):
show_info_message("Content Calendar feature coming soon!")
def render_recent_tweets():
"""Render the recent tweets tab content."""
# Tweet form
tweet_form = TweetForm(
on_submit=lambda: handle_tweet_submit()
with col4:
if st.button("⚙️ Settings", use_container_width=True, key="quick_settings"):
st.session_state.current_page = "settings"
st.rerun()
def render_metrics_overview():
"""Render key metrics overview."""
st.markdown("### 📈 Performance Overview")
# Generate sample metrics (replace with real data)
col1, col2, col3, col4 = st.columns(4)
with col1:
st.markdown("""
<div class="metric-card">
<div class="metric-value">1,234</div>
<div class="metric-label">Total Tweets</div>
</div>
""", unsafe_allow_html=True)
with col2:
st.markdown("""
<div class="metric-card">
<div class="metric-value">45.2K</div>
<div class="metric-label">Total Engagement</div>
</div>
""", unsafe_allow_html=True)
with col3:
st.markdown("""
<div class="metric-card">
<div class="metric-value">3.8%</div>
<div class="metric-label">Engagement Rate</div>
</div>
""", unsafe_allow_html=True)
with col4:
st.markdown("""
<div class="metric-card">
<div class="metric-value">12.5K</div>
<div class="metric-label">Followers</div>
</div>
""", unsafe_allow_html=True)
def render_engagement_chart():
"""Render engagement trends chart."""
st.markdown("### 📊 Engagement Trends")
# Generate sample data (replace with real Twitter data)
dates = pd.date_range(start=datetime.now() - timedelta(days=30), periods=30)
engagement = np.random.normal(100, 20, 30)
engagement = np.maximum(engagement, 0) # Ensure positive values
df = pd.DataFrame({
'Date': dates,
'Engagement': engagement,
'Likes': engagement * 0.6,
'Retweets': engagement * 0.3,
'Replies': engagement * 0.1
})
# Create interactive chart
fig = make_subplots(
rows=2, cols=1,
subplot_titles=('Total Engagement', 'Engagement Breakdown'),
vertical_spacing=0.1,
row_heights=[0.7, 0.3]
)
tweet_form.render()
# Recent tweets
st.markdown("### Recent Tweets")
tweets = get_from_session("tweets", [])
for tweet in tweets:
TweetCard(
content=tweet["content"],
engagement_score=tweet["engagement_score"],
hashtags=tweet["hashtags"],
emojis=tweet["emojis"],
metrics=tweet["metrics"],
on_copy=lambda: copy_tweet(tweet),
on_save=lambda: save_tweet(tweet)
).render()
# Main engagement line
fig.add_trace(
go.Scatter(
x=df['Date'],
y=df['Engagement'],
mode='lines+markers',
name='Total Engagement',
line=dict(color='#1DA1F2', width=3),
marker=dict(size=6)
),
row=1, col=1
)
def render_analytics():
"""Render the analytics tab content."""
st.markdown("### Tweet Analytics")
st.info("Analytics features coming soon!")
# Stacked area chart for breakdown
fig.add_trace(
go.Scatter(
x=df['Date'],
y=df['Likes'],
mode='lines',
name='Likes',
fill='tonexty',
line=dict(color='#E53E3E')
),
row=2, col=1
)
def handle_tweet_submit():
"""Handle tweet form submission."""
# Get form data
content = get_from_session("tweet_content")
tone = get_from_session("tone")
length = get_from_session("length")
hashtags = get_from_session("hashtags")
emojis = get_from_session("emojis")
engagement_boost = get_from_session("engagement_boost")
fig.add_trace(
go.Scatter(
x=df['Date'],
y=df['Retweets'],
mode='lines',
name='Retweets',
fill='tonexty',
line=dict(color='#38A169')
),
row=2, col=1
)
# Create tweet object
tweet = {
"content": content,
"tone": tone,
"length": length,
"hashtags": hashtags,
"emojis": emojis,
"engagement_score": engagement_boost,
"metrics": {
"Engagement": engagement_boost,
"Reach": engagement_boost * 0.8,
"Growth": engagement_boost * 0.6
fig.add_trace(
go.Scatter(
x=df['Date'],
y=df['Replies'],
mode='lines',
name='Replies',
fill='tonexty',
line=dict(color='#D69E2E')
),
row=2, col=1
)
fig.update_layout(
height=500,
showlegend=True,
hovermode='x unified',
plot_bgcolor='rgba(0,0,0,0)',
paper_bgcolor='rgba(0,0,0,0)'
)
fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
st.plotly_chart(fig, use_container_width=True)
def render_feature_grid():
"""Render the feature grid with modern cards."""
st.markdown("### 🛠️ Available Tools")
features = [
{
"title": "Smart Tweet Generator",
"description": "Create engaging tweets with AI assistance, hashtag suggestions, and emoji optimization",
"icon": "✨",
"status": "active",
"action": "tweet_generator"
},
{
"title": "Performance Predictor",
"description": "Predict tweet engagement and find optimal posting times",
"icon": "🔮",
"status": "coming_soon",
"action": None
},
{
"title": "Content Calendar",
"description": "Plan and schedule your Twitter content strategy",
"icon": "📅",
"status": "coming_soon",
"action": None
},
{
"title": "Hashtag Research",
"description": "Discover trending hashtags and analyze their performance",
"icon": "#️⃣",
"status": "coming_soon",
"action": None
},
{
"title": "Visual Content",
"description": "Create quote cards, infographics, and visual tweets",
"icon": "🎨",
"status": "coming_soon",
"action": None
},
{
"title": "Analytics Dashboard",
"description": "Deep dive into your Twitter performance metrics",
"icon": "📊",
"status": "coming_soon",
"action": None
}
]
# Create grid layout
cols = st.columns(3)
for i, feature in enumerate(features):
with cols[i % 3]:
status_class = "status-active" if feature["status"] == "active" else "status-coming-soon"
card_html = f"""
<div class="feature-card" onclick="handleFeatureClick('{feature['action']}')">
<span class="feature-icon">{feature['icon']}</span>
<h3 class="feature-title">{feature['title']}</h3>
<p class="feature-description">{feature['description']}</p>
<span class="feature-status {status_class}">{feature['status'].replace('_', ' ')}</span>
</div>
"""
st.markdown(card_html, unsafe_allow_html=True)
# Add button for active features
if feature["status"] == "active" and feature["action"]:
if st.button(f"Launch {feature['title']}", key=f"launch_{i}", use_container_width=True):
st.session_state.current_page = feature["action"]
st.rerun()
def render_recent_activity():
"""Render recent activity feed."""
st.markdown("### 📱 Recent Activity")
# Sample activity data (replace with real data)
activities = [
{"time": "2 hours ago", "action": "Generated tweet", "details": "AI-powered content about social media trends"},
{"time": "5 hours ago", "action": "Analyzed performance", "details": "Tweet received 45 likes and 12 retweets"},
{"time": "1 day ago", "action": "Scheduled tweet", "details": "Content scheduled for optimal posting time"},
{"time": "2 days ago", "action": "Updated hashtags", "details": "Added trending hashtags to improve reach"}
]
for activity in activities:
st.markdown(f"""
<div style="
background: white;
border-radius: 8px;
padding: 1rem;
margin-bottom: 0.5rem;
border-left: 3px solid #1DA1F2;
box-shadow: 0 2px 8px rgba(0,0,0,0.05);
">
<div style="font-weight: 600; color: #2D3748; margin-bottom: 0.25rem;">
{activity['action']}
</div>
<div style="color: #718096; font-size: 0.9rem; margin-bottom: 0.25rem;">
{activity['details']}
</div>
<div style="color: #A0AEC0; font-size: 0.8rem;">
{activity['time']}
</div>
</div>
""", unsafe_allow_html=True)
def run_dashboard():
"""Main function to run the enhanced Twitter dashboard."""
# Apply modern styling
apply_modern_styling()
# Initialize session state
if "current_page" not in st.session_state:
st.session_state.current_page = "dashboard"
# Handle page navigation
if st.session_state.current_page == "tweet_generator":
if st.button("← Back to Dashboard", key="back_to_dashboard"):
st.session_state.current_page = "dashboard"
st.rerun()
smart_tweet_generator()
return
# Main dashboard container
st.markdown('<div class="main-container">', unsafe_allow_html=True)
# Render dashboard header
render_dashboard_header()
# Render connection status
render_connection_status()
# Create main layout
tab1, tab2, tab3 = st.tabs(["🏠 Overview", "📊 Analytics", "⚙️ Settings"])
with tab1:
# Quick actions
render_quick_actions()
# Metrics overview
render_metrics_overview()
# Feature grid
render_feature_grid()
# Recent activity
col1, col2 = st.columns([2, 1])
with col1:
render_engagement_chart()
with col2:
render_recent_activity()
with tab2:
st.markdown("### 📈 Advanced Analytics")
# Time range selector
col1, col2 = st.columns([1, 3])
with col1:
time_range = st.selectbox(
"Time Range",
["Last 7 days", "Last 30 days", "Last 90 days", "Last year"],
index=1
)
# Detailed analytics
render_engagement_chart()
# Performance insights
st.markdown("### 💡 Performance Insights")
insights = [
"Your tweets perform 23% better when posted between 2-4 PM",
"Tweets with 2-3 hashtags get 15% more engagement",
"Visual content increases engagement by 35%",
"Questions in tweets boost replies by 28%"
]
for insight in insights:
st.info(f"💡 {insight}")
with tab3:
st.markdown("### ⚙️ Dashboard Settings")
# Twitter API settings
with st.expander("🔑 Twitter API Configuration", expanded=False):
st.markdown("Configure your Twitter API credentials to enable full functionality.")
api_key = st.text_input("API Key", type="password", help="Your Twitter API key")
api_secret = st.text_input("API Secret", type="password", help="Your Twitter API secret")
access_token = st.text_input("Access Token", type="password", help="Your Twitter access token")
access_token_secret = st.text_input("Access Token Secret", type="password", help="Your Twitter access token secret")
if st.button("Save API Configuration"):
# Save configuration (implement secure storage)
show_success_message("API configuration saved successfully!")
# Dashboard preferences
with st.expander("🎨 Dashboard Preferences", expanded=True):
theme = st.selectbox("Theme", ["Light", "Dark", "Auto"], index=0)
default_tone = st.selectbox("Default Tweet Tone", ["Professional", "Casual", "Humorous", "Inspirational"], index=1)
auto_hashtags = st.checkbox("Auto-suggest hashtags", value=True)
if st.button("Save Preferences"):
show_success_message("Preferences saved successfully!")
# Account management
with st.expander("👤 Account Management", expanded=False):
st.markdown("Manage your connected Twitter accounts and permissions.")
if get_from_session("twitter_connected", False):
st.success("✅ Twitter account connected")
if st.button("Disconnect Account"):
save_to_session("twitter_connected", False)
st.rerun()
else:
st.warning("⚠️ No Twitter account connected")
if st.button("Connect Account"):
save_to_session("twitter_connected", True)
st.rerun()
st.markdown('</div>', unsafe_allow_html=True)
# JavaScript for handling feature clicks
st.markdown("""
<script>
function handleFeatureClick(action) {
if (action && action !== 'null') {
// This would trigger a Streamlit rerun with the selected action
console.log('Feature clicked:', action);
}
# Add to tweets list
tweets = get_from_session("tweets", [])
tweets.append(tweet)
save_to_session("tweets", tweets)
# Show success message
show_success_message("Tweet created successfully!")
def copy_tweet(tweet: Dict):
"""Copy tweet to clipboard."""
show_success_message("Tweet copied to clipboard!")
def save_tweet(tweet: Dict):
"""Save tweet for later."""
show_success_message("Tweet saved!")
}
</script>
""", unsafe_allow_html=True)
if __name__ == "__main__":
run_dashboard()

742
lib/ai_writers/twitter_writers/twitter_streamlit_ui/components/cards.py
View File

@@ -1,174 +1,634 @@
"""
Card components for Twitter UI.
Provides consistent card layouts for features and tweets.
Enhanced UI Cards with modern styling and improved functionality.
"""
import streamlit as st
from typing import Dict, Any, Optional, List
from ..styles.theme import Theme
from typing import Dict, List, Optional, Callable
import plotly.express as px
import plotly.graph_objects as go
from datetime import datetime
class BaseCard:
"""Base class for all card components."""
def apply_cards_styling():
"""Apply modern CSS styling for cards."""
st.markdown("""
<style>
/* Modern Card Styles */
.modern-card {
background: rgba(255, 255, 255, 0.95);
backdrop-filter: blur(20px);
border-radius: 16px;
padding: 1.5rem;
margin: 1rem 0;
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
border: 1px solid rgba(255, 255, 255, 0.2);
transition: all 0.3s ease;
position: relative;
overflow: hidden;
}
.modern-card:hover {
transform: translateY(-4px);
box-shadow: 0 12px 40px rgba(0, 0, 0, 0.15);
}
.modern-card::before {
content: '';
position: absolute;
top: 0;
left: 0;
right: 0;
height: 4px;
background: linear-gradient(135deg, #1DA1F2, #0C85D0);
}
.feature-card {
background: white;
border-radius: 12px;
padding: 1.5rem;
margin: 0.75rem 0;
box-shadow: 0 4px 20px rgba(0, 0, 0, 0.08);
border: 1px solid #E1E8ED;
transition: all 0.3s ease;
cursor: pointer;
}
.feature-card:hover {
transform: translateY(-2px);
box-shadow: 0 8px 30px rgba(29, 161, 242, 0.15);
border-color: #1DA1F2;
}
.feature-card-header {
display: flex;
align-items: center;
gap: 1rem;
margin-bottom: 1rem;
}
.feature-icon {
font-size: 2rem;
width: 60px;
height: 60px;
display: flex;
align-items: center;
justify-content: center;
background: linear-gradient(135deg, #E6F7FF, #F0F9FF);
border-radius: 12px;
border: 2px solid #91D5FF;
}
.feature-title {
font-size: 1.25rem;
font-weight: 600;
color: #2D3748;
margin: 0;
}
.feature-description {
color: #657786;
font-size: 0.95rem;
line-height: 1.5;
margin-bottom: 1rem;
}
.feature-stats {
display: flex;
gap: 1rem;
margin-top: 1rem;
padding-top: 1rem;
border-top: 1px solid #E1E8ED;
}
.stat-item {
text-align: center;
flex: 1;
}
.stat-value {
font-size: 1.5rem;
font-weight: 700;
color: #1DA1F2;
display: block;
}
.stat-label {
font-size: 0.8rem;
color: #657786;
text-transform: uppercase;
letter-spacing: 0.5px;
}
.tweet-card {
background: white;
border: 1px solid #E1E8ED;
border-radius: 16px;
padding: 1.5rem;
margin: 1rem 0;
box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
position: relative;
}
.tweet-card::before {
content: "🐦";
position: absolute;
top: -10px;
left: 20px;
background: white;
padding: 0 10px;
font-size: 1.2rem;
}
.tweet-content {
font-size: 1.1rem;
line-height: 1.5;
color: #14171A;
margin-bottom: 1rem;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
}
.tweet-metadata {
display: flex;
justify-content: space-between;
align-items: center;
color: #657786;
font-size: 0.9rem;
border-top: 1px solid #E1E8ED;
padding-top: 1rem;
}
.engagement-badge {
background: linear-gradient(135deg, #52C41A, #73D13D);
color: white;
padding: 0.5rem 1rem;
border-radius: 20px;
font-weight: 600;
font-size: 0.9rem;
display: flex;
align-items: center;
gap: 0.5rem;
}
.character-badge {
padding: 0.25rem 0.75rem;
border-radius: 20px;
font-weight: 600;
font-size: 0.8rem;
}
.char-good { background: #E6F7FF; color: #1890FF; }
.char-warning { background: #FFF7E6; color: #FA8C16; }
.char-danger { background: #FFF1F0; color: #F5222D; }
.card-actions {
display: flex;
gap: 0.5rem;
margin-top: 1rem;
flex-wrap: wrap;
}
.action-button {
background: #F7F9FA;
border: 1px solid #E1E8ED;
border-radius: 8px;
padding: 0.5rem 1rem;
color: #657786;
font-size: 0.9rem;
cursor: pointer;
transition: all 0.3s ease;
text-decoration: none;
display: inline-flex;
align-items: center;
gap: 0.5rem;
}
.action-button:hover {
background: #1DA1F2;
color: white;
border-color: #1DA1F2;
transform: translateY(-1px);
}
.action-button.primary {
background: #1DA1F2;
color: white;
border-color: #1DA1F2;
}
.action-button.primary:hover {
background: #0C85D0;
border-color: #0C85D0;
}
.metrics-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
gap: 1rem;
margin: 1rem 0;
}
.metric-card {
background: white;
border-radius: 8px;
padding: 1rem;
text-align: center;
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
border: 1px solid #E1E8ED;
}
.metric-value {
font-size: 1.5rem;
font-weight: 700;
color: #1DA1F2;
display: block;
margin-bottom: 0.25rem;
}
.metric-label {
font-size: 0.8rem;
color: #657786;
text-transform: uppercase;
letter-spacing: 0.5px;
}
/* Responsive Design */
@media (max-width: 768px) {
.modern-card, .feature-card, .tweet-card {
margin: 0.5rem;
padding: 1rem;
}
.feature-card-header {
flex-direction: column;
text-align: center;
}
.feature-stats {
flex-direction: column;
gap: 0.5rem;
}
.card-actions {
justify-content: center;
}
.metrics-grid {
grid-template-columns: repeat(2, 1fr);
}
}
</style>
""", unsafe_allow_html=True)
class FeatureCard:
"""Modern feature card component."""
def __init__(
self,
title: str,
description: str,
icon: Optional[str] = None,
status: Optional[str] = None,
actions: Optional[List[Dict[str, Any]]] = None
icon: str = "🔧",
stats: Optional[Dict[str, any]] = None,
actions: Optional[List[Dict]] = None,
on_click: Optional[Callable] = None
):
self.title = title
self.description = description
self.icon = icon
self.status = status
self.stats = stats or {}
self.actions = actions or []
def render(self) -> None:
"""Render the card with consistent styling."""
with st.container():
st.markdown(f"""
<div class="card">
<div style="display: flex; align-items: center; margin-bottom: {Theme.SPACING["sm"]};">
{f'<span style="font-size: 1.5em; margin-right: {Theme.SPACING["sm"]};">{self.icon}</span>' if self.icon else ''}
<h3 style="margin: 0;">{self.title}</h3>
</div>
<p style="color: {Theme.COLORS["text_secondary"]}; margin: {Theme.SPACING["sm"]} 0;">
{self.description}
</p>
{f'<span class="status-badge status-{self.status}">{self.status.title()}</span>' if self.status else ''}
</div>
""", unsafe_allow_html=True)
if self.actions:
cols = st.columns(len(self.actions))
for i, action in enumerate(self.actions):
with cols[i]:
if st.button(
action["label"],
key=f"action_{i}",
help=action.get("help"),
use_container_width=True
):
action["callback"]()
class FeatureCard(BaseCard):
"""Card component for displaying features."""
def __init__(
self,
title: str,
description: str,
icon: str,
status: str = "active",
features: Optional[List[Dict[str, Any]]] = None,
on_click: Optional[callable] = None
):
super().__init__(title, description, icon, status)
self.features = features or []
self.on_click = on_click
def render(self) -> None:
"""Render the feature card with enhanced styling."""
with st.container():
st.markdown(f"""
<div class="card feature-card">
<div style="display: flex; align-items: center; margin-bottom: {Theme.SPACING["sm"]};">
<span style="font-size: 1.5em; margin-right: {Theme.SPACING["sm"]};">{self.icon}</span>
<h3 style="margin: 0;">{self.title}</h3>
def render(self):
"""Render the feature card."""
apply_cards_styling()
# Create stats HTML
stats_html = ""
if self.stats:
stats_items = []
for label, value in self.stats.items():
stats_items.append(f"""
<div class="stat-item">
<span class="stat-value">{value}</span>
<span class="stat-label">{label}</span>
</div>
<p style="color: {Theme.COLORS["text_secondary"]}; margin: {Theme.SPACING["sm"]} 0;">
{self.description}
</p>
<span class="status-badge status-{self.status}">{self.status.title()}</span>
""")
stats_html = f"""
<div class="feature-stats">
{''.join(stats_items)}
</div>
""", unsafe_allow_html=True)
"""
if self.features:
for feature in self.features:
st.markdown(f"""
<div style="margin-left: {Theme.SPACING["lg"]}; margin-top: {Theme.SPACING["sm"]};">
<p style="margin: 0;">
<strong>{feature["name"]}</strong>: {feature["description"]}
</p>
</div>
""", unsafe_allow_html=True)
# Create actions HTML
actions_html = ""
if self.actions:
action_buttons = []
for action in self.actions:
button_class = "action-button"
if action.get("primary", False):
button_class += " primary"
if self.on_click:
if st.button(
f"Launch {self.title}",
key=f"launch_{self.title.lower().replace(' ', '_')}",
use_container_width=True
):
self.on_click()
action_buttons.append(f"""
<button class="{button_class}" onclick="{action.get('onclick', '')}">
{action.get('icon', '')} {action.get('label', 'Action')}
</button>
""")
actions_html = f"""
<div class="card-actions">
{''.join(action_buttons)}
</div>
"""
class TweetCard(BaseCard):
"""Card component for displaying tweets."""
# Render the card
card_html = f"""
<div class="feature-card" onclick="{self.on_click or ''}">
<div class="feature-card-header">
<div class="feature-icon">{self.icon}</div>
<div>
<h3 class="feature-title">{self.title}</h3>
</div>
</div>
<p class="feature-description">{self.description}</p>
{stats_html}
{actions_html}
</div>
"""
st.markdown(card_html, unsafe_allow_html=True)
class TweetCard:
"""Modern tweet card component."""
def __init__(
self,
content: str,
engagement_score: float,
hashtags: List[str],
emojis: List[str],
metrics: Optional[Dict[str, Any]] = None,
on_copy: Optional[callable] = None,
on_save: Optional[callable] = None
engagement_score: int = 0,
hashtags: List[str] = None,
emojis: List[str] = None,
metrics: Optional[Dict] = None,
timestamp: Optional[str] = None,
on_copy: Optional[Callable] = None,
on_save: Optional[Callable] = None,
on_edit: Optional[Callable] = None,
on_post: Optional[Callable] = None
):
super().__init__(
title="Tweet",
description=content,
icon="🐦",
actions=[
{
"label": "Copy",
"callback": on_copy or (lambda: None),
"help": "Copy tweet to clipboard"
},
{
"label": "Save",
"callback": on_save or (lambda: None),
"help": "Save tweet for later"
}
]
)
self.content = content
self.engagement_score = engagement_score
self.hashtags = hashtags
self.emojis = emojis
self.hashtags = hashtags or []
self.emojis = emojis or []
self.metrics = metrics or {}
self.timestamp = timestamp or datetime.now().strftime("%Y-%m-%d %H:%M")
self.on_copy = on_copy
self.on_save = on_save
self.on_edit = on_edit
self.on_post = on_post
def render(self) -> None:
"""Render the tweet card with metrics and actions."""
with st.container():
st.markdown(f"""
<div class="card tweet-card">
<div style="display: flex; align-items: center; margin-bottom: {Theme.SPACING["sm"]};">
<span style="font-size: 1.5em; margin-right: {Theme.SPACING["sm"]};">{self.icon}</span>
<h3 style="margin: 0;">Tweet</h3>
</div>
<p style="color: {Theme.COLORS["text"]}; margin: {Theme.SPACING["sm"]} 0;">
{self.description}
</p>
<div style="display: flex; gap: {Theme.SPACING["sm"]}; margin: {Theme.SPACING["sm"]} 0;">
{''.join(f'<span style="color: {Theme.COLORS["primary"]};">{tag}</span>' for tag in self.hashtags)}
</div>
<div style="display: flex; gap: {Theme.SPACING["sm"]}; margin: {Theme.SPACING["sm"]} 0;">
{''.join(f'<span>{emoji}</span>' for emoji in self.emojis)}
</div>
<div style="margin-top: {Theme.SPACING["md"]};">
<div style="display: flex; justify-content: space-between; align-items: center;">
<span>Engagement Score: {self.engagement_score}%</span>
<div style="display: flex; gap: {Theme.SPACING["sm"]};">
<button class="stButton" onclick="copyTweet()">Copy</button>
<button class="stButton" onclick="saveTweet()">Save</button>
</div>
</div>
def _get_character_info(self):
"""Get character count information."""
full_text = f"{self.content} {' '.join(self.hashtags)}"
count = len(full_text)
remaining = 280 - count
if count <= 240:
status_class = "char-good"
elif count <= 270:
status_class = "char-warning"
else:
status_class = "char-danger"
return {
"count": count,
"remaining": remaining,
"status_class": status_class
}
def render(self):
"""Render the tweet card."""
apply_cards_styling()
char_info = self._get_character_info()
full_content = f"{self.content} {' '.join(self.hashtags)}"
# Create metrics HTML
metrics_html = ""
if self.metrics:
metric_items = []
for label, value in self.metrics.items():
metric_items.append(f"""
<div class="metric-card">
<span class="metric-value">{value}</span>
<span class="metric-label">{label}</span>
</div>
""")
metrics_html = f"""
<div class="metrics-grid">
{''.join(metric_items)}
</div>
""", unsafe_allow_html=True)
"""
if self.metrics:
cols = st.columns(len(self.metrics))
for i, (metric, value) in enumerate(self.metrics.items()):
with cols[i]:
st.metric(metric, f"{value}%")
# Create actions
actions = []
if self.on_copy:
actions.append('<button class="action-button" onclick="copyTweet()">📋 Copy</button>')
if self.on_save:
actions.append('<button class="action-button" onclick="saveTweet()">💾 Save</button>')
if self.on_edit:
actions.append('<button class="action-button" onclick="editTweet()">✏️ Edit</button>')
if self.on_post:
actions.append('<button class="action-button primary" onclick="postTweet()">🐦 Post</button>')
actions_html = f'<div class="card-actions">{"".join(actions)}</div>' if actions else ""
# Render the card
card_html = f"""
<div class="tweet-card">
<div class="tweet-content">{full_content}</div>
{metrics_html}
<div class="tweet-metadata">
<div class="engagement-badge">
📊 {self.engagement_score}% Engagement
</div>
<div class="character-badge {char_info['status_class']}">
{char_info['count']}/280
</div>
</div>
{actions_html}
</div>
"""
st.markdown(card_html, unsafe_allow_html=True)
class MetricsCard:
"""Modern metrics display card."""
def __init__(
self,
title: str,
metrics: Dict[str, any],
chart_data: Optional[Dict] = None,
trend: Optional[str] = None
):
self.title = title
self.metrics = metrics
self.chart_data = chart_data
self.trend = trend
def render(self):
"""Render the metrics card."""
apply_cards_styling()
# Create metrics grid
metric_items = []
for label, value in self.metrics.items():
metric_items.append(f"""
<div class="metric-card">
<span class="metric-value">{value}</span>
<span class="metric-label">{label}</span>
</div>
""")
metrics_grid = f"""
<div class="metrics-grid">
{''.join(metric_items)}
</div>
"""
# Add trend indicator
trend_html = ""
if self.trend:
trend_color = "#52C41A" if "up" in self.trend.lower() else "#F5222D"
trend_icon = "📈" if "up" in self.trend.lower() else "📉"
trend_html = f"""
<div style="text-align: center; margin-top: 1rem; color: {trend_color};">
{trend_icon} {self.trend}
</div>
"""
# Render the card
card_html = f"""
<div class="modern-card">
<h3 style="margin-bottom: 1rem; color: #2D3748;">{self.title}</h3>
{metrics_grid}
{trend_html}
</div>
"""
st.markdown(card_html, unsafe_allow_html=True)
# Add chart if provided
if self.chart_data:
self._render_chart()
def _render_chart(self):
"""Render chart for metrics."""
if self.chart_data.get("type") == "line":
fig = px.line(
x=self.chart_data.get("x", []),
y=self.chart_data.get("y", []),
title=self.chart_data.get("title", ""),
labels=self.chart_data.get("labels", {})
)
elif self.chart_data.get("type") == "bar":
fig = px.bar(
x=self.chart_data.get("x", []),
y=self.chart_data.get("y", []),
title=self.chart_data.get("title", ""),
labels=self.chart_data.get("labels", {})
)
else:
return
fig.update_layout(
plot_bgcolor='rgba(0,0,0,0)',
paper_bgcolor='rgba(0,0,0,0)',
showlegend=False,
height=300
)
st.plotly_chart(fig, use_container_width=True)
class StatusCard:
"""Status indicator card."""
def __init__(
self,
title: str,
status: str,
message: str,
icon: str = "ℹ️",
actions: Optional[List[Dict]] = None
):
self.title = title
self.status = status # success, warning, error, info
self.message = message
self.icon = icon
self.actions = actions or []
def render(self):
"""Render the status card."""
apply_cards_styling()
# Status colors
status_colors = {
"success": "#52C41A",
"warning": "#FA8C16",
"error": "#F5222D",
"info": "#1890FF"
}
color = status_colors.get(self.status, "#1890FF")
# Create actions
actions_html = ""
if self.actions:
action_buttons = []
for action in self.actions:
action_buttons.append(f"""
<button class="action-button" onclick="{action.get('onclick', '')}">
{action.get('icon', '')} {action.get('label', 'Action')}
</button>
""")
actions_html = f"""
<div class="card-actions">
{''.join(action_buttons)}
</div>
"""
# Render the card
card_html = f"""
<div class="modern-card" style="border-left: 4px solid {color};">
<div style="display: flex; align-items: center; gap: 1rem; margin-bottom: 1rem;">
<span style="font-size: 2rem;">{self.icon}</span>
<div>
<h3 style="margin: 0; color: #2D3748;">{self.title}</h3>
<span style="color: {color}; font-weight: 600; text-transform: uppercase; font-size: 0.8rem;">
{self.status}
</span>
</div>
</div>
<p style="color: #657786; margin-bottom: 1rem;">{self.message}</p>
{actions_html}
</div>
"""
st.markdown(card_html, unsafe_allow_html=True)
# Utility functions for creating common cards
def create_feature_card(title: str, description: str, icon: str = "🔧", **kwargs):
"""Create and render a feature card."""
card = FeatureCard(title, description, icon, **kwargs)
card.render()
def create_tweet_card(content: str, **kwargs):
"""Create and render a tweet card."""
card = TweetCard(content, **kwargs)
card.render()
def create_metrics_card(title: str, metrics: Dict, **kwargs):
"""Create and render a metrics card."""
card = MetricsCard(title, metrics, **kwargs)
card.render()
def create_status_card(title: str, status: str, message: str, **kwargs):
"""Create and render a status card."""
card = StatusCard(title, status, message, **kwargs)
card.render()

1236
lib/ai_writers/twitter_writers/twitter_streamlit_ui/components/forms.py
View File

File diff suppressed because it is too large Load Diff

658
lib/ai_writers/twitter_writers/twitter_streamlit_ui/components/navigation.py
View File

@@ -1,232 +1,554 @@
"""
Navigation components for Twitter UI.
Provides consistent navigation and layout structure.
Enhanced Navigation Component for Twitter UI with modern styling and improved functionality.
"""
import streamlit as st
from typing import Dict, Any, Optional, List
from typing import Dict, List, Optional, Callable, Any
from ..styles.theme import Theme
import os
def apply_navigation_styling():
"""Apply modern CSS styling for navigation components."""
st.markdown("""
<style>
/* Navigation Styles */
.nav-container {
background: rgba(255, 255, 255, 0.95);
backdrop-filter: blur(20px);
border-radius: 16px;
padding: 1rem;
margin-bottom: 2rem;
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
border: 1px solid rgba(255, 255, 255, 0.2);
}
.nav-header {
display: flex;
align-items: center;
justify-content: space-between;
margin-bottom: 1rem;
padding-bottom: 1rem;
border-bottom: 2px solid #E2E8F0;
}
.nav-title {
font-size: 1.5rem;
font-weight: 700;
color: #1DA1F2;
display: flex;
align-items: center;
gap: 0.5rem;
}
.nav-status {
display: flex;
align-items: center;
gap: 0.5rem;
padding: 0.5rem 1rem;
border-radius: 20px;
font-size: 0.9rem;
font-weight: 600;
}
.status-connected {
background: linear-gradient(135deg, #52C41A, #73D13D);
color: white;
}
.status-disconnected {
background: linear-gradient(135deg, #FA8C16, #FFA940);
color: white;
}
.nav-menu {
display: flex;
gap: 0.5rem;
flex-wrap: wrap;
}
.nav-item {
background: #F7F9FA;
border: 2px solid transparent;
border-radius: 12px;
padding: 0.75rem 1.5rem;
color: #657786;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
text-decoration: none;
display: flex;
align-items: center;
gap: 0.5rem;
}
.nav-item:hover {
background: #E1F5FE;
border-color: #1DA1F2;
color: #1DA1F2;
transform: translateY(-2px);
box-shadow: 0 4px 15px rgba(29, 161, 242, 0.2);
}
.nav-item.active {
background: linear-gradient(135deg, #1DA1F2, #0C85D0);
color: white;
border-color: #1DA1F2;
box-shadow: 0 4px 15px rgba(29, 161, 242, 0.3);
}
.nav-item.active:hover {
transform: translateY(-2px);
box-shadow: 0 6px 20px rgba(29, 161, 242, 0.4);
}
.nav-breadcrumb {
display: flex;
align-items: center;
gap: 0.5rem;
margin-bottom: 1rem;
font-size: 0.9rem;
color: #657786;
}
.breadcrumb-item {
display: flex;
align-items: center;
gap: 0.25rem;
}
.breadcrumb-separator {
color: #CBD5E0;
margin: 0 0.5rem;
}
.nav-actions {
display: flex;
gap: 0.5rem;
align-items: center;
}
.action-button {
background: linear-gradient(135deg, #52C41A, #73D13D);
color: white;
border: none;
border-radius: 8px;
padding: 0.5rem 1rem;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
display: flex;
align-items: center;
gap: 0.5rem;
}
.action-button:hover {
transform: translateY(-2px);
box-shadow: 0 4px 15px rgba(82, 196, 26, 0.3);
}
.action-button.secondary {
background: #F7F9FA;
color: #657786;
border: 1px solid #E1E8ED;
}
.action-button.secondary:hover {
background: #E1F5FE;
color: #1DA1F2;
border-color: #1DA1F2;
}
/* Mobile Responsive */
@media (max-width: 768px) {
.nav-header {
flex-direction: column;
gap: 1rem;
align-items: flex-start;
}
.nav-menu {
flex-direction: column;
width: 100%;
}
.nav-item {
width: 100%;
justify-content: center;
}
.nav-actions {
width: 100%;
justify-content: center;
}
}
</style>
""", unsafe_allow_html=True)
class TwitterNavigation:
"""Enhanced navigation component for Twitter dashboard."""
def __init__(self, theme: Optional[Theme] = None):
self.theme = theme or Theme()
self.current_page = st.session_state.get('current_page', 'dashboard')
def render_header(self, title: str = "Twitter AI Assistant", show_status: bool = True):
"""Render the navigation header with title and status."""
apply_navigation_styling()
st.markdown('<div class="nav-container">', unsafe_allow_html=True)
st.markdown('<div class="nav-header">', unsafe_allow_html=True)
# Title
st.markdown(f'<div class="nav-title">🐦 {title}</div>', unsafe_allow_html=True)
# Status indicator
if show_status:
twitter_connected = self._check_twitter_connection()
status_class = "status-connected" if twitter_connected else "status-disconnected"
status_text = "Connected" if twitter_connected else "Not Connected"
status_icon = "✅" if twitter_connected else "⚠️"
st.markdown(f'''
<div class="nav-status {status_class}">
{status_icon} Twitter {status_text}
</div>
''', unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def render_menu(self, menu_items: List[Dict], current_page: Optional[str] = None):
"""Render navigation menu with items."""
if current_page:
self.current_page = current_page
st.session_state.current_page = current_page
st.markdown('<div class="nav-menu">', unsafe_allow_html=True)
cols = st.columns(len(menu_items))
for i, item in enumerate(menu_items):
with cols[i]:
active_class = "active" if item.get('key') == self.current_page else ""
if st.button(
f"{item.get('icon', '')} {item.get('label', '')}",
key=f"nav_{item.get('key', i)}",
use_container_width=True,
type="primary" if active_class else "secondary"
):
st.session_state.current_page = item.get('key')
if item.get('callback'):
item['callback']()
st.rerun()
st.markdown('</div>', unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
return st.session_state.get('current_page', menu_items[0].get('key'))
def render_breadcrumb(self, items: List[Dict]):
"""Render breadcrumb navigation."""
st.markdown('<div class="nav-breadcrumb">', unsafe_allow_html=True)
for i, item in enumerate(items):
if i > 0:
st.markdown('<span class="breadcrumb-separator">›</span>', unsafe_allow_html=True)
icon = item.get('icon', '')
label = item.get('label', '')
if item.get('active', False):
st.markdown(f'<span class="breadcrumb-item"><strong>{icon} {label}</strong></span>', unsafe_allow_html=True)
else:
st.markdown(f'<span class="breadcrumb-item">{icon} {label}</span>', unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def render_actions(self, actions: List[Dict]):
"""Render action buttons in navigation."""
st.markdown('<div class="nav-actions">', unsafe_allow_html=True)
cols = st.columns(len(actions))
for i, action in enumerate(actions):
with cols[i]:
button_type = action.get('type', 'primary')
if st.button(
f"{action.get('icon', '')} {action.get('label', '')}",
key=f"action_{action.get('key', i)}",
type=button_type,
use_container_width=True,
help=action.get('help', '')
):
if action.get('callback'):
action['callback']()
st.markdown('</div>', unsafe_allow_html=True)
def render_sidebar_menu(self, menu_items: List[Dict]):
"""Render sidebar navigation menu."""
with st.sidebar:
st.markdown("### 🐦 Twitter Tools")
for item in menu_items:
icon = item.get('icon', '')
label = item.get('label', '')
key = item.get('key', '')
if st.button(f"{icon} {label}", key=f"sidebar_{key}", use_container_width=True):
st.session_state.current_page = key
if item.get('callback'):
item['callback']()
st.rerun()
# Twitter connection status in sidebar
st.markdown("---")
twitter_connected = self._check_twitter_connection()
if twitter_connected:
st.success("🐦 Twitter Connected")
else:
st.warning("⚠️ Twitter Not Connected")
if st.button("🔧 Configure Twitter", use_container_width=True):
st.session_state.show_twitter_config = True
st.rerun()
def _check_twitter_connection(self) -> bool:
"""Check if Twitter is connected."""
twitter_config = st.session_state.get('twitter_config', {})
return bool(twitter_config and all([
twitter_config.get('api_key'),
twitter_config.get('api_secret'),
twitter_config.get('access_token'),
twitter_config.get('access_token_secret')
]))
class Sidebar:
"""Sidebar navigation component."""
def __init__(
self,
title: str = "Twitter Tools",
logo: Optional[str] = None,
menu_items: Optional[List[Dict[str, Any]]] = None
):
def __init__(self, title: str = "Navigation", logo: Optional[str] = None):
"""Initialize the sidebar."""
self.title = title
self.logo = logo
self.menu_items = menu_items or []
self.menu_items = []
def add_menu_item(
self,
label: str,
icon: str,
page: str,
badge: Optional[str] = None
) -> None:
def add_menu_item(self, label: str, icon: str, key: str, callback: Optional[Callable] = None):
"""Add a menu item to the sidebar."""
self.menu_items.append({
"label": label,
"icon": icon,
"page": page,
"badge": badge
'label': label,
'icon': icon,
'key': key,
'callback': callback
})
def render(self) -> None:
"""Render the sidebar with consistent styling."""
def render(self) -> str:
"""Render the sidebar and return the selected page."""
with st.sidebar:
# Logo and title
if self.logo:
try:
import os
if os.path.exists(self.logo):
st.image(self.logo, width=50)
else:
# Show a placeholder or just skip the logo
st.markdown("🐦", help="Twitter Tools Logo")
except Exception as e:
# If there's any error loading the image, show an emoji instead
st.markdown("🐦", help="Twitter Tools Logo")
st.markdown(f"""
<h2 style="margin: {Theme.SPACING["sm"]} 0;">{self.title}</h2>
""", unsafe_allow_html=True)
if self.logo and os.path.exists(self.logo):
st.image(self.logo, width=100)
st.title(self.title)
st.markdown("---")
# Menu items
selected_page = None
for item in self.menu_items:
st.markdown(f"""
<div class="menu-item">
<span style="font-size: 1.2em; margin-right: {Theme.SPACING["sm"]};">{item["icon"]}</span>
<span>{item["label"]}</span>
{f'<span class="badge">{item["badge"]}</span>' if item.get("badge") else ""}
</div>
""", unsafe_allow_html=True)
if st.button(
item["label"],
key=f"nav_{item['page']}",
f"{item['icon']} {item['label']}",
key=f"sidebar_{item['key']}",
use_container_width=True
):
st.session_state["current_page"] = item["page"]
selected_page = item['key']
if item.get('callback'):
item['callback']()
return selected_page or st.session_state.get('current_page', 'dashboard')
class Header:
"""Header navigation component."""
"""Header component with title and actions."""
def __init__(
self,
title: str,
subtitle: Optional[str] = None,
actions: Optional[List[Dict[str, Any]]] = None
):
def __init__(self, title: str = "Dashboard", subtitle: str = ""):
"""Initialize the header."""
self.title = title
self.subtitle = subtitle
self.actions = actions or []
self.actions = []
def add_action(
self,
label: str,
icon: str,
callback: callable,
help_text: Optional[str] = None
) -> None:
def add_action(self, label: str, icon: str, callback: Callable, help_text: str = ""):
"""Add an action button to the header."""
self.actions.append({
"label": label,
"icon": icon,
"callback": callback,
"help_text": help_text
'label': label,
'icon': icon,
'callback': callback,
'help': help_text
})
def render(self) -> None:
"""Render the header with consistent styling."""
# Build action buttons HTML
action_buttons = []
for action in self.actions:
help_text = action.get("help_text", "")
action_buttons.append(f"""
<button class="header-action" title="{help_text}">
<span style="font-size: 1.2em; margin-right: {Theme.SPACING["xs"]};">{action["icon"]}</span>
{action["label"]}
</button>
""")
def render(self):
"""Render the header."""
col1, col2 = st.columns([3, 1])
st.markdown(f"""
<div class="header">
<div>
<h1 style="margin: 0;">{self.title}</h1>
{f'<p style="color: {Theme.COLORS["text_secondary"]}; margin: {Theme.SPACING["xs"]} 0;">{self.subtitle}</p>' if self.subtitle else ""}
</div>
<div style="display: flex; gap: {Theme.SPACING["sm"]};">
{''.join(action_buttons)}
</div>
</div>
""", unsafe_allow_html=True)
with col1:
st.title(f"{self.title}")
if self.subtitle:
st.markdown(f"*{self.subtitle}*")
with col2:
if self.actions:
for i, action in enumerate(self.actions):
if st.button(
f"{action['icon']} {action['label']}",
key=f"header_action_{i}",
help=action.get('help', ''),
use_container_width=True
):
action['callback']()
# Add action button callbacks
for i, action in enumerate(self.actions):
if st.button(
action["label"],
key=f"header_action_{i}",
help=action.get("help_text")
):
action["callback"]()
class Tabs:
"""Tab navigation component."""
def __init__(
self,
tabs: Optional[List[Dict[str, Any]]] = None,
default_tab: Optional[str] = None
):
self.tabs = tabs or []
self.default_tab = default_tab
def __init__(self):
"""Initialize the tabs."""
self.tabs = []
def add_tab(
self,
label: str,
icon: Optional[str] = None,
content: Optional[callable] = None
) -> None:
"""Add a tab to the navigation."""
def add_tab(self, label: str, icon: str, content_func: Callable):
"""Add a tab."""
self.tabs.append({
"label": label,
"icon": icon,
"content": content
'label': label,
'icon': icon,
'content_func': content_func
})
def render(self) -> None:
"""Render the tabs with consistent styling."""
def render(self):
"""Render the tabs."""
if not self.tabs:
return
# Create tab labels with icons
tab_labels = [
f"{tab['icon']} {tab['label']}" if tab.get('icon') else tab['label']
for tab in self.tabs
]
tab_labels = [f"{tab['icon']} {tab['label']}" for tab in self.tabs]
selected_tabs = st.tabs(tab_labels)
# Get current tab from session state or use default
current_tab = st.session_state.get("current_tab", self.default_tab or self.tabs[0]["label"])
for i, tab in enumerate(self.tabs):
with selected_tabs[i]:
tab['content_func']()
# Render tabs
selected_tab = st.tabs(tab_labels)[tab_labels.index(current_tab)]
# Update session state
st.session_state["current_tab"] = current_tab
# Render tab content
with selected_tab:
for tab in self.tabs:
if tab["label"] == current_tab and tab.get("content"):
tab["content"]()
class Breadcrumbs:
"""Breadcrumb navigation component."""
def __init__(
self,
items: Optional[List[Dict[str, Any]]] = None
):
self.items = items or []
def __init__(self):
"""Initialize breadcrumbs."""
self.items = []
def add_item(
self,
label: str,
page: Optional[str] = None,
icon: Optional[str] = None
) -> None:
def add_item(self, label: str, key: str = None, callback: Callable = None):
"""Add a breadcrumb item."""
self.items.append({
"label": label,
"page": page,
"icon": icon
'label': label,
'key': key,
'callback': callback
})
def render(self) -> None:
"""Render the breadcrumbs with consistent styling."""
def render(self):
"""Render the breadcrumbs."""
if not self.items:
return
breadcrumb_items = []
breadcrumb_html = '<div class="nav-breadcrumb">'
for i, item in enumerate(self.items):
icon_html = f'<span style="font-size: 1.2em; margin-right: {Theme.SPACING["xs"]};">{item["icon"]}</span>' if item.get("icon") else ""
link_html = f'<a href="#" onclick="setPage(\'{item["page"]}\')">{item["label"]}</a>' if item.get("page") else f'<span>{item["label"]}</span>'
separator = f'<span style="margin: 0 {Theme.SPACING["xs"]};">/</span>' if i < len(self.items) - 1 else ""
if i > 0:
breadcrumb_html += '<span class="breadcrumb-separator">›</span>'
breadcrumb_items.append(f"""
<span class="breadcrumb-item">
{icon_html}
{link_html}
</span>
{separator}
""")
if item.get('callback'):
breadcrumb_html += f'<span class="breadcrumb-item clickable" onclick="handleBreadcrumbClick(\'{item["key"]}\')">{item["label"]}</span>'
else:
breadcrumb_html += f'<span class="breadcrumb-item">{item["label"]}</span>'
st.markdown(f"""
<div class="breadcrumbs">
{''.join(breadcrumb_items)}
</div>
""", unsafe_allow_html=True)
breadcrumb_html += '</div>'
st.markdown(breadcrumb_html, unsafe_allow_html=True)
def create_main_navigation() -> TwitterNavigation:
"""Create and return the main navigation instance."""
return TwitterNavigation()
def render_page_header(title: str, subtitle: str = "", icon: str = ""):
"""Render a consistent page header."""
st.markdown(f"""
<div style="text-align: center; margin-bottom: 2rem; padding: 2rem; background: linear-gradient(135deg, #E6F7FF, #F0F9FF); border-radius: 16px;">
<h1 style="color: #1DA1F2; margin-bottom: 0.5rem;">{icon} {title}</h1>
{f'<p style="color: #657786; font-size: 1.1rem;">{subtitle}</p>' if subtitle else ''}
</div>
""", unsafe_allow_html=True)
def render_quick_actions(actions: List[Dict]):
"""Render quick action buttons."""
st.markdown("### ⚡ Quick Actions")
cols = st.columns(len(actions))
for i, action in enumerate(actions):
with cols[i]:
if st.button(
f"{action.get('icon', '')} {action.get('label', '')}",
key=f"quick_action_{i}",
use_container_width=True,
help=action.get('help', '')
):
if action.get('callback'):
action['callback']()
# Default menu items for Twitter dashboard
DEFAULT_MENU_ITEMS = [
{
'key': 'dashboard',
'label': 'Dashboard',
'icon': '🏠',
'help': 'Main dashboard overview'
},
{
'key': 'generator',
'label': 'Tweet Generator',
'icon': '✨',
'help': 'AI-powered tweet generation'
},
{
'key': 'analytics',
'label': 'Analytics',
'icon': '📊',
'help': 'Tweet performance analytics'
},
{
'key': 'scheduler',
'label': 'Scheduler',
'icon': '📅',
'help': 'Schedule tweets for later'
},
{
'key': 'settings',
'label': 'Settings',
'icon': '⚙️',
'help': 'Twitter account and API settings'
}
]
DEFAULT_QUICK_ACTIONS = [
{
'key': 'new_tweet',
'label': 'New Tweet',
'icon': '✍️',
'help': 'Create a new tweet'
},
{
'key': 'ai_generate',
'label': 'AI Generate',
'icon': '🤖',
'help': 'Generate tweets with AI'
},
{
'key': 'view_analytics',
'label': 'View Analytics',
'icon': '📈',
'help': 'Check tweet performance'
}
]

503
lib/ai_writers/twitter_writers/twitter_streamlit_ui/twitter_dashboard.py Normal file
View File

@@ -0,0 +1,503 @@
"""
Enhanced Twitter Dashboard with real authentication and posting capabilities.
"""
import streamlit as st
import asyncio
from datetime import datetime, timedelta
import json
from typing import Dict, Any, List, Optional
# Import our enhanced components
from .components.navigation import TwitterNavigation, create_main_navigation
from .components.cards import TwitterCard, create_analytics_card, create_tweet_card
from .components.forms import TweetForm, TwitterConfigForm
from ..tweet_generator.smart_tweet_generator import (
smart_tweet_generator,
post_tweet_to_twitter,
get_real_tweet_analytics,
render_twitter_authentication
)
from ....integrations.twitter_auth_bridge import (
TwitterAuthBridge,
save_twitter_credentials,
load_twitter_credentials,
is_twitter_authenticated,
setup_twitter_session,
clear_twitter_session
)
# Initialize authentication bridge
auth_bridge = TwitterAuthBridge()
def initialize_dashboard():
"""Initialize the Twitter dashboard with proper styling and state management."""
# Apply custom CSS
st.markdown("""
<style>
.main-dashboard {
padding: 1rem;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
}
.dashboard-header {
background: white;
padding: 2rem;
border-radius: 15px;
box-shadow: 0 10px 30px rgba(0,0,0,0.1);
margin-bottom: 2rem;
text-align: center;
}
.dashboard-title {
font-size: 2.5rem;
font-weight: 700;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
margin-bottom: 0.5rem;
}
.dashboard-subtitle {
color: #666;
font-size: 1.1rem;
margin-bottom: 1rem;
}
.status-indicator {
display: inline-flex;
align-items: center;
gap: 0.5rem;
padding: 0.5rem 1rem;
border-radius: 25px;
font-weight: 500;
font-size: 0.9rem;
}
.status-connected {
background: #d4edda;
color: #155724;
border: 1px solid #c3e6cb;
}
.status-disconnected {
background: #f8d7da;
color: #721c24;
border: 1px solid #f5c6cb;
}
.dashboard-grid {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 2rem;
margin-bottom: 2rem;
}
@media (max-width: 768px) {
.dashboard-grid {
grid-template-columns: 1fr;
}
}
.action-button {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
border: none;
padding: 0.75rem 1.5rem;
border-radius: 8px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s ease;
}
.action-button:hover {
transform: translateY(-2px);
box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
}
.metrics-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 1rem;
margin: 1rem 0;
}
.metric-card {
background: white;
padding: 1.5rem;
border-radius: 10px;
box-shadow: 0 5px 15px rgba(0,0,0,0.1);
text-align: center;
}
.metric-value {
font-size: 2rem;
font-weight: 700;
color: #667eea;
margin-bottom: 0.5rem;
}
.metric-label {
color: #666;
font-size: 0.9rem;
text-transform: uppercase;
letter-spacing: 0.5px;
}
</style>
""", unsafe_allow_html=True)
# Initialize session state
if 'twitter_dashboard_initialized' not in st.session_state:
st.session_state.twitter_dashboard_initialized = True
st.session_state.current_page = 'dashboard'
st.session_state.tweet_drafts = []
st.session_state.posted_tweets = []
st.session_state.analytics_data = {}
def render_dashboard_header():
"""Render the main dashboard header with connection status."""
st.markdown('<div class="dashboard-header">', unsafe_allow_html=True)
col1, col2, col3 = st.columns([1, 2, 1])
with col2:
st.markdown('<h1 class="dashboard-title">🐦 Twitter AI Dashboard</h1>', unsafe_allow_html=True)
st.markdown('<p class="dashboard-subtitle">AI-Powered Tweet Generation & Analytics</p>', unsafe_allow_html=True)
# Connection status
is_connected = is_twitter_authenticated()
if is_connected:
user_info = st.session_state.get('twitter_user', {})
username = user_info.get('screen_name', 'Unknown')
st.markdown(f'''
<div class="status-indicator status-connected">
✅ Connected as @{username}
</div>
''', unsafe_allow_html=True)
else:
st.markdown('''
<div class="status-indicator status-disconnected">
❌ Not Connected to Twitter
</div>
''', unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def render_quick_actions():
"""Render quick action buttons."""
st.markdown("### 🚀 Quick Actions")
col1, col2, col3, col4 = st.columns(4)
with col1:
if st.button("📝 Generate Tweet", key="quick_generate", help="Create AI-powered tweets"):
st.session_state.current_page = 'generate'
st.rerun()
with col2:
if st.button("📊 View Analytics", key="quick_analytics", help="View tweet performance"):
st.session_state.current_page = 'analytics'
st.rerun()
with col3:
if st.button("⚙️ Settings", key="quick_settings", help="Configure Twitter connection"):
st.session_state.current_page = 'settings'
st.rerun()
with col4:
if st.button("📋 Drafts", key="quick_drafts", help="Manage tweet drafts"):
st.session_state.current_page = 'drafts'
st.rerun()
def render_dashboard_overview():
"""Render the main dashboard overview with metrics."""
if not is_twitter_authenticated():
st.warning("⚠️ Please connect your Twitter account to view dashboard metrics.")
if st.button("Connect Twitter Account", type="primary"):
st.session_state.current_page = 'settings'
st.rerun()
return
# Get user metrics
user_info = st.session_state.get('twitter_user', {})
# Display metrics
st.markdown("### 📈 Account Overview")
col1, col2, col3, col4 = st.columns(4)
with col1:
st.markdown(f'''
<div class="metric-card">
<div class="metric-value">{user_info.get('followers_count', 0):,}</div>
<div class="metric-label">Followers</div>
</div>
''', unsafe_allow_html=True)
with col2:
st.markdown(f'''
<div class="metric-card">
<div class="metric-value">{user_info.get('friends_count', 0):,}</div>
<div class="metric-label">Following</div>
</div>
''', unsafe_allow_html=True)
with col3:
posted_count = len(st.session_state.get('posted_tweets', []))
st.markdown(f'''
<div class="metric-card">
<div class="metric-value">{posted_count}</div>
<div class="metric-label">Posted Today</div>
</div>
''', unsafe_allow_html=True)
with col4:
draft_count = len(st.session_state.get('tweet_drafts', []))
st.markdown(f'''
<div class="metric-card">
<div class="metric-value">{draft_count}</div>
<div class="metric-label">Drafts</div>
</div>
''', unsafe_allow_html=True)
# Recent activity
st.markdown("### 📝 Recent Activity")
recent_tweets = st.session_state.get('posted_tweets', [])[-5:] # Last 5 tweets
if recent_tweets:
for tweet in reversed(recent_tweets):
with st.expander(f"Tweet: {tweet.get('text', '')[:50]}..."):
col1, col2 = st.columns([2, 1])
with col1:
st.write(f"**Text:** {tweet.get('text', '')}")
st.write(f"**Posted:** {tweet.get('created_at', '')}")
if tweet.get('metrics'):
metrics = tweet['metrics']
st.write(f"**Engagement:** {metrics.get('favorite_count', 0)} likes, "
f"{metrics.get('retweet_count', 0)} retweets")
with col2:
if st.button(f"View Analytics", key=f"analytics_{tweet.get('id')}"):
st.session_state.selected_tweet_id = tweet.get('id')
st.session_state.current_page = 'analytics'
st.rerun()
else:
st.info("No recent tweets found. Start by generating and posting some content!")
def render_settings_page():
"""Render the settings page for Twitter configuration."""
st.markdown("### ⚙️ Twitter Configuration")
# Twitter Authentication Section
with st.expander("🔐 Twitter API Configuration", expanded=not is_twitter_authenticated()):
render_twitter_authentication()
# Account Information
if is_twitter_authenticated():
st.markdown("### 👤 Account Information")
user_info = st.session_state.get('twitter_user', {})
col1, col2 = st.columns(2)
with col1:
st.write(f"**Username:** @{user_info.get('screen_name', 'N/A')}")
st.write(f"**Display Name:** {user_info.get('name', 'N/A')}")
st.write(f"**Followers:** {user_info.get('followers_count', 0):,}")
with col2:
st.write(f"**Following:** {user_info.get('friends_count', 0):,}")
st.write(f"**Tweets:** {user_info.get('statuses_count', 0):,}")
st.write(f"**Account Created:** {user_info.get('created_at', 'N/A')}")
# Disconnect option
st.markdown("---")
if st.button("🔓 Disconnect Twitter Account", type="secondary"):
clear_twitter_session()
st.success("Twitter account disconnected successfully!")
st.rerun()
def render_analytics_page():
"""Render the analytics page with real Twitter metrics."""
st.markdown("### 📊 Tweet Analytics")
if not is_twitter_authenticated():
st.warning("Please connect your Twitter account to view analytics.")
return
# Tweet selection
posted_tweets = st.session_state.get('posted_tweets', [])
if not posted_tweets:
st.info("No tweets found. Generate and post some tweets to see analytics!")
return
# Select tweet for analysis
tweet_options = {
f"{tweet.get('text', '')[:50]}... ({tweet.get('created_at', '')})": tweet.get('id')
for tweet in posted_tweets
}
selected_tweet_text = st.selectbox(
"Select a tweet to analyze:",
options=list(tweet_options.keys())
)
if selected_tweet_text:
tweet_id = tweet_options[selected_tweet_text]
# Get analytics
with st.spinner("Loading analytics..."):
analytics_result = asyncio.run(get_real_tweet_analytics(tweet_id))
if analytics_result.get('success'):
analytics_data = analytics_result['data']
# Display metrics
st.markdown("#### 📈 Performance Metrics")
col1, col2, col3, col4 = st.columns(4)
metrics = analytics_data.get('metrics', {})
with col1:
st.metric("Likes", metrics.get('likes', 0))
with col2:
st.metric("Retweets", metrics.get('retweets', 0))
with col3:
st.metric("Replies", metrics.get('replies', 0))
with col4:
engagement = analytics_data.get('engagement', {})
st.metric("Engagement Rate", f"{engagement.get('engagement_rate', 0):.2f}%")
# Detailed analytics
st.markdown("#### 🔍 Detailed Analysis")
col1, col2 = st.columns(2)
with col1:
st.markdown("**Engagement Breakdown:**")
total_engagement = metrics.get('total_engagement', 0)
st.write(f"• Total Engagement: {total_engagement}")
st.write(f"• Likes Rate: {engagement.get('likes_rate', 0):.2f}%")
st.write(f"• Retweets Rate: {engagement.get('retweets_rate', 0):.2f}%")
with col2:
st.markdown("**Content Analysis:**")
content_analysis = analytics_data.get('content_analysis', {})
st.write(f"• Character Count: {content_analysis.get('character_count', 0)}")
st.write(f"• Hashtags: {content_analysis.get('hashtag_count', 0)}")
st.write(f"• Mentions: {content_analysis.get('mention_count', 0)}")
# Timing analysis
timing = analytics_data.get('timing', {})
if timing:
st.markdown("#### ⏰ Timing Analysis")
st.write(f"• Posted: {timing.get('posted_at', 'N/A')}")
st.write(f"• Age: {timing.get('age_hours', 0):.1f} hours")
st.write(f"• Peak Period: {timing.get('peak_engagement_period', 'N/A')}")
st.write(f"• Engagement Velocity: {timing.get('engagement_velocity', 0):.2f} per hour")
else:
st.error(f"Failed to load analytics: {analytics_result.get('error', 'Unknown error')}")
def render_drafts_page():
"""Render the drafts management page."""
st.markdown("### 📋 Tweet Drafts")
drafts = st.session_state.get('tweet_drafts', [])
if not drafts:
st.info("No drafts found. Create some tweets in the generator to save as drafts!")
return
for i, draft in enumerate(drafts):
with st.expander(f"Draft {i+1}: {draft.get('text', '')[:50]}..."):
col1, col2 = st.columns([3, 1])
with col1:
st.write(f"**Text:** {draft.get('text', '')}")
st.write(f"**Created:** {draft.get('created_at', '')}")
if draft.get('hashtags'):
st.write(f"**Hashtags:** {', '.join(draft['hashtags'])}")
with col2:
if st.button(f"Post Now", key=f"post_draft_{i}"):
if is_twitter_authenticated():
with st.spinner("Posting tweet..."):
result = asyncio.run(post_tweet_to_twitter(draft))
if result.get('success'):
st.success("Tweet posted successfully!")
# Move from drafts to posted
st.session_state.posted_tweets.append(result['data'])
st.session_state.tweet_drafts.pop(i)
st.rerun()
else:
st.error(f"Failed to post: {result.get('error')}")
else:
st.error("Please connect your Twitter account first!")
if st.button(f"Delete", key=f"delete_draft_{i}"):
st.session_state.tweet_drafts.pop(i)
st.rerun()
def main_twitter_dashboard():
"""Main Twitter dashboard function."""
# Initialize dashboard
initialize_dashboard()
# Create navigation
nav = TwitterNavigation()
current_page = nav.render_main_navigation()
# Update session state if page changed
if current_page != st.session_state.get('current_page'):
st.session_state.current_page = current_page
# Render dashboard header
render_dashboard_header()
# Route to appropriate page
page = st.session_state.get('current_page', 'dashboard')
if page == 'dashboard':
render_quick_actions()
render_dashboard_overview()
elif page == 'generate':
st.markdown("### 🤖 AI Tweet Generator")
smart_tweet_generator()
elif page == 'analytics':
render_analytics_page()
elif page == 'settings':
render_settings_page()
elif page == 'drafts':
render_drafts_page()
else:
# Default to dashboard
render_quick_actions()
render_dashboard_overview()
if __name__ == "__main__":
main_twitter_dashboard()

169
lib/alwrity_ui/alwrity_researcher/README.md Normal file
View File

@@ -0,0 +1,169 @@
# AI Web Researcher Dashboard for Content Creators
## Overview
The AI Web Researcher Dashboard is a comprehensive suite of research tools designed specifically for content creators. This dashboard integrates various web research modules to streamline the content research process, enhance content quality, and improve workflow efficiency.
## Available Research Modules
### 1. Search Engine Research Tools
#### Google SERP Search
- **Functionality**: Retrieves organic search results, People Also Ask questions, and related searches
- **Best for**: Initial topic research, understanding search intent, and identifying content gaps
- **Key features**: Comprehensive search results with structured data extraction
#### Tavily AI Search
- **Functionality**: Advanced AI-powered search with semantic understanding
- **Best for**: In-depth research requiring contextual understanding
- **Key features**: Provides direct answers to questions and follow-up question suggestions
### 2. Neural Search Tools
#### Metaphor Neural Search
- **Functionality**: Semantic search technology for finding related content
- **Best for**: Discovering content based on conceptual similarity rather than keyword matching
- **Key features**: Find similar articles, competitor analysis, and content inspiration
### 3. Trend Analysis Tools
#### Google Trends Researcher
- **Functionality**: Analyzes search term popularity over time
- **Best for**: Content planning, seasonal topic identification, and trend forecasting
- **Key features**: Interest over time visualization, regional interest mapping, and related query analysis
### 4. Web Crawling & Analysis Tools
#### Async Web Crawler
- **Functionality**: Crawls websites to extract structured content
- **Best for**: Content auditing, competitor analysis, and data extraction
- **Key features**: Extracts titles, descriptions, main content, headings, links, and images
#### Firecrawl Web Crawler
- **Functionality**: Specialized crawler for single-page or website scraping
- **Best for**: Detailed content extraction from specific URLs
- **Key features**: Configurable depth and page limits for targeted crawling
#### Website Analyzer
- **Functionality**: Comprehensive website analysis for content and technical aspects
- **Best for**: Content quality assessment, SEO analysis, and technical audits
- **Key features**: Content quality metrics, SEO recommendations, and technical performance insights
## Optimal Workflows for Content Creators
### Research Workflow 1: Comprehensive Topic Research
1. **Initial Exploration** (Google SERP Search)
- Search for your main topic to understand the search landscape
- Analyze People Also Ask questions to identify user intent
2. **In-depth Research** (Tavily AI Search)
- Use identified subtopics for deeper research
- Collect factual information and expert insights
3. **Competitive Analysis** (Metaphor Neural Search + Web Crawler)
- Find similar content from competitors
- Analyze content structure and approach
4. **Trend Validation** (Google Trends Researcher)
- Verify topic popularity and seasonal patterns
- Identify related trending topics
### Research Workflow 2: Content Gap Analysis
1. **Competitor Content Mapping** (Async Web Crawler)
- Crawl competitor websites to extract content structure
- Identify their content categories and topics
2. **Topic Opportunity Discovery** (Google Trends + Metaphor Search)
- Research trending topics in your niche
- Find content areas with high interest but low competition
3. **Content Quality Benchmarking** (Website Analyzer)
- Analyze top-performing content in your niche
- Identify quality benchmarks and content standards
### Research Workflow 3: Content Refresh & Update
1. **Content Performance Analysis** (Website Analyzer)
- Analyze existing content for improvement opportunities
- Identify outdated information and gaps
2. **Current Trend Integration** (Google Trends Researcher)
- Research current trends related to your content
- Identify new angles and perspectives
3. **Competitive Edge Research** (Tavily AI + Metaphor Search)
- Research what competitors have updated recently
- Find new research, statistics, and information to incorporate
## Integration with Content Creation Process
### Pre-Writing Phase
- Use research modules to gather comprehensive information
- Create content briefs based on research findings
- Identify key points, statistics, and examples to include
### Writing Phase
- Reference research findings for accurate information
- Use competitor insights to differentiate your content
- Incorporate trending topics and keywords
### Post-Publishing Phase
- Monitor content performance against researched benchmarks
- Update content based on new research findings
- Plan related content based on research insights
## Dashboard Usage Examples
### Example 1: Creating a Comprehensive Blog Post
1. Start with Google SERP Search for your main topic
2. Use Tavily AI Search to gather in-depth information on subtopics
3. Analyze competitor content with Metaphor Neural Search
4. Check topic seasonality with Google Trends Researcher
5. Create content that addresses all aspects discovered in research
### Example 2: Developing a Content Strategy
1. Use Google Trends to identify trending topics in your niche
2. Analyze competitor websites with Async Web Crawler
3. Research content gaps using Metaphor Neural Search
4. Prioritize content topics based on trend data and competition
5. Create a content calendar incorporating research insights
### Example 3: Updating Existing Content
1. Analyze current content with Website Analyzer
2. Research new developments with Tavily AI Search
3. Check for changing trends with Google Trends Researcher
4. Identify new angles with Metaphor Neural Search
5. Update content with new information and perspectives
## Best Practices for Effective Research
1. **Start Broad, Then Narrow**: Begin with general search tools before using specialized ones
2. **Combine Multiple Research Methods**: Use different modules for comprehensive insights
3. **Focus on User Intent**: Prioritize research that reveals what your audience wants
4. **Validate with Data**: Use trend analysis to validate topic importance
5. **Organize Research Findings**: Create structured notes from your research
6. **Set Research Goals**: Define what you need to learn before starting
7. **Schedule Regular Research**: Keep content updated with periodic research
## Technical Requirements
- API keys for various services (Google, Tavily, Metaphor, etc.)
- Proper configuration in the .env file
- Sufficient system resources for web crawling operations
## Future Enhancements
- Integration with content planning calendar
- Automated research reports
- Competitive content gap analysis
- AI-powered content brief generation
- Customizable research workflows
---
This dashboard is designed to streamline the research process for content creators, providing powerful tools to enhance content quality, relevance, and performance. By following the suggested workflows and best practices, content creators can significantly improve their research efficiency and content outcomes.

98
lib/alwrity_ui/alwrity_researcher/README_DASHBOARD.md Normal file
View File

@@ -0,0 +1,98 @@
# AI Web Researcher Dashboard
## Overview
The AI Web Researcher Dashboard is a modern, intuitive interface designed specifically for content creators and digital marketing professionals. This dashboard integrates various web research tools to streamline the content research process, enhance content quality, and improve workflow efficiency.
## Features
### 1. Intuitive User Interface
- Modern, colorful, and professional design
- Easy navigation through different research tools
- Responsive layout that works on various screen sizes
### 2. Integrated Research Tools
- **Search Engine Research**: Google SERP Search and Tavily AI Search
- **Neural Search**: Metaphor Neural Search for finding conceptually similar content
- **Trend Analysis**: Google Trends Researcher for analyzing search term popularity
- **Web Crawling & Analysis**: Tools for extracting and analyzing web content
### 3. Guided Research Workflows
- Comprehensive Topic Research workflow
- Content Gap Analysis workflow
- Content Refresh & Update workflow
## Installation
1. Ensure you have Python 3.8+ installed
2. Install the required dependencies:
```
pip install -r requirements.txt
```
3. Set up the necessary API keys in your environment variables or .env file
## Usage
1. Navigate to the dashboard directory:
```
cd AI-Writer/lib/alwrity_ui/alwrity_researcher
```
2. Run the dashboard:
```
python -m streamlit run main.py
```
3. Access the dashboard in your web browser at http://localhost:8501
## Dashboard Sections
### Dashboard Home
Provides an overview of available research tools and featured workflows.
### Search Tools
Access to Google SERP Search and Tavily AI Search for comprehensive search capabilities.
### Neural Search
Use Metaphor Neural Search to find content based on conceptual similarity rather than keyword matching.
### Trend Analysis
Analyze search term popularity over time using Google Trends Researcher.
### Web Crawling
Extract structured content from websites using various web crawling tools.
### Research Workflows
Guided workflows that combine multiple tools for specific research objectives.
## Current Implementation Status
This is the initial implementation of the dashboard with placeholder functionality. The UI is fully implemented, but the actual integration with the AI web research modules will be completed in the next phase.
### What's Implemented
- Complete user interface with all sections and forms
- Mock data visualization for demonstration purposes
- Placeholder functionality for all research tools
### Next Steps
- Integrate with actual AI web research modules
- Implement data processing and visualization with real data
- Add user authentication and result saving functionality
## Technical Details
- Built with Streamlit for rapid UI development
- Modular design for easy extension and maintenance
- Responsive layout that works on desktop and mobile devices
## File Structure
- `main.py`: Entry point for the application
- `dashboard.py`: Main dashboard implementation
- `utils.py`: Utility functions for data processing and visualization
- `style.css`: Custom CSS for styling the dashboard
- `requirements.txt`: Required Python packages
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.

66
lib/alwrity_ui/alwrity_researcher/config.py Normal file
View File

@@ -0,0 +1,66 @@
import os
import streamlit as st
from dotenv import load_dotenv
# Load environment variables from .env file
load_dotenv()
def get_api_key(key_name):
"""Get API key from environment variables or Streamlit secrets"""
# Try to get from environment variables first
api_key = os.getenv(key_name)
# If not found in environment, try Streamlit secrets
if not api_key and key_name in st.secrets:
api_key = st.secrets[key_name]
return api_key
def check_api_configuration():
"""Check if all required API keys are configured"""
api_status = {
"SERPER_API_KEY": bool(get_api_key("SERPER_API_KEY")),
"TAVILY_API_KEY": bool(get_api_key("TAVILY_API_KEY")),
"METAPHOR_API_KEY": bool(get_api_key("METAPHOR_API_KEY")),
"FIRECRAWL_API_KEY": bool(get_api_key("FIRECRAWL_API_KEY"))
}
return api_status
def display_api_configuration_status():
"""Display API configuration status in the sidebar with improved styling"""
api_status = check_api_configuration()
st.sidebar.markdown("<div class='api-status-container'>", unsafe_allow_html=True)
st.sidebar.markdown("<div class='api-status-title'>API Configuration Status</div>", unsafe_allow_html=True)
# Display API status with improved styling
for api_name, is_configured in api_status.items():
if is_configured:
st.sidebar.markdown(
f"<div class='api-status-item configured'>✅ {api_name}</div>",
unsafe_allow_html=True
)
else:
st.sidebar.markdown(
f"<div class='api-status-item not-configured'>❌ {api_name}</div>",
unsafe_allow_html=True
)
# Display instructions if any API key is missing with improved styling
if not all(api_status.values()):
with st.sidebar.expander("How to configure API keys"):
st.markdown("""
<div style="background-color: #f8fafc; padding: 12px; border-radius: 6px; border-left: 4px solid #3b82f6;">
<p style="margin-bottom: 10px; font-weight: 500;">To configure missing API keys, create a <code>.env</code> file in the project root with the following format:</p>
<pre style="background-color: #f1f5f9; padding: 10px; border-radius: 4px; overflow-x: auto; font-size: 0.9em;">
SERPER_API_KEY=your_serper_api_key
TAVILY_API_KEY=your_tavily_api_key
METAPHOR_API_KEY=your_metaphor_api_key
FIRECRAWL_API_KEY=your_firecrawl_api_key
</pre>
<p style="margin-top: 10px;">Alternatively, you can set these as environment variables in your system.</p>
</div>
""", unsafe_allow_html=True)
st.sidebar.markdown("</div>", unsafe_allow_html=True)

729
lib/alwrity_ui/alwrity_researcher/dashboard.py Normal file
View File

@@ -0,0 +1,729 @@
import streamlit as st
import sys
import os
from pathlib import Path
# Add parent directory to path to import modules
sys.path.append(str(Path(__file__).parent.parent.parent))
# Import utils module
from utils import (
load_css,
display_google_serp_results,
display_tavily_results,
display_metaphor_results,
display_google_trends_results,
display_crawler_results,
display_analyzer_results
)
# Configure Streamlit page settings
st.set_page_config(
page_title="AI Web Researcher Dashboard",
page_icon="🔍",
layout="wide",
initial_sidebar_state="expanded"
)
# Apply custom CSS immediately
st.markdown("""
<style>
.main-header {
font-size: 24px;
font-weight: bold;
margin-bottom: 20px;
}
.category-header {
font-size: 20px;
font-weight: bold;
margin: 15px 0;
color: #0066cc;
}
/* Make the dashboard responsive */
.stTabs [data-baseweb="tab-list"] {
gap: 2px;
flex-wrap: wrap;
}
.stTabs [data-baseweb="tab"] {
white-space: pre-wrap;
min-width: fit-content;
font-size: 14px;
padding: 8px 16px;
}
/* Adjust container width */
.block-container {
max-width: 95% !important;
padding: 1rem 1rem 10rem !important;
}
/* Additional styling for better visibility */
.stApp {
background-color: #f8f9fa;
}
.stTabs [data-baseweb="tab"] [data-testid="stMarkdownContainer"] p {
font-size: 14px !important;
margin-bottom: 0px !important;
}
.stTabs [data-baseweb="tab-list"] button {
background-color: #ffffff;
border: 1px solid #e9ecef;
border-radius: 4px;
margin: 2px;
}
.stTabs [data-baseweb="tab-list"] button[aria-selected="true"] {
background-color: #e7f1ff;
border-color: #b8daff;
}
</style>
""", unsafe_allow_html=True)
# CSS is now loaded at the top of the file
# Initialize session state variables
def init_session_state():
if 'current_section' not in st.session_state:
st.session_state['current_section'] = 'Dashboard Home'
# Initialize session state at startup
init_session_state()
def main():
# Initialize session state before accessing it
init_session_state()
# Main navigation header
st.markdown('<div class="main-nav-header">AI Web Researcher</div>', unsafe_allow_html=True)
# Create tabs for navigation
selected_section = st.tabs([
"🏠 Dashboard Home",
"🔍 Search Tools",
"🧠 Neural Search",
"📈 Trend Analysis",
"🕸️ Web Crawling",
"📚 Academic Research",
"📋 Research Workflows"
])
# Display appropriate section based on selected tab
with selected_section[0]:
display_home()
with selected_section[1]:
display_search_tools()
with selected_section[2]:
display_neural_search()
with selected_section[3]:
display_trend_analysis()
with selected_section[4]:
display_web_crawling()
with selected_section[5]:
display_academic_research()
with selected_section[6]:
display_research_workflows()
# Ensure CSS is consistently applied
load_css()
def display_home():
# Main header with improved styling
st.markdown('<div class="main-header">AI Web Researcher Dashboard</div>', unsafe_allow_html=True)
# Introduction with better formatting
st.markdown("""
<div class="intro-container">
<p class="intro-text">Welcome to the <span class="intro-highlight">AI Web Researcher Dashboard</span>, a comprehensive suite of research tools designed
specifically for content creators and digital marketing professionals. This dashboard integrates
various web research modules to streamline your content research process, enhance content quality,
and improve workflow efficiency.</p>
</div>
""", unsafe_allow_html=True)
# Quick access to tool categories with improved header
st.markdown('<div class="category-header">Research Tool Categories</div>', unsafe_allow_html=True)
# Use 2 columns with equal width for better layout
col1, col2 = st.columns([1, 1])
with col1:
st.markdown("""
<div class="tool-card">
<div class="tool-title">🔍 Search Engine Research</div>
<div class="tool-description">Powerful search tools to understand search intent, identify content gaps, and discover high-performing content in your niche</div>
<div class="tool-features"><b>Includes:</b> Google SERP Search • Tavily AI Search</div>
<div class="tool-features"><b>Use cases:</b> Keyword research, competitor analysis, content planning, identifying user questions</div>
<div style="margin-top: 12px;">
<span class="tool-badge">SERP Analysis</span>
<span class="tool-badge ai-powered">AI-Powered</span>
</div>
</div>
<div class="tool-card">
<div class="tool-title">🧠 Neural Search</div>
<div class="tool-description">Advanced semantic search technology that understands concepts rather than just keywords to find truly relevant content</div>
<div class="tool-features"><b>Includes:</b> Metaphor Neural Search</div>
<div class="tool-features"><b>Use cases:</b> Finding conceptually similar articles, discovering unique content angles, competitive research</div>
<div style="margin-top: 12px;">
<span class="tool-badge semantic">Semantic</span>
<span class="tool-badge deep-learning">Deep Learning</span>
</div>
</div>
""", unsafe_allow_html=True)
with col2:
st.markdown("""
<div class="tool-card">
<div class="tool-title">📈 Trend Analysis</div>
<div class="tool-description">Comprehensive trend analysis tools that track search term popularity over time to identify seasonal patterns and emerging topics</div>
<div class="tool-features"><b>Includes:</b> Google Trends Researcher</div>
<div class="tool-features"><b>Use cases:</b> Seasonal content planning, topic validation, identifying rising trends, content calendar optimization</div>
<div style="margin-top: 12px;">
<span class="tool-badge time-series">Time Series</span>
<span class="tool-badge forecasting">Forecasting</span>
</div>
</div>
<div class="tool-card">
<div class="tool-title">🕸️ Web Crawling & Analysis</div>
<div class="tool-description">Powerful web extraction tools that gather and structure content from websites for in-depth analysis and insights</div>
<div class="tool-features"><b>Includes:</b> Async Web Crawler • Firecrawl Web Crawler • Website Analyzer</div>
<div class="tool-features"><b>Use cases:</b> Content auditing, competitor analysis, data extraction, market research, content aggregation</div>
<div style="margin-top: 12px;">
<span class="tool-badge content-extraction">Content Extraction</span>
<span class="tool-badge data-analysis">Data Analysis</span>
</div>
</div>
""", unsafe_allow_html=True)
# Featured workflow with improved header
st.markdown('<div class="category-header">Featured Research Workflow</div>', unsafe_allow_html=True)
st.markdown("""
<div class="workflow-card">
<div class="workflow-title">Comprehensive Topic Research Workflow</div>
<p style="color: #4b5563; margin-bottom: 1.25rem;">Follow this proven research workflow to develop comprehensive, data-driven content that resonates with your audience and performs well in search.</p>
<div class="workflow-step-container">
<div class="workflow-step-number">1</div>
<div class="workflow-step-content">
<div class="step-title">Initial Exploration</div>
<div class="workflow-step-description">Use Google SERP Search to understand the search landscape, identify user intent, and discover what content currently ranks well. Analyze People Also Ask questions to identify key user concerns.</div>
</div>
</div>
<div class="workflow-step-container">
<div class="workflow-step-number">2</div>
<div class="workflow-step-content">
<div class="step-title">In-depth Research</div>
<div class="workflow-step-description">Use Tavily AI Search for deeper research on identified subtopics. The AI-powered search provides more contextual information and helps uncover expert insights that might be missed in traditional searches.</div>
</div>
</div>
<div class="workflow-step-container">
<div class="workflow-step-number">3</div>
<div class="workflow-step-content">
<div class="step-title">Competitive Analysis</div>
<div class="workflow-step-description">Use Metaphor Neural Search to find conceptually similar content from competitors. Analyze their approach, identify content gaps, and discover unique angles that differentiate your content.</div>
</div>
</div>
<div class="workflow-step-container">
<div class="workflow-step-number">4</div>
<div class="workflow-step-content">
<div class="step-title">Trend Validation</div>
<div class="workflow-step-description">Use Google Trends Researcher to verify topic popularity, identify seasonal patterns, and discover related trending topics. This ensures your content is timely and aligned with current audience interests.</div>
</div>
</div>
<div class="workflow-step-container">
<div class="workflow-step-number">5</div>
<div class="workflow-step-content">
<div class="step-title">Content Extraction</div>
<div class="workflow-step-description">Use Web Crawling tools to extract specific content from top-performing pages for detailed analysis. This helps identify content structure, depth, and formatting approaches that resonate with your audience.</div>
</div>
</div>
</div>
""", unsafe_allow_html=True)
def display_search_tools():
st.markdown('<div class="main-header">Search Engine Research Tools</div>', unsafe_allow_html=True)
# Google SERP Search
st.markdown('<div class="category-header">Google SERP Search</div>', unsafe_allow_html=True)
st.markdown("""
<div class="tool-card">
<div class="tool-title">Google SERP Search</div>
<div class="tool-description">Retrieves organic search results, People Also Ask questions, and related searches</div>
<div class="tool-features">
<b>Best for:</b> Initial topic research, understanding search intent, and identifying content gaps<br>
<b>Key features:</b> Comprehensive search results with structured data extraction
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Google SERP Search
with st.form("google_serp_search_form"):
search_query = st.text_input("Enter your search query")
col1, col2 = st.columns(2)
with col1:
num_results = st.slider("Number of results", 5, 30, 10)
with col2:
include_paa = st.checkbox("Include People Also Ask", value=True)
submitted = st.form_submit_button("Search")
if submitted and search_query:
try:
with st.spinner("Searching Google SERP..."):
# Import the actual module
from ai_web_researcher.google_serp_search import google_search
# Call the actual implementation
results = google_search(search_query)
# Display the results
if results:
display_google_serp_results(results)
else:
st.error("No results found. Please try a different query.")
except Exception as e:
st.error(f"Error performing Google SERP search: {str(e)}")
st.info("Please check your API configuration in the .env file.")
st.info("Required API: SERPER_API_KEY for Google SERP Search")
display_google_serp_results(None)
# Tavily AI Search
st.markdown('<div class="category-header">Tavily AI Search</div>', unsafe_allow_html=True)
st.markdown("""
<div class="tool-card">
<div class="tool-title">Tavily AI Search</div>
<div class="tool-description">Advanced AI-powered search with semantic understanding</div>
<div class="tool-features">
<b>Best for:</b> In-depth research requiring contextual understanding<br>
<b>Key features:</b> Provides direct answers to questions and follow-up question suggestions
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Tavily AI Search
with st.form("tavily_ai_search_form"):
search_query = st.text_input("Enter your search query or question")
search_depth = st.select_slider("Search depth", options=["basic", "medium", "deep"], value="medium")
submitted = st.form_submit_button("Search with Tavily AI")
if submitted and search_query:
try:
with st.spinner("Searching with Tavily AI..."):
# Import the actual module
from ai_web_researcher.tavily_ai_search import do_tavily_ai_search
# Call the actual implementation
results = do_tavily_ai_search(search_query, search_depth=search_depth)
# Display the results
if results:
display_tavily_results(results)
else:
st.error("No results found. Please try a different query.")
except Exception as e:
st.error(f"Error performing Tavily AI search: {str(e)}")
st.info("Please check your API configuration in the .env file.")
st.info("Required API: TAVILY_API_KEY for Tavily AI Search")
display_tavily_results(None)
def display_neural_search():
st.markdown('<div class="main-header">Neural Search Tools</div>', unsafe_allow_html=True)
# Metaphor Neural Search
st.markdown('<div class="category-header">Metaphor Neural Search</div>', unsafe_allow_html=True)
st.markdown("""
<div class="tool-card">
<div class="tool-title">Metaphor Neural Search</div>
<div class="tool-description">Semantic search technology for finding related content</div>
<div class="tool-features">
<b>Best for:</b> Discovering content based on conceptual similarity rather than keyword matching<br>
<b>Key features:</b> Find similar articles, competitor analysis, and content inspiration
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Metaphor Neural Search
with st.form("metaphor_search_form"):
st.markdown("**Search by keyword or find similar content to a URL**")
search_type = st.radio("Search type", ["Keyword Search", "Similar Content Search"])
if search_type == "Keyword Search":
search_query = st.text_input("Enter your search query")
url_input = ""
else:
search_query = ""
url_input = st.text_input("Enter a URL to find similar content")
num_results = st.slider("Number of results", 3, 20, 5)
submitted = st.form_submit_button("Search with Metaphor")
if submitted and (search_query or url_input):
try:
with st.spinner("Searching with Metaphor Neural Search..."):
# Import the actual module
from ai_web_researcher.metaphor_basic_neural_web_search import metaphor_search_articles, metaphor_find_similar
# Call the actual implementation
if search_query:
results = metaphor_search_articles(search_query, num_results=num_results)
else:
results = metaphor_find_similar(url_input, num_results=num_results)
# Display the results
if results:
display_metaphor_results(results)
else:
st.error("No results found. Please try a different query.")
except Exception as e:
st.error(f"Error performing Metaphor Neural search: {str(e)}")
st.info("Please check your API configuration in the .env file.")
st.info("Required API: METAPHOR_API_KEY for Metaphor Neural Search")
display_metaphor_results(None)
def display_trend_analysis():
st.markdown('<div class="main-header">Trend Analysis Tools</div>', unsafe_allow_html=True)
# Google Trends Researcher
st.markdown('<div class="category-header">Google Trends Researcher</div>', unsafe_allow_html=True)
st.markdown("""
<div class="tool-card">
<div class="tool-title">Google Trends Researcher</div>
<div class="tool-description">Analyze search term popularity and related queries</div>
<div class="tool-features">
<b>Best for:</b> Content planning, trend forecasting, and seasonal content optimization<br>
<b>Key features:</b> Interest over time charts, related queries, and regional interest data
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Google Trends Researcher
with st.form("google_trends_form"):
search_terms = st.text_area("Enter search terms (one per line)")
col1, col2 = st.columns(2)
with col1:
time_frame = st.select_slider("Time range", options=["past_hour", "past_day", "past_week", "past_month", "past_90_days", "past_12_months", "past_5_years"], value="past_12_months")
with col2:
geo = st.text_input("Geographic region (ISO country code, e.g., 'US')", value="US")
submitted = st.form_submit_button("Analyze Trends")
if submitted and search_terms:
try:
with st.spinner("Analyzing Google Trends..."):
# Import the actual module
from ai_web_researcher.google_trends_researcher import do_google_trends_analysis
# Call the actual implementation
search_terms_list = [term.strip() for term in search_terms.split('\n') if term.strip()]
results = do_google_trends_analysis(search_terms_list, time_frame=time_frame, geo=geo)
# Display the results
if results:
display_google_trends_results(results)
else:
st.error("No trend data found. Please try different search terms.")
except Exception as e:
st.error(f"Error analyzing Google Trends: {str(e)}")
st.info("Google Trends analysis doesn't require an API key, but there might be rate limiting or network issues.")
display_google_trends_results(None)
def display_web_crawling():
st.markdown('<div class="main-header">Web Crawling & Analysis Tools</div>', unsafe_allow_html=True)
# Create tabs for different crawling tools
tab1, tab2, tab3 = st.tabs(["Firecrawl Web Crawler", "Website Analyzer", "Async Web Crawler"])
with tab1:
st.markdown("""
<div class="tool-card">
<div class="tool-title">Firecrawl Web Crawler</div>
<div class="tool-description">Extract structured content from websites</div>
<div class="tool-features">
<b>Best for:</b> Content extraction, competitor analysis, and website auditing<br>
<b>Key features:</b> Extracts titles, descriptions, headings, and content from web pages
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Firecrawl Web Crawler
with st.form("firecrawl_form"):
website_url = st.text_input("Enter website URL")
depth = st.slider("Crawl depth", 1, 5, 1)
max_pages = st.slider("Maximum pages", 1, 50, 10)
submitted = st.form_submit_button("Crawl Website")
if submitted and website_url:
try:
with st.spinner("Crawling website..."):
# Import the actual module
from ai_web_researcher.firecrawl_web_crawler import scrape_website
# Call the actual implementation
results = scrape_website(website_url, depth=depth, max_pages=max_pages)
# Display the results
if results:
display_crawler_results(results)
else:
st.error("No crawler results found. Please try a different URL.")
except Exception as e:
st.error(f"Error crawling website: {str(e)}")
st.info("Please check your API configuration in the .env file.")
st.info("Required API: FIRECRAWL_API_KEY for Web Crawler")
display_crawler_results(None)
with tab2:
st.markdown("""
<div class="tool-card">
<div class="tool-title">Website Analyzer</div>
<div class="tool-description">Analyze website content and structure</div>
<div class="tool-features">
<b>Best for:</b> Content analysis, SEO auditing, and competitor research<br>
<b>Key features:</b> Content analysis, keyword extraction, and readability metrics
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Website Analyzer
with st.form("website_analyzer_form"):
website_url = st.text_input("Enter website URL")
analyze_type = st.selectbox("Analysis type", ["Basic Analysis", "SEO Analysis", "Content Analysis", "Competitor Analysis"])
submitted = st.form_submit_button("Analyze Website")
if submitted and website_url:
st.info("Website Analyzer is coming soon. This feature is under development.")
with tab3:
st.markdown("""
<div class="tool-card">
<div class="tool-title">Async Web Crawler</div>
<div class="tool-description">High-performance asynchronous web crawler</div>
<div class="tool-features">
<b>Best for:</b> Large-scale crawling, data extraction, and content aggregation<br>
<b>Key features:</b> Fast, efficient crawling with customizable extraction rules
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Async Web Crawler
with st.form("async_crawler_form"):
website_url = st.text_input("Enter website URL")
max_urls = st.slider("Maximum URLs to crawl", 10, 100, 30)
submitted = st.form_submit_button("Start Crawling")
if submitted and website_url:
st.info("Async Web Crawler is coming soon. This feature is under development.")
def display_academic_research():
st.markdown('<div class="main-header">Academic Research Tools</div>', unsafe_allow_html=True)
# ArXiv Search Section
st.markdown('<div class="category-header">ArXiv Scholarly Search</div>', unsafe_allow_html=True)
# Search Parameters
search_col1, search_col2 = st.columns([2, 1])
with search_col1:
search_query = st.text_input("🔍 Enter research topic or keywords", key="arxiv_search")
with search_col2:
max_results = st.number_input("Maximum Results", min_value=1, max_value=50, value=10)
# Search Button
if st.button("🔎 Search ArXiv", key="arxiv_search_button"):
if search_query:
with st.spinner("Searching ArXiv database..."):
try:
# Import arxiv search function
from ai_web_researcher.arxiv_schlorly_research import fetch_arxiv_data, create_dataframe
# Fetch results
results = fetch_arxiv_data(search_query, max_results)
if results:
# Create DataFrame
df = create_dataframe(results, ["Title", "Published Date", "ArXiv ID", "Summary", "PDF URL"])
# Display results in an expander
with st.expander("📚 Search Results", expanded=True):
# Display each paper with options to view abstract and download
for idx, row in df.iterrows():
st.markdown(f"### {row['Title']}")
st.markdown(f"*Published: {row['Published Date']}*")
# Create columns for buttons
btn_col1, btn_col2, btn_col3 = st.columns([1, 1, 1])
with btn_col1:
if st.button(f"📄 View Abstract #{idx}"):
st.markdown(f"**Abstract:**\n{row['Summary']}")
with btn_col2:
st.markdown(f"[📥 Download PDF]({row['PDF URL']})")
if st.button(f"📝 Summarize #{idx}"):
with st.spinner("Generating summary..."):
try:
from ai_web_researcher.gpt_summarize_web_content import summarize_web_content
summary = summarize_web_content(row['PDF URL'])
if summary:
st.markdown("### GPT Summary")
st.markdown(summary)
# Add export option for the summary
st.download_button(
label="📥 Export Summary",
data=summary,
file_name=f"summary_{row['ArXiv ID']}.txt",
mime="text/plain"
)
except Exception as e:
st.error(f"Error generating summary: {str(e)}")
with btn_col3:
if st.button(f"🔍 Related Web Content #{idx}"):
# Use Google SERP to find related content
from ai_web_researcher.google_serp_search import google_search
web_results = google_search(row['Title'])
if web_results:
st.markdown("### Related Web Content")
for result in web_results['organic'][:3]:
st.markdown(f"- [{result['title']}]({result['link']})\n {result['snippet']}")
st.markdown("---")
else:
st.warning("No results found. Try modifying your search terms.")
except Exception as e:
st.error(f"An error occurred while searching: {str(e)}")
else:
st.warning("Please enter a search query.")
# Research Notes Section
st.markdown('<div class="category-header">Research Notes</div>', unsafe_allow_html=True)
# Initialize session state for notes if not exists
if 'research_notes' not in st.session_state:
st.session_state.research_notes = {}
notes_col1, notes_col2 = st.columns([2, 1])
with notes_col1:
paper_id = st.text_input("ArXiv ID or Paper Title", key="notes_paper_id")
notes_content = st.text_area("Research Notes", height=200, key="notes_content")
if st.button("Save Notes"):
if paper_id:
st.session_state.research_notes[paper_id] = notes_content
st.success("Notes saved successfully!")
else:
st.warning("Please enter a paper identifier.")
with notes_col2:
st.markdown("### Saved Notes")
for paper_id, notes in st.session_state.research_notes.items():
with st.expander(f"📝 {paper_id}"):
st.text_area("Saved Notes", value=notes, height=150, key=f"saved_{paper_id}", disabled=True)
if st.button("Export Notes", key=f"export_{paper_id}"):
notes_export = f"Research Notes for {paper_id}\n\n{notes}"
st.download_button(
label="📥 Download Notes",
data=notes_export,
file_name=f"research_notes_{paper_id}.txt",
mime="text/plain"
)
# Citation Management Section
st.markdown('<div class="category-header">Citation Management</div>', unsafe_allow_html=True)
# BibTeX Export
st.markdown("### Export Citations")
arxiv_id = st.text_input("Enter ArXiv ID for citation export")
if arxiv_id and st.button("Generate BibTeX"):
try:
from ai_web_researcher.arxiv_schlorly_research import arxiv_bibtex
bibtex = arxiv_bibtex(arxiv_id)
if bibtex:
st.code(bibtex, language="bibtex")
st.download_button(
label="📥 Download BibTeX",
data=bibtex,
file_name=f"citation_{arxiv_id}.bib",
mime="text/plain"
)
except Exception as e:
st.error(f"Error generating citation: {str(e)}")
def display_research_workflows():
st.markdown('<div class="main-header">Research Workflows</div>', unsafe_allow_html=True)
st.markdown("""
<div class="workflow-description">
Research workflows combine multiple research tools to provide comprehensive insights for specific content creation tasks.
Select a workflow to get started.
</div>
""", unsafe_allow_html=True)
# Create tabs for different workflows
tab1, tab2, tab3 = st.tabs(["Topic Research", "Competitor Analysis", "Trend Discovery"])
with tab1:
st.markdown("""
<div class="workflow-card">
<div class="workflow-title">Comprehensive Topic Research</div>
<div class="workflow-description">
This workflow helps you thoroughly research a topic for content creation by combining search results,
semantic understanding, and trend analysis.
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Topic Research workflow
with st.form("topic_research_form"):
topic = st.text_input("Enter your topic")
include_trends = st.checkbox("Include trend analysis", value=True)
include_competitors = st.checkbox("Include competitor analysis", value=True)
submitted = st.form_submit_button("Start Research Workflow")
if submitted and topic:
st.info("Research workflows are coming soon. This feature is under development.")
with tab2:
st.markdown("""
<div class="workflow-card">
<div class="workflow-title">Competitor Content Analysis</div>
<div class="workflow-description">
This workflow analyzes your competitors' content to identify gaps and opportunities for your own content strategy.
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Competitor Analysis workflow
with st.form("competitor_analysis_form"):
competitor_urls = st.text_area("Enter competitor URLs (one per line)")
topic_focus = st.text_input("Topic focus (optional)")
submitted = st.form_submit_button("Start Competitor Analysis")
if submitted and competitor_urls:
st.info("Research workflows are coming soon. This feature is under development.")
with tab3:
st.markdown("""
<div class="workflow-card">
<div class="workflow-title">Trend Discovery & Content Planning</div>
<div class="workflow-description">
This workflow identifies trending topics in your niche and helps you plan content around them.
</div>
</div>
""", unsafe_allow_html=True)
# Input form for Trend Discovery workflow
with st.form("trend_discovery_form"):
niche = st.text_input("Enter your niche or industry")
time_period = st.select_slider("Time period", options=["past_week", "past_month", "past_90_days", "past_12_months"], value="past_month")
submitted = st.form_submit_button("Discover Trends")
if submitted and niche:
st.info("Research workflows are coming soon. This feature is under development.")

14
lib/alwrity_ui/alwrity_researcher/main.py Normal file
View File

@@ -0,0 +1,14 @@
import streamlit as st
import sys
import os
from pathlib import Path
# Add the current directory to the path
sys.path.append(str(Path(__file__).parent))
# Import the dashboard module
from dashboard import main
# Run the dashboard
if __name__ == "__main__":
main()

517
lib/alwrity_ui/alwrity_researcher/style.css Normal file
View File

@@ -0,0 +1,517 @@
/* Main Dashboard Styles */
body {
font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
background-color: #f0f4f8;
color: #1f2937;
background-image: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
}
.main-header {
font-size: 2.2rem;
background: linear-gradient(120deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
text-align: center;
margin: 1.5rem 0;
font-weight: 700;
letter-spacing: -0.025em;
padding-bottom: 0.75rem;
border-bottom: 1px solid rgba(229, 231, 235, 0.5);
text-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
}
.category-header {
font-size: 1.4rem;
background: linear-gradient(90deg, #2563eb 0%, #4f46e5 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
margin-top: 1.5rem;
margin-bottom: 1rem;
font-weight: 600;
padding-left: 0.5rem;
border-left: 4px solid;
border-image: linear-gradient(to bottom, #3b82f6, #4f46e5) 1;
text-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
}
/* Glassomorphic Tool Card Styles */
.tool-card {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.75rem;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
border: 1px solid rgba(255, 255, 255, 0.18);
margin-bottom: 1.5rem;
border-left: 4px solid;
border-image: linear-gradient(to bottom, rgba(59, 130, 246, 0.8), rgba(79, 70, 229, 0.8)) 1;
transition: all 0.3s ease;
}
.tool-card:hover {
transform: translateY(-5px);
box-shadow: 0 15px 30px rgba(31, 38, 135, 0.25);
border-image: linear-gradient(to bottom, rgba(59, 130, 246, 1), rgba(79, 70, 229, 1)) 1;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.9) 0%, rgba(240, 249, 255, 0.8) 100%);
}
.tool-title {
font-size: 1.3rem;
font-weight: 600;
background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
margin-bottom: 0.75rem;
display: flex;
align-items: center;
gap: 0.5rem;
}
.tool-description {
color: #374151;
margin-bottom: 1rem;
line-height: 1.6;
font-size: 1rem;
}
.tool-features {
font-size: 0.95rem;
color: #4b5563;
margin-bottom: 0.75rem;
line-height: 1.6;
background-color: rgba(243, 244, 246, 0.6);
padding: 0.85rem;
border-radius: 8px;
border: 1px solid rgba(229, 231, 235, 0.5);
}
/* Tool Badge Styles */
.tool-badge {
display: inline-block;
padding: 0.35rem 0.75rem;
border-radius: 20px;
font-size: 0.75rem;
font-weight: 500;
margin-right: 0.5rem;
background-color: rgba(243, 244, 246, 0.8);
color: #4b5563;
border: 1px solid rgba(209, 213, 219, 0.5);
backdrop-filter: blur(5px);
}
.tool-badge.ai-powered {
background-color: rgba(79, 70, 229, 0.15);
color: #4338ca;
border-color: rgba(79, 70, 229, 0.3);
}
.tool-badge.semantic {
background-color: rgba(16, 185, 129, 0.15);
color: #065f46;
border-color: rgba(16, 185, 129, 0.3);
}
.tool-badge.deep-learning {
background-color: rgba(245, 158, 11, 0.15);
color: #92400e;
border-color: rgba(245, 158, 11, 0.3);
}
.tool-badge.time-series {
background-color: rgba(6, 182, 212, 0.15);
color: #0e7490;
border-color: rgba(6, 182, 212, 0.3);
}
.tool-badge.forecasting {
background-color: rgba(168, 85, 247, 0.15);
color: #6d28d9;
border-color: rgba(168, 85, 247, 0.3);
}
.tool-badge.content-extraction {
background-color: rgba(236, 72, 153, 0.15);
color: #be185d;
border-color: rgba(236, 72, 153, 0.3);
}
.tool-badge.data-analysis {
background-color: rgba(14, 165, 233, 0.15);
color: #0369a1;
border-color: rgba(14, 165, 233, 0.3);
}
/* Glassomorphic Workflow Card Styles */
.workflow-card {
background: linear-gradient(135deg, rgba(239, 246, 255, 0.8) 0%, rgba(219, 234, 254, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.75rem;
margin-bottom: 1.5rem;
border-left: 4px solid;
border-image: linear-gradient(to bottom, rgba(37, 99, 235, 0.8), rgba(79, 70, 229, 0.8)) 1;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.workflow-title {
font-size: 1.3rem;
font-weight: 600;
background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
margin-bottom: 1.25rem;
padding-bottom: 0.75rem;
border-bottom: 1px solid rgba(191, 219, 254, 0.5);
}
.workflow-step-container {
display: flex;
margin-bottom: 1.25rem;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.7) 0%, rgba(240, 249, 255, 0.6) 100%);
border-radius: 10px;
padding: 1rem;
box-shadow: 0 4px 6px rgba(31, 38, 135, 0.1);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.workflow-step-number {
display: flex;
align-items: center;
justify-content: center;
width: 2rem;
height: 2rem;
background: linear-gradient(135deg, rgba(37, 99, 235, 0.9) 0%, rgba(79, 70, 229, 0.9) 100%);
color: white;
border-radius: 50%;
font-weight: 600;
margin-right: 1rem;
box-shadow: 0 4px 6px rgba(37, 99, 235, 0.3);
}
.workflow-step-content {
flex: 1;
}
.step-title {
font-weight: 600;
background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
margin-bottom: 0.5rem;
font-size: 1.05rem;
}
.workflow-step-description {
color: #4b5563;
line-height: 1.5;
font-size: 0.95rem;
}
/* Navigation Styles */
.nav-header {
font-size: 2rem;
background: linear-gradient(120deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
text-align: center;
margin: 1.5rem 0;
font-weight: 700;
letter-spacing: -0.025em;
padding-bottom: 0.75rem;
border-bottom: 1px solid rgba(229, 231, 235, 0.5);
text-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
}
.nav-container {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.75rem;
margin-bottom: 1.5rem;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.nav-button {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.5rem;
margin-bottom: 1rem;
border: 1px solid rgba(255, 255, 255, 0.18);
border-left: 4px solid;
border-image: linear-gradient(to bottom, rgba(59, 130, 246, 0.8), rgba(79, 70, 229, 0.8)) 1;
transition: all 0.3s ease;
width: 100%;
cursor: pointer;
display: flex;
flex-direction: column;
align-items: center;
}
.nav-button:hover {
transform: translateY(-5px);
box-shadow: 0 15px 30px rgba(31, 38, 135, 0.25);
border-image: linear-gradient(to bottom, rgba(59, 130, 246, 1), rgba(79, 70, 229, 1)) 1;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.9) 0%, rgba(240, 249, 255, 0.8) 100%);
}
.nav-button.selected {
background: linear-gradient(120deg, rgba(239, 246, 255, 0.9) 0%, rgba(219, 234, 254, 0.8) 100%);
border-image: linear-gradient(to bottom, #3b82f6, #4f46e5) 1;
box-shadow: 0 8px 20px rgba(31, 38, 135, 0.2);
}
.nav-icon {
font-size: 1.8rem;
margin-bottom: 0.75rem;
background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
}
.nav-title {
font-size: 1.1rem;
font-weight: 600;
background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
text-align: center;
}
[data-testid="stSidebar"] {
background-color: rgba(248, 250, 252, 0.7);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-right: 1px solid rgba(229, 231, 235, 0.5);
}
[data-testid="stSidebarNav"] {
background-color: transparent;
}
.st-emotion-cache-16txtl3 {
padding-top: 2rem;
}
.sidebar-header {
font-size: 1.3rem;
font-weight: 700;
color: #1e3a8a;
margin: 1rem 0;
padding-bottom: 0.75rem;
border-bottom: 1px solid rgba(229, 231, 235, 0.5);
text-align: center;
text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
}
/* Button Styles */
.stButton>button {
background: linear-gradient(135deg, #3b82f6 0%, #4f46e5 100%);
color: white;
width: 100%;
font-weight: 500;
border-radius: 8px;
border: 1px solid rgba(255, 255, 255, 0.18);
padding: 0.6rem 1.2rem;
transition: all 0.3s ease;
backdrop-filter: blur(5px);
-webkit-backdrop-filter: blur(5px);
box-shadow: 0 4px 6px rgba(31, 38, 135, 0.15);
}
.stButton>button:hover {
background: linear-gradient(135deg, #2563eb 0%, #4338ca 100%);
box-shadow: 0 8px 15px rgba(31, 38, 135, 0.2);
transform: translateY(-2px);
}
/* Glassomorphic Results Display Styles */
.results-container {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.75rem;
margin-top: 1.25rem;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.result-item {
padding: 1.25rem;
border-bottom: 1px solid rgba(229, 231, 235, 0.5);
margin-bottom: 1.25rem;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.7) 0%, rgba(248, 250, 252, 0.6) 100%);
border-radius: 8px;
transition: all 0.2s ease;
}
.result-item:hover {
background-color: rgba(255, 255, 255, 0.8);
box-shadow: 0 4px 6px rgba(31, 38, 135, 0.1);
}
.result-title {
font-size: 1.15rem;
font-weight: 600;
color: #1e3a8a;
margin-bottom: 0.6rem;
}
.result-snippet {
color: #4b5563;
font-size: 0.95rem;
line-height: 1.6;
}
.result-url {
color: #059669;
font-size: 0.85rem;
margin-top: 0.6rem;
word-break: break-all;
}
/* Form Styles */
.stTextInput>div>div>input {
border-radius: 8px;
border: 1px solid rgba(209, 213, 219, 0.5);
background-color: rgba(255, 255, 255, 0.7);
backdrop-filter: blur(5px);
-webkit-backdrop-filter: blur(5px);
}
.stTextInput>div>div>input:focus {
border-color: rgba(59, 130, 246, 0.7);
box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.2);
background-color: rgba(255, 255, 255, 0.9);
}
/* Dashboard Home Styles */
.intro-container {
background: linear-gradient(135deg, rgba(239, 246, 255, 0.8) 0%, rgba(224, 242, 254, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
padding: 1.75rem;
border-radius: 12px;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
margin-bottom: 1.5rem;
border-left: 4px solid rgba(59, 130, 246, 0.7);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.intro-text {
color: #374151;
line-height: 1.7;
font-size: 1.05rem;
margin: 0;
}
.intro-highlight {
color: #1e3a8a;
font-weight: 600;
}
/* Chart Container Styles */
.chart-container {
background-color: rgba(255, 255, 255, 0.7);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 12px;
padding: 1.5rem;
margin: 1.25rem 0;
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
border: 1px solid rgba(255, 255, 255, 0.18);
}
.chart-title {
font-size: 1.1rem;
font-weight: 600;
color: #1e3a8a;
margin-bottom: 1rem;
text-align: center;
}
/* Tab Styles */
.stTabs [data-baseweb="tab-list"] {
gap: 12px;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
padding: 1rem;
border-radius: 12px;
border: 1px solid rgba(255, 255, 255, 0.18);
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
}
.stTabs [data-baseweb="tab"] {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.7) 0%, rgba(240, 249, 255, 0.6) 100%);
backdrop-filter: blur(5px);
-webkit-backdrop-filter: blur(5px);
border-radius: 10px;
padding: 0.75rem 1.25rem;
border: 1px solid rgba(255, 255, 255, 0.18);
border-left: 3px solid;
border-image: linear-gradient(to bottom, rgba(59, 130, 246, 0.8), rgba(79, 70, 229, 0.8)) 1;
transition: all 0.3s ease;
font-weight: 500;
color: #1e3a8a;
}
.stTabs [data-baseweb="tab"]:hover {
transform: translateY(-2px);
box-shadow: 0 8px 15px rgba(31, 38, 135, 0.15);
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
}
.stTabs [aria-selected="true"] {
background: linear-gradient(135deg, #3b82f6 0%, #4f46e5 100%) !important;
color: white !important;
border-image: none !important;
border-left: 3px solid #3b82f6 !important;
box-shadow: 0 8px 15px rgba(59, 130, 246, 0.25) !important;
}
/* Additional Styles for Tabs Content */
.stTabs [data-baseweb="tab-panel"] {
background: linear-gradient(120deg, rgba(255, 255, 255, 0.8) 0%, rgba(240, 249, 255, 0.7) 100%);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px);
border-radius: 0 12px 12px 12px;
padding: 1.75rem;
border: 1px solid rgba(255, 255, 255, 0.18);
box-shadow: 0 8px 32px rgba(31, 38, 135, 0.15);
margin-top: -1px;
}
/* Responsive Adjustments */
@media (max-width: 768px) {
.tool-card, .workflow-card, .intro-container, .results-container {
padding: 1.25rem;
}
.main-header {
font-size: 1.8rem;
}
.category-header {
font-size: 1.2rem;
}
.tool-title, .workflow-title {
font-size: 1.15rem;
}
}

380
lib/alwrity_ui/alwrity_researcher/utils.py Normal file
View File

@@ -0,0 +1,380 @@
import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import sys
import os
from pathlib import Path
# Add parent directory to path to import modules
sys.path.append(str(Path(__file__).parent.parent.parent))
# Import research modules (placeholder imports for now)
try:
from ai_web_researcher import (
google_serp_search,
tavily_ai_search,
metaphor_basic_neural_web_search,
google_trends_researcher,
firecrawl_web_crawler
)
except ImportError:
# For development/testing without actual modules
pass
def load_css():
"""Load custom CSS"""
css_file = Path(__file__).parent / "style.css"
with open(css_file) as f:
css_content = f.read()
# Use session state to track if CSS has been loaded
if 'css_loaded' not in st.session_state:
st.session_state['css_loaded'] = False
# Always apply CSS on each page load to ensure styles persist during navigation
st.markdown(f"<style>{css_content}</style>", unsafe_allow_html=True)
st.session_state['css_loaded'] = True
def display_google_serp_results(results):
"""Display Google SERP search results"""
# Check if results are available
if not results:
st.warning("No search results available. Please try a different query or check your API configuration.")
return
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display organic results
st.markdown('<div class="category-header">Search Results</div>', unsafe_allow_html=True)
# Display actual organic results
organic_results = results.get('organic', [])
if organic_results:
for result in organic_results:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{result.get('title', 'No Title')}</div>
<div class="result-url">{result.get('link', '#')}</div>
<div class="result-snippet">{result.get('snippet', 'No description available.')}</div>
</div>
""", unsafe_allow_html=True)
else:
st.info("No organic search results found.")
# Display People Also Ask
paa_results = results.get('peopleAlsoAsk', [])
if paa_results:
st.markdown('<div class="category-header">People Also Ask</div>', unsafe_allow_html=True)
for question in paa_results:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{question.get('question', 'No Question')}</div>
<div class="result-snippet">{question.get('snippet', 'No answer available.')}</div>
</div>
""", unsafe_allow_html=True)
# Display Related Searches if available
related_searches = results.get('relatedSearches', [])
if related_searches:
st.markdown('<div class="category-header">Related Searches</div>', unsafe_allow_html=True)
for search in related_searches:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{search}</div>
</div>
""", unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def display_tavily_results(results):
"""Display Tavily AI search results"""
# Check if results are available
if not results:
st.warning("No Tavily search results available. Please try a different query or check your API configuration.")
return
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display answer if available
answer = results.get('answer', '')
if answer:
st.markdown('<div class="category-header">Answer</div>', unsafe_allow_html=True)
st.markdown(f"""
<div class="result-item">
<div class="result-snippet">{answer}</div>
</div>
""", unsafe_allow_html=True)
# Display search results
search_results = results.get('results', [])
if search_results:
st.markdown('<div class="category-header">Search Results</div>', unsafe_allow_html=True)
for result in search_results:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{result.get('title', 'No Title')}</div>
<div class="result-url">{result.get('url', '#')}</div>
<div class="result-snippet">{result.get('content', 'No content available.')}</div>
</div>
""", unsafe_allow_html=True)
else:
st.info("No search results found.")
# Display follow-up questions if available
follow_up_questions = results.get('follow_up_questions', [])
if follow_up_questions:
st.markdown('<div class="category-header">Follow-up Questions</div>', unsafe_allow_html=True)
for question in follow_up_questions:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{question}</div>
</div>
""", unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def display_metaphor_results(results):
"""Display Metaphor Neural Search results"""
# Check if results are available
if not results:
st.warning("No Metaphor search results available. Please try a different query or check your API configuration.")
return
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display search results
st.markdown('<div class="category-header">Similar Content</div>', unsafe_allow_html=True)
# Display actual results
documents = results.get('documents', [])
if documents:
for doc in documents:
title = doc.get('title', 'No Title')
url = doc.get('url', '#')
extract = doc.get('extract', 'No content available.')
st.markdown(f"""
<div class="result-item">
<div class="result-title">{title}</div>
<div class="result-url">{url}</div>
<div class="result-snippet">{extract}</div>
</div>
""", unsafe_allow_html=True)
else:
st.info("No similar content found.")
# Display summary if available
summary = results.get('summary', '')
if summary:
st.markdown('<div class="category-header">Content Summary</div>', unsafe_allow_html=True)
st.markdown(f"""
<div class="result-item">
<div class="result-snippet">{summary}</div>
</div>
""", unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def display_google_trends_results(results):
"""Display Google Trends results"""
# Check if results are available
if not results:
st.warning("No Google Trends results available. Please try a different query or check your API configuration.")
return
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display interest over time chart if available
interest_over_time = results.get('interest_over_time')
if interest_over_time is not None and not interest_over_time.empty:
st.markdown('<div class="category-header">Interest Over Time</div>', unsafe_allow_html=True)
st.markdown('<div class="chart-container">', unsafe_allow_html=True)
st.markdown('<div class="chart-title">Search Interest Over Time</div>', unsafe_allow_html=True)
# Convert to DataFrame if it's not already
if not isinstance(interest_over_time, pd.DataFrame):
interest_over_time = pd.DataFrame(interest_over_time)
# Prepare data for visualization
if 'date' in interest_over_time.columns:
# Melt the DataFrame to get it in the right format for plotting
terms = [col for col in interest_over_time.columns if col != 'date']
df = interest_over_time.melt('date', value_vars=terms, var_name='Term', value_name='Interest')
# Create and display the chart
fig = px.line(df, x='date', y='Interest', color='Term', title='Search Interest Over Time')
st.plotly_chart(fig, use_container_width=True)
else:
st.error("Interest over time data is not in the expected format.")
st.markdown('</div>', unsafe_allow_html=True)
# Display related queries if available
related_queries = results.get('related_queries', {})
if related_queries:
st.markdown('<div class="category-header">Related Queries</div>', unsafe_allow_html=True)
# Display top related queries
for term, queries in related_queries.items():
if 'top' in queries:
st.markdown(f'<div class="subcategory-header">Top queries for "{term}"</div>', unsafe_allow_html=True)
for query in queries['top'].get('query', []):
st.markdown(f"""
<div class="result-item">
<div class="result-title">{query}</div>
</div>
""", unsafe_allow_html=True)
if 'rising' in queries:
st.markdown(f'<div class="subcategory-header">Rising queries for "{term}"</div>', unsafe_allow_html=True)
for query in queries['rising'].get('query', []):
st.markdown(f"""
<div class="result-item">
<div class="result-title">{query}</div>
</div>
""", unsafe_allow_html=True)
# Display related topics if available
related_topics = results.get('related_topics', {})
if related_topics:
st.markdown('<div class="category-header">Related Topics</div>', unsafe_allow_html=True)
# Display top related topics
for term, topics in related_topics.items():
if 'top' in topics:
st.markdown(f'<div class="subcategory-header">Top topics for "{term}"</div>', unsafe_allow_html=True)
for topic in topics['top'].get('topic', []):
st.markdown(f"""
<div class="result-item">
<div class="result-title">{topic}</div>
</div>
""", unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)
def display_crawler_results(results):
"""Display Web Crawler results"""
# Check if results are available
if not results:
st.warning("No web crawler results available. Please try a different URL or check your API configuration.")
return
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display crawled pages
st.markdown('<div class="category-header">Crawled Pages</div>', unsafe_allow_html=True)
# Handle different result formats
if isinstance(results, dict):
# Single page result
page_data = results
st.markdown(f"""
<div class="result-item">
<div class="result-title">{page_data.get('title', 'No Title')}</div>
<div class="result-url">{page_data.get('url', '#')}</div>
<div class="result-snippet">
<b>Title:</b> {page_data.get('title', 'No Title')}<br>
<b>Description:</b> {page_data.get('description', 'No description available.')}<br>
<b>Word Count:</b> {page_data.get('word_count', 'Unknown')}
</div>
</div>
""", unsafe_allow_html=True)
# Display content sections if available
content = page_data.get('content', [])
if content:
st.markdown('<div class="category-header">Page Content</div>', unsafe_allow_html=True)
for section in content:
if isinstance(section, dict):
section_type = section.get('type', '')
section_content = section.get('content', '')
if section_type and section_content:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{section_type}</div>
<div class="result-snippet">{section_content}</div>
</div>
""", unsafe_allow_html=True)
elif isinstance(results, list):
# Multiple pages result
for page_data in results:
if isinstance(page_data, dict):
st.markdown(f"""
<div class="result-item">
<div class="result-title">{page_data.get('title', 'No Title')}</div>
<div class="result-url">{page_data.get('url', '#')}</div>
<div class="result-snippet">
<b>Title:</b> {page_data.get('title', 'No Title')}<br>
<b>Description:</b> {page_data.get('description', 'No description available.')}<br>
<b>Word Count:</b> {page_data.get('word_count', 'Unknown')}
</div>
</div>
""", unsafe_allow_html=True)
# Display content structure
st.markdown('<div class="category-header">Content Structure</div>', unsafe_allow_html=True)
# Placeholder data for chart
labels = ['Blog Posts', 'Product Pages', 'Category Pages', 'About Pages', 'Contact Pages']
values = [38, 27, 18, 10, 7]
fig = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.3)])
fig.update_layout(title_text='Content Type Distribution')
st.plotly_chart(fig, use_container_width=True)
st.markdown('</div>', unsafe_allow_html=True)
def display_analyzer_results(results):
"""Display Website Analyzer results"""
# This is a placeholder function that will be implemented when integrated with actual modules
st.markdown('<div class="results-container">', unsafe_allow_html=True)
# Display content quality metrics
st.markdown('<div class="category-header">Content Quality Metrics</div>', unsafe_allow_html=True)
# Placeholder data for chart
categories = ['Readability', 'Engagement', 'Relevance', 'Uniqueness', 'Comprehensiveness']
values = [4.2, 3.8, 4.5, 3.9, 4.1]
fig = go.Figure()
fig.add_trace(go.Scatterpolar(
r=values,
theta=categories,
fill='toself',
name='Content Quality'
))
fig.update_layout(
polar=dict(
radialaxis=dict(
visible=True,
range=[0, 5]
)),
showlegend=False
)
st.plotly_chart(fig, use_container_width=True)
# Display SEO recommendations
st.markdown('<div class="category-header">SEO Recommendations</div>', unsafe_allow_html=True)
# Placeholder data
recommendations = [
"Improve meta descriptions for better click-through rates",
"Add more internal links to related content",
"Optimize images with descriptive alt text",
"Improve page loading speed by optimizing images",
"Add structured data markup for better search visibility"
]
for recommendation in recommendations:
st.markdown(f"""
<div class="result-item">
<div class="result-title">{recommendation}</div>
</div>
""", unsafe_allow_html=True)
st.markdown('</div>', unsafe_allow_html=True)

99
lib/alwrity_ui/content_generation/README.md Normal file
View File

@@ -0,0 +1,99 @@
# Content Generation Dashboard
## Overview
The Content Generation Dashboard is a central hub for ALwrity's content creation tools, providing an intuitive interface for accessing various AI-powered content generation capabilities.
## Features
### 1. Modality-Based Organization
- **Text Generation**
- Blog Writing
- Story Creation
- Product Descriptions
- News Articles
- Long-form Content
- **Social Media**
- Instagram Posts
- LinkedIn Content
- YouTube Scripts
- **Image Generation**
- AI Image Creation
- Visual Content Tools
- **Audio/Video**
- Speech to Blog
- Audio Transcription
### 2. Smart Navigation
- Quick access to recently used tools
- Favorite tools management
- Hierarchical navigation structure
- Minimal-click access to tools
### 3. Error Handling
- Custom exception handling
- User-friendly error messages
- Automatic error recovery
- Detailed error logging
### 4. State Management
- Persistent tool states
- Usage analytics tracking
- Performance monitoring
- Session management
## Architecture
### Core Components
1. **Dashboard UI (`dashboard.py`)**
- Main interface rendering
- Tool card management
- Navigation controls
- User interaction handling
2. **State Manager (`state_manager.py`)**
- Tool state tracking
- Usage metrics collection
- State persistence
- Navigation history
3. **Error Handler (`error_handler.py`)**
- Custom exceptions
- Error logging
- Recovery mechanisms
- User feedback
## Implementation Status
### Completed Features
- ✅ Basic dashboard layout
- ✅ Tool card implementation
- ✅ Error handling system
- ✅ State management
- ✅ Navigation structure
### In Progress
- 🔄 Performance optimization
- 🔄 User analytics integration
- 🔄 Tool loading improvements
### Planned Features
- ⏳ Advanced error recovery
- ⏳ Tool usage suggestions
- ⏳ Accessibility improvements
- ⏳ Performance monitoring
## Usage
### For Users
1. Access the dashboard through ALwrity's main interface
2. Select desired content generation modality
3. Choose specific tool from available options
4. Follow tool-specific workflows
### For Developers
1. Error Handling:
```python
from content_generation.error_handler import DashboardError

629
lib/alwrity_ui/content_generation/content_generation_dashboard.py Normal file
View File

@@ -0,0 +1,629 @@
import streamlit as st
from typing import Dict, List
from functools import lru_cache
from datetime import datetime
from loguru import logger
# Import all necessary AI writer functions
from lib.ai_writers.ai_blog_writer.ai_blog_generator import ai_blog_writer_page
from lib.ai_writers.ai_essay_writer import ai_essay_generator
from lib.ai_writers.ai_news_article_writer import ai_news_generation
from lib.utils.alwrity_utils import ai_news_writer, ai_finance_ta_writer, ai_social_writer, essay_writer
from lib.ai_writers.ai_facebook_writer.facebook_ai_writer import facebook_main_menu
from lib.ai_writers.linkedin_writer.linkedin_ai_writer import linkedin_main_menu
from lib.ai_writers.twitter_writers import run_dashboard as twitter_writer
from lib.ai_writers.insta_ai_writer import insta_writer
from lib.ai_writers.youtube_writers.youtube_ai_writer import youtube_main_menu
from lib.ai_writers.ai_agents_crew_writer import ai_agents_writers
from lib.utils.alwrity_utils import ai_agents_team
# Import SEO tools from ai_seo_tools
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_seo_tools.content_title_generator import ai_title_generator, generate_blog_titles
from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
from lib.ai_seo_tools.seo_structured_data import ai_structured_data
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.google_pagespeed_insights import google_pagespeed_insights
from lib.ai_seo_tools.sitemap_analysis import main as sitemap_analyzer
from lib.ai_seo_tools.twitter_tags_generator import display_app as twitter_tags_app
from lib.ai_seo_tools.enterprise_seo_suite import render_enterprise_seo_suite
from lib.alwrity_ui.seo_tools_dashboard import ai_seo_tools
@lru_cache(maxsize=None)
def get_tool_implementations() -> Dict[str, callable]:
"""
Return a mapping of tool names to their implementation functions.
Uses caching to avoid repeated imports.
"""
tool_mapping = {
# Text Generation Tools
"AI Blog Writer": ai_blog_writer_page,
"AI Essay Writer": essay_writer,
"AI News Writer": ai_news_writer,
"AI Content Team": ai_agents_team,
# Business Content Tools
"Financial TA Writer": ai_finance_ta_writer,
"AI Social Media": ai_social_writer,
# Social Media Specific Tools
"Facebook Writer": facebook_main_menu,
"LinkedIn Writer": linkedin_main_menu,
"Twitter Writer": twitter_writer,
"Instagram Writer": insta_writer,
"YouTube Writer": youtube_main_menu,
# SEO & Optimization Tools
"SEO Dashboard": ai_seo_tools,
"On-Page SEO Analyzer": analyze_onpage_seo,
"URL SEO Checker": url_seo_checker,
"AI Title Generator": lambda: _render_seo_tool("AI Title Generator", generate_blog_titles),
"Meta Description Generator": metadesc_generator_main,
"Structured Data Generator": ai_structured_data,
"Alt Text Generator": alt_text_gen,
"OpenGraph Tags": og_tag_generator,
"Page Speed Insights": google_pagespeed_insights,
"Sitemap Analyzer": sitemap_analyzer,
"Twitter Cards Generator": twitter_tags_app,
"Enterprise SEO Suite": render_enterprise_seo_suite,
# Creative Content Tools - placeholder functions for now
"Story Generator": lambda: st.info("Story Generator coming soon!"),
"Poetry Writer": lambda: st.info("Poetry Writer coming soon!"),
"Script Writer": lambda: st.info("Script Writer coming soon!"),
"Email Templates": lambda: st.info("Email Templates coming soon!"),
# Marketing Content Tools - placeholder functions
"Ad Copy Generator": lambda: st.info("Ad Copy Generator coming soon!"),
"Product Descriptions": lambda: st.info("Product Descriptions coming soon!"),
"Press Releases": lambda: st.info("Press Releases coming soon!"),
"Landing Page Copy": lambda: st.info("Landing Page Copy coming soon!"),
# Educational Content Tools - placeholder functions
"Course Content": lambda: st.info("Course Content coming soon!"),
"Tutorial Writer": lambda: st.info("Tutorial Writer coming soon!"),
"Quiz Generator": lambda: st.info("Quiz Generator coming soon!"),
"Study Guides": lambda: st.info("Study Guides coming soon!")
}
# Handle import errors gracefully
failed_imports = []
working_tools = {}
for tool_name, tool_func in tool_mapping.items():
try:
# Test if the function is callable
if callable(tool_func):
working_tools[tool_name] = tool_func
else:
failed_imports.append(tool_name)
except Exception as e:
logger.warning(f"Failed to load tool {tool_name}: {e}")
failed_imports.append(tool_name)
if failed_imports:
logger.info(f"Some tools are not available: {failed_imports}")
return working_tools
def _render_seo_tool(tool_name: str, tool_function):
"""Render SEO tools with consistent styling and handle errors."""
st.markdown(f"## 🔍 {tool_name}")
st.markdown("---")
# Handle AI Title Generator specifically
if "Title Generator" in tool_name:
_render_title_generator_ui()
else:
# For other SEO tools, call them directly
try:
if callable(tool_function):
tool_function()
else:
st.warning(f"Tool '{tool_name}' is not properly configured.")
except Exception as e:
st.error(f"Error loading tool: {str(e)}")
logger.error(f"Error in SEO tool {tool_name}: {str(e)}")
def _render_title_generator_ui():
"""Render a custom UI for the AI Title Generator."""
st.markdown("### Generate SEO-Optimized Titles")
# Input form
with st.form("title_generator_form"):
col1, col2 = st.columns(2)
with col1:
keywords = st.text_input(
"Blog Keywords",
placeholder="Enter your main keywords (comma-separated)",
help="Primary keywords for your content"
)
title_type = st.selectbox(
"Content Type",
["How-to Guide", "Listicle", "News Article", "Product Review", "Tutorial", "Case Study", "Opinion", "Research"]
)
with col2:
content = st.text_area(
"Blog Content (Optional)",
placeholder="Paste your blog content here for more targeted titles...",
height=100,
help="Optional: Paste existing content for more relevant titles"
)
title_intent = st.selectbox(
"Search Intent",
["Informational", "Commercial", "Transactional", "Navigational"]
)
language = st.selectbox(
"Language",
["English", "Spanish", "French", "German", "Italian", "Portuguese", "Hindi"]
)
submitted = st.form_submit_button("🚀 Generate Titles", use_container_width=True)
if submitted:
if not keywords:
st.warning("Please enter at least some keywords to generate titles.")
return
with st.spinner("🎯 Generating SEO-optimized titles..."):
try:
# Import and call the title generation function
from lib.ai_seo_tools.content_title_generator import generate_blog_titles
result = generate_blog_titles(
input_blog_keywords=keywords,
input_blog_content=content if content else None,
input_title_type=title_type,
input_title_intent=title_intent,
input_language=language
)
if result:
st.success("✅ Titles generated successfully!")
st.markdown("### 🎯 Your SEO-Optimized Titles:")
# Display the result in a nice format
st.markdown(f"```\n{result}\n```")
# Add copy buttons or additional features
if st.button("📋 Copy All Titles"):
st.success("Titles copied to clipboard! (Feature coming soon)")
else:
st.error("Failed to generate titles. Please try again.")
except Exception as e:
st.error(f"Error generating titles: {str(e)}")
logger.error(f"Title generation error: {str(e)}")
def render_content_generation_dashboard():
"""Main function to render the content generation dashboard."""
# Initialize dashboard state
dashboard_state = DashboardState()
# Apply modern CSS
apply_modern_css()
# Main dashboard header
st.markdown("""
<div class="main-dashboard">
<div class="dashboard-title">🚀 Alwrity Content Hub</div>
<div class="dashboard-subtitle">
Complete AI-powered content creation and SEO optimization suite. From writing to ranking - everything you need in one place.
</div>
<div style="display: flex; justify-content: center; gap: 2rem; margin-top: 1rem; flex-wrap: wrap;">
<div style="text-align: center;">
<div style="font-size: 2rem;">✍️</div>
<div style="font-size: 0.9rem; opacity: 0.8;">AI Writing</div>
</div>
<div style="text-align: center;">
<div style="font-size: 2rem;">🔍</div>
<div style="font-size: 0.9rem; opacity: 0.8;">SEO Tools</div>
</div>
<div style="text-align: center;">
<div style="font-size: 2rem;">📱</div>
<div style="font-size: 0.9rem; opacity: 0.8;">Social Media</div>
</div>
<div style="text-align: center;">
<div style="font-size: 2rem;">📊</div>
<div style="font-size: 0.9rem; opacity: 0.8;">Analytics</div>
</div>
</div>
</div>
""", unsafe_allow_html=True)
# Quick access section
st.markdown("""
<div class="quick-access">
<div class="section-title">⚡ Quick Access</div>
</div>
""", unsafe_allow_html=True)
# Recent tools
if st.session_state.get('recent_tools'):
st.markdown("### 📝 Recently Used")
cols = st.columns(min(len(st.session_state.recent_tools), 5))
for idx, tool in enumerate(st.session_state.recent_tools[:5]):
with cols[idx]:
if st.button(f"🔄 {tool}", key=f"recent_{tool}_{idx}"):
handle_tool_selection(tool, dashboard_state)
# Popular tools
popular_tools = ToolAnalytics.get_popular_tools()
if popular_tools:
st.markdown("### 🔥 Popular Tools")
cols = st.columns(min(len(popular_tools), 5))
for idx, tool in enumerate(popular_tools[:5]):
with cols[idx]:
if st.button(f"⭐ {tool}", key=f"popular_{tool}_{idx}"):
handle_tool_selection(tool, dashboard_state)
# Content tools by category
content_tools = {
"Text Generation": {
"tools": [
{"name": "AI Blog Writer", "icon": "✍️", "desc": "Create SEO-optimized blog posts with AI assistance"},
{"name": "AI Essay Writer", "icon": "📝", "desc": "Generate academic essays and research papers"},
{"name": "AI News Writer", "icon": "📰", "desc": "Write breaking news articles and reports"},
{"name": "AI Content Team", "icon": "👥", "desc": "Collaborative AI writing team for complex projects"}
]
},
"SEO & Optimization": {
"tools": [
{"name": "SEO Dashboard", "icon": "🔍", "desc": "Comprehensive SEO tools and analytics dashboard"},
{"name": "On-Page SEO Analyzer", "icon": "📊", "desc": "Analyze and optimize individual page SEO elements"},
{"name": "AI Title Generator", "icon": "🏷️", "desc": "Generate SEO-optimized titles for better rankings"},
{"name": "Meta Description Generator", "icon": "📄", "desc": "Create compelling meta descriptions that drive clicks"},
{"name": "Structured Data Generator", "icon": "🏗️", "desc": "Generate schema markup for rich search results"},
{"name": "Page Speed Insights", "icon": "⚡", "desc": "Analyze and improve website performance metrics"},
{"name": "Enterprise SEO Suite", "icon": "🏢", "desc": "Advanced SEO workflows for enterprise needs"}
]
},
"Business Content": {
"tools": [
{"name": "Financial TA Writer", "icon": "📊", "desc": "Generate technical analysis reports for stocks"},
{"name": "Email Templates", "icon": "📧", "desc": "Professional email templates for business"},
{"name": "Press Releases", "icon": "📢", "desc": "Company announcements and press releases"},
{"name": "Landing Page Copy", "icon": "🌐", "desc": "High-converting landing page content"}
]
},
"Social Media": {
"tools": [
{"name": "Facebook Writer", "icon": "📘", "desc": "Facebook posts, ads, and content strategies"},
{"name": "LinkedIn Writer", "icon": "💼", "desc": "Professional LinkedIn articles and posts"},
{"name": "Twitter Writer", "icon": "🐦", "desc": "Engaging tweets and Twitter threads"},
{"name": "Instagram Writer", "icon": "📷", "desc": "Instagram captions and story content"},
{"name": "YouTube Writer", "icon": "🎬", "desc": "YouTube descriptions and video scripts"},
{"name": "OpenGraph Tags", "icon": "🔗", "desc": "Optimize social media sharing with Open Graph tags"},
{"name": "Twitter Cards Generator", "icon": "🐦", "desc": "Create Twitter Card markup for rich previews"}
]
},
"Creative Content": {
"tools": [
{"name": "Story Generator", "icon": "📚", "desc": "Creative short stories and narratives"},
{"name": "Poetry Writer", "icon": "🎭", "desc": "Beautiful poems and verses"},
{"name": "Script Writer", "icon": "🎬", "desc": "Scripts for videos, plays, and presentations"},
{"name": "Song Lyrics", "icon": "🎵", "desc": "Original song lyrics and musical content"}
]
}
}
# Render categories
for category, category_data in content_tools.items():
st.markdown(f"""
<div class="category-section">
<div class="category-header">{category}</div>
<div class="category-grid">
""", unsafe_allow_html=True)
# Create columns for tools in this category
tools = category_data["tools"]
cols = st.columns(min(len(tools), 3))
for idx, tool in enumerate(tools):
col_idx = idx % 3
with cols[col_idx]:
# Create tool card with button
if st.button(
f"{tool['icon']} {tool['name']}\n{tool['desc']}",
key=f"tool_{tool['name']}_{category}",
help=tool['desc']
):
handle_tool_selection(tool['name'], dashboard_state)
st.markdown("</div></div>", unsafe_allow_html=True)
# Footer with statistics
st.markdown("---")
st.markdown("### 📈 Alwrity Analytics")
col1, col2, col3, col4 = st.columns(4)
total_tools = len(get_tool_implementations())
seo_tools_count = len([tool for category in content_tools.values() for tool in category["tools"] if "SEO" in category.get("name", "") or any(seo_keyword in tool["name"] for seo_keyword in ["SEO", "Meta", "Title", "Structured", "Speed", "OpenGraph"])])
with col1:
st.metric("🛠️ Total Tools", total_tools)
with col2:
st.metric("🔍 SEO Tools", 12) # Based on our SEO tool count
with col3:
st.metric("📝 Recent Tools", len(st.session_state.get('recent_tools', [])))
with col4:
st.metric("⭐ Favorites", len(st.session_state.get('favorite_tools', [])))
# Add capability showcase
st.markdown("""
<div style="background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); padding: 1.5rem; border-radius: 10px; margin-top: 1rem;">
<h4 style="color: #2c3e50; margin-bottom: 1rem;">✨ Why Choose Alwrity?</h4>
<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 1rem;">
<div>
<strong>🎯 All-in-One Solution</strong><br>
<small>Content creation, SEO optimization, and social media management in one platform</small>
</div>
<div>
<strong>🤖 AI-Powered Intelligence</strong><br>
<small>Advanced AI models for content generation and SEO analysis</small>
</div>
<div>
<strong>📊 Enterprise-Ready</strong><br>
<small>Scalable tools designed for teams and enterprise workflows</small>
</div>
<div>
<strong>🚀 Continuously Updated</strong><br>
<small>Regular updates with new tools and enhanced capabilities</small>
</div>
</div>
</div>
""", unsafe_allow_html=True)
class DashboardState:
"""Manage dashboard state and user preferences."""
def __init__(self):
self.initialize_session_state()
def initialize_session_state(self):
"""Initialize session state variables."""
if 'recent_tools' not in st.session_state:
st.session_state.recent_tools = []
if 'favorite_tools' not in st.session_state:
st.session_state.favorite_tools = []
if 'tool_usage_count' not in st.session_state:
st.session_state.tool_usage_count = {}
def add_recent_tool(self, tool_name: str):
"""Add a tool to recent tools list."""
if tool_name in st.session_state.recent_tools:
st.session_state.recent_tools.remove(tool_name)
st.session_state.recent_tools.insert(0, tool_name)
# Keep only last 5 recent tools
st.session_state.recent_tools = st.session_state.recent_tools[:5]
def toggle_favorite(self, tool_name: str):
"""Toggle tool favorite status."""
if tool_name in st.session_state.favorite_tools:
st.session_state.favorite_tools.remove(tool_name)
else:
st.session_state.favorite_tools.append(tool_name)
def increment_usage(self, tool_name: str):
"""Increment tool usage count."""
st.session_state.tool_usage_count[tool_name] = st.session_state.tool_usage_count.get(tool_name, 0) + 1
class ToolAnalytics:
"""Analytics for tool usage and recommendations."""
@staticmethod
def get_popular_tools(limit: int = 5) -> List[str]:
"""Get most popular tools based on usage."""
usage_count = st.session_state.get('tool_usage_count', {})
if not usage_count:
# Return default popular tools showcasing Alwrity's key capabilities
return ["AI Blog Writer", "SEO Dashboard", "AI Title Generator", "Meta Description Generator", "On-Page SEO Analyzer"]
sorted_tools = sorted(usage_count.items(), key=lambda x: x[1], reverse=True)
return [tool[0] for tool in sorted_tools[:limit]]
def apply_modern_css():
"""Apply modern CSS styling to the dashboard."""
st.markdown("""
<style>
/* Main dashboard styling */
.main-dashboard {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
padding: 2rem;
border-radius: 15px;
margin-bottom: 2rem;
color: white;
}
.dashboard-title {
font-size: 3rem;
font-weight: 700;
text-align: center;
margin-bottom: 1rem;
text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
}
.dashboard-subtitle {
font-size: 1.2rem;
text-align: center;
opacity: 0.9;
margin-bottom: 2rem;
}
/* Tool cards */
.tool-card {
background: white;
border-radius: 12px;
padding: 1.5rem;
margin: 0.5rem;
box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
transition: all 0.3s ease;
cursor: pointer;
border: 2px solid transparent;
height: 200px;
display: flex;
flex-direction: column;
justify-content: space-between;
}
.tool-card:hover {
transform: translateY(-5px);
box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15);
border-color: #667eea;
}
.tool-icon {
font-size: 2.5rem;
text-align: center;
margin-bottom: 1rem;
}
.tool-title {
font-size: 1.1rem;
font-weight: 600;
color: #333;
text-align: center;
margin-bottom: 0.5rem;
}
.tool-description {
font-size: 0.9rem;
color: #666;
text-align: center;
line-height: 1.4;
}
/* Quick access section */
.quick-access {
background: #f8f9fa;
border-radius: 10px;
padding: 1.5rem;
margin-bottom: 2rem;
}
.section-title {
font-size: 1.5rem;
font-weight: 600;
color: #333;
margin-bottom: 1rem;
display: flex;
align-items: center;
gap: 0.5rem;
}
/* Recent tools styling */
.recent-tool {
background: linear-gradient(135deg, #ff6b6b, #ee5a24);
color: white;
padding: 0.75rem 1rem;
border-radius: 8px;
margin: 0.25rem;
font-weight: 500;
text-align: center;
cursor: pointer;
transition: all 0.3s ease;
}
.recent-tool:hover {
transform: scale(1.05);
box-shadow: 0 4px 12px rgba(255, 107, 107, 0.4);
}
/* Category sections */
.category-section {
margin-bottom: 3rem;
}
.category-header {
background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
color: white;
padding: 1rem 1.5rem;
border-radius: 10px 10px 0 0;
font-size: 1.3rem;
font-weight: 600;
}
.category-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
gap: 1rem;
padding: 1.5rem;
background: #f8f9fa;
border-radius: 0 0 10px 10px;
}
/* Responsive design */
@media (max-width: 768px) {
.dashboard-title {
font-size: 2rem;
}
.category-grid {
grid-template-columns: 1fr;
}
.tool-card {
height: auto;
min-height: 150px;
}
}
/* Success and info messages */
.success-message {
background: linear-gradient(135deg, #56ab2f, #a8e6cf);
color: white;
padding: 1rem;
border-radius: 8px;
margin: 1rem 0;
}
.info-message {
background: linear-gradient(135deg, #74b9ff, #0984e3);
color: white;
padding: 1rem;
border-radius: 8px;
margin: 1rem 0;
}
</style>
""", unsafe_allow_html=True)
def handle_tool_selection(tool_name: str, dashboard_state: DashboardState):
"""Handle tool selection and navigation."""
try:
# Update usage statistics
dashboard_state.add_recent_tool(tool_name)
dashboard_state.increment_usage(tool_name)
# Get tool implementations
tools = get_tool_implementations()
if tool_name in tools:
st.markdown(f"<div class='success-message'>🚀 Launching {tool_name}...</div>", unsafe_allow_html=True)
# Show loading state
with st.spinner(f"Loading {tool_name}..."):
try:
# Execute the tool function
tools[tool_name]()
logger.info(f"Successfully launched tool: {tool_name}")
except Exception as e:
st.error(f"Error running {tool_name}: {str(e)}")
logger.error(f"Error running tool {tool_name}: {e}")
else:
st.warning(f"Tool '{tool_name}' is not available yet.")
except ImportError as e:
st.error(f"Unable to load {tool_name}. Some dependencies may be missing.")
logger.error(f"Import error for {tool_name}: {e}")
except Exception as e:
st.error(f"An unexpected error occurred: {str(e)}")
logger.error(f"Unexpected error in tool selection: {e}")
# Main entry point
if __name__ == "__main__":
render_content_generation_dashboard()

684
lib/alwrity_ui/content_performance_predictor_ui.py Normal file
View File

@@ -0,0 +1,684 @@
"""
Streamlit UI for Content Performance Predictor
Interactive interface for predicting and optimizing content performance
"""
import streamlit as st
import asyncio
import json
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime, timedelta
import pandas as pd
from typing import Dict, List, Any, Optional
import logging
# Import the predictor
try:
from lib.content_performance_predictor.content_performance_predictor import (
ContentPerformancePredictor,
ContentType,
predict_content_performance
)
except ImportError:
st.error("Content Performance Predictor module not found. Please check the installation.")
logger = logging.getLogger(__name__)
class ContentPerformancePredictorUI:
"""Streamlit UI for Content Performance Predictor"""
def __init__(self):
self.predictor = None
self.initialize_predictor()
def initialize_predictor(self):
"""Initialize the predictor with error handling"""
try:
self.predictor = ContentPerformancePredictor()
except Exception as e:
st.error(f"Failed to initialize predictor: {str(e)}")
self.predictor = None
def render_main_interface(self):
"""Render the main Content Performance Predictor interface"""
st.title("🎯 Content Performance Predictor")
st.markdown("### Predict content success before you publish!")
# Create tabs for different features
tab1, tab2, tab3, tab4 = st.tabs([
"📊 Predict Performance",
"📈 Batch Analysis",
"🔧 Optimization Tools",
"📚 Performance History"
])
with tab1:
self.render_single_prediction_tab()
with tab2:
self.render_batch_analysis_tab()
with tab3:
self.render_optimization_tab()
with tab4:
self.render_history_tab()
def render_single_prediction_tab(self):
"""Render single content prediction interface"""
st.header("Single Content Analysis")
# Input section
col1, col2 = st.columns([2, 1])
with col1:
# Content input
content_input = st.text_area(
"Enter your content:",
height=200,
placeholder="Paste your content here...\n\nExample:\n🚀 Just discovered an amazing AI writing tool that's changing the game!\n\n#AIWriting #ContentCreation"
)
# Target keywords
keywords_input = st.text_input(
"Target Keywords (optional):",
placeholder="AI writing, content creation, SEO"
)
with col2:
# Content type selection
content_type = st.selectbox(
"Content Type:",
["twitter", "linkedin", "facebook", "instagram", "blog_post", "email", "youtube"],
help="Select the platform where you plan to publish"
)
# Analysis options
st.subheader("Analysis Options")
include_seo = st.checkbox("Include SEO Analysis", value=True)
include_trends = st.checkbox("Include Trend Analysis", value=True)
include_competitor = st.checkbox("Include Competitor Analysis", value=False)
# Advanced settings
with st.expander("Advanced Settings"):
target_audience = st.selectbox(
"Target Audience:",
["General", "Business", "Tech", "Marketing", "Education", "Entertainment"]
)
urgency_level = st.slider(
"Content Urgency:",
0.0, 1.0, 0.5,
help="How time-sensitive is this content?"
)
# Predict button
if st.button("🎯 Predict Performance", type="primary", use_container_width=True):
if not content_input.strip():
st.error("Please enter content to analyze")
return
# Process keywords
keywords = [k.strip() for k in keywords_input.split(",")] if keywords_input else None
# Show loading spinner
with st.spinner("Analyzing content performance..."):
# Run prediction
prediction_result = self.run_prediction(
content_input,
content_type,
keywords,
include_seo,
include_trends,
include_competitor
)
if prediction_result:
self.display_prediction_results(prediction_result)
else:
st.error("Failed to analyze content. Please try again.")
def run_prediction(
self,
content: str,
content_type: str,
keywords: Optional[List[str]],
include_seo: bool,
include_trends: bool,
include_competitor: bool
) -> Optional[Dict[str, Any]]:
"""Run the content performance prediction"""
try:
# Run async prediction
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
result = loop.run_until_complete(
predict_content_performance(
content=content,
content_type=content_type,
target_keywords=keywords
)
)
loop.close()
return result
except Exception as e:
logger.error(f"Error in prediction: {str(e)}")
st.error(f"Prediction failed: {str(e)}")
return None
def display_prediction_results(self, result: Dict[str, Any]):
"""Display the prediction results with visualizations"""
st.success("✅ Analysis Complete!")
# Overall score section
st.subheader("📊 Overall Performance Score")
col1, col2, col3 = st.columns(3)
with col1:
# Overall score gauge
score = result.get("overall_score", 0)
self.render_score_gauge(score, "Overall Score")
with col2:
# Success probability
prob = result.get("success_probability", 0) * 100
self.render_score_gauge(prob, "Success Probability")
with col3:
# Performance rating
rating = self.get_performance_rating(score)
st.metric(
"Performance Rating",
rating["label"],
help=rating["description"]
)
# Detailed scores breakdown
st.subheader("🔍 Detailed Score Breakdown")
scores = result.get("individual_scores", {})
if scores:
self.render_scores_breakdown(scores)
# Recommendations section
st.subheader("💡 Optimization Recommendations")
recommendations = result.get("recommendations", [])
if recommendations:
for i, rec in enumerate(recommendations, 1):
st.markdown(f"**{i}.** {rec}")
else:
st.info("No specific recommendations available")
# Predicted metrics
st.subheader("📊 Predicted Performance Metrics")
metrics = result.get("predicted_metrics", {})
if metrics:
self.render_predicted_metrics(metrics)
# Content analysis details
st.subheader("📝 Content Analysis Details")
analysis = result.get("content_analysis", {})
if analysis:
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Word Count", analysis.get("word_count", 0))
with col2:
st.metric("Character Count", analysis.get("character_count", 0))
with col3:
st.metric("Hashtags", analysis.get("hashtag_count", 0))
with col4:
st.metric("Readability", f"{analysis.get('readability_score', 0):.1f}")
# Export options
st.subheader("📤 Export Results")
col1, col2 = st.columns(2)
with col1:
if st.button("📄 Generate Report"):
report = self.generate_text_report(result)
st.text_area("Report:", value=report, height=200)
with col2:
if st.button("📊 Download JSON"):
json_str = json.dumps(result, indent=2)
st.download_button(
label="Download JSON",
data=json_str,
file_name=f"content_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
mime="application/json"
)
def render_score_gauge(self, score: float, title: str):
"""Render a gauge chart for scores"""
fig = go.Figure(go.Indicator(
mode = "gauge+number+delta",
value = score,
domain = {'x': [0, 1], 'y': [0, 1]},
title = {'text': title},
delta = {'reference': 50},
gauge = {
'axis': {'range': [None, 100]},
'bar': {'color': "darkblue"},
'steps': [
{'range': [0, 25], 'color': "lightgray"},
{'range': [25, 50], 'color': "yellow"},
{'range': [50, 75], 'color': "orange"},
{'range': [75, 100], 'color': "green"}],
'threshold': {
'line': {'color': "red", 'width': 4},
'thickness': 0.75,
'value': 90}}))
fig.update_layout(height=300)
st.plotly_chart(fig, use_container_width=True)
def render_scores_breakdown(self, scores: Dict[str, float]):
"""Render radar chart for score breakdown"""
categories = list(scores.keys())
values = list(scores.values())
# Close the radar chart
categories.append(categories[0])
values.append(values[0])
fig = go.Figure()
fig.add_trace(go.Scatterpolar(
r=values,
theta=categories,
fill='toself',
name='Performance Scores'
))
fig.update_layout(
polar=dict(
radialaxis=dict(
visible=True,
range=[0, 100]
)),
showlegend=True,
title="Performance Score Breakdown"
)
st.plotly_chart(fig, use_container_width=True)
# Display scores as metrics
cols = st.columns(len(scores))
for i, (category, score) in enumerate(scores.items()):
with cols[i]:
st.metric(category.title(), f"{score:.1f}")
def render_predicted_metrics(self, metrics: Dict[str, Any]):
"""Render predicted performance metrics"""
cols = st.columns(len(metrics))
for i, (metric, value) in enumerate(metrics.items()):
with cols[i]:
# Format metric name
display_name = metric.replace("predicted_", "").replace("_", " ").title()
st.metric(display_name, f"{value:,}")
def get_performance_rating(self, score: float) -> Dict[str, str]:
"""Get performance rating based on score"""
if score >= 80:
return {"label": "Excellent", "description": "High chance of success"}
elif score >= 60:
return {"label": "Good", "description": "Solid performance expected"}
elif score >= 40:
return {"label": "Average", "description": "Room for improvement"}
else:
return {"label": "Needs Work", "description": "Optimization recommended"}
def render_batch_analysis_tab(self):
"""Render batch analysis interface"""
st.header("Batch Content Analysis")
st.info("Analyze multiple pieces of content at once")
# File upload
uploaded_file = st.file_uploader(
"Upload CSV with content",
type=['csv'],
help="CSV should have columns: 'content', 'content_type', 'keywords' (optional)"
)
if uploaded_file is not None:
try:
df = pd.read_csv(uploaded_file)
# Validate required columns
required_cols = ['content', 'content_type']
missing_cols = [col for col in required_cols if col not in df.columns]
if missing_cols:
st.error(f"Missing required columns: {', '.join(missing_cols)}")
return
st.success(f"✅ Loaded {len(df)} content items")
# Preview data
with st.expander("Preview Data"):
st.dataframe(df.head())
# Analysis options
col1, col2 = st.columns(2)
with col1:
max_items = st.number_input(
"Max items to analyze:",
min_value=1,
max_value=100,
value=min(10, len(df))
)
with col2:
export_format = st.selectbox(
"Export format:",
["CSV", "JSON", "Excel"]
)
# Run batch analysis
if st.button("🚀 Run Batch Analysis", type="primary"):
with st.spinner(f"Analyzing {max_items} content items..."):
batch_df = df.head(max_items)
results = self.run_batch_analysis(batch_df)
if results:
self.display_batch_results(results)
else:
st.error("Batch analysis failed")
except Exception as e:
st.error(f"Error processing file: {str(e)}")
def run_batch_analysis(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
"""Run batch analysis on multiple content items"""
results = []
progress = st.progress(0)
for i, row in df.iterrows():
try:
content = row['content']
content_type = row['content_type']
keywords = row.get('keywords', '').split(',') if row.get('keywords') else None
result = self.run_prediction(content, content_type, keywords, True, True, False)
if result:
result['original_content'] = content
result['content_type'] = content_type
results.append(result)
progress.progress((i + 1) / len(df))
except Exception as e:
st.warning(f"Error analyzing row {i}: {str(e)}")
continue
return results
def display_batch_results(self, results: List[Dict[str, Any]]):
"""Display batch analysis results"""
st.success(f"✅ Analyzed {len(results)} content items")
# Summary statistics
st.subheader("📊 Batch Summary")
scores = [r.get('overall_score', 0) for r in results]
avg_score = sum(scores) / len(scores) if scores else 0
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Average Score", f"{avg_score:.1f}")
with col2:
st.metric("Best Score", f"{max(scores):.1f}" if scores else "0")
with col3:
st.metric("Worst Score", f"{min(scores):.1f}" if scores else "0")
with col4:
good_content = len([s for s in scores if s >= 60])
st.metric("Good Content", f"{good_content}/{len(scores)}")
# Results table
st.subheader("📋 Detailed Results")
# Create summary DataFrame
summary_data = []
for i, result in enumerate(results):
summary_data.append({
"Content": result['original_content'][:50] + "..." if len(result['original_content']) > 50 else result['original_content'],
"Type": result['content_type'],
"Overall Score": result.get('overall_score', 0),
"Success Probability": result.get('success_probability', 0) * 100,
"Engagement": result.get('individual_scores', {}).get('engagement', 0),
"SEO": result.get('individual_scores', {}).get('seo', 0),
"Virality": result.get('individual_scores', {}).get('virality', 0)
})
summary_df = pd.DataFrame(summary_data)
st.dataframe(summary_df, use_container_width=True)
# Download results
if st.button("📥 Download Results"):
csv = summary_df.to_csv(index=False)
st.download_button(
label="Download CSV",
data=csv,
file_name=f"batch_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv"
)
def render_optimization_tab(self):
"""Render content optimization tools"""
st.header("🔧 Content Optimization Tools")
# A/B Testing section
st.subheader("🧪 A/B Content Testing")
col1, col2 = st.columns(2)
with col1:
st.markdown("**Version A**")
content_a = st.text_area(
"Content A:",
height=150,
key="content_a",
placeholder="Enter first version of your content..."
)
with col2:
st.markdown("**Version B**")
content_b = st.text_area(
"Content B:",
height=150,
key="content_b",
placeholder="Enter second version of your content..."
)
# Common settings
content_type = st.selectbox(
"Content Type for both:",
["twitter", "linkedin", "facebook", "instagram", "blog_post", "email", "youtube"],
key="ab_content_type"
)
if st.button("⚡ Compare Versions", type="primary"):
if not content_a.strip() or not content_b.strip():
st.error("Please enter both versions of content")
return
with st.spinner("Comparing content versions..."):
result_a = self.run_prediction(content_a, content_type, None, True, True, False)
result_b = self.run_prediction(content_b, content_type, None, True, True, False)
if result_a and result_b:
self.display_ab_comparison(result_a, result_b)
# Optimization suggestions
st.subheader("💡 Optimization Suggestions")
optimization_content = st.text_area(
"Content to optimize:",
height=150,
placeholder="Enter content for optimization suggestions..."
)
if st.button("🚀 Get Suggestions") and optimization_content.strip():
with st.spinner("Generating optimization suggestions..."):
suggestions = self.generate_optimization_suggestions(optimization_content)
if suggestions:
st.success("✅ Optimization suggestions generated!")
for i, suggestion in enumerate(suggestions, 1):
st.markdown(f"**{i}.** {suggestion}")
def display_ab_comparison(self, result_a: Dict[str, Any], result_b: Dict[str, Any]):
"""Display A/B test comparison results"""
st.success("✅ A/B Comparison Complete!")
# Overall comparison
col1, col2, col3 = st.columns(3)
score_a = result_a.get('overall_score', 0)
score_b = result_b.get('overall_score', 0)
winner = "A" if score_a > score_b else "B" if score_b > score_a else "Tie"
with col1:
st.metric("Version A Score", f"{score_a:.1f}")
with col2:
st.metric("Version B Score", f"{score_b:.1f}")
with col3:
st.metric("Winner", winner, delta=f"{abs(score_a - score_b):.1f} point difference")
# Detailed comparison chart
scores_a = result_a.get('individual_scores', {})
scores_b = result_b.get('individual_scores', {})
categories = list(scores_a.keys())
values_a = list(scores_a.values())
values_b = list(scores_b.values())
# Create comparison bar chart
fig = go.Figure(data=[
go.Bar(name='Version A', x=categories, y=values_a),
go.Bar(name='Version B', x=categories, y=values_b)
])
fig.update_layout(
barmode='group',
title="Detailed Score Comparison",
yaxis_title="Score",
xaxis_title="Category"
)
st.plotly_chart(fig, use_container_width=True)
# Recommendations comparison
st.subheader("📋 Recommendations Comparison")
col1, col2 = st.columns(2)
with col1:
st.markdown("**Version A Recommendations:**")
recs_a = result_a.get('recommendations', [])
for rec in recs_a[:5]:
st.markdown(f"• {rec}")
with col2:
st.markdown("**Version B Recommendations:**")
recs_b = result_b.get('recommendations', [])
for rec in recs_b[:5]:
st.markdown(f"• {rec}")
def generate_optimization_suggestions(self, content: str) -> List[str]:
"""Generate optimization suggestions for content"""
suggestions = []
# Basic content analysis
word_count = len(content.split())
char_count = len(content)
hashtag_count = content.count('#')
# Length optimization
if word_count < 10:
suggestions.append("Consider adding more detail to your content for better engagement")
elif word_count > 50:
suggestions.append("Consider shortening your content for better social media performance")
# Hashtag optimization
if hashtag_count == 0:
suggestions.append("Add relevant hashtags to increase discoverability")
elif hashtag_count > 5:
suggestions.append("Reduce the number of hashtags for better readability")
# Engagement optimization
if '?' not in content:
suggestions.append("Consider adding a question to encourage engagement")
if '!' not in content and '.' in content:
suggestions.append("Add some excitement with exclamation marks")
# Call to action
cta_words = ['click', 'share', 'comment', 'like', 'follow', 'subscribe']
has_cta = any(word in content.lower() for word in cta_words)
if not has_cta:
suggestions.append("Include a clear call-to-action (like, share, comment)")
# Emoji usage
emoji_count = len([char for char in content if ord(char) > 127])
if emoji_count == 0:
suggestions.append("Consider adding relevant emojis to make content more engaging")
return suggestions[:5] # Limit to top 5 suggestions
def render_history_tab(self):
"""Render performance history interface"""
st.header("📚 Performance History")
st.info("Performance history tracking coming soon!")
st.markdown("This feature will allow you to:")
st.markdown("• Track your content performance over time")
st.markdown("• Compare predicted vs actual performance")
st.markdown("• Identify your best-performing content patterns")
st.markdown("• Generate performance reports")
def generate_text_report(self, result: Dict[str, Any]) -> str:
"""Generate a text report of the analysis"""
report = f"""
CONTENT PERFORMANCE ANALYSIS REPORT
Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
OVERALL PERFORMANCE
Overall Score: {result.get('overall_score', 0):.1f}/100
Success Probability: {result.get('success_probability', 0)*100:.1f}%
Performance Rating: {self.get_performance_rating(result.get('overall_score', 0))['label']}
DETAILED SCORES
"""
scores = result.get('individual_scores', {})
for category, score in scores.items():
report += f"{category.title()}: {score:.1f}/100\n"
report += "\nCONTENT ANALYSIS\n"
analysis = result.get('content_analysis', {})
for key, value in analysis.items():
report += f"{key.replace('_', ' ').title()}: {value}\n"
report += "\nRECOMMENDATIONS\n"
recommendations = result.get('recommendations', [])
for i, rec in enumerate(recommendations, 1):
report += f"{i}. {rec}\n"
return report
def render_content_performance_predictor():
"""Main function to render the Content Performance Predictor UI"""
ui = ContentPerformancePredictorUI()
ui.render_main_interface()
if __name__ == "__main__":
render_content_performance_predictor()

898
lib/alwrity_ui/seo_tools_dashboard.py
View File

@@ -1,5 +1,6 @@
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
@@ -23,13 +24,228 @@ 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."""
from lib.ai_seo_tools.content_gap_analysis.ui import ContentGapAnalysisUI
# Initialize and run the Content Gap Analysis UI
ui = ContentGapAnalysisUI()
ui.run()
@@ -38,10 +254,9 @@ def render_enhanced_content_gap_analysis_ui():
render_enhanced_content_gap_analysis()
def render_content_calendar():
"""Render the content calendar dashboard."""
"""Render the content calendar dashboard with proper error handling."""
import logging
import sys
from datetime import datetime
# Configure logging
logging.basicConfig(
@@ -52,16 +267,16 @@ def render_content_calendar():
logging.FileHandler('content_calendar.log', mode='a')
]
)
logger = logging.getLogger('content_calendar')
calendar_logger = logging.getLogger('content_calendar')
try:
logger.info("Initializing Content Calendar Dashboard")
calendar_logger.info("Initializing Content Calendar Dashboard")
dashboard = ContentCalendarDashboard()
logger.info("Rendering Content Calendar Dashboard")
calendar_logger.info("Rendering Content Calendar Dashboard")
dashboard.render()
logger.info("Content Calendar Dashboard rendered successfully")
calendar_logger.info("Content Calendar Dashboard rendered successfully")
except Exception as e:
logger.error(f"Error rendering content calendar: {str(e)}", exc_info=True)
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():
@@ -77,37 +292,41 @@ def render_readability_analyzer():
if st.button("Analyze Readability"):
if text_input.strip():
from textstat import textstat
# Calculate various metrics
metrics = {
"Flesch Reading Ease": textstat.flesch_reading_ease(text_input),
"Flesch-Kincaid Grade Level": textstat.flesch_kincaid_grade(text_input),
"Gunning Fog Index": textstat.gunning_fog(text_input),
"SMOG Index": textstat.smog_index(text_input),
"Automated Readability Index": textstat.automated_readability_index(text_input),
"Coleman-Liau Index": textstat.coleman_liau_index(text_input),
"Linsear Write Formula": textstat.linsear_write_formula(text_input),
"Dale-Chall Readability Score": textstat.dale_chall_readability_score(text_input),
"Readability Consensus": textstat.readability_consensus(text_input)
}
# Display metrics
st.subheader("Text Analysis Results")
for metric, value in metrics.items():
st.metric(metric, f"{value:.2f}")
# Add 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!
""")
_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")
@@ -117,253 +336,291 @@ def render_wordcloud_generator():
if st.button("Generate Word Cloud"):
if text_input.strip():
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_input)
# 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)
# Add some statistics
st.subheader("Text Statistics")
words = text_input.split()
unique_words = set(words)
st.metric("Total Words", len(words))
st.metric("Unique Words", len(unique_words))
_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 a modern dashboard for SEO tools with premium glassmorphic design."""
"""Render comprehensive SEO tools dashboard with enterprise features."""
st.title("🚀 Alwrity AI SEO Tools")
st.markdown("**Enterprise-level SEO tools powered by artificial intelligence**")
# Apply common dashboard styling
apply_dashboard_style()
# Create tabs for different tool categories
tab1, tab2, tab3, tab4, tab5 = st.tabs([
"🏢 Enterprise Suite",
"📊 Analytics & Intelligence",
"🔧 Technical SEO",
"📝 Content & Strategy",
"🎯 Basic Tools"
])
# Enhanced dashboard header with modern design
render_dashboard_header(
"🚀 SEO AI Power Suite",
"Dominate search rankings with our comprehensive AI-powered SEO toolkit. From keyword research to content optimization, master every aspect of search engine optimization."
)
with tab1:
render_enterprise_tab()
# Define SEO tools organized by real use cases and existing functionality
seo_tools = {
"Content Creation & Optimization": {
"Content Title Generator": {
"icon": "📝",
"description": "Create attention-grabbing, SEO-optimized titles that resonate with your audience",
"category": "Content",
"path": "blog_title",
"features": ["Keyword Optimization", "Title Variations", "CTR Enhancement", "SEO Best Practices"]
},
"Meta Description Generator": {
"icon": "🏷️",
"description": "Generate compelling meta descriptions that boost click-through rates from search results",
"category": "Meta Tags",
"path": "meta_description",
"features": ["SERP Optimization", "Character Limits", "Keyword Integration", "CTR Improvement"]
},
"Structured Data Generator": {
"icon": "🏗️",
"description": "Create schema markup to enhance search result appearance with rich snippets",
"category": "Technical",
"path": "structured_data",
"features": ["Rich Snippets", "Schema Markup", "Search Enhancement", "SERP Features"]
}
},
"Image & Media Optimization": {
"Image Alt Text Generator": {
"icon": "🖼️",
"description": "Generate SEO-friendly alt text for images to improve accessibility and search visibility",
"category": "Images",
"path": "alt_text",
"features": ["Accessibility", "Image SEO", "Screen Reader Support", "Search Discovery"]
},
"Image Optimizer": {
"icon": "🎯",
"description": "Optimize images for web performance and faster loading times",
"category": "Performance",
"path": "image_optimizer",
"features": ["File Compression", "Format Optimization", "Performance Boost", "Web Standards"]
}
},
"Social Media Optimization": {
"OpenGraph Generator": {
"icon": "📱",
"description": "Create OpenGraph tags for beautiful social media sharing experiences",
"category": "Social",
"path": "opengraph",
"features": ["Social Sharing", "Visual Appeal", "Engagement Boost", "Platform Optimization"]
},
"Twitter Tags Generator": {
"icon": "🐦",
"description": "Generate trending and relevant Twitter hashtags for maximum engagement",
"category": "Social",
"path": "twitter_tags",
"features": ["Hashtag Research", "Trend Analysis", "Engagement Boost", "Content Discovery"]
}
},
"Technical SEO Analysis": {
"Technical SEO Crawler": {
"icon": "🔧",
"description": "Comprehensive site-wide technical SEO analysis with AI-powered recommendations. Identify and fix technical issues that impact your search rankings.",
"category": "Technical",
"path": "technical_seo_crawler",
"features": ["Site-wide Crawling", "Technical Issues Detection", "Performance Analysis", "AI Recommendations"]
},
"On-Page SEO Analyzer": {
"icon": "🔍",
"description": "Comprehensive analysis of on-page SEO factors with actionable recommendations",
"category": "Analysis",
"path": "onpage_seo",
"features": ["Content Analysis", "SEO Scoring", "Recommendations", "Best Practices"]
},
"Website Speed Insights": {
"icon": "⚡",
"description": "Analyze website performance using Google PageSpeed Insights",
"category": "Performance",
"path": "pagespeed",
"features": ["Core Web Vitals", "Performance Metrics", "Optimization Tips", "Mobile Analysis"]
},
"URL SEO Checker": {
"icon": "🌐",
"description": "Analyze URL structure and SEO factors for better search rankings",
"category": "Technical",
"path": "url_checker",
"features": ["URL Analysis", "SEO Factors", "Technical Issues", "Optimization Tips"]
},
"Sitemap Analyzer": {
"icon": "🗺️",
"description": "Analyze website sitemaps to understand content structure and publishing trends",
"category": "Technical",
"path": "sitemap_analysis",
"features": ["Content Structure", "Publishing Trends", "URL Analysis", "Site Architecture"]
}
},
"Content Analysis & Research": {
"Content Gap Analysis": {
"icon": "📊",
"description": "Identify content opportunities and gaps in your SEO strategy",
"category": "Research",
"path": "content_gap_analysis",
"features": ["Competitor Analysis", "Keyword Gaps", "Content Opportunities", "Strategic Insights"]
},
"Enhanced Content Gap Analysis": {
"icon": "🎯",
"description": "Advanced content gap analysis with SERP intelligence, competitor crawling, and AI insights using advertools",
"category": "Research",
"path": "enhanced_content_gap_analysis",
"features": ["SERP Analysis", "Competitor Intelligence", "Keyword Expansion", "AI Strategic Insights"]
},
"Text Readability Analyzer": {
"icon": "📖",
"description": "Analyze text readability and get suggestions for content improvement",
"category": "Content",
"path": "readability_analyzer",
"features": ["Reading Level", "Clarity Score", "Improvement Tips", "Audience Targeting"]
},
"Word Cloud Generator": {
"icon": "☁️",
"description": "Visualize the most important words and terms in your content",
"category": "Visualization",
"path": "wordcloud_generator",
"features": ["Content Visualization", "Keyword Analysis", "Theme Identification", "Text Statistics"]
}
},
"Strategy & Planning": {
"Content Calendar": {
"icon": "📅",
"description": "Plan and organize your content strategy with AI-powered scheduling",
"category": "Planning",
"path": "content_calendar",
"features": ["Content Planning", "Publishing Schedule", "Strategy Management", "Team Collaboration"]
},
"Backlink Analysis": {
"icon": "🔗",
"description": "Analyze backlink opportunities and develop link building strategies",
"category": "Link Building",
"path": "backlinking",
"features": ["Link Analysis", "Opportunity Discovery", "Authority Building", "Outreach Planning"]
}
}
}
with tab2:
render_analytics_tab()
# Render categories and tools
for category, tools in seo_tools.items():
# Render category header
render_category_header(category)
with tab3:
render_technical_tab()
# Create responsive grid for tools in this category
cols = st.columns(3)
for idx, (tool_name, details) in enumerate(tools.items()):
with cols[idx % 3]:
# Use the common card renderer
if render_card(
icon=details['icon'],
title=tool_name,
description=details['description'],
category=details['category'],
key_suffix=f"seo_{tool_name.replace(' ', '_')}",
help_text=f"Open {tool_name} - {details['description'][:50]}..."
):
# Set query parameters to redirect to the specific tool
st.query_params["tool"] = details["path"]
st.rerun()
with tab4:
render_content_tab()
# Add SEO insights section
st.markdown("""
<div style="margin-top: 3rem;">
<div class="dashboard-header" style="margin-bottom: 2rem;">
<h1 style="font-size: 2.2em;">🎯 Why Choose Our SEO Tools?</h1>
<p>Real tools, real results. Each tool is designed to solve specific SEO challenges and drive measurable improvements.</p>
</div>
</div>
""", unsafe_allow_html=True)
with tab5:
render_basic_tools_tab()
# SEO insights grid
insight_cols = st.columns(2)
insights = [
{
"title": "🤖 AI-Powered Analysis",
"description": "Advanced algorithms analyze your content and provide data-driven optimization recommendations for better rankings."
},
{
"title": "📈 Actionable Insights",
"description": "Get specific, implementable suggestions that directly impact your search engine visibility and traffic."
},
{
"title": "🎯 Comprehensive Coverage",
"description": "From technical SEO to content optimization, our tools cover every aspect of search engine optimization."
},
{
"title": "🚀 Proven Results",
"description": "Based on industry best practices and proven SEO strategies that deliver measurable improvements."
}
]
for idx, insight in enumerate(insights):
with insight_cols[idx % 2]:
st.markdown(f"""
<div class="premium-card" style="min-height: 160px; cursor: default;">
<div class="card-glow"></div>
<div class="card-content">
<div class="card-title" style="margin-bottom: 0.8rem;">{insight['title']}</div>
<div class="card-description" style="margin-bottom: 0;">{insight['description']}</div>
</div>
<div class="card-shine"></div>
</div>
""", unsafe_allow_html=True)
# Close dashboard container
st.markdown('</div>', unsafe_allow_html=True)
# Add footer with enterprise features highlight
render_enterprise_features_footer()
def ai_seo_tools():
"""Render the SEO tools dashboard with premium glassmorphic design."""
"""Main entry point for SEO tools dashboard with premium glassmorphic design."""
logger.info("Starting SEO Tools Dashboard")
# Apply common dashboard styling
@@ -373,86 +630,52 @@ def ai_seo_tools():
selected_tool = st.query_params.get("tool")
if selected_tool:
# Map tool paths to their respective functions - ONLY existing, working tools
tool_functions = {
# 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")
}
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()
_handle_selected_tool(selected_tool)
else:
# Show the dashboard if no tool is selected
render_seo_tools_dashboard()
def run_tool_combination(tools, combination_name):
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
tabs = st.tabs(tab_names)
# Run each tool in its own tab
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:
@@ -461,7 +684,8 @@ def run_tool_combination(tools, combination_name):
st.error(f"Error running tool: {str(e)}")
logger.error(f"Error in tool combination: {str(e)}")
# Add cross-tool analysis section
def _render_analysis_summary():
"""Render the analysis summary section."""
with st.expander("📊 Analysis Summary", expanded=True):
st.markdown("""
### Key Recommendations:

488
lib/competitive_intelligence/README.md Normal file
View File

@@ -0,0 +1,488 @@
# 🥷 AI-Powered Competitive Intelligence
**AI Competitive Intelligence Suite for Entrepreneurs**
Transform your competitive analysis with AI-powered intelligence gathering, content strategy insights, and market opportunity identification. Perfect for entrepreneurs and small teams who need enterprise-level competitive intelligence without the enterprise budget.
## 📋 Table of Contents
- [Overview](#overview)
- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
- [Architecture](#architecture)
- [AI Analysis Capabilities](#ai-analysis-capabilities)
- [API Reference](#api-reference)
- [File Structure](#file-structure)
- [Configuration](#configuration)
- [Development](#development)
- [Use Cases](#use-cases)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
## 🔍 Overview
The AI-Powered Competitive Intelligence suite provides comprehensive competitor analysis and market insights using advanced AI capabilities:
- **AI Competitive Intelligence**: Advanced competitive analysis with AI insights
- **AI Content Strategy Analysis**: Understand what content works for competitors
- **Market Opportunity Detection**: Identify gaps and opportunities in your market
- **Strategic Recommendations**: AI-powered actionable insights
### Key Benefits
- **🧠 AI-Powered Analysis**: Leverages LLM intelligence for deep competitive insights
- **⚡ Quick Setup**: Get started with competitor intelligence in minutes
- **💰 Cost-Effective**: Enterprise-level insights without enterprise costs
- **🎯 Actionable Insights**: Clear recommendations for competitive advantage
- **📊 Strategic Intelligence**: Market gaps, opportunities, and positioning insights
## ✨ Features
### Core Intelligence Capabilities
#### 1. **AI Competitor Analysis**
- Rapid competitive landscape assessment
- Competitor strength/weakness analysis
- Market positioning insights
- Content strategy evaluation
#### 2. **AI Content Intelligence**
- Competitor content performance analysis
- Content gap identification
- Strategic content recommendations
- Optimal content strategy insights
#### 3. **Market Opportunity Detection**
- Underserved market segment identification
- Content opportunity mapping
- Competitive advantage discovery
- Strategic positioning recommendations
#### 4. **Strategic Recommendations**
- Competitive differentiation strategies
- Market entry recommendations
- Content strategy optimization
- Positioning improvements
### Analysis Categories
1. **🎯 Competitive Positioning**: Where you stand vs competitors
2. **📈 Content Performance**: What content works in your space
3. **🔍 Market Gaps**: Opportunities competitors are missing
4. **💡 Strategic Insights**: AI-powered competitive recommendations
5. **⚡ Quick Wins**: Immediate actions for competitive advantage
6. **🚀 Growth Opportunities**: Long-term strategic opportunities
## 🚀 Installation
### Prerequisites
```bash
# Already included in Alwrity - no additional installation required!
# Uses existing dependencies: streamlit, llm_text_gen, requests
```
### Setup
1. **Auto-Integration** (already included):
```python
# Available in AI Writer Dashboard
# Access via: "Bootstrap AI Competitive Suite"
```
2. **Direct Usage**:
```python
from lib.competitive_intelligence.ai_competitive_intelligence import AICompetitiveIntelligence
```
3. **Full Suite Access**:
```python
from lib.ai_competitive_suite.bootstrap_ai_suite import BootstrapAISuite
```
4. **UI Components**:
```python
from lib.competitive_intelligence.ai_competitive_intelligence import render_ai_competitive_intelligence_ui
from lib.ai_competitive_suite.bootstrap_ai_suite import render_bootstrap_ai_suite
```
## 📖 Usage
### Through AI Writer Dashboard
1. Open Alwrity
2. Navigate to "AI Writer Dashboard"
3. Select "🚀 Bootstrap AI Competitive Suite"
4. Enter competitor information or industry
5. Get comprehensive competitive intelligence!
### AI Competitor Analysis
```python
from lib.competitive_intelligence.ai_competitive_intelligence import AICompetitiveIntelligence
# Initialize AI analyzer
intel = AICompetitiveIntelligence()
# Quick competitor analysis
result = await intel.analyze_competitors(
competitor_urls=["https://jasper.ai", "https://copy.ai"],
industry="AI writing tools",
your_strengths=["AI-first approach", "Solo entrepreneur focus"]
)
print(f"Key Insights: {result['competitor_insights']}")
print(f"Opportunities: {result['strategic_opportunities']}")
```
### Full AI Competitive Suite
```python
from lib.ai_competitive_suite.bootstrap_ai_suite import BootstrapAISuite
# Initialize full suite
suite = BootstrapAISuite()
# Comprehensive analysis
analysis = await suite.get_competitive_content_strategy(
content="Your content here",
target_platform="twitter",
competitor_urls=["https://competitor1.com", "https://competitor2.com"],
industry="content creation",
your_strengths=["AI expertise", "Bootstrap approach"]
)
print(f"Integrated Strategy: {analysis['integrated_strategy']}")
print(f"Action Plan: {analysis['action_plan']}")
```
### Programmatic Usage
```python
import streamlit as st
from lib.competitive_intelligence.ai_competitive_intelligence import render_ai_competitive_intelligence_ui
# Add to your Streamlit app
st.title("AI Competitive Intelligence")
render_ai_competitive_intelligence_ui()
```
## 🏗️ Architecture
### System Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ STREAMLIT UI │
│ (render_bootstrap_ai_suite / render_ai_intelligence_ui) │
└─────────────────┬───────────────────────────────────────────┘
│
┌─────────────────┴───────────────────────────────────────────┐
│ BOOTSTRAP AI COMPETITIVE SUITE │
│ (BootstrapAISuite) │
│ ┌─────────────────┐ ┌─────────────────────────────────┐ │
│ │ Competitor │ │ Market Intelligence │ │
│ │ Analysis │ │ (Opportunities & Gaps) │ │
│ └─────────────────┘ └─────────────────────────────────┘ │
└─────────────────┬───────────────────────────────────────────┘
│
┌─────────────────┴───────────────────────────────────────────┐
│ BOOTSTRAP COMPETITOR INTEL │
│ (BootstrapCompetitorIntel) │
│ ┌─────────────────┐ ┌─────────────────────────────────┐ │
│ │ Industry │ │ Competitive Positioning │ │
│ │ Analysis │ │ & Strategic Insights │ │
│ └─────────────────┘ └─────────────────────────────────┘ │
└─────────────────┬───────────────────────────────────────────┘
│
┌─────────────────┴───────────────────────────────────────────┐
│ ALWRITY LLM ENGINE │
│ (llm_text_gen) │
└─────────────────────────────────────────────────────────────┘
```
### Component Details
1. **BootstrapAISuite**: Complete competitive intelligence platform
2. **BootstrapCompetitorIntel**: Core competitor analysis engine
3. **Market Intelligence**: Opportunity detection and gap analysis
4. **Strategic Insights**: AI-powered recommendations and positioning
5. **UI Components**: Interactive analysis interfaces
## 🧠 AI Analysis Capabilities
### Competitive Intelligence Analysis
The suite uses sophisticated AI prompts to analyze:
- **Competitor Strengths**: What makes competitors successful
- **Market Weaknesses**: Where competitors are failing
- **Content Strategies**: What content approaches work best
- **Positioning Opportunities**: How to differentiate effectively
### Market Intelligence Features
#### Industry Landscape Analysis
- Market size and growth trends
- Key player identification
- Competitive dynamics assessment
- Market maturity evaluation
#### Competitive Positioning
- Strength/weakness matrix
- Differentiation opportunities
- Market positioning gaps
- Value proposition analysis
#### Content Strategy Intelligence
- High-performing content identification
- Content gap analysis
- Viral content pattern recognition
- Platform-specific strategies
#### Strategic Recommendations
- Competitive advantage opportunities
- Market entry strategies
- Product positioning advice
- Growth opportunity identification
## 🚀 Bootstrap Features
### Quick Setup Intelligence
#### 1. **Rapid Competitor Analysis**
- Input: Industry + Competitors
- Output: Comprehensive competitive landscape
- Time: 2-3 minutes
- Insight: Market positioning and opportunities
#### 2. **Industry Assessment**
- Input: Industry description
- Output: Market dynamics and key players
- Time: 1-2 minutes
- Insight: Market opportunities and threats
#### 3. **Strategic Positioning**
- Input: Your product + competitors
- Output: Differentiation strategy
- Time: 2-3 minutes
- Insight: Competitive advantages and positioning
#### 4. **Content Intelligence**
- Input: Industry + content focus
- Output: Content strategy recommendations
- Time: 2-3 minutes
- Insight: What content works and content gaps
### Bootstrap Configurations
Located in the intelligence modules:
```python
ANALYSIS_TEMPLATES = {
"competitor_analysis": {
"focus_areas": ["strengths", "weaknesses", "positioning"],
"output_format": "strategic_insights",
"depth": "comprehensive"
},
"market_intelligence": {
"analysis_type": "opportunity_detection",
"scope": "industry_wide",
"recommendations": "actionable"
}
}
```
## 📊 Analysis Output
### Competitive Analysis Report
```python
{
"executive_summary": "Key findings and strategic recommendations",
"competitor_analysis": {
"direct_competitors": [...],
"indirect_competitors": [...],
"competitive_advantages": [...],
"competitive_threats": [...]
},
"market_intelligence": {
"market_size": "Large/Medium/Small",
"growth_rate": "High/Medium/Low",
"key_trends": [...],
"opportunities": [...]
},
"strategic_recommendations": {
"positioning": "How to position your product",
"differentiation": "Key differentiators to focus on",
"content_strategy": "What content to create",
"quick_wins": "Immediate actions to take"
},
"content_opportunities": {
"content_gaps": [...],
"viral_patterns": [...],
"platform_strategies": {...}
}
}
```
### Intelligence Categories
1. **Market Position**: Where you stand competitively
2. **Opportunities**: Gaps competitors haven't filled
3. **Threats**: Competitive risks to monitor
4. **Strategy**: Recommended competitive approach
5. **Content**: What content strategy to pursue
6. **Quick Wins**: Immediate competitive advantages
## 🔧 Configuration
### Analysis Settings
Customize analysis depth and focus:
```python
# Configure analysis parameters
analysis_config = {
"depth": "comprehensive", # quick, standard, comprehensive
"focus": "content_strategy", # market_position, content_strategy, opportunities
"industry": "your_industry",
"competitive_scope": "direct_competitors" # direct, indirect, all
}
```
### Customization Options
- **Analysis Depth**: Quick overview vs comprehensive analysis
- **Focus Areas**: Market positioning, content strategy, opportunities
- **Industry Scope**: Narrow niche vs broad market analysis
- **Output Format**: Executive summary, detailed report, action items
## 🚀 Development
### Adding New Analysis Types
1. Extend analysis templates in configuration
2. Add new AI prompts for specific analysis
3. Update UI to support new analysis types
### Enhancing Intelligence Gathering
1. Add new data sources for competitive information
2. Implement automated monitoring capabilities
3. Enhance AI analysis with additional insights
## 📈 Use Cases
### Solo Entrepreneurs
- **Quick Market Assessment**: Understand competitive landscape fast
- **Content Strategy**: Identify what content works in your niche
- **Positioning**: Find your unique market position
- **Opportunities**: Discover gaps competitors are missing
### Small Teams
- **Competitive Strategy**: Develop comprehensive competitive approach
- **Market Intelligence**: Ongoing competitive monitoring
- **Strategic Planning**: AI-powered strategic recommendations
- **Content Planning**: Content strategy based on competitive analysis
### Growing Businesses
- **Market Expansion**: Identify new market opportunities
- **Competitive Advantage**: Maintain edge over competitors
- **Strategic Positioning**: Refine market positioning strategy
- **Growth Planning**: AI-powered growth recommendations
## 🔍 Troubleshooting
### Common Issues
**No Analysis Generated**:
- Check LLM service availability
- Verify competitor/industry information is provided
- Ensure sufficient detail in input
**Generic Insights**:
- Provide more specific industry information
- Include specific competitor names
- Add context about your product/service
**UI Not Loading**:
- Check Streamlit dependencies
- Verify import paths
- Ensure LLM service is configured
### Debug Mode
Enable detailed logging:
```python
import logging
logging.basicConfig(level=logging.DEBUG)
```
## 📈 Performance Tips
1. **Specific Industries**: Provide detailed industry information for better analysis
2. **Competitor Details**: Include specific competitor names and details
3. **Context**: Add context about your business for relevant insights
4. **Iterate**: Use insights to refine your competitive strategy
## 🤝 Contributing
1. Fork the repository
2. Create a feature branch
3. Add new analysis capabilities or improve existing ones
4. Test with different industries and competitors
5. Submit a pull request
### Development Setup
```bash
# No additional setup required!
# Uses existing Alwrity infrastructure
```
## 📝 License
Part of the Alwrity AI Content Creation Suite.
---
**Ready to gain competitive intelligence? Access the Bootstrap AI Competitive Suite through the AI Writer Dashboard now!**
## 🎯 Quick Start Examples
### Example 1: SaaS Competitive Analysis
```python
# Analyze SaaS competitive landscape
result = await intel.analyze_competitor_landscape(
industry="AI writing software",
competitors=["Jasper", "Copy.ai", "Writesonic"],
your_product="Alwrity - AI writer for solo developers"
)
```
### Example 2: Content Strategy Intelligence
```python
# Get content strategy insights
content_intel = await suite.analyze_content_opportunities(
industry="digital marketing",
content_focus="social media content creation"
)
```
### Example 3: Market Opportunity Detection
```python
# Find market gaps
opportunities = await intel.identify_market_opportunities(
industry="productivity software",
target_audience="small business owners"
)
```
---
**Transform your competitive strategy with AI-powered intelligence! 🥷**

725
lib/competitive_intelligence/ai_competitive_intelligence.py Normal file
View File

@@ -0,0 +1,725 @@
"""
AI-Powered Competitive Intelligence
Advanced competitive intelligence for entrepreneurs using AI.
Provides strategic insights, competitor analysis, and market opportunities.
"""
import asyncio
import json
from datetime import datetime
from typing import Dict, Any, List, Optional
from loguru import logger
import streamlit as st
from urllib.parse import urlparse
import requests
from bs4 import BeautifulSoup
# Import existing Alwrity modules
from lib.ai_seo_tools.content_gap_analysis.competitor_analyzer import CompetitorAnalyzer
from lib.ai_web_researcher.gpt_online_researcher import do_google_pytrends_analysis
from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
class AICompetitiveIntelligence:
"""
AI-powered competitive intelligence for entrepreneurs and startups.
Uses existing AI capabilities to provide strategic insights.
"""
def __init__(self):
"""Initialize the AI competitive intelligence."""
self.competitor_analyzer = CompetitorAnalyzer()
self.analysis_history = []
logger.info("AI Competitive Intelligence initialized")
async def analyze_competitors(
self,
competitor_urls: List[str],
industry: str,
your_strengths: List[str] = None
) -> Dict[str, Any]:
"""
Analyze competitors using AI-powered insights.
Args:
competitor_urls: List of competitor URLs
industry: Your industry/niche
your_strengths: Your current strengths (optional)
Returns:
AI-powered competitive analysis
"""
logger.info(f"Starting AI competitive analysis for {len(competitor_urls)} competitors")
try:
analysis_report = {
'analysis_metadata': {
'timestamp': datetime.now().isoformat(),
'competitors_analyzed': len(competitor_urls),
'industry': industry,
'your_strengths': your_strengths or []
},
'competitor_insights': {},
'strategic_opportunities': [],
'content_gap_analysis': {},
'ai_recommendations': [],
'quick_wins': [],
'competitive_positioning': {}
}
# Step 1: Basic competitor analysis using existing tools
st.info("🔍 Analyzing competitor basics...")
basic_analysis = self.competitor_analyzer.analyze(competitor_urls, industry)
# Step 2: AI-powered deep analysis
st.info("🧠 AI is analyzing competitive landscape...")
ai_insights = await self._get_ai_competitive_insights(
competitor_urls, industry, basic_analysis, your_strengths
)
# Step 3: Content gap opportunities
st.info("🎯 Identifying content opportunities...")
content_opportunities = await self._find_content_opportunities(
competitor_urls, industry, basic_analysis
)
# Step 4: Strategic recommendations
st.info("💡 Generating strategic recommendations...")
strategic_recommendations = await self._generate_strategic_recommendations(
competitor_urls, industry, ai_insights, content_opportunities, your_strengths
)
# Compile results
analysis_report.update({
'competitor_insights': ai_insights,
'content_gap_analysis': content_opportunities,
'ai_recommendations': strategic_recommendations,
'quick_wins': self._extract_quick_wins(strategic_recommendations),
'competitive_positioning': self._analyze_positioning(ai_insights, your_strengths)
})
# Save to history
self.analysis_history.append({
'timestamp': datetime.now().isoformat(),
'industry': industry,
'competitors_count': len(competitor_urls),
'report_id': f"{industry}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
})
logger.info("AI competitive analysis completed successfully")
return analysis_report
except Exception as e:
error_msg = f"Error in competitive analysis: {str(e)}"
logger.error(error_msg, exc_info=True)
return {'error': error_msg}
async def _get_ai_competitive_insights(
self,
competitor_urls: List[str],
industry: str,
basic_analysis: Dict[str, Any],
your_strengths: List[str] = None
) -> Dict[str, Any]:
"""Get AI-powered competitive insights."""
competitors_list = [urlparse(url).netloc for url in competitor_urls]
your_strengths_str = ', '.join(your_strengths) if your_strengths else "Not specified"
insights_prompt = f"""
You are a competitive intelligence expert analyzing the {industry} market.
COMPETITORS TO ANALYZE:
{', '.join(competitors_list)}
BASIC COMPETITIVE ANALYSIS DATA:
{json.dumps(basic_analysis, indent=2)[:3000]}
YOUR CURRENT STRENGTHS:
{your_strengths_str}
Please provide a comprehensive competitive analysis with these insights:
1. MARKET LANDSCAPE OVERVIEW:
- Who are the dominant players?
- What's the competitive intensity like?
- What are the key market trends?
- Where are the market gaps?
2. COMPETITOR STRENGTHS & WEAKNESSES:
For each major competitor, identify:
- Their main competitive advantages
- Their key weaknesses or blind spots
- Their content strategy approach
- Their target audience focus
3. DIFFERENTIATION OPPORTUNITIES:
- How can you position differently?
- What unique value can you offer?
- Which competitor weaknesses can you exploit?
- What underserved market segments exist?
4. THREAT ASSESSMENT:
- Which competitors pose the biggest threat to you?
- What are they doing better than you?
- Where are they vulnerable?
- How quickly are they evolving?
5. STRATEGIC INSIGHTS:
- What patterns do you see across all competitors?
- What are they all missing that you could provide?
- Where is the market heading?
- What first-mover opportunities exist?
Provide specific, actionable insights that a solo entrepreneur can use to compete effectively.
Focus on realistic strategies that don't require massive resources.
"""
try:
ai_insights = llm_text_gen(
insights_prompt,
system_prompt="You are a strategic business consultant specializing in competitive analysis for startups and small businesses. Provide practical, actionable insights."
)
return {
'full_analysis': ai_insights,
'key_insights': self._extract_key_insights(ai_insights),
'threat_levels': self._assess_threat_levels(ai_insights, competitors_list),
'opportunities': self._extract_opportunities(ai_insights)
}
except Exception as e:
logger.error(f"Error getting AI insights: {str(e)}")
return {
'full_analysis': f"Error generating insights: {str(e)}",
'key_insights': ["Unable to generate AI insights"],
'threat_levels': {},
'opportunities': []
}
async def _find_content_opportunities(
self,
competitor_urls: List[str],
industry: str,
basic_analysis: Dict[str, Any]
) -> Dict[str, Any]:
"""Find content opportunities using AI analysis."""
content_gaps = basic_analysis.get('content_gaps', [])
advantages = basic_analysis.get('advantages', [])
content_prompt = f"""
Analyze content opportunities in the {industry} space based on competitor analysis:
COMPETITOR CONTENT GAPS IDENTIFIED:
{json.dumps(content_gaps[:10], indent=2)}
COMPETITOR ADVANTAGES:
{json.dumps(advantages[:10], indent=2)}
INDUSTRY: {industry}
Provide specific content opportunities analysis:
1. HIGH-PRIORITY CONTENT GAPS:
- What topics are competitors not covering well?
- What questions are audiences asking that aren't being answered?
- What content formats are underutilized?
- What pain points are being ignored?
2. CONTENT DIFFERENTIATION OPPORTUNITIES:
- How can you approach common topics differently?
- What unique perspective can you bring?
- What content formats can you innovate with?
- How can you provide more value than competitors?
3. TRENDING CONTENT OPPORTUNITIES:
- What emerging topics should you cover first?
- What seasonal content opportunities exist?
- What industry changes create content needs?
- What tools/technologies need better content coverage?
4. AUDIENCE-SPECIFIC CONTENT GAPS:
- Which audience segments are underserved?
- What skill levels need better content?
- What use cases are poorly addressed?
- What demographics are being ignored?
5. QUICK CONTENT WINS:
- What content can you create quickly that competitors lack?
- What simple explanations are missing from the market?
- What FAQ content is needed but not provided?
- What beginner content opportunities exist?
Prioritize opportunities that a solo creator can realistically execute.
"""
try:
content_analysis = llm_text_gen(
content_prompt,
system_prompt="You are a content strategist specializing in competitive content analysis. Provide specific, actionable content opportunities."
)
return {
'full_analysis': content_analysis,
'priority_gaps': self._extract_priority_gaps(content_analysis),
'quick_wins': self._extract_content_quick_wins(content_analysis),
'differentiation_opportunities': self._extract_differentiation_opps(content_analysis)
}
except Exception as e:
logger.error(f"Error finding content opportunities: {str(e)}")
return {
'full_analysis': f"Error analyzing content opportunities: {str(e)}",
'priority_gaps': content_gaps[:5],
'quick_wins': [],
'differentiation_opportunities': []
}
async def _generate_strategic_recommendations(
self,
competitor_urls: List[str],
industry: str,
ai_insights: Dict[str, Any],
content_opportunities: Dict[str, Any],
your_strengths: List[str] = None
) -> List[Dict[str, Any]]:
"""Generate strategic recommendations using AI."""
your_strengths_str = ', '.join(your_strengths) if your_strengths else "Not specified"
strategy_prompt = f"""
Based on the competitive analysis, provide strategic recommendations for competing in {industry}:
AI COMPETITIVE INSIGHTS:
{ai_insights.get('full_analysis', '')[:2000]}
CONTENT OPPORTUNITIES:
{content_opportunities.get('full_analysis', '')[:2000]}
YOUR CURRENT STRENGTHS:
{your_strengths_str}
BUDGET CONSTRAINT: Solo entrepreneur with limited resources
Provide specific, actionable recommendations in these categories:
1. IMMEDIATE ACTIONS (0-30 days):
- What can you implement this week?
- Which competitor weaknesses can you exploit quickly?
- What low-cost marketing tactics should you try?
- Which content should you create first?
2. SHORT-TERM STRATEGY (1-3 months):
- How should you position against competitors?
- What features/content should you prioritize?
- Which partnerships should you pursue?
- How should you differentiate your messaging?
3. MEDIUM-TERM POSITIONING (3-6 months):
- How can you build sustainable competitive advantages?
- Which market segments should you focus on?
- What unique value proposition should you develop?
- How can you build barriers to competition?
4. RESOURCE ALLOCATION:
- Where should you spend your limited time?
- Which marketing channels offer best ROI?
- What tools/software investments are worthwhile?
- How should you prioritize feature development?
5. COMPETITIVE DEFENSE:
- How can you protect against competitor moves?
- What should you do if competitors copy you?
- How can you build customer loyalty?
- What contingency plans should you have?
For each recommendation:
- Specify the exact action to take
- Estimate time/resource requirements
- Explain expected impact
- Rate priority (High/Medium/Low)
- Provide success metrics
Focus on David vs Goliath strategies that work for solo entrepreneurs.
"""
try:
strategic_recommendations = llm_text_gen(
strategy_prompt,
system_prompt="You are a startup strategist specializing in helping solo entrepreneurs compete against established players. Provide practical, executable strategies."
)
return self._parse_strategic_recommendations(strategic_recommendations)
except Exception as e:
logger.error(f"Error generating strategic recommendations: {str(e)}")
return [
{
'category': 'Content Strategy',
'priority': 'High',
'timeframe': '0-30 days',
'action': 'Create content addressing competitor blind spots',
'expected_impact': 'Attract underserved audience segments',
'resources_needed': 'Time for content creation',
'success_metrics': 'Website traffic, engagement rates'
}
]
def _extract_key_insights(self, ai_analysis: str) -> List[str]:
"""Extract key insights from AI analysis."""
insights = []
# Simple parsing to extract key points
lines = ai_analysis.split('\n')
for line in lines:
line = line.strip()
if line and (line.startswith('•') or line.startswith('-') or line.startswith('*')):
insight = line.lstrip('•-* ').strip()
if len(insight) > 20: # Only substantial insights
insights.append(insight)
return insights[:8] # Return top 8 insights
def _assess_threat_levels(self, ai_analysis: str, competitors: List[str]) -> Dict[str, str]:
"""Assess threat levels for each competitor."""
threat_levels = {}
# Simple heuristic based on AI analysis content
for competitor in competitors:
if competitor.lower() in ai_analysis.lower():
if any(word in ai_analysis.lower() for word in ['dominant', 'leader', 'strong', 'established']):
threat_levels[competitor] = 'High'
elif any(word in ai_analysis.lower() for word in ['weak', 'vulnerable', 'gaps', 'opportunity']):
threat_levels[competitor] = 'Low'
else:
threat_levels[competitor] = 'Medium'
else:
threat_levels[competitor] = 'Medium' # Default
return threat_levels
def _extract_opportunities(self, ai_analysis: str) -> List[str]:
"""Extract opportunities from AI analysis."""
opportunities = []
# Look for opportunity-related keywords
opportunity_keywords = ['opportunity', 'gap', 'underserved', 'missing', 'lack', 'could', 'should']
lines = ai_analysis.split('\n')
for line in lines:
line = line.strip()
if any(keyword in line.lower() for keyword in opportunity_keywords) and len(line) > 30:
opportunities.append(line.lstrip('•-* ').strip())
return opportunities[:6] # Return top 6 opportunities
def _extract_priority_gaps(self, content_analysis: str) -> List[str]:
"""Extract priority content gaps."""
gaps = []
# Look for gaps in the analysis
gap_keywords = ['gap', 'missing', 'lack', 'absent', 'underserved', 'neglected']
lines = content_analysis.split('\n')
for line in lines:
line = line.strip()
if any(keyword in line.lower() for keyword in gap_keywords) and len(line) > 20:
gaps.append(line.lstrip('•-* ').strip())
return gaps[:5] # Top 5 priority gaps
def _extract_content_quick_wins(self, content_analysis: str) -> List[str]:
"""Extract content quick wins."""
quick_wins = []
# Look for quick win indicators
quick_keywords = ['quick', 'easy', 'simple', 'immediately', 'now', 'today']
lines = content_analysis.split('\n')
for line in lines:
line = line.strip()
if any(keyword in line.lower() for keyword in quick_keywords) and len(line) > 15:
quick_wins.append(line.lstrip('•-* ').strip())
return quick_wins[:4] # Top 4 quick wins
def _extract_differentiation_opps(self, content_analysis: str) -> List[str]:
"""Extract differentiation opportunities."""
diff_opps = []
# Look for differentiation keywords
diff_keywords = ['different', 'unique', 'innovative', 'better', 'superior', 'distinct']
lines = content_analysis.split('\n')
for line in lines:
line = line.strip()
if any(keyword in line.lower() for keyword in diff_keywords) and len(line) > 20:
diff_opps.append(line.lstrip('•-* ').strip())
return diff_opps[:4] # Top 4 differentiation opportunities
def _parse_strategic_recommendations(self, recommendations: str) -> List[Dict[str, Any]]:
"""Parse strategic recommendations into structured format."""
structured_recs = []
# Split by sections and parse
sections = recommendations.split('\n\n')
for section in sections:
lines = section.split('\n')
for line in lines:
line = line.strip()
if line and len(line) > 30: # Substantial recommendations
structured_recs.append({
'category': 'Strategic Recommendation',
'priority': 'Medium', # Default
'timeframe': 'Short-term',
'action': line.lstrip('•-* ').strip()[:300], # Limit length
'expected_impact': 'Competitive advantage',
'resources_needed': 'Time and effort',
'success_metrics': 'Market position improvement'
})
return structured_recs[:10] # Return top 10 recommendations
def _extract_quick_wins(self, recommendations: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Extract quick wins from recommendations."""
quick_wins = []
for rec in recommendations:
action = rec.get('action', '').lower()
if any(word in action for word in ['quick', 'immediate', 'now', 'today', 'easy', 'simple']):
quick_wins.append({
'action': rec.get('action', ''),
'timeframe': rec.get('timeframe', '0-30 days'),
'impact': rec.get('expected_impact', 'Quick improvement')
})
# Add some default quick wins if none found
if len(quick_wins) < 3:
quick_wins.extend([
{
'action': 'Create content addressing competitor blind spots',
'timeframe': '1-2 weeks',
'impact': 'Immediate traffic from underserved topics'
},
{
'action': 'Optimize social media with competitor hashtag gaps',
'timeframe': '1 week',
'impact': 'Better discoverability'
},
{
'action': 'Set up Google Alerts for competitor mentions',
'timeframe': '1 day',
'impact': 'Real-time competitive intelligence'
}
])
return quick_wins[:5] # Top 5 quick wins
def _analyze_positioning(self, ai_insights: Dict[str, Any], your_strengths: List[str]) -> Dict[str, Any]:
"""Analyze competitive positioning."""
return {
'your_advantages': your_strengths or ['Agility', 'Personal touch', 'Niche focus'],
'competitor_weaknesses': ai_insights.get('opportunities', [])[:3],
'positioning_strategy': 'Focus on agility and personal service vs big competitors',
'unique_value_prop': 'Personalized solutions that big players can\'t match'
}
def get_analysis_summary(self) -> Dict[str, Any]:
"""Get summary of analysis activities."""
return {
'total_analyses': len(self.analysis_history),
'recent_analyses': self.analysis_history[-3:] if self.analysis_history else [],
'capabilities': [
'AI-powered competitive insights',
'Content gap analysis',
'Strategic recommendations',
'Quick win identification',
'Positioning strategy'
]
}
# Streamlit interface for AI competitive intelligence
def render_ai_competitive_intelligence_ui():
"""Render the AI competitive intelligence interface."""
st.title("🥷 AI Competitive Intelligence")
st.markdown("AI-powered competitive analysis for solo entrepreneurs and bootstrapped startups")
# Initialize intelligence engine
if 'ai_intel' not in st.session_state:
st.session_state.ai_intel = AICompetitiveIntelligence()
intel_engine = st.session_state.ai_intel
# Input section
st.header("🎯 Competitor Analysis Setup")
col1, col2 = st.columns(2)
with col1:
industry = st.text_input(
"Your Industry/Niche",
value="AI Content Creation",
help="What industry are you competing in?"
)
competitor_urls = st.text_area(
"Competitor URLs (one per line)",
value="https://jasper.ai\nhttps://copy.ai\nhttps://writesonic.com",
height=100,
help="Enter competitor websites to analyze"
)
with col2:
your_strengths = st.text_area(
"Your Current Strengths (optional)",
value="Personal touch, Agility, Niche expertise",
height=100,
help="What are your competitive advantages?"
)
# Process inputs
urls = [url.strip() for url in competitor_urls.split('\n') if url.strip()]
strengths = [s.strip() for s in your_strengths.split(',') if s.strip()] if your_strengths else []
if st.button("🧠 Analyze Competitors", type="primary"):
if urls and industry:
with st.spinner("🕵️ AI is analyzing your competition..."):
results = asyncio.run(
intel_engine.analyze_competitors(urls, industry, strengths)
)
if 'error' not in results:
st.success("✅ Competitive analysis complete!")
# Analysis overview
metadata = results.get('analysis_metadata', {})
st.header("📊 Analysis Overview")
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Competitors Analyzed", metadata.get('competitors_analyzed', 0))
with col2:
st.metric("Industry", metadata.get('industry', 'N/A'))
with col3:
st.metric("Your Strengths", len(metadata.get('your_strengths', [])))
# Quick wins first (most important for bootstrapped entrepreneurs)
quick_wins = results.get('quick_wins', [])
if quick_wins:
st.header("🚀 Quick Wins (Do These First!)")
for i, win in enumerate(quick_wins):
with st.expander(f"Quick Win #{i+1}: {win.get('timeframe', 'N/A')}"):
st.write(f"**Action:** {win.get('action', 'N/A')}")
st.write(f"**Expected Impact:** {win.get('impact', 'N/A')}")
st.write(f"**Timeframe:** {win.get('timeframe', 'N/A')}")
# Key competitive insights
insights = results.get('competitor_insights', {})
if insights:
st.header("🧠 AI Competitive Insights")
key_insights = insights.get('key_insights', [])
for insight in key_insights[:5]:
st.info(f"💡 {insight}")
# Threat levels
threat_levels = insights.get('threat_levels', {})
if threat_levels:
st.subheader("⚠️ Competitor Threat Assessment")
for competitor, threat in threat_levels.items():
color = {'High': '🔴', 'Medium': '🟡', 'Low': '🟢'}.get(threat, '⚪')
st.write(f"{color} **{competitor}**: {threat} threat level")
# Content opportunities
content_opps = results.get('content_gap_analysis', {})
if content_opps:
st.header("✍️ Content Opportunities")
priority_gaps = content_opps.get('priority_gaps', [])
if priority_gaps:
st.subheader("🎯 Priority Content Gaps")
for gap in priority_gaps[:4]:
st.write(f"• {gap}")
quick_content_wins = content_opps.get('quick_wins', [])
if quick_content_wins:
st.subheader("⚡ Quick Content Wins")
for win in quick_content_wins[:3]:
st.write(f"• {win}")
# Strategic recommendations
recommendations = results.get('ai_recommendations', [])
if recommendations:
st.header("🎯 Strategic Recommendations")
for i, rec in enumerate(recommendations[:6]):
with st.expander(f"Strategy #{i+1}: {rec.get('category', 'Strategic Move')}"):
st.write(f"**Action:** {rec.get('action', 'N/A')}")
st.write(f"**Timeframe:** {rec.get('timeframe', 'N/A')}")
st.write(f"**Expected Impact:** {rec.get('expected_impact', 'N/A')}")
st.write(f"**Priority:** {rec.get('priority', 'Medium')}")
# Competitive positioning
positioning = results.get('competitive_positioning', {})
if positioning:
st.header("🏆 Your Competitive Position")
st.subheader("Your Key Advantages:")
for advantage in positioning.get('your_advantages', []):
st.write(f"✅ {advantage}")
st.subheader("Competitor Weaknesses to Exploit:")
for weakness in positioning.get('competitor_weaknesses', []):
st.write(f"🎯 {weakness}")
# Full AI analysis
with st.expander("🤖 Complete AI Analysis"):
ai_analysis = insights.get('full_analysis', 'No detailed analysis available')
st.write(ai_analysis)
# Export functionality
st.subheader("📥 Export Analysis")
if st.button("Download Report"):
report_json = json.dumps(results, indent=2, default=str)
st.download_button(
label="Download JSON Report",
data=report_json,
file_name=f"competitor_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
mime="application/json"
)
else:
st.error(f"❌ Analysis failed: {results.get('error')}")
else:
st.warning("⚠️ Please provide competitor URLs and industry information")
# Sidebar with tips
st.sidebar.header("💡 AI Competition Tips")
st.sidebar.info("""
**David vs Goliath Strategies:**
• Focus on what big competitors can't do
• Be more personal and responsive
• Serve niche audiences they ignore
• Move faster than they can
• Provide better customer service
• Build deeper relationships
• Innovate in areas they neglect
""")
# Analysis history
summary = intel_engine.get_analysis_summary()
st.sidebar.metric("Total Analyses", summary.get('total_analyses', 0))
# Main execution
if __name__ == "__main__":
render_ai_competitive_intelligence_ui()

344
lib/content_performance_predictor/README.md Normal file
View File

@@ -0,0 +1,344 @@
# 🎯 AI Content Performance Predictor
**LLM-Powered Content Success Prediction for Solo Developers**
The AI Content Performance Predictor is an intelligent feature that leverages Large Language Models (LLMs) to analyze your content and predict its potential success before you publish. Perfect for solo developers and entrepreneurs who need smart content insights without complex ML infrastructure.
## 📋 Table of Contents
- [Overview](#overview)
- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
- [Architecture](#architecture)
- [AI Analysis Engine](#ai-analysis-engine)
- [API Reference](#api-reference)
- [File Structure](#file-structure)
- [Configuration](#configuration)
- [Development](#development)
- [Performance Metrics](#performance-metrics)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
## 🔍 Overview
The AI Content Performance Predictor uses advanced LLM capabilities to provide intelligent content analysis and predictions:
- **LLM-Powered Analysis**: Uses your existing `llm_text_gen` integration for smart predictions
- **Platform-Specific Insights**: Tailored analysis for Twitter, LinkedIn, Facebook, Instagram, and more
- **Zero Training Required**: No ML model training needed - works immediately
- **Solo Developer Friendly**: Designed for resource-constrained environments
- **Real-time Predictions**: Instant analysis and recommendations
### Key Benefits
- **🧠 AI-Powered Intelligence**: Leverages LLM understanding for content analysis
- **⚡ Instant Predictions**: No waiting for model training or data collection
- **📊 Smart Insights**: Platform-specific recommendations and optimization tips
- **🎯 Success Scoring**: Comprehensive performance scoring system
- **🔄 Adaptive Learning**: Improves recommendations based on platform best practices
- **🎨 Multi-platform**: Optimized for different social media platforms
## ✨ Features
### Core Features
#### 1. **AI Prediction Engine**
- Overall performance score (0-100)
- Success probability percentage
- Platform-specific optimization
- Content quality assessment
#### 2. **LLM Integration**
- Uses existing Alwrity LLM infrastructure
- No additional API costs or setup
- Intelligent content understanding
- Context-aware analysis
#### 3. **Platform Optimization**
- Twitter: Character limits, hashtag optimization, engagement factors
- LinkedIn: Professional tone, optimal length, business focus
- Facebook: Community engagement, storytelling elements
- Instagram: Visual content readiness, hashtag strategy
#### 4. **Smart Recommendations**
- Content improvement suggestions
- Optimal posting strategies
- Engagement enhancement tips
- SEO optimization advice
#### 5. **Interactive UI**
- Clean Streamlit interface
- Real-time analysis
- Visual performance indicators
- Actionable insights display
### Analysis Categories
1. **📈 Engagement Potential**: Predicted likes, comments, shares
2. **🎯 Content Quality**: Overall content effectiveness score
3. **⏰ Timing Insights**: Optimal posting time recommendations
4. **🔍 SEO Score**: Search engine optimization assessment
5. **🏷️ Hashtag Strategy**: Hashtag effectiveness analysis
6. **👥 Audience Alignment**: Content-audience fit assessment
## 🚀 Installation
### Prerequisites
```bash
# Already included in Alwrity - no additional installation required!
# Uses existing dependencies: streamlit, llm_text_gen
```
### Setup
1. **Auto-Integration** (already included):
```python
# Available in AI Writer Dashboard
# Access via: "AI Content Performance Predictor"
```
2. **Direct Usage**:
```python
from lib.content_performance_predictor.ai_performance_predictor import AIContentPerformancePredictor
```
3. **UI Component**:
```python
from lib.content_performance_predictor.ai_performance_predictor import render_ai_predictor_ui
```
## 📖 Usage
### Through AI Writer Dashboard
1. Open Alwrity
2. Navigate to "AI Writer Dashboard"
3. Select "🎯 AI Content Performance Predictor"
4. Enter your content and select platform
5. Get instant AI-powered predictions!
### Direct API Usage
```python
from lib.content_performance_predictor.ai_performance_predictor import AIContentPerformancePredictor
# Initialize predictor
predictor = AIContentPerformancePredictor()
# Analyze content
result = await predictor.predict_performance(
content="Your amazing content here!",
platform="twitter",
target_audience="tech entrepreneurs"
)
print(f"Overall Score: {result['overall_score']}")
print(f"Recommendations: {result['recommendations']}")
```
### Programmatic Usage
```python
import streamlit as st
from lib.content_performance_predictor.ai_performance_predictor import render_ai_predictor_ui
# Add to your Streamlit app
st.title("Content Analysis")
render_ai_predictor_ui()
```
### Batch Content Analysis
```python
# Analyze multiple pieces of content
contents = [
{"content": "Post 1", "platform": "twitter"},
{"content": "Post 2", "platform": "linkedin"},
{"content": "Post 3", "platform": "facebook"}
]
for content_data in contents:
result = await predictor.predict_performance(**content_data)
print(f"Content: {content_data['content'][:50]}...")
print(f"Score: {result['overall_score']}")
print("---")
```
## 🏗️ Architecture
### System Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ STREAMLIT UI │
│ (render_ai_predictor_ui) │
└─────────────────┬───────────────────────────────────────────┘
│
┌─────────────────┴───────────────────────────────────────────┐
│ AI PREDICTION ENGINE │
│ (AIContentPerformancePredictor) │
│ ┌─────────────────┐ ┌─────────────────────────────────┐ │
│ │ AI Analysis │ │ Platform Configs │ │
│ │ (LLM-powered) │ │ (Twitter, LinkedIn, etc.) │ │
│ └─────────────────┘ └─────────────────────────────────┘ │
└─────────────────┬───────────────────────────────────────────┘
│
┌─────────────────┴───────────────────────────────────────────┐
│ ALWRITY LLM ENGINE │
│ (llm_text_gen) │
└─────────────────────────────────────────────────────────────┘
```
### Component Details
1. **AIContentPerformancePredictor**: Main prediction class
2. **Platform Configurations**: Optimized settings for each platform
3. **LLM Integration**: Seamless integration with existing AI infrastructure
4. **UI Components**: Interactive Streamlit interface
## 🧠 AI Analysis Engine
### LLM-Powered Predictions
The predictor uses sophisticated prompts to analyze:
- **Content Quality**: Grammar, readability, engagement potential
- **Platform Fit**: Alignment with platform best practices
- **Audience Appeal**: Target audience relevance
- **Optimization Opportunities**: Specific improvement suggestions
### Platform-Specific Analysis
#### Twitter Configuration
- Optimal Length: 100-280 characters
- Hashtags: 1-3 relevant hashtags
- Engagement Factors: Questions, calls-to-action, trending topics
#### LinkedIn Configuration
- Optimal Length: 150-300 words
- Professional Tone: Business-focused language
- Engagement: Industry insights, professional experiences
#### Facebook Configuration
- Optimal Length: 40-80 characters for high engagement
- Community Focus: Shareable, relatable content
- Visual Ready: Content that complements images/videos
#### Instagram Configuration
- Visual Emphasis: Content supporting visual storytelling
- Hashtags: 5-10 strategic hashtags
- Story Potential: Content suitable for Instagram Stories
## 📊 Performance Metrics
### Success Indicators
- **Overall Score**: 0-100 performance prediction
- **Platform Alignment**: How well content fits the platform
- **Engagement Prediction**: Expected interaction levels
- **Optimization Score**: Room for improvement rating
### Recommendation Categories
1. **Content Improvements**: Direct text enhancements
2. **Platform Optimization**: Platform-specific adjustments
3. **Timing Suggestions**: Optimal posting strategies
4. **Engagement Boosters**: Tactics to increase interaction
## 🔧 Configuration
### Platform Settings
Located in `ai_performance_predictor.py`:
```python
PLATFORM_CONFIGS = {
"twitter": {
"optimal_length": {"min": 100, "max": 280},
"hashtag_range": {"min": 1, "max": 3},
"engagement_factors": ["questions", "cta", "trending"]
},
# ... other platforms
}
```
### Customization
You can modify:
- Platform-specific parameters
- Analysis prompts
- Scoring algorithms
- UI components
## 🚀 Development
### Adding New Platforms
1. Add platform config to `PLATFORM_CONFIGS`
2. Update analysis prompts
3. Test with platform-specific content
### Enhancing AI Analysis
1. Modify prompts in `_create_analysis_prompt()`
2. Add new scoring criteria
3. Implement additional recommendation types
## 🔍 Troubleshooting
### Common Issues
**No Predictions Generated**:
- Check LLM service availability
- Verify content input format
- Ensure platform is supported
**Low Accuracy Scores**:
- Content may be too short/long for platform
- Platform mismatch with content style
- Generic content without specific appeal
**UI Not Loading**:
- Check Streamlit dependencies
- Verify import paths
- Ensure LLM service is configured
### Debug Mode
Enable detailed logging:
```python
import logging
logging.basicConfig(level=logging.DEBUG)
```
## 📈 Performance Tips
1. **Content Length**: Follow platform-specific optimal lengths
2. **Platform Selection**: Choose the right platform for your content type
3. **Target Audience**: Specify your audience for better predictions
4. **Iterate**: Use recommendations to improve content before posting
## 🤝 Contributing
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Test with different content types
5. Submit a pull request
### Development Setup
```bash
# No additional setup required!
# Uses existing Alwrity infrastructure
```
## 📝 License
Part of the Alwrity AI Content Creation Suite.
---
**Ready to predict your content's success? Access the AI Content Performance Predictor through the AI Writer Dashboard now!**

662
lib/content_performance_predictor/ai_performance_predictor.py Normal file
View File

@@ -0,0 +1,662 @@
"""
AI-Powered Content Performance Predictor
This module uses AI (LLM) to predict content performance instead of traditional ML models.
Perfect for solo developers who want competitive intelligence without expensive ML infrastructure.
"""
import asyncio
import json
from datetime import datetime, timedelta
from typing import Dict, Any, List, Optional
from loguru import logger
import streamlit as st
# Import existing Alwrity modules
from lib.database.twitter_service import TwitterDatabaseService
from lib.ai_web_researcher.google_trends_researcher import do_google_trends_analysis
from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
class AIContentPerformancePredictor:
"""
AI-powered content performance predictor using LLM intelligence.
No ML training required - uses AI's existing knowledge of content patterns.
"""
def __init__(self):
"""Initialize the AI predictor."""
self.twitter_service = TwitterDatabaseService()
self.platform_configs = {
'twitter': {
'optimal_length': 120,
'hashtag_range': (1, 3),
'best_times': [9, 12, 15, 18, 21],
'engagement_factors': ['questions', 'hashtags', 'mentions', 'visuals']
},
'linkedin': {
'optimal_length': 1500,
'hashtag_range': (3, 7),
'best_times': [8, 12, 17],
'engagement_factors': ['professional_insights', 'industry_expertise', 'networking']
},
'facebook': {
'optimal_length': 200,
'hashtag_range': (1, 5),
'best_times': [12, 15, 18],
'engagement_factors': ['visual_content', 'community_building', 'emotional_connection']
},
'instagram': {
'optimal_length': 150,
'hashtag_range': (5, 15),
'best_times': [11, 13, 17, 19],
'engagement_factors': ['visual_appeal', 'storytelling', 'trending_hashtags']
}
}
logger.info("AI Content Performance Predictor initialized")
async def predict_content_performance(self, content_data: Dict[str, Any]) -> Dict[str, Any]:
"""
Predict content performance using AI analysis.
Args:
content_data: Dictionary containing content and metadata
Returns:
AI-powered performance prediction with insights
"""
try:
st.info("🧠 AI is analyzing your content...")
# Extract content details
content = content_data.get('content', '')
platform = content_data.get('platform', 'twitter')
hashtags = content_data.get('hashtags', [])
posting_time = content_data.get('posting_time', datetime.now())
# Get current trends for context
trending_context = await self._get_trending_context(platform)
# Create comprehensive AI prompt for prediction
prediction_prompt = self._create_prediction_prompt(
content, platform, hashtags, posting_time, trending_context
)
# Get AI prediction
ai_response = llm_text_gen(
prediction_prompt,
system_prompt="You are an expert social media analyst with deep knowledge of content performance patterns across all platforms. Provide specific, actionable predictions."
)
# Parse AI response into structured prediction
structured_prediction = self._parse_ai_prediction(ai_response, content_data)
# Add platform-specific insights
platform_insights = self._get_platform_insights(content_data, platform)
# Generate actionable recommendations
recommendations = await self._generate_ai_recommendations(content_data, structured_prediction)
return {
'success': True,
'content_analyzed': content[:100] + "..." if len(content) > 100 else content,
'platform': platform,
'ai_prediction': structured_prediction,
'platform_insights': platform_insights,
'recommendations': recommendations,
'trending_context': trending_context,
'analysis_timestamp': datetime.now().isoformat(),
'confidence_level': self._calculate_confidence_level(content_data)
}
except Exception as e:
error_msg = f"Error in AI prediction: {str(e)}"
logger.error(error_msg, exc_info=True)
return {'error': error_msg}
def _create_prediction_prompt(
self,
content: str,
platform: str,
hashtags: List[str],
posting_time: datetime,
trending_context: Dict[str, Any]
) -> str:
"""Create a comprehensive prompt for AI prediction."""
config = self.platform_configs.get(platform, {})
prompt = f"""
Analyze this {platform} content and predict its performance:
CONTENT TO ANALYZE:
"{content}"
METADATA:
- Platform: {platform}
- Hashtags: {hashtags}
- Posting Time: {posting_time.strftime('%A %I:%M %p')}
- Content Length: {len(content)} characters
- Word Count: {len(content.split())} words
PLATFORM CONTEXT:
- Optimal Length: {config.get('optimal_length', 'N/A')} characters
- Recommended Hashtags: {config.get('hashtag_range', 'N/A')}
- Best Posting Times: {config.get('best_times', 'N/A')}
CURRENT TRENDS:
{json.dumps(trending_context, indent=2)}
PREDICTION REQUIREMENTS:
Please provide a detailed analysis with these specific predictions:
1. ENGAGEMENT PREDICTION:
- Estimated engagement rate (0-10%)
- Estimated likes (number)
- Estimated shares/retweets (number)
- Estimated comments (number)
2. PERFORMANCE ANALYSIS:
- Strengths of this content
- Weaknesses to address
- Viral potential (Low/Medium/High)
- Audience appeal rating (1-10)
3. OPTIMIZATION OPPORTUNITIES:
- How to improve engagement potential
- Better hashtag suggestions
- Content format improvements
- Timing optimization
4. COMPETITIVE ASSESSMENT:
- How this compares to typical content in this niche
- Unique elements that stand out
- Missing elements competitors usually include
Format your response as a detailed analysis with specific numbers and actionable insights.
Be realistic but optimistic in your predictions.
"""
return prompt
async def _get_trending_context(self, platform: str) -> Dict[str, Any]:
"""Get current trending context for better predictions."""
try:
# Use existing Twitter integration if available
if platform == 'twitter' and hasattr(self.twitter_service, 'get_trending_topics'):
trending_topics = self.twitter_service.get_trending_topics()
else:
# Fallback to general trends
trending_topics = [
'AI and technology',
'Content creation',
'Social media marketing',
'Digital transformation',
'Remote work'
]
return {
'trending_topics': trending_topics[:5],
'platform': platform,
'analysis_date': datetime.now().isoformat()
}
except Exception as e:
logger.error(f"Error getting trending context: {str(e)}")
return {
'trending_topics': ['General content', 'Engagement tips'],
'platform': platform,
'analysis_date': datetime.now().isoformat()
}
def _parse_ai_prediction(self, ai_response: str, content_data: Dict[str, Any]) -> Dict[str, Any]:
"""Parse AI response into structured prediction data."""
try:
# Extract numerical predictions using simple parsing
# This is a simplified version - in production, you might want more sophisticated parsing
prediction = {
'engagement_rate': self._extract_percentage(ai_response, 'engagement rate'),
'estimated_likes': self._extract_number(ai_response, 'likes'),
'estimated_shares': self._extract_number(ai_response, ['shares', 'retweets']),
'estimated_comments': self._extract_number(ai_response, 'comments'),
'viral_potential': self._extract_rating(ai_response, 'viral potential'),
'audience_appeal': self._extract_rating(ai_response, 'audience appeal'),
'strengths': self._extract_list_items(ai_response, 'strengths'),
'weaknesses': self._extract_list_items(ai_response, 'weaknesses'),
'full_analysis': ai_response
}
return prediction
except Exception as e:
logger.error(f"Error parsing AI prediction: {str(e)}")
return {
'engagement_rate': 2.5, # Default reasonable prediction
'estimated_likes': 50,
'estimated_shares': 10,
'estimated_comments': 5,
'viral_potential': 'Medium',
'audience_appeal': 7,
'full_analysis': ai_response
}
def _get_platform_insights(self, content_data: Dict[str, Any], platform: str) -> Dict[str, Any]:
"""Get platform-specific insights."""
config = self.platform_configs.get(platform, {})
content = content_data.get('content', '')
hashtags = content_data.get('hashtags', [])
insights = {
'platform_optimization': [],
'timing_analysis': {},
'format_analysis': {},
'hashtag_analysis': {}
}
# Length analysis
optimal_length = config.get('optimal_length', 200)
current_length = len(content)
if abs(current_length - optimal_length) > 50:
insights['platform_optimization'].append(
f"Content length ({current_length}) differs from optimal ({optimal_length}) for {platform}"
)
else:
insights['platform_optimization'].append(
f"Content length is well-optimized for {platform}"
)
# Hashtag analysis
hashtag_range = config.get('hashtag_range', (1, 5))
hashtag_count = len(hashtags)
if hashtag_count < hashtag_range[0]:
insights['hashtag_analysis']['recommendation'] = f"Add more hashtags (optimal: {hashtag_range[0]}-{hashtag_range[1]})"
elif hashtag_count > hashtag_range[1]:
insights['hashtag_analysis']['recommendation'] = f"Consider reducing hashtags (optimal: {hashtag_range[0]}-{hashtag_range[1]})"
else:
insights['hashtag_analysis']['recommendation'] = "Hashtag count is optimal"
# Timing analysis
best_times = config.get('best_times', [])
current_hour = datetime.now().hour
insights['timing_analysis'] = {
'best_times': best_times,
'current_timing': 'Optimal' if current_hour in best_times else 'Suboptimal',
'suggestion': f"Consider posting at {best_times} for better engagement" if current_hour not in best_times else "Current timing is optimal"
}
return insights
async def _generate_ai_recommendations(
self,
content_data: Dict[str, Any],
prediction: Dict[str, Any]
) -> List[Dict[str, str]]:
"""Generate AI-powered recommendations for improvement."""
recommendations_prompt = f"""
Based on this content analysis, provide specific improvement recommendations:
CONTENT: "{content_data.get('content', '')[:200]}..."
PLATFORM: {content_data.get('platform', 'twitter')}
PREDICTED ENGAGEMENT: {prediction.get('engagement_rate', 'N/A')}%
VIRAL POTENTIAL: {prediction.get('viral_potential', 'N/A')}
Provide 5-7 specific, actionable recommendations to improve this content's performance:
1. Content optimization suggestions
2. Hashtag improvements
3. Timing recommendations
4. Format enhancements
5. Engagement boosters
6. Audience targeting tips
7. Platform-specific optimizations
Format each recommendation as:
- Category: [category]
- Action: [specific action to take]
- Expected Impact: [what improvement to expect]
- Priority: [High/Medium/Low]
Focus on quick wins and high-impact changes.
"""
try:
ai_recommendations = llm_text_gen(
recommendations_prompt,
system_prompt="You are a content optimization expert. Provide specific, actionable recommendations that can be implemented immediately."
)
# Parse recommendations into structured format
return self._parse_recommendations(ai_recommendations)
except Exception as e:
logger.error(f"Error generating AI recommendations: {str(e)}")
return [
{
'category': 'Content Enhancement',
'action': 'Add more engaging elements like questions or calls-to-action',
'expected_impact': 'Increase engagement by 20-30%',
'priority': 'High'
},
{
'category': 'Hashtag Optimization',
'action': 'Research and add 2-3 trending relevant hashtags',
'expected_impact': 'Improve discoverability',
'priority': 'Medium'
}
]
def _extract_percentage(self, text: str, keyword: str) -> float:
"""Extract percentage value from AI response."""
import re
patterns = [
rf'{keyword}.*?(\d+\.?\d*)%',
rf'(\d+\.?\d*)%.*?{keyword}',
rf'{keyword}.*?(\d+\.?\d*) percent'
]
for pattern in patterns:
match = re.search(pattern, text, re.IGNORECASE)
if match:
return float(match.group(1))
return 2.5 # Default reasonable engagement rate
def _extract_number(self, text: str, keywords: List[str]) -> int:
"""Extract number from AI response."""
import re
if isinstance(keywords, str):
keywords = [keywords]
for keyword in keywords:
patterns = [
rf'{keyword}.*?(\d+)',
rf'(\d+).*?{keyword}'
]
for pattern in patterns:
match = re.search(pattern, text, re.IGNORECASE)
if match:
return int(match.group(1))
return 25 # Default reasonable number
def _extract_rating(self, text: str, keyword: str) -> str:
"""Extract rating (High/Medium/Low) from AI response."""
import re
pattern = rf'{keyword}.*?(High|Medium|Low)'
match = re.search(pattern, text, re.IGNORECASE)
if match:
return match.group(1).capitalize()
return 'Medium' # Default
def _extract_list_items(self, text: str, section: str) -> List[str]:
"""Extract list items from a section of AI response."""
import re
# Find the section
section_pattern = rf'{section}:?\s*(.*?)(?=\n\n|\d\.|[A-Z]+:|$)'
match = re.search(section_pattern, text, re.IGNORECASE | re.DOTALL)
if match:
section_text = match.group(1)
# Extract bullet points or numbered items
items = re.findall(r'[-•]\s*(.+)', section_text)
if not items:
items = re.findall(r'\d+\.\s*(.+)', section_text)
return [item.strip() for item in items[:3]] # Return first 3 items
return []
def _parse_recommendations(self, ai_recommendations: str) -> List[Dict[str, str]]:
"""Parse AI recommendations into structured format."""
recommendations = []
try:
# Simple parsing - split by numbers or bullet points
import re
sections = re.split(r'\d+\.|[-•]', ai_recommendations)
for section in sections[1:6]: # Take first 5 recommendations
if len(section.strip()) > 10: # Only substantial recommendations
recommendations.append({
'category': 'AI Recommendation',
'action': section.strip()[:200], # Limit length
'expected_impact': 'Improved engagement',
'priority': 'Medium'
})
except Exception as e:
logger.error(f"Error parsing recommendations: {str(e)}")
# Ensure we have at least a few recommendations
if len(recommendations) < 3:
recommendations.extend([
{
'category': 'Engagement',
'action': 'Add questions to encourage audience interaction',
'expected_impact': '20-30% more engagement',
'priority': 'High'
},
{
'category': 'Visibility',
'action': 'Use trending hashtags relevant to your niche',
'expected_impact': 'Better discoverability',
'priority': 'Medium'
},
{
'category': 'Timing',
'action': 'Post during peak engagement hours for your audience',
'expected_impact': '15-25% more reach',
'priority': 'Medium'
}
])
return recommendations[:7] # Return max 7 recommendations
def _calculate_confidence_level(self, content_data: Dict[str, Any]) -> str:
"""Calculate confidence level of prediction."""
confidence_factors = 0
# More complete data = higher confidence
if content_data.get('content'):
confidence_factors += 1
if content_data.get('hashtags'):
confidence_factors += 1
if content_data.get('platform'):
confidence_factors += 1
if content_data.get('posting_time'):
confidence_factors += 1
if confidence_factors >= 4:
return 'High'
elif confidence_factors >= 2:
return 'Medium'
else:
return 'Low'
async def analyze_content_batch(self, content_list: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
"""Analyze multiple pieces of content."""
results = []
for i, content_data in enumerate(content_list):
st.write(f"🔍 Analyzing content {i+1}/{len(content_list)}")
result = await self.predict_content_performance(content_data)
results.append(result)
return results
def get_platform_best_practices(self, platform: str) -> Dict[str, Any]:
"""Get best practices for a specific platform."""
config = self.platform_configs.get(platform, {})
return {
'platform': platform,
'optimal_length': config.get('optimal_length'),
'hashtag_range': config.get('hashtag_range'),
'best_posting_times': config.get('best_times'),
'engagement_factors': config.get('engagement_factors', []),
'tips': [
f"Keep content around {config.get('optimal_length', 200)} characters",
f"Use {config.get('hashtag_range', (1, 5))[0]}-{config.get('hashtag_range', (1, 5))[1]} relevant hashtags",
f"Post during peak hours: {config.get('best_times', [])}",
"Include engaging elements like questions or calls-to-action",
"Use visuals when possible to increase engagement"
]
}
# Usage example and Streamlit interface
def render_ai_predictor_ui():
"""Render the AI content performance predictor interface."""
st.title("🎯 AI Content Performance Predictor")
st.markdown("Get AI-powered predictions for your content performance - no ML training required!")
# Initialize predictor
if 'ai_predictor' not in st.session_state:
st.session_state.ai_predictor = AIContentPerformancePredictor()
predictor = st.session_state.ai_predictor
# Input section
st.header("📝 Content Analysis")
col1, col2 = st.columns(2)
with col1:
platform = st.selectbox(
"Platform",
["twitter", "linkedin", "facebook", "instagram"],
help="Choose your target platform"
)
posting_time = st.time_input("Posting Time", value=datetime.now().time())
with col2:
hashtags_input = st.text_input(
"Hashtags (comma-separated)",
value="AI, ContentCreation, Marketing",
help="Enter hashtags without # symbol"
)
content = st.text_area(
"Content to Analyze",
value="Discover how AI is revolutionizing content creation! What's your experience with AI tools? Share your thoughts below! 🚀",
height=150,
help="Enter the content you want to analyze"
)
# Process hashtags
hashtags = [tag.strip() for tag in hashtags_input.split(',') if tag.strip()]
if st.button("🧠 Analyze Content Performance", type="primary"):
if content:
# Prepare content data
content_data = {
'content': content,
'platform': platform,
'hashtags': hashtags,
'posting_time': datetime.combine(datetime.now().date(), posting_time)
}
# Run AI analysis
with st.spinner("🤖 AI is analyzing your content..."):
results = asyncio.run(predictor.predict_content_performance(content_data))
if results.get('success'):
st.success("✅ Analysis Complete!")
# Display predictions
st.header("📊 AI Performance Prediction")
prediction = results.get('ai_prediction', {})
# Key metrics
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric(
"Engagement Rate",
f"{prediction.get('engagement_rate', 0):.1f}%"
)
with col2:
st.metric(
"Est. Likes",
f"{prediction.get('estimated_likes', 0):,}"
)
with col3:
st.metric(
"Est. Shares",
f"{prediction.get('estimated_shares', 0):,}"
)
with col4:
st.metric(
"Viral Potential",
prediction.get('viral_potential', 'Medium')
)
# Platform insights
platform_insights = results.get('platform_insights', {})
if platform_insights:
st.subheader("🎯 Platform Optimization")
for insight in platform_insights.get('platform_optimization', []):
st.info(f"💡 {insight}")
# Timing analysis
timing = platform_insights.get('timing_analysis', {})
if timing:
st.write(f"**Timing Analysis:** {timing.get('suggestion', 'N/A')}")
# Hashtag analysis
hashtag_analysis = platform_insights.get('hashtag_analysis', {})
if hashtag_analysis:
st.write(f"**Hashtag Recommendation:** {hashtag_analysis.get('recommendation', 'N/A')}")
# AI Recommendations
recommendations = results.get('recommendations', [])
if recommendations:
st.subheader("🚀 AI Recommendations")
for i, rec in enumerate(recommendations):
with st.expander(f"💡 {rec.get('category', 'Recommendation')} - {rec.get('priority', 'Medium')} Priority"):
st.write(f"**Action:** {rec.get('action', 'N/A')}")
st.write(f"**Expected Impact:** {rec.get('expected_impact', 'N/A')}")
# Full AI Analysis
if prediction.get('full_analysis'):
with st.expander("🤖 Complete AI Analysis"):
st.write(prediction['full_analysis'])
else:
st.error(f"❌ Analysis failed: {results.get('error')}")
else:
st.warning("⚠️ Please enter content to analyze")
# Platform best practices
st.sidebar.header("📚 Platform Best Practices")
selected_platform = st.sidebar.selectbox("Get tips for:", ["twitter", "linkedin", "facebook", "instagram"])
best_practices = predictor.get_platform_best_practices(selected_platform)
st.sidebar.write(f"**{selected_platform.title()} Best Practices:**")
for tip in best_practices.get('tips', []):
st.sidebar.write(f"• {tip}")
# Main execution
if __name__ == "__main__":
render_ai_predictor_ui()

164
lib/database/__init__.py Normal file
View File

@@ -0,0 +1,164 @@
"""
Database Package for ALwrity
============================
This package provides database models and services for managing data
in the ALwrity application, including Twitter-specific functionality.
Main Components:
- models.py: Core application database models
- twitter_models.py: Twitter-specific database models
- twitter_service.py: High-level Twitter database service
- twitter_init.py: Database initialization and management utilities
Usage:
# Initialize Twitter database
from lib.database import initialize_twitter_database
initialize_twitter_database()
# Use Twitter database service
from lib.database import twitter_db
user = twitter_db.create_or_update_user(user_data)
# Use Twitter models directly
from lib.database.twitter_models import TwitterUser, Tweet
"""
# Import core models
from .models import (
SEOData, ContentType, Platform, ScheduleStatus,
ContentItem, Schedule, create_engine, init_db, get_session
)
# Import Twitter-specific components
try:
from .twitter_models import (
# Models
TwitterUser, Tweet, ScheduledTweet, TwitterAnalytics,
TweetAnalytics, EngagementData, AudienceInsight,
HashtagPerformance, ContentTemplate, TwitterSettings,
# Enums and Data Classes
TwitterAccountType, TweetType, TweetStatus, EngagementType,
AnalyticsTimeframe, ContentCategory, TwitterCredentials, TweetMetrics,
# Database functions
get_twitter_engine, init_twitter_db, get_twitter_session,
create_twitter_user, update_user_metrics, create_tweet_record,
update_tweet_metrics, calculate_virality_score, get_user_analytics_summary
)
from .twitter_service import TwitterDatabaseService, twitter_db
from .twitter_init import (
TwitterDatabaseInitializer, initialize_twitter_database,
check_twitter_database_health
)
TWITTER_AVAILABLE = True
except ImportError as e:
# Twitter components not available (missing dependencies)
TWITTER_AVAILABLE = False
print(f"Warning: Twitter database components not available: {e}")
# Package metadata
__version__ = "1.0.0"
__author__ = "ALwrity Team"
# Export main components
__all__ = [
# Core models
'SEOData', 'ContentType', 'Platform', 'ScheduleStatus',
'ContentItem', 'Schedule', 'create_engine', 'init_db', 'get_session',
# Twitter availability flag
'TWITTER_AVAILABLE',
]
# Add Twitter exports if available
if TWITTER_AVAILABLE:
__all__.extend([
# Twitter Models
'TwitterUser', 'Tweet', 'ScheduledTweet', 'TwitterAnalytics',
'TweetAnalytics', 'EngagementData', 'AudienceInsight',
'HashtagPerformance', 'ContentTemplate', 'TwitterSettings',
# Twitter Enums and Data Classes
'TwitterAccountType', 'TweetType', 'TweetStatus', 'EngagementType',
'AnalyticsTimeframe', 'ContentCategory', 'TwitterCredentials', 'TweetMetrics',
# Twitter Database Functions
'get_twitter_engine', 'init_twitter_db', 'get_twitter_session',
'create_twitter_user', 'update_user_metrics', 'create_tweet_record',
'update_tweet_metrics', 'calculate_virality_score', 'get_user_analytics_summary',
# Twitter Service
'TwitterDatabaseService', 'twitter_db',
# Twitter Initialization
'TwitterDatabaseInitializer', 'initialize_twitter_database',
'check_twitter_database_health'
])
def setup_database(db_url: str = "sqlite:///alwrity.db", twitter_db_url: str = "sqlite:///twitter_data.db"):
"""
Setup both core and Twitter databases.
Args:
db_url: URL for the core database
twitter_db_url: URL for the Twitter database
Returns:
dict: Setup results
"""
results = {
'core_db': False,
'twitter_db': False,
'errors': []
}
try:
# Initialize core database
engine = create_engine(db_url)
init_db(engine)
results['core_db'] = True
except Exception as e:
results['errors'].append(f"Core database setup failed: {e}")
if TWITTER_AVAILABLE:
try:
# Initialize Twitter database
success = initialize_twitter_database(twitter_db_url)
results['twitter_db'] = success
if not success:
results['errors'].append("Twitter database initialization failed")
except Exception as e:
results['errors'].append(f"Twitter database setup failed: {e}")
else:
results['errors'].append("Twitter database components not available")
return results
def get_database_info():
"""
Get information about available database components.
Returns:
dict: Database component information
"""
info = {
'core_models_available': True,
'twitter_models_available': TWITTER_AVAILABLE,
'version': __version__
}
if TWITTER_AVAILABLE:
try:
# Get Twitter database stats if service is available
stats = twitter_db.get_database_stats()
info['twitter_stats'] = stats
except Exception as e:
info['twitter_stats_error'] = str(e)
return info

524
lib/database/twitter_init.py Normal file
View File

@@ -0,0 +1,524 @@
"""
Twitter Database Initialization and Migration Script
===================================================
This module provides utilities for initializing the Twitter database,
handling schema migrations, and managing database setup.
Features:
- Database initialization and table creation
- Schema migration utilities
- Data seeding for development/testing
- Database health checks and maintenance
"""
import os
import logging
from typing import Dict, Any, List, Optional
from datetime import datetime
import json
from pathlib import Path
from sqlalchemy import create_engine, text, inspect
from sqlalchemy.orm import sessionmaker
from sqlalchemy.exc import SQLAlchemyError
from .twitter_models import (
Base, TwitterUser, Tweet, ScheduledTweet, TwitterAnalytics,
TweetAnalytics, EngagementData, AudienceInsight, HashtagPerformance,
ContentTemplate, TwitterSettings, TwitterAccountType, TweetType,
TweetStatus, EngagementType, AnalyticsTimeframe, ContentCategory
)
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class TwitterDatabaseInitializer:
"""
Handles Twitter database initialization and management.
"""
def __init__(self, db_url: str = "sqlite:///twitter_data.db"):
"""Initialize the database initializer."""
self.db_url = db_url
self.engine = create_engine(db_url, echo=False)
self.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
# Create database directory if using SQLite
if db_url.startswith('sqlite:///'):
db_path = db_url.replace('sqlite:///', '')
os.makedirs(os.path.dirname(os.path.abspath(db_path)), exist_ok=True)
def initialize_database(self, force_recreate: bool = False) -> bool:
"""
Initialize the Twitter database with all required tables.
Args:
force_recreate: If True, drop existing tables and recreate
Returns:
bool: True if successful, False otherwise
"""
try:
if force_recreate:
logger.info("Dropping existing tables...")
Base.metadata.drop_all(bind=self.engine)
logger.info("Creating Twitter database tables...")
Base.metadata.create_all(bind=self.engine)
# Verify tables were created
inspector = inspect(self.engine)
tables = inspector.get_table_names()
expected_tables = [
'twitter_users', 'tweets', 'scheduled_tweets', 'twitter_analytics',
'tweet_analytics', 'engagement_data', 'audience_insights',
'hashtag_performance', 'content_templates', 'twitter_settings'
]
missing_tables = [table for table in expected_tables if table not in tables]
if missing_tables:
logger.error(f"Missing tables: {missing_tables}")
return False
logger.info(f"Successfully created {len(tables)} tables")
# Create indexes for better performance
self._create_indexes()
# Seed initial data if needed
self._seed_initial_data()
logger.info("Twitter database initialization completed successfully")
return True
except Exception as e:
logger.error(f"Error initializing database: {e}")
return False
def _create_indexes(self):
"""Create database indexes for better query performance."""
try:
with self.engine.connect() as conn:
# User indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_users_user_id ON twitter_users(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_users_twitter_user_id ON twitter_users(twitter_user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_users_username ON twitter_users(username)"))
# Tweet indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweets_user_id ON tweets(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweets_status ON tweets(status)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweets_posted_at ON tweets(posted_at)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweets_tweet_id ON tweets(tweet_id)"))
# Scheduled tweet indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_scheduled_tweets_user_id ON scheduled_tweets(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_scheduled_tweets_status ON scheduled_tweets(status)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_scheduled_tweets_scheduled_time ON scheduled_tweets(scheduled_time)"))
# Analytics indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_analytics_user_id ON twitter_analytics(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_analytics_date ON twitter_analytics(date)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_twitter_analytics_timeframe ON twitter_analytics(timeframe)"))
# Tweet analytics indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweet_analytics_tweet_id ON tweet_analytics(tweet_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_tweet_analytics_recorded_at ON tweet_analytics(recorded_at)"))
# Engagement data indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_engagement_data_tweet_id ON engagement_data(tweet_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_engagement_data_occurred_at ON engagement_data(occurred_at)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_engagement_data_type ON engagement_data(engagement_type)"))
# Hashtag performance indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_hashtag_performance_user_id ON hashtag_performance(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_hashtag_performance_hashtag ON hashtag_performance(hashtag)"))
# Content template indexes
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_content_templates_user_id ON content_templates(user_id)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_content_templates_category ON content_templates(category)"))
conn.execute(text("CREATE INDEX IF NOT EXISTS idx_content_templates_is_active ON content_templates(is_active)"))
conn.commit()
logger.info("Database indexes created successfully")
except Exception as e:
logger.error(f"Error creating indexes: {e}")
def _seed_initial_data(self):
"""Seed the database with initial data for development/testing."""
try:
session = self.SessionLocal()
# Check if we already have data
if session.query(TwitterUser).count() > 0:
logger.info("Database already contains data, skipping seeding")
session.close()
return
# Create sample content templates
sample_templates = [
{
'name': 'Daily Motivation',
'description': 'Motivational quotes and thoughts',
'template_text': 'Start your day with this thought: {quote} #motivation #success',
'category': ContentCategory.PERSONAL,
'variables': ['quote'],
'default_hashtags': ['#motivation', '#success', '#mindset'],
'ai_prompt': 'Generate an inspiring motivational quote',
'ai_tone': 'inspirational',
'ai_target_audience': 'professionals and entrepreneurs'
},
{
'name': 'Tech News Share',
'description': 'Template for sharing tech news',
'template_text': 'Interesting development in {topic}: {summary} {link} #tech #innovation',
'category': ContentCategory.EDUCATIONAL,
'variables': ['topic', 'summary', 'link'],
'default_hashtags': ['#tech', '#innovation', '#technology'],
'ai_prompt': 'Summarize this tech news in an engaging way',
'ai_tone': 'informative',
'ai_target_audience': 'tech enthusiasts and professionals'
},
{
'name': 'Question Engagement',
'description': 'Template for asking engaging questions',
'template_text': 'Quick question for my followers: {question} What do you think? #community #discussion',
'category': ContentCategory.QUESTION,
'variables': ['question'],
'default_hashtags': ['#community', '#discussion', '#question'],
'ai_prompt': 'Generate an engaging question for social media',
'ai_tone': 'conversational',
'ai_target_audience': 'general audience'
},
{
'name': 'Product Update',
'description': 'Template for product announcements',
'template_text': 'Excited to share: {update} {details} #product #update #announcement',
'category': ContentCategory.PROMOTIONAL,
'variables': ['update', 'details'],
'default_hashtags': ['#product', '#update', '#announcement'],
'ai_prompt': 'Write an exciting product update announcement',
'ai_tone': 'enthusiastic',
'ai_target_audience': 'customers and prospects'
}
]
# Note: We can't create templates without a user, so we'll skip this for now
# In a real scenario, templates would be created when users are added
session.close()
logger.info("Initial data seeding completed")
except Exception as e:
logger.error(f"Error seeding initial data: {e}")
def check_database_health(self) -> Dict[str, Any]:
"""
Check the health and status of the Twitter database.
Returns:
Dict containing health check results
"""
health_status = {
'status': 'healthy',
'timestamp': datetime.utcnow().isoformat(),
'tables': {},
'indexes': {},
'issues': []
}
try:
inspector = inspect(self.engine)
# Check table existence and row counts
expected_tables = [
'twitter_users', 'tweets', 'scheduled_tweets', 'twitter_analytics',
'tweet_analytics', 'engagement_data', 'audience_insights',
'hashtag_performance', 'content_templates', 'twitter_settings'
]
session = self.SessionLocal()
for table_name in expected_tables:
if table_name in inspector.get_table_names():
# Get row count
try:
result = session.execute(text(f"SELECT COUNT(*) FROM {table_name}"))
count = result.scalar()
health_status['tables'][table_name] = {
'exists': True,
'row_count': count
}
except Exception as e:
health_status['tables'][table_name] = {
'exists': True,
'row_count': 'error',
'error': str(e)
}
health_status['issues'].append(f"Error counting rows in {table_name}: {e}")
else:
health_status['tables'][table_name] = {'exists': False}
health_status['issues'].append(f"Missing table: {table_name}")
# Check indexes
for table_name in inspector.get_table_names():
indexes = inspector.get_indexes(table_name)
health_status['indexes'][table_name] = len(indexes)
session.close()
# Set overall status
if health_status['issues']:
health_status['status'] = 'issues_found'
return health_status
except Exception as e:
health_status['status'] = 'error'
health_status['error'] = str(e)
logger.error(f"Error checking database health: {e}")
return health_status
def backup_database(self, backup_path: str) -> bool:
"""
Create a backup of the database.
Args:
backup_path: Path where to save the backup
Returns:
bool: True if successful, False otherwise
"""
try:
if not self.db_url.startswith('sqlite:///'):
logger.error("Backup currently only supported for SQLite databases")
return False
# Get the database file path
db_file = self.db_url.replace('sqlite:///', '')
if not os.path.exists(db_file):
logger.error(f"Database file not found: {db_file}")
return False
# Create backup directory if it doesn't exist
os.makedirs(os.path.dirname(backup_path), exist_ok=True)
# Copy the database file
import shutil
shutil.copy2(db_file, backup_path)
logger.info(f"Database backed up to: {backup_path}")
return True
except Exception as e:
logger.error(f"Error backing up database: {e}")
return False
def restore_database(self, backup_path: str) -> bool:
"""
Restore database from a backup.
Args:
backup_path: Path to the backup file
Returns:
bool: True if successful, False otherwise
"""
try:
if not self.db_url.startswith('sqlite:///'):
logger.error("Restore currently only supported for SQLite databases")
return False
if not os.path.exists(backup_path):
logger.error(f"Backup file not found: {backup_path}")
return False
# Get the database file path
db_file = self.db_url.replace('sqlite:///', '')
# Copy the backup file to the database location
import shutil
shutil.copy2(backup_path, db_file)
logger.info(f"Database restored from: {backup_path}")
return True
except Exception as e:
logger.error(f"Error restoring database: {e}")
return False
def migrate_schema(self, migration_scripts: List[str]) -> bool:
"""
Apply schema migration scripts.
Args:
migration_scripts: List of SQL migration scripts
Returns:
bool: True if successful, False otherwise
"""
try:
with self.engine.connect() as conn:
# Create migration tracking table if it doesn't exist
conn.execute(text("""
CREATE TABLE IF NOT EXISTS schema_migrations (
id INTEGER PRIMARY KEY AUTOINCREMENT,
migration_name TEXT NOT NULL UNIQUE,
applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
"""))
for script in migration_scripts:
# Check if migration was already applied
result = conn.execute(text(
"SELECT COUNT(*) FROM schema_migrations WHERE migration_name = :name"
), {"name": script})
if result.scalar() == 0:
# Apply migration
logger.info(f"Applying migration: {script}")
# Read and execute migration script
script_path = Path(script)
if script_path.exists():
with open(script_path, 'r') as f:
migration_sql = f.read()
conn.execute(text(migration_sql))
# Record migration as applied
conn.execute(text(
"INSERT INTO schema_migrations (migration_name) VALUES (:name)"
), {"name": script})
else:
logger.error(f"Migration script not found: {script}")
return False
else:
logger.info(f"Migration already applied: {script}")
conn.commit()
logger.info("Schema migration completed successfully")
return True
except Exception as e:
logger.error(f"Error applying schema migration: {e}")
return False
def cleanup_old_data(self, days: int = 90) -> Dict[str, int]:
"""
Clean up old data to maintain database performance.
Args:
days: Number of days to keep data for
Returns:
Dict with cleanup statistics
"""
try:
cutoff_date = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
cutoff_date = cutoff_date.replace(day=cutoff_date.day - days)
session = self.SessionLocal()
# Count records to be deleted
old_tweet_analytics = session.query(TweetAnalytics).filter(
TweetAnalytics.recorded_at < cutoff_date
).count()
old_engagement_data = session.query(EngagementData).filter(
EngagementData.occurred_at < cutoff_date
).count()
# Delete old records
session.query(TweetAnalytics).filter(
TweetAnalytics.recorded_at < cutoff_date
).delete()
session.query(EngagementData).filter(
EngagementData.occurred_at < cutoff_date
).delete()
session.commit()
session.close()
cleanup_stats = {
'tweet_analytics_deleted': old_tweet_analytics,
'engagement_data_deleted': old_engagement_data,
'cutoff_date': cutoff_date.isoformat()
}
logger.info(f"Cleanup completed: {cleanup_stats}")
return cleanup_stats
except Exception as e:
logger.error(f"Error during cleanup: {e}")
return {'error': str(e)}
def initialize_twitter_database(db_url: str = "sqlite:///twitter_data.db", force_recreate: bool = False) -> bool:
"""
Convenience function to initialize the Twitter database.
Args:
db_url: Database URL
force_recreate: Whether to recreate existing tables
Returns:
bool: True if successful, False otherwise
"""
initializer = TwitterDatabaseInitializer(db_url)
return initializer.initialize_database(force_recreate)
def check_twitter_database_health(db_url: str = "sqlite:///twitter_data.db") -> Dict[str, Any]:
"""
Convenience function to check Twitter database health.
Args:
db_url: Database URL
Returns:
Dict with health check results
"""
initializer = TwitterDatabaseInitializer(db_url)
return initializer.check_database_health()
if __name__ == "__main__":
# Command line interface for database management
import argparse
parser = argparse.ArgumentParser(description="Twitter Database Management")
parser.add_argument("--db-url", default="sqlite:///twitter_data.db", help="Database URL")
parser.add_argument("--init", action="store_true", help="Initialize database")
parser.add_argument("--force", action="store_true", help="Force recreate tables")
parser.add_argument("--health", action="store_true", help="Check database health")
parser.add_argument("--backup", help="Create database backup")
parser.add_argument("--restore", help="Restore from backup")
parser.add_argument("--cleanup", type=int, help="Cleanup data older than N days")
args = parser.parse_args()
initializer = TwitterDatabaseInitializer(args.db_url)
if args.init:
success = initializer.initialize_database(args.force)
print(f"Database initialization: {'SUCCESS' if success else 'FAILED'}")
if args.health:
health = initializer.check_database_health()
print(json.dumps(health, indent=2))
if args.backup:
success = initializer.backup_database(args.backup)
print(f"Database backup: {'SUCCESS' if success else 'FAILED'}")
if args.restore:
success = initializer.restore_database(args.restore)
print(f"Database restore: {'SUCCESS' if success else 'FAILED'}")
if args.cleanup:
stats = initializer.cleanup_old_data(args.cleanup)
print(f"Cleanup completed: {stats}")

791
lib/database/twitter_models.py Normal file
View File

@@ -0,0 +1,791 @@
"""
Twitter Database Models for ALwrity
===================================
This module defines SQLAlchemy models for storing Twitter-related data including:
- User profiles and authentication
- Tweet content and metadata
- Analytics and engagement metrics
- Scheduling and automation data
- Performance tracking and insights
This allows the application to store Twitter data locally and reduce API calls
while providing rich analytics and historical data to users.
"""
from sqlalchemy import (
create_engine, Column, Integer, String, Text, DateTime, Boolean, Float,
Enum, ForeignKey, JSON, BigInteger, Index, UniqueConstraint
)
from sqlalchemy.orm import declarative_base, relationship, sessionmaker
from datetime import datetime, timedelta
import enum
from dataclasses import dataclass
from typing import List, Dict, Any, Optional
import json
Base = declarative_base()
# --- ENUMS ---
class TwitterAccountType(enum.Enum):
PERSONAL = "personal"
BUSINESS = "business"
CREATOR = "creator"
BRAND = "brand"
class TweetType(enum.Enum):
ORIGINAL = "original"
REPLY = "reply"
RETWEET = "retweet"
QUOTE_TWEET = "quote_tweet"
THREAD = "thread"
class TweetStatus(enum.Enum):
DRAFT = "draft"
SCHEDULED = "scheduled"
POSTED = "posted"
FAILED = "failed"
DELETED = "deleted"
class EngagementType(enum.Enum):
LIKE = "like"
RETWEET = "retweet"
REPLY = "reply"
QUOTE_TWEET = "quote_tweet"
BOOKMARK = "bookmark"
IMPRESSION = "impression"
PROFILE_CLICK = "profile_click"
URL_CLICK = "url_click"
HASHTAG_CLICK = "hashtag_click"
MENTION_CLICK = "mention_click"
class AnalyticsTimeframe(enum.Enum):
HOURLY = "hourly"
DAILY = "daily"
WEEKLY = "weekly"
MONTHLY = "monthly"
class ContentCategory(enum.Enum):
EDUCATIONAL = "educational"
PROMOTIONAL = "promotional"
PERSONAL = "personal"
NEWS = "news"
ENTERTAINMENT = "entertainment"
QUESTION = "question"
POLL = "poll"
THREAD = "thread"
# --- DATACLASSES ---
@dataclass
class TwitterCredentials:
"""Dataclass for Twitter API credentials"""
api_key: str = ""
api_secret: str = ""
access_token: str = ""
access_token_secret: str = ""
bearer_token: str = ""
def to_dict(self) -> Dict[str, str]:
return {
'api_key': self.api_key,
'api_secret': self.api_secret,
'access_token': self.access_token,
'access_token_secret': self.access_token_secret,
'bearer_token': self.bearer_token
}
@classmethod
def from_dict(cls, data: Dict[str, str]) -> 'TwitterCredentials':
return cls(
api_key=data.get('api_key', ''),
api_secret=data.get('api_secret', ''),
access_token=data.get('access_token', ''),
access_token_secret=data.get('access_token_secret', ''),
bearer_token=data.get('bearer_token', '')
)
@dataclass
class TweetMetrics:
"""Dataclass for tweet performance metrics"""
likes: int = 0
retweets: int = 0
replies: int = 0
quotes: int = 0
bookmarks: int = 0
impressions: int = 0
profile_clicks: int = 0
url_clicks: int = 0
hashtag_clicks: int = 0
engagement_rate: float = 0.0
reach: int = 0
def to_dict(self) -> Dict[str, Any]:
return {
'likes': self.likes,
'retweets': self.retweets,
'replies': self.replies,
'quotes': self.quotes,
'bookmarks': self.bookmarks,
'impressions': self.impressions,
'profile_clicks': self.profile_clicks,
'url_clicks': self.url_clicks,
'hashtag_clicks': self.hashtag_clicks,
'engagement_rate': self.engagement_rate,
'reach': self.reach
}
# --- MODELS ---
class TwitterUser(Base):
"""
Stores Twitter user profile information and authentication data.
This reduces API calls for user profile information.
"""
__tablename__ = "twitter_users"
id = Column(Integer, primary_key=True)
user_id = Column(String, nullable=False, unique=True) # ALwrity user ID
twitter_user_id = Column(BigInteger, nullable=False, unique=True) # Twitter user ID
username = Column(String, nullable=False, index=True) # @username
display_name = Column(String, nullable=False)
bio = Column(Text)
location = Column(String)
website = Column(String)
profile_image_url = Column(String)
banner_image_url = Column(String)
# Account metrics
followers_count = Column(Integer, default=0)
following_count = Column(Integer, default=0)
tweet_count = Column(Integer, default=0)
listed_count = Column(Integer, default=0)
# Account details
account_type = Column(Enum(TwitterAccountType), default=TwitterAccountType.PERSONAL)
verified = Column(Boolean, default=False)
protected = Column(Boolean, default=False)
created_at_twitter = Column(DateTime) # When Twitter account was created
# Authentication and API data
credentials_encrypted = Column(Text) # Encrypted JSON of TwitterCredentials
api_rate_limit_remaining = Column(Integer, default=0)
api_rate_limit_reset = Column(DateTime)
last_api_call = Column(DateTime)
# Metadata
is_active = Column(Boolean, default=True)
last_sync = Column(DateTime, default=datetime.utcnow)
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
tweets = relationship("Tweet", back_populates="user", cascade="all, delete-orphan")
analytics = relationship("TwitterAnalytics", back_populates="user", cascade="all, delete-orphan")
scheduled_tweets = relationship("ScheduledTweet", back_populates="user", cascade="all, delete-orphan")
engagement_data = relationship("EngagementData", back_populates="user", cascade="all, delete-orphan")
audience_insights = relationship("AudienceInsight", back_populates="user", cascade="all, delete-orphan")
# Indexes
__table_args__ = (
Index('idx_twitter_user_username', 'username'),
Index('idx_twitter_user_sync', 'last_sync'),
Index('idx_twitter_user_active', 'is_active'),
)
class Tweet(Base):
"""
Stores tweet content, metadata, and performance data.
Includes both posted tweets and drafts.
"""
__tablename__ = "tweets"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
tweet_id = Column(BigInteger, unique=True, index=True) # Twitter tweet ID (null for drafts)
# Content
text = Column(Text, nullable=False)
hashtags = Column(JSON, default=list) # List of hashtags
mentions = Column(JSON, default=list) # List of mentioned users
urls = Column(JSON, default=list) # List of URLs in tweet
media_urls = Column(JSON, default=list) # List of media URLs
# Tweet metadata
tweet_type = Column(Enum(TweetType), default=TweetType.ORIGINAL)
status = Column(Enum(TweetStatus), default=TweetStatus.DRAFT)
category = Column(Enum(ContentCategory))
# Engagement metrics (updated periodically)
likes_count = Column(Integer, default=0)
retweets_count = Column(Integer, default=0)
replies_count = Column(Integer, default=0)
quotes_count = Column(Integer, default=0)
bookmarks_count = Column(Integer, default=0)
impressions_count = Column(Integer, default=0)
# Performance metrics
engagement_rate = Column(Float, default=0.0)
reach = Column(Integer, default=0)
click_through_rate = Column(Float, default=0.0)
# AI and generation data
ai_generated = Column(Boolean, default=False)
ai_model_used = Column(String) # Which AI model generated this
ai_prompt = Column(Text) # Original prompt used
ai_confidence_score = Column(Float) # AI confidence in content quality
generation_metadata = Column(JSON, default=dict) # Additional AI metadata
# Scheduling and posting
scheduled_for = Column(DateTime)
posted_at = Column(DateTime)
last_metrics_update = Column(DateTime)
# Thread information
thread_id = Column(String) # For grouping thread tweets
thread_position = Column(Integer) # Position in thread (1, 2, 3...)
parent_tweet_id = Column(BigInteger) # For replies
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser", back_populates="tweets")
analytics = relationship("TweetAnalytics", back_populates="tweet", cascade="all, delete-orphan")
# Indexes
__table_args__ = (
Index('idx_tweet_user_status', 'user_id', 'status'),
Index('idx_tweet_posted_at', 'posted_at'),
Index('idx_tweet_engagement', 'engagement_rate'),
Index('idx_tweet_thread', 'thread_id'),
)
class ScheduledTweet(Base):
"""
Stores scheduled tweets with automation settings.
"""
__tablename__ = "scheduled_tweets"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
tweet_id = Column(Integer, ForeignKey("tweets.id"), nullable=False)
# Scheduling details
scheduled_time = Column(DateTime, nullable=False)
timezone = Column(String, default="UTC")
recurrence_pattern = Column(String) # cron-like pattern for recurring tweets
# Automation settings
auto_optimize_time = Column(Boolean, default=False) # AI-optimize posting time
auto_add_hashtags = Column(Boolean, default=False)
auto_add_emojis = Column(Boolean, default=False)
# Status and execution
status = Column(Enum(TweetStatus), default=TweetStatus.SCHEDULED)
attempts = Column(Integer, default=0)
last_attempt = Column(DateTime)
error_message = Column(Text)
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser", back_populates="scheduled_tweets")
tweet = relationship("Tweet")
# Indexes
__table_args__ = (
Index('idx_scheduled_time', 'scheduled_time'),
Index('idx_scheduled_status', 'status'),
)
class TwitterAnalytics(Base):
"""
Stores aggregated Twitter analytics data for users.
Updated periodically to track account performance over time.
"""
__tablename__ = "twitter_analytics"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
# Time period
date = Column(DateTime, nullable=False)
timeframe = Column(Enum(AnalyticsTimeframe), nullable=False)
# Account metrics
followers_gained = Column(Integer, default=0)
followers_lost = Column(Integer, default=0)
net_follower_change = Column(Integer, default=0)
following_change = Column(Integer, default=0)
# Content metrics
tweets_posted = Column(Integer, default=0)
total_impressions = Column(Integer, default=0)
total_engagements = Column(Integer, default=0)
total_likes = Column(Integer, default=0)
total_retweets = Column(Integer, default=0)
total_replies = Column(Integer, default=0)
total_quotes = Column(Integer, default=0)
# Performance metrics
average_engagement_rate = Column(Float, default=0.0)
top_tweet_id = Column(BigInteger) # Best performing tweet
top_tweet_engagement = Column(Integer, default=0)
# Audience metrics
profile_visits = Column(Integer, default=0)
mention_count = Column(Integer, default=0)
hashtag_performance = Column(JSON, default=dict) # Top hashtags and their performance
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser", back_populates="analytics")
# Indexes
__table_args__ = (
Index('idx_analytics_user_date', 'user_id', 'date'),
Index('idx_analytics_timeframe', 'timeframe'),
UniqueConstraint('user_id', 'date', 'timeframe', name='uq_user_date_timeframe'),
)
class TweetAnalytics(Base):
"""
Stores detailed analytics for individual tweets.
Updated periodically to track tweet performance over time.
"""
__tablename__ = "tweet_analytics"
id = Column(Integer, primary_key=True)
tweet_id = Column(Integer, ForeignKey("tweets.id"), nullable=False)
# Time period
recorded_at = Column(DateTime, nullable=False, default=datetime.utcnow)
# Engagement metrics
likes = Column(Integer, default=0)
retweets = Column(Integer, default=0)
replies = Column(Integer, default=0)
quotes = Column(Integer, default=0)
bookmarks = Column(Integer, default=0)
# Reach metrics
impressions = Column(Integer, default=0)
reach = Column(Integer, default=0)
profile_clicks = Column(Integer, default=0)
# Click metrics
url_clicks = Column(Integer, default=0)
hashtag_clicks = Column(Integer, default=0)
mention_clicks = Column(Integer, default=0)
media_views = Column(Integer, default=0)
# Calculated metrics
engagement_rate = Column(Float, default=0.0)
click_through_rate = Column(Float, default=0.0)
virality_score = Column(Float, default=0.0) # Custom metric for viral potential
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
# Relationships
tweet = relationship("Tweet", back_populates="analytics")
# Indexes
__table_args__ = (
Index('idx_tweet_analytics_recorded', 'recorded_at'),
Index('idx_tweet_analytics_engagement', 'engagement_rate'),
)
class EngagementData(Base):
"""
Stores individual engagement events for detailed analysis.
"""
__tablename__ = "engagement_data"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
tweet_id = Column(Integer, ForeignKey("tweets.id"))
# Engagement details
engagement_type = Column(Enum(EngagementType), nullable=False)
engaging_user_id = Column(BigInteger) # Twitter ID of user who engaged
engaging_username = Column(String)
# Metadata
occurred_at = Column(DateTime, nullable=False)
created_at = Column(DateTime, default=datetime.utcnow)
# Relationships
user = relationship("TwitterUser", back_populates="engagement_data")
tweet = relationship("Tweet")
# Indexes
__table_args__ = (
Index('idx_engagement_user_type', 'user_id', 'engagement_type'),
Index('idx_engagement_occurred', 'occurred_at'),
)
class AudienceInsight(Base):
"""
Stores audience demographics and behavior insights.
"""
__tablename__ = "audience_insights"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
# Time period
date = Column(DateTime, nullable=False)
# Demographics (aggregated data)
top_locations = Column(JSON, default=list) # Top follower locations
age_demographics = Column(JSON, default=dict) # Age distribution
gender_demographics = Column(JSON, default=dict) # Gender distribution
language_demographics = Column(JSON, default=dict) # Language distribution
# Behavior insights
most_active_hours = Column(JSON, default=list) # When audience is most active
top_interests = Column(JSON, default=list) # Audience interests
engagement_patterns = Column(JSON, default=dict) # How audience engages
# Content preferences
preferred_content_types = Column(JSON, default=dict)
top_hashtags_used = Column(JSON, default=list)
response_rate_by_content = Column(JSON, default=dict)
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser", back_populates="audience_insights")
# Indexes
__table_args__ = (
Index('idx_audience_user_date', 'user_id', 'date'),
)
class HashtagPerformance(Base):
"""
Tracks performance of hashtags used by the user.
"""
__tablename__ = "hashtag_performance"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
# Hashtag details
hashtag = Column(String, nullable=False, index=True)
usage_count = Column(Integer, default=0)
# Performance metrics
total_impressions = Column(Integer, default=0)
total_engagements = Column(Integer, default=0)
average_engagement_rate = Column(Float, default=0.0)
# Best performing tweet with this hashtag
best_tweet_id = Column(Integer, ForeignKey("tweets.id"))
best_tweet_engagement = Column(Integer, default=0)
# Time tracking
first_used = Column(DateTime)
last_used = Column(DateTime)
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser")
best_tweet = relationship("Tweet")
# Indexes
__table_args__ = (
Index('idx_hashtag_user_performance', 'user_id', 'average_engagement_rate'),
UniqueConstraint('user_id', 'hashtag', name='uq_user_hashtag'),
)
class ContentTemplate(Base):
"""
Stores reusable tweet templates and AI prompts.
"""
__tablename__ = "content_templates"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False)
# Template details
name = Column(String, nullable=False)
description = Column(Text)
template_text = Column(Text, nullable=False)
category = Column(Enum(ContentCategory))
# Template variables and settings
variables = Column(JSON, default=list) # List of template variables
default_hashtags = Column(JSON, default=list)
suggested_times = Column(JSON, default=list) # Best times to post this type
# AI settings
ai_prompt = Column(Text) # AI prompt for generating content
ai_tone = Column(String) # Tone for AI generation
ai_target_audience = Column(String)
# Usage tracking
usage_count = Column(Integer, default=0)
last_used = Column(DateTime)
average_performance = Column(Float, default=0.0)
# Metadata
is_active = Column(Boolean, default=True)
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser")
# Indexes
__table_args__ = (
Index('idx_template_user_category', 'user_id', 'category'),
Index('idx_template_performance', 'average_performance'),
)
class TwitterSettings(Base):
"""
Stores user-specific Twitter settings and preferences.
"""
__tablename__ = "twitter_settings"
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("twitter_users.id"), nullable=False, unique=True)
# Posting preferences
default_hashtags = Column(JSON, default=list)
auto_add_hashtags = Column(Boolean, default=False)
auto_add_emojis = Column(Boolean, default=False)
max_hashtags_per_tweet = Column(Integer, default=2)
# Scheduling preferences
preferred_posting_times = Column(JSON, default=list)
timezone = Column(String, default="UTC")
auto_optimize_timing = Column(Boolean, default=False)
# AI preferences
ai_tone_preference = Column(String, default="casual")
ai_target_audience = Column(String, default="general")
ai_creativity_level = Column(Float, default=0.7) # 0-1 scale
# Analytics preferences
analytics_frequency = Column(String, default="daily") # hourly, daily, weekly
track_competitor_hashtags = Column(JSON, default=list)
notification_preferences = Column(JSON, default=dict)
# Content preferences
content_categories = Column(JSON, default=list) # Preferred content types
avoid_topics = Column(JSON, default=list) # Topics to avoid
brand_keywords = Column(JSON, default=list) # Brand-related keywords
# Automation settings
auto_retweet_keywords = Column(JSON, default=list)
auto_like_keywords = Column(JSON, default=list)
auto_follow_back = Column(Boolean, default=False)
# Metadata
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
user = relationship("TwitterUser")
# --- DATABASE FUNCTIONS ---
def get_twitter_engine(db_url: str = "sqlite:///twitter_data.db"):
"""Create and return database engine for Twitter data."""
return create_engine(db_url, echo=False)
def init_twitter_db(engine):
"""Initialize Twitter database tables."""
Base.metadata.create_all(engine)
def get_twitter_session(engine):
"""Create and return database session for Twitter data."""
Session = sessionmaker(bind=engine)
return Session()
def create_twitter_user(session, user_data: Dict[str, Any]) -> TwitterUser:
"""Create a new Twitter user record."""
twitter_user = TwitterUser(
user_id=user_data['user_id'],
twitter_user_id=user_data['twitter_user_id'],
username=user_data['username'],
display_name=user_data['display_name'],
bio=user_data.get('bio', ''),
location=user_data.get('location', ''),
website=user_data.get('website', ''),
profile_image_url=user_data.get('profile_image_url', ''),
banner_image_url=user_data.get('banner_image_url', ''),
followers_count=user_data.get('followers_count', 0),
following_count=user_data.get('following_count', 0),
tweet_count=user_data.get('tweet_count', 0),
verified=user_data.get('verified', False),
protected=user_data.get('protected', False),
created_at_twitter=user_data.get('created_at_twitter'),
credentials_encrypted=user_data.get('credentials_encrypted', ''),
)
session.add(twitter_user)
session.commit()
return twitter_user
def update_user_metrics(session, user_id: int, metrics: Dict[str, Any]):
"""Update user metrics from Twitter API."""
user = session.query(TwitterUser).filter_by(id=user_id).first()
if user:
user.followers_count = metrics.get('followers_count', user.followers_count)
user.following_count = metrics.get('following_count', user.following_count)
user.tweet_count = metrics.get('tweet_count', user.tweet_count)
user.last_sync = datetime.utcnow()
session.commit()
def create_tweet_record(session, tweet_data: Dict[str, Any]) -> Tweet:
"""Create a new tweet record."""
# Handle both 'text' and 'content' field names for compatibility
text_content = tweet_data.get('text') or tweet_data.get('content')
if not text_content:
raise ValueError("Tweet must have either 'text' or 'content' field")
tweet = Tweet(
user_id=tweet_data['user_id'],
tweet_id=tweet_data.get('tweet_id'),
text=text_content,
hashtags=tweet_data.get('hashtags', []),
mentions=tweet_data.get('mentions', []),
urls=tweet_data.get('urls', []),
media_urls=tweet_data.get('media_urls', []),
tweet_type=TweetType(tweet_data.get('tweet_type', 'original')),
status=TweetStatus(tweet_data.get('status', 'draft')),
category=ContentCategory(tweet_data['category']) if tweet_data.get('category') else None,
ai_generated=tweet_data.get('ai_generated', False),
ai_model_used=tweet_data.get('ai_model_used'),
ai_prompt=tweet_data.get('ai_prompt'),
ai_confidence_score=tweet_data.get('ai_confidence_score'),
generation_metadata=tweet_data.get('generation_metadata', {}),
scheduled_for=tweet_data.get('scheduled_for'),
posted_at=tweet_data.get('posted_at'),
thread_id=tweet_data.get('thread_id'),
thread_position=tweet_data.get('thread_position'),
parent_tweet_id=tweet_data.get('parent_tweet_id'),
)
session.add(tweet)
session.commit()
return tweet
def update_tweet_metrics(session, tweet_id: int, metrics: TweetMetrics):
"""Update tweet metrics from Twitter API."""
tweet = session.query(Tweet).filter_by(id=tweet_id).first()
if tweet:
tweet.likes_count = metrics.likes
tweet.retweets_count = metrics.retweets
tweet.replies_count = metrics.replies
tweet.quotes_count = metrics.quotes
tweet.bookmarks_count = metrics.bookmarks
tweet.impressions_count = metrics.impressions
tweet.engagement_rate = metrics.engagement_rate
tweet.reach = metrics.reach
tweet.last_metrics_update = datetime.utcnow()
session.commit()
# Also create analytics record
analytics = TweetAnalytics(
tweet_id=tweet_id,
likes=metrics.likes,
retweets=metrics.retweets,
replies=metrics.replies,
quotes=metrics.quotes,
bookmarks=metrics.bookmarks,
impressions=metrics.impressions,
reach=metrics.reach,
engagement_rate=metrics.engagement_rate,
click_through_rate=metrics.url_clicks / max(metrics.impressions, 1) * 100,
virality_score=calculate_virality_score(metrics)
)
session.add(analytics)
session.commit()
def calculate_virality_score(metrics: TweetMetrics) -> float:
"""Calculate a custom virality score based on engagement metrics."""
if metrics.impressions == 0:
return 0.0
# Weight different engagement types
engagement_score = (
metrics.likes * 1.0 +
metrics.retweets * 3.0 + # Retweets are more valuable
metrics.replies * 2.0 +
metrics.quotes * 2.5 +
metrics.bookmarks * 1.5
)
# Normalize by impressions and scale
virality = (engagement_score / metrics.impressions) * 100
return min(virality, 100.0) # Cap at 100
def get_user_analytics_summary(session, user_id: int, days: int = 30) -> Dict[str, Any]:
"""Get analytics summary for a user over specified days."""
from sqlalchemy import func
start_date = datetime.utcnow() - timedelta(days=days)
# Get tweet metrics
tweet_stats = session.query(
func.count(Tweet.id).label('total_tweets'),
func.avg(Tweet.engagement_rate).label('avg_engagement'),
func.sum(Tweet.likes_count).label('total_likes'),
func.sum(Tweet.retweets_count).label('total_retweets'),
func.sum(Tweet.impressions_count).label('total_impressions')
).filter(
Tweet.user_id == user_id,
Tweet.posted_at >= start_date,
Tweet.status == TweetStatus.POSTED
).first()
# Get follower growth
user = session.query(TwitterUser).filter_by(id=user_id).first()
return {
'total_tweets': tweet_stats.total_tweets or 0,
'average_engagement_rate': float(tweet_stats.avg_engagement or 0),
'total_likes': tweet_stats.total_likes or 0,
'total_retweets': tweet_stats.total_retweets or 0,
'total_impressions': tweet_stats.total_impressions or 0,
'current_followers': user.followers_count if user else 0,
'period_days': days
}
# Export all models and functions
__all__ = [
# Models
'TwitterUser', 'Tweet', 'ScheduledTweet', 'TwitterAnalytics', 'TweetAnalytics',
'EngagementData', 'AudienceInsight', 'HashtagPerformance', 'ContentTemplate',
'TwitterSettings',
# Enums
'TwitterAccountType', 'TweetType', 'TweetStatus', 'EngagementType',
'AnalyticsTimeframe', 'ContentCategory',
# Dataclasses
'TwitterCredentials', 'TweetMetrics',
# Functions
'get_twitter_engine', 'init_twitter_db', 'get_twitter_session',
'create_twitter_user', 'update_user_metrics', 'create_tweet_record',
'update_tweet_metrics', 'calculate_virality_score', 'get_user_analytics_summary'
]

766
lib/database/twitter_service.py Normal file
View File

@@ -0,0 +1,766 @@
"""
Twitter Database Service Layer
=============================
This module provides high-level service functions for managing Twitter data
in the database. It acts as an interface between the application and the
database models, providing convenient methods for common operations.
Key Features:
- User profile management and synchronization
- Tweet creation, updating, and analytics tracking
- Scheduled tweet management
- Analytics data aggregation and reporting
- Hashtag performance tracking
- Audience insights management
"""
import logging
from typing import Dict, List, Any, Optional, Tuple
from datetime import datetime, timedelta
from sqlalchemy.orm import Session
from sqlalchemy import func, desc, and_, or_
import json
from cryptography.fernet import Fernet
import os
from .twitter_models import (
TwitterUser, Tweet, ScheduledTweet, TwitterAnalytics, TweetAnalytics,
EngagementData, AudienceInsight, HashtagPerformance, ContentTemplate,
TwitterSettings, TwitterCredentials, TweetMetrics,
TwitterAccountType, TweetType, TweetStatus, EngagementType,
AnalyticsTimeframe, ContentCategory,
get_twitter_engine, init_twitter_db, get_twitter_session,
create_twitter_user, update_user_metrics, create_tweet_record,
update_tweet_metrics, calculate_virality_score, get_user_analytics_summary
)
# Configure logging
logger = logging.getLogger(__name__)
class TwitterDatabaseService:
"""
High-level service for managing Twitter data in the database.
"""
def __init__(self, db_url: str = "sqlite:///twitter_data.db", encryption_key: Optional[str] = None):
"""Initialize the Twitter database service."""
self.engine = get_twitter_engine(db_url)
self.encryption_key = encryption_key or self._get_or_create_encryption_key()
self.cipher = Fernet(self.encryption_key.encode() if isinstance(self.encryption_key, str) else self.encryption_key)
# Initialize database
init_twitter_db(self.engine)
logger.info("Twitter database service initialized")
def _get_or_create_encryption_key(self) -> str:
"""Get or create encryption key for sensitive data."""
key_file = "twitter_encryption.key"
if os.path.exists(key_file):
with open(key_file, 'rb') as f:
return f.read()
else:
key = Fernet.generate_key()
with open(key_file, 'wb') as f:
f.write(key)
return key
def _encrypt_credentials(self, credentials: TwitterCredentials) -> str:
"""Encrypt Twitter credentials for secure storage."""
credentials_json = json.dumps(credentials.to_dict())
encrypted = self.cipher.encrypt(credentials_json.encode())
return encrypted.decode()
def _decrypt_credentials(self, encrypted_credentials: str) -> TwitterCredentials:
"""Decrypt Twitter credentials from storage."""
try:
decrypted = self.cipher.decrypt(encrypted_credentials.encode())
credentials_dict = json.loads(decrypted.decode())
return TwitterCredentials.from_dict(credentials_dict)
except Exception as e:
logger.error(f"Failed to decrypt credentials: {e}")
return TwitterCredentials()
def get_session(self) -> Session:
"""Get a database session."""
return get_twitter_session(self.engine)
# --- USER MANAGEMENT ---
def create_or_update_user(self, user_data: Dict[str, Any]) -> TwitterUser:
"""Create a new Twitter user or update existing one."""
session = self.get_session()
try:
# Check if user already exists
existing_user = session.query(TwitterUser).filter_by(
user_id=user_data['user_id']
).first()
if existing_user:
# Update existing user
for key, value in user_data.items():
if hasattr(existing_user, key) and key != 'id':
setattr(existing_user, key, value)
existing_user.updated_at = datetime.utcnow()
session.commit()
logger.info(f"Updated Twitter user: {existing_user.username}")
return existing_user
else:
# Create new user
twitter_user = create_twitter_user(session, user_data)
logger.info(f"Created new Twitter user: {twitter_user.username}")
return twitter_user
except Exception as e:
session.rollback()
logger.error(f"Error creating/updating user: {e}")
raise
finally:
session.close()
def save_user_credentials(self, user_id: str, credentials: TwitterCredentials) -> bool:
"""Save encrypted Twitter credentials for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if user:
encrypted_creds = self._encrypt_credentials(credentials)
user.credentials_encrypted = encrypted_creds
user.updated_at = datetime.utcnow()
session.commit()
logger.info(f"Saved credentials for user: {user.username}")
return True
else:
logger.error(f"User not found: {user_id}")
return False
except Exception as e:
session.rollback()
logger.error(f"Error saving credentials: {e}")
return False
finally:
session.close()
def get_user_credentials(self, user_id: str) -> Optional[TwitterCredentials]:
"""Get decrypted Twitter credentials for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if user and user.credentials_encrypted:
return self._decrypt_credentials(user.credentials_encrypted)
return None
except Exception as e:
logger.error(f"Error getting credentials: {e}")
return None
finally:
session.close()
def get_user_by_id(self, user_id: str) -> Optional[TwitterUser]:
"""Get Twitter user by ALwrity user ID."""
session = self.get_session()
try:
return session.query(TwitterUser).filter_by(user_id=user_id).first()
finally:
session.close()
def get_user_by_twitter_id(self, twitter_user_id: int) -> Optional[TwitterUser]:
"""Get Twitter user by Twitter user ID."""
session = self.get_session()
try:
return session.query(TwitterUser).filter_by(twitter_user_id=twitter_user_id).first()
finally:
session.close()
def update_user_profile(self, user_id: str, profile_data: Dict[str, Any]) -> bool:
"""Update user profile information from Twitter API."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if user:
update_user_metrics(session, user.id, profile_data)
logger.info(f"Updated profile for user: {user.username}")
return True
return False
except Exception as e:
session.rollback()
logger.error(f"Error updating user profile: {e}")
return False
finally:
session.close()
# --- TWEET MANAGEMENT ---
def save_tweet(self, tweet_data: Dict[str, Any]) -> Tweet:
"""Save a tweet to the database."""
session = self.get_session()
try:
tweet = create_tweet_record(session, tweet_data)
logger.info(f"Saved tweet: {tweet.id}")
return tweet
except Exception as e:
session.rollback()
logger.error(f"Error saving tweet: {e}")
raise
finally:
session.close()
def update_tweet_status(self, tweet_id: int, status: TweetStatus, twitter_tweet_id: Optional[int] = None) -> bool:
"""Update tweet status (e.g., from draft to posted)."""
session = self.get_session()
try:
tweet = session.query(Tweet).filter_by(id=tweet_id).first()
if tweet:
tweet.status = status
if twitter_tweet_id:
tweet.tweet_id = twitter_tweet_id
if status == TweetStatus.POSTED:
tweet.posted_at = datetime.utcnow()
tweet.updated_at = datetime.utcnow()
session.commit()
logger.info(f"Updated tweet {tweet_id} status to {status.value}")
return True
return False
except Exception as e:
session.rollback()
logger.error(f"Error updating tweet status: {e}")
return False
finally:
session.close()
def get_user_tweets(self, user_id: str, status: Optional[TweetStatus] = None, limit: int = 50) -> List[Tweet]:
"""Get tweets for a user, optionally filtered by status."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return []
query = session.query(Tweet).filter_by(user_id=user.id)
if status:
query = query.filter_by(status=status)
return query.order_by(desc(Tweet.created_at)).limit(limit).all()
finally:
session.close()
def get_tweet_by_id(self, tweet_id: int) -> Optional[Tweet]:
"""Get tweet by database ID."""
session = self.get_session()
try:
return session.query(Tweet).filter_by(id=tweet_id).first()
finally:
session.close()
def get_tweet_by_twitter_id(self, twitter_tweet_id: int) -> Optional[Tweet]:
"""Get tweet by Twitter tweet ID."""
session = self.get_session()
try:
return session.query(Tweet).filter_by(tweet_id=twitter_tweet_id).first()
finally:
session.close()
def update_tweet_analytics(self, tweet_id: int, metrics: TweetMetrics) -> bool:
"""Update tweet analytics from Twitter API."""
session = self.get_session()
try:
update_tweet_metrics(session, tweet_id, metrics)
logger.info(f"Updated analytics for tweet: {tweet_id}")
return True
except Exception as e:
session.rollback()
logger.error(f"Error updating tweet analytics: {e}")
return False
finally:
session.close()
def get_top_performing_tweets(self, user_id: str, days: int = 30, limit: int = 10) -> List[Tweet]:
"""Get top performing tweets for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return []
start_date = datetime.utcnow() - timedelta(days=days)
return session.query(Tweet).filter(
and_(
Tweet.user_id == user.id,
Tweet.status == TweetStatus.POSTED,
Tweet.posted_at >= start_date
)
).order_by(desc(Tweet.engagement_rate)).limit(limit).all()
finally:
session.close()
# --- SCHEDULED TWEETS ---
def schedule_tweet(self, tweet_id: int, scheduled_time: datetime, settings: Dict[str, Any] = None) -> ScheduledTweet:
"""Schedule a tweet for posting."""
session = self.get_session()
try:
tweet = session.query(Tweet).filter_by(id=tweet_id).first()
if not tweet:
raise ValueError(f"Tweet {tweet_id} not found")
scheduled_tweet = ScheduledTweet(
user_id=tweet.user_id,
tweet_id=tweet_id,
scheduled_time=scheduled_time,
timezone=settings.get('timezone', 'UTC'),
auto_optimize_time=settings.get('auto_optimize_time', False),
auto_add_hashtags=settings.get('auto_add_hashtags', False),
auto_add_emojis=settings.get('auto_add_emojis', False)
)
session.add(scheduled_tweet)
# Update tweet status
tweet.status = TweetStatus.SCHEDULED
tweet.scheduled_for = scheduled_time
session.commit()
logger.info(f"Scheduled tweet {tweet_id} for {scheduled_time}")
return scheduled_tweet
except Exception as e:
session.rollback()
logger.error(f"Error scheduling tweet: {e}")
raise
finally:
session.close()
def get_pending_scheduled_tweets(self, user_id: Optional[str] = None) -> List[ScheduledTweet]:
"""Get tweets scheduled for posting."""
session = self.get_session()
try:
query = session.query(ScheduledTweet).filter(
and_(
ScheduledTweet.status == TweetStatus.SCHEDULED,
ScheduledTweet.scheduled_time <= datetime.utcnow()
)
)
if user_id:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if user:
query = query.filter_by(user_id=user.id)
return query.order_by(ScheduledTweet.scheduled_time).all()
finally:
session.close()
def mark_scheduled_tweet_posted(self, scheduled_tweet_id: int, twitter_tweet_id: int) -> bool:
"""Mark a scheduled tweet as posted."""
session = self.get_session()
try:
scheduled_tweet = session.query(ScheduledTweet).filter_by(id=scheduled_tweet_id).first()
if scheduled_tweet:
scheduled_tweet.status = TweetStatus.POSTED
# Update the associated tweet
tweet = session.query(Tweet).filter_by(id=scheduled_tweet.tweet_id).first()
if tweet:
tweet.status = TweetStatus.POSTED
tweet.tweet_id = twitter_tweet_id
tweet.posted_at = datetime.utcnow()
session.commit()
logger.info(f"Marked scheduled tweet {scheduled_tweet_id} as posted")
return True
return False
except Exception as e:
session.rollback()
logger.error(f"Error marking scheduled tweet as posted: {e}")
return False
finally:
session.close()
# --- ANALYTICS ---
def save_daily_analytics(self, user_id: str, analytics_data: Dict[str, Any]) -> TwitterAnalytics:
"""Save daily analytics data for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
raise ValueError(f"User {user_id} not found")
# Check if analytics for today already exist
today = datetime.utcnow().date()
existing = session.query(TwitterAnalytics).filter(
and_(
TwitterAnalytics.user_id == user.id,
func.date(TwitterAnalytics.date) == today,
TwitterAnalytics.timeframe == AnalyticsTimeframe.DAILY
)
).first()
if existing:
# Update existing record
for key, value in analytics_data.items():
if hasattr(existing, key):
setattr(existing, key, value)
existing.updated_at = datetime.utcnow()
session.commit()
return existing
else:
# Create new record
analytics = TwitterAnalytics(
user_id=user.id,
date=datetime.utcnow(),
timeframe=AnalyticsTimeframe.DAILY,
**analytics_data
)
session.add(analytics)
session.commit()
logger.info(f"Saved daily analytics for user: {user.username}")
return analytics
except Exception as e:
session.rollback()
logger.error(f"Error saving analytics: {e}")
raise
finally:
session.close()
def get_analytics_summary(self, user_id: str, days: int = 30) -> Dict[str, Any]:
"""Get comprehensive analytics summary for a user."""
session = self.get_session()
try:
return get_user_analytics_summary(session, user_id, days)
finally:
session.close()
def get_engagement_trends(self, user_id: str, days: int = 30) -> List[Dict[str, Any]]:
"""Get engagement trends over time."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return []
start_date = datetime.utcnow() - timedelta(days=days)
analytics = session.query(TwitterAnalytics).filter(
and_(
TwitterAnalytics.user_id == user.id,
TwitterAnalytics.date >= start_date,
TwitterAnalytics.timeframe == AnalyticsTimeframe.DAILY
)
).order_by(TwitterAnalytics.date).all()
return [
{
'date': a.date.isoformat(),
'engagement_rate': a.average_engagement_rate,
'total_engagements': a.total_engagements,
'impressions': a.total_impressions,
'followers_change': a.net_follower_change
}
for a in analytics
]
finally:
session.close()
# --- HASHTAG PERFORMANCE ---
def track_hashtag_performance(self, user_id: str, hashtag: str, tweet_id: int, engagement_metrics: Dict[str, Any]) -> bool:
"""Track performance of a hashtag."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return False
# Get or create hashtag performance record
hashtag_perf = session.query(HashtagPerformance).filter(
and_(
HashtagPerformance.user_id == user.id,
HashtagPerformance.hashtag == hashtag
)
).first()
if hashtag_perf:
# Update existing record
hashtag_perf.usage_count += 1
hashtag_perf.total_impressions += engagement_metrics.get('impressions', 0)
hashtag_perf.total_engagements += engagement_metrics.get('engagements', 0)
hashtag_perf.last_used = datetime.utcnow()
# Update average engagement rate
if hashtag_perf.usage_count > 0:
hashtag_perf.average_engagement_rate = (
hashtag_perf.total_engagements / hashtag_perf.total_impressions * 100
if hashtag_perf.total_impressions > 0 else 0
)
# Update best performing tweet if this one is better
current_engagement = engagement_metrics.get('engagements', 0)
if current_engagement > hashtag_perf.best_tweet_engagement:
hashtag_perf.best_tweet_id = tweet_id
hashtag_perf.best_tweet_engagement = current_engagement
else:
# Create new record
hashtag_perf = HashtagPerformance(
user_id=user.id,
hashtag=hashtag,
usage_count=1,
total_impressions=engagement_metrics.get('impressions', 0),
total_engagements=engagement_metrics.get('engagements', 0),
average_engagement_rate=(
engagement_metrics.get('engagements', 0) /
max(engagement_metrics.get('impressions', 1), 1) * 100
),
best_tweet_id=tweet_id,
best_tweet_engagement=engagement_metrics.get('engagements', 0),
first_used=datetime.utcnow(),
last_used=datetime.utcnow()
)
session.add(hashtag_perf)
session.commit()
return True
except Exception as e:
session.rollback()
logger.error(f"Error tracking hashtag performance: {e}")
return False
finally:
session.close()
def get_top_hashtags(self, user_id: str, limit: int = 10) -> List[HashtagPerformance]:
"""Get top performing hashtags for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return []
return session.query(HashtagPerformance).filter_by(
user_id=user.id
).order_by(desc(HashtagPerformance.average_engagement_rate)).limit(limit).all()
finally:
session.close()
# --- CONTENT TEMPLATES ---
def save_content_template(self, user_id: str, template_data: Dict[str, Any]) -> ContentTemplate:
"""Save a content template."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
raise ValueError(f"User {user_id} not found")
template = ContentTemplate(
user_id=user.id,
name=template_data['name'],
description=template_data.get('description', ''),
template_text=template_data['template_text'],
category=ContentCategory(template_data['category']) if template_data.get('category') else None,
variables=template_data.get('variables', []),
default_hashtags=template_data.get('default_hashtags', []),
ai_prompt=template_data.get('ai_prompt', ''),
ai_tone=template_data.get('ai_tone', ''),
ai_target_audience=template_data.get('ai_target_audience', '')
)
session.add(template)
session.commit()
logger.info(f"Saved content template: {template.name}")
return template
except Exception as e:
session.rollback()
logger.error(f"Error saving content template: {e}")
raise
finally:
session.close()
def get_user_templates(self, user_id: str, category: Optional[ContentCategory] = None) -> List[ContentTemplate]:
"""Get content templates for a user."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return []
query = session.query(ContentTemplate).filter(
and_(
ContentTemplate.user_id == user.id,
ContentTemplate.is_active == True
)
)
if category:
query = query.filter_by(category=category)
return query.order_by(desc(ContentTemplate.average_performance)).all()
finally:
session.close()
# --- SETTINGS ---
def save_user_settings(self, user_id: str, settings_data: Dict[str, Any]) -> TwitterSettings:
"""Save user Twitter settings."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
raise ValueError(f"User {user_id} not found")
# Check if settings already exist
existing_settings = session.query(TwitterSettings).filter_by(user_id=user.id).first()
if existing_settings:
# Update existing settings
for key, value in settings_data.items():
if hasattr(existing_settings, key):
setattr(existing_settings, key, value)
existing_settings.updated_at = datetime.utcnow()
session.commit()
return existing_settings
else:
# Create new settings
settings = TwitterSettings(
user_id=user.id,
**settings_data
)
session.add(settings)
session.commit()
logger.info(f"Saved settings for user: {user.username}")
return settings
except Exception as e:
session.rollback()
logger.error(f"Error saving user settings: {e}")
raise
finally:
session.close()
def get_user_settings(self, user_id: str) -> Optional[TwitterSettings]:
"""Get user Twitter settings."""
session = self.get_session()
try:
user = session.query(TwitterUser).filter_by(user_id=user_id).first()
if not user:
return None
return session.query(TwitterSettings).filter_by(user_id=user.id).first()
finally:
session.close()
# --- UTILITY METHODS ---
def cleanup_old_data(self, days_old: int = 30) -> Dict[str, int]:
"""
Clean up old data to maintain database performance.
Args:
days_old: Number of days old data to keep
Returns:
Dictionary with cleanup statistics
"""
try:
cutoff_date = datetime.utcnow() - timedelta(days=days_old)
with self.get_session() as session:
# Clean up old analytics data
old_analytics = session.query(TwitterAnalytics).filter(
TwitterAnalytics.created_at < cutoff_date
).count()
session.query(TwitterAnalytics).filter(
TwitterAnalytics.created_at < cutoff_date
).delete()
# Clean up old tweet analytics
old_tweet_analytics = session.query(TweetAnalytics).filter(
TweetAnalytics.created_at < cutoff_date
).count()
session.query(TweetAnalytics).filter(
TweetAnalytics.created_at < cutoff_date
).delete()
session.commit()
stats = {
'old_analytics_removed': old_analytics,
'old_tweet_analytics_removed': old_tweet_analytics,
'cutoff_date': cutoff_date.isoformat()
}
logger.info(f"Cleaned up old data: {stats}")
return stats
except Exception as e:
logger.error(f"Error cleaning up old data: {e}")
return {'error': str(e)}
def get_database_stats(self) -> Dict[str, int]:
"""
Get database statistics.
Returns:
Dictionary with database statistics
"""
try:
with self.get_session() as session:
stats = {
'total_users': session.query(TwitterUser).count(),
'total_tweets': session.query(Tweet).count(),
'posted_tweets': session.query(Tweet).filter(
Tweet.status == TweetStatus.POSTED
).count(),
'scheduled_tweets': session.query(ScheduledTweet).filter(
ScheduledTweet.status == TweetStatus.SCHEDULED
).count(),
'total_analytics_records': session.query(TwitterAnalytics).count(),
'total_templates': session.query(ContentTemplate).count()
}
return stats
except Exception as e:
logger.error(f"Error getting database stats: {e}")
return {'error': str(e)}
def close(self):
"""
Close database connections and clean up resources.
"""
try:
if hasattr(self, 'engine') and self.engine:
self.engine.dispose()
logger.info("Database connections closed successfully")
except Exception as e:
logger.error(f"Error closing database connections: {e}")
# Create a global instance for easy access
twitter_db = TwitterDatabaseService()
# Export the service and key functions
__all__ = [
'TwitterDatabaseService',
'twitter_db'
]

485
lib/integrations/platform_adapters/twitter.py
View File

@@ -1,26 +1,32 @@
"""
Twitter platform adapter implementation.
Twitter platform adapter implementation with enhanced error handling and real metrics.
"""
from typing import Dict, Any, Optional, List
from datetime import datetime
import tweepy
from tweepy.models import Status
import logging
import time
from .base import PlatformAdapter
logger = logging.getLogger(__name__)
class TwitterAdapter(PlatformAdapter):
"""Twitter platform adapter."""
"""Enhanced Twitter platform adapter with real metrics and error handling."""
def __init__(self, config: Dict[str, Any]):
"""Initialize Twitter adapter with configuration."""
super().__init__(config)
self._validate_config()
self._initialize_client()
self.rate_limit_tracker = {}
def _initialize_client(self) -> None:
"""Initialize Twitter API client."""
"""Initialize Twitter API client with enhanced error handling."""
try:
# Initialize OAuth handler
auth = tweepy.OAuthHandler(
self.config['api_key'],
self.config['api_secret']
@@ -29,31 +35,54 @@ class TwitterAdapter(PlatformAdapter):
self.config['access_token'],
self.config['access_token_secret']
)
self.client = tweepy.API(auth)
self.client.verify_credentials()
except Exception as e:
raise Exception(
f"Failed to initialize Twitter client: {str(e)}"
# Create API client with wait_on_rate_limit
self.client = tweepy.API(
auth,
wait_on_rate_limit=True,
retry_count=3,
retry_delay=5
)
# Verify credentials
user = self.client.verify_credentials()
if not user:
raise Exception("Failed to verify Twitter credentials")
logger.info(f"Twitter client initialized for @{user.screen_name}")
except tweepy.Unauthorized:
raise Exception("Invalid Twitter API credentials")
except tweepy.Forbidden:
raise Exception("Access forbidden - check API permissions")
except Exception as e:
raise Exception(f"Failed to initialize Twitter client: {str(e)}")
async def publish_content(
self,
content: Dict[str, Any],
schedule_time: Optional[datetime] = None
) -> Dict[str, Any]:
"""Publish content to Twitter."""
"""Publish content to Twitter with enhanced error handling."""
try:
# Validate content
# Validate content first
validation = await self.validate_content(content)
if not validation.get('success'):
return validation
# Check rate limits
if not self._check_rate_limit('tweets'):
return self._format_error_response(
Exception("Rate limit exceeded for tweets"),
{'content': content}
)
# Prepare tweet content
tweet_text = content.get('text', '')
media_ids = []
# Handle media attachments if present
if 'media' in content:
if 'media' in content and content['media']:
for media in content['media']:
media_id = self._upload_media(media)
if media_id:
@@ -65,37 +94,348 @@ class TwitterAdapter(PlatformAdapter):
media_ids=media_ids if media_ids else None
)
return self._format_success_response({
'id': tweet.id_str,
'text': tweet.text,
'created_at': tweet.created_at.isoformat()
})
# Update rate limit tracker
self._update_rate_limit_tracker('tweets')
except Exception as e:
return self._format_error_response(
e,
{'content': content, 'schedule_time': schedule_time}
)
async def get_content_status(
self,
content_id: str
) -> Dict[str, Any]:
"""Get status of a tweet."""
try:
tweet = self.client.get_status(content_id)
return self._format_success_response({
# Format response with comprehensive data
tweet_data = {
'id': tweet.id_str,
'text': tweet.text,
'created_at': tweet.created_at.isoformat(),
'favorite_count': tweet.favorite_count,
'retweet_count': tweet.retweet_count
})
except Exception as e:
'user': {
'screen_name': tweet.user.screen_name,
'name': tweet.user.name,
'followers_count': tweet.user.followers_count
},
'metrics': {
'retweet_count': tweet.retweet_count,
'favorite_count': tweet.favorite_count,
'reply_count': getattr(tweet, 'reply_count', 0)
},
'urls': {
'tweet_url': f"https://twitter.com/{tweet.user.screen_name}/status/{tweet.id_str}"
}
}
return self._format_success_response(tweet_data)
except tweepy.Unauthorized:
return self._format_error_response(
e,
Exception("Authentication failed - please reconnect your account"),
{'content': content}
)
except tweepy.Forbidden as e:
error_msg = "Access forbidden"
if "duplicate" in str(e).lower():
error_msg = "Duplicate tweet detected - please modify your content"
elif "automated" in str(e).lower():
error_msg = "Tweet appears automated - please make it more personal"
return self._format_error_response(
Exception(error_msg),
{'content': content}
)
except tweepy.TooManyRequests:
return self._format_error_response(
Exception("Rate limit exceeded - please wait before posting again"),
{'content': content}
)
except Exception as e:
return self._format_error_response(e, {'content': content})
async def get_content_status(self, content_id: str) -> Dict[str, Any]:
"""Get status of a tweet with real metrics."""
try:
tweet = self.client.get_status(
content_id,
include_entities=True,
tweet_mode='extended'
)
tweet_data = {
'id': tweet.id_str,
'text': tweet.full_text,
'created_at': tweet.created_at.isoformat(),
'metrics': {
'retweet_count': tweet.retweet_count,
'favorite_count': tweet.favorite_count,
'reply_count': getattr(tweet, 'reply_count', 0),
'quote_count': getattr(tweet, 'quote_count', 0)
},
'engagement': {
'engagement_rate': self._calculate_engagement_rate(tweet),
'total_engagement': tweet.retweet_count + tweet.favorite_count + getattr(tweet, 'reply_count', 0)
},
'user': {
'screen_name': tweet.user.screen_name,
'followers_count': tweet.user.followers_count
}
}
return self._format_success_response(tweet_data)
except tweepy.NotFound:
return self._format_error_response(
Exception("Tweet not found - it may have been deleted"),
{'content_id': content_id}
)
except Exception as e:
return self._format_error_response(e, {'content_id': content_id})
async def get_analytics(
self,
content_id: str,
start_date: Optional[datetime] = None,
end_date: Optional[datetime] = None
) -> Dict[str, Any]:
"""Get comprehensive analytics for a tweet."""
try:
# Get tweet details
tweet = self.client.get_status(
content_id,
include_entities=True,
tweet_mode='extended'
)
# Calculate engagement metrics
total_engagement = (
tweet.retweet_count +
tweet.favorite_count +
getattr(tweet, 'reply_count', 0) +
getattr(tweet, 'quote_count', 0)
)
engagement_rate = self._calculate_engagement_rate(tweet)
# Get time-based metrics (if tweet is recent)
time_metrics = self._calculate_time_metrics(tweet)
analytics_data = {
'tweet_id': tweet.id_str,
'metrics': {
'likes': tweet.favorite_count,
'retweets': tweet.retweet_count,
'replies': getattr(tweet, 'reply_count', 0),
'quotes': getattr(tweet, 'quote_count', 0),
'total_engagement': total_engagement,
'impressions': getattr(tweet, 'impression_count', 0) # May not be available
},
'engagement': {
'engagement_rate': engagement_rate,
'likes_rate': (tweet.favorite_count / tweet.user.followers_count * 100) if tweet.user.followers_count > 0 else 0,
'retweets_rate': (tweet.retweet_count / tweet.user.followers_count * 100) if tweet.user.followers_count > 0 else 0
},
'timing': time_metrics,
'audience': {
'followers_at_post': tweet.user.followers_count,
'reach_percentage': (total_engagement / tweet.user.followers_count * 100) if tweet.user.followers_count > 0 else 0
},
'content_analysis': {
'character_count': len(tweet.full_text),
'hashtag_count': len([entity for entity in tweet.entities.get('hashtags', [])]),
'mention_count': len([entity for entity in tweet.entities.get('user_mentions', [])]),
'url_count': len([entity for entity in tweet.entities.get('urls', [])])
}
}
return self._format_success_response(analytics_data)
except Exception as e:
return self._format_error_response(e, {
'content_id': content_id,
'start_date': start_date,
'end_date': end_date
})
async def validate_content(self, content: Dict[str, Any]) -> Dict[str, Any]:
"""Enhanced content validation."""
try:
errors = []
warnings = []
# Check text
text = content.get('text', '')
if not text.strip():
errors.append("Tweet text cannot be empty")
# Check length
if len(text) > 280:
errors.append(f"Tweet text exceeds 280 characters ({len(text)}/280)")
elif len(text) > 270:
warnings.append("Tweet is close to character limit")
# Check for very short tweets
if len(text) < 10:
warnings.append("Very short tweets may get less engagement")
# Check media
media = content.get('media', [])
if len(media) > 4:
errors.append("Maximum 4 media attachments allowed")
# Check for spam indicators
if text.count('#') > 3:
warnings.append("Too many hashtags may reduce engagement")
if text.count('@') > 5:
warnings.append("Too many mentions may appear spammy")
# Check for duplicate content (basic check)
if self._is_potential_duplicate(text):
warnings.append("Content may be similar to recent tweets")
if errors:
return self._format_error_response(
ValueError(f"Validation failed: {'; '.join(errors)}"),
{'content': content, 'warnings': warnings}
)
validation_data = {
'valid': True,
'content': content,
'warnings': warnings,
'suggestions': self._get_content_suggestions(text)
}
return self._format_success_response(validation_data)
except Exception as e:
return self._format_error_response(e, {'content': content})
def _calculate_engagement_rate(self, tweet: Status) -> float:
"""Calculate engagement rate for a tweet."""
try:
total_engagement = (
tweet.favorite_count +
tweet.retweet_count +
getattr(tweet, 'reply_count', 0) +
getattr(tweet, 'quote_count', 0)
)
followers = tweet.user.followers_count
return (total_engagement / followers * 100) if followers > 0 else 0.0
except Exception:
return 0.0
def _calculate_time_metrics(self, tweet: Status) -> Dict[str, Any]:
"""Calculate time-based metrics for a tweet."""
try:
now = datetime.now()
tweet_time = tweet.created_at.replace(tzinfo=None)
age_hours = (now - tweet_time).total_seconds() / 3600
# Calculate engagement velocity (engagement per hour)
total_engagement = (
tweet.favorite_count +
tweet.retweet_count +
getattr(tweet, 'reply_count', 0)
)
engagement_velocity = total_engagement / max(age_hours, 1)
return {
'age_hours': round(age_hours, 2),
'engagement_velocity': round(engagement_velocity, 2),
'peak_engagement_period': self._estimate_peak_period(tweet_time),
'posted_at': tweet_time.isoformat()
}
except Exception:
return {}
def _estimate_peak_period(self, tweet_time: datetime) -> str:
"""Estimate if tweet was posted during peak engagement period."""
hour = tweet_time.hour
if 9 <= hour <= 10:
return "Morning Peak (9-10 AM)"
elif 12 <= hour <= 13:
return "Lunch Peak (12-1 PM)"
elif 19 <= hour <= 21:
return "Evening Peak (7-9 PM)"
else:
return "Off-Peak Hours"
def _check_rate_limit(self, endpoint: str) -> bool:
"""Check if we're within rate limits for an endpoint."""
try:
rate_limits = self.client.get_rate_limit_status()
endpoint_map = {
'tweets': '/statuses/update',
'user_timeline': '/statuses/user_timeline',
'verify_credentials': '/account/verify_credentials'
}
if endpoint in endpoint_map:
limit_info = rate_limits['resources']['statuses'].get(endpoint_map[endpoint])
if limit_info:
return limit_info['remaining'] > 0
return True # Default to allowing if we can't check
except Exception:
return True # Default to allowing if check fails
def _update_rate_limit_tracker(self, endpoint: str) -> None:
"""Update internal rate limit tracker."""
now = time.time()
if endpoint not in self.rate_limit_tracker:
self.rate_limit_tracker[endpoint] = []
# Add current request
self.rate_limit_tracker[endpoint].append(now)
# Clean old requests (older than 15 minutes)
self.rate_limit_tracker[endpoint] = [
timestamp for timestamp in self.rate_limit_tracker[endpoint]
if now - timestamp < 900 # 15 minutes
]
def _is_potential_duplicate(self, text: str) -> bool:
"""Basic check for potential duplicate content."""
# This is a simplified check - in production, you'd want more sophisticated detection
try:
# Get recent tweets from user
recent_tweets = self.client.user_timeline(count=20, tweet_mode='extended')
for tweet in recent_tweets:
# Simple similarity check
if self._calculate_text_similarity(text, tweet.full_text) > 0.8:
return True
return False
except Exception:
return False # If we can't check, assume it's not a duplicate
def _calculate_text_similarity(self, text1: str, text2: str) -> float:
"""Calculate simple text similarity."""
# Simple word-based similarity
words1 = set(text1.lower().split())
words2 = set(text2.lower().split())
if not words1 or not words2:
return 0.0
intersection = words1.intersection(words2)
union = words1.union(words2)
return len(intersection) / len(union) if union else 0.0
def _get_content_suggestions(self, text: str) -> List[str]:
"""Get suggestions for improving tweet content."""
suggestions = []
if len(text) < 50:
suggestions.append("Consider adding more context to increase engagement")
if not any(char in text for char in '!?'):
suggestions.append("Adding punctuation can make tweets more engaging")
if '#' not in text:
suggestions.append("Consider adding 1-2 relevant hashtags")
if not any(emoji_char in text for emoji_char in '😀😃😄😁😆😅😂🤣'):
suggestions.append("Emojis can increase engagement and visual appeal")
return suggestions
async def delete_content(
self,
@@ -134,68 +474,6 @@ class TwitterAdapter(PlatformAdapter):
}
)
async def get_analytics(
self,
content_id: str,
start_date: Optional[datetime] = None,
end_date: Optional[datetime] = None
) -> Dict[str, Any]:
"""Get analytics for a tweet."""
try:
tweet = self.client.get_status(content_id)
return self._format_success_response({
'id': tweet.id_str,
'metrics': {
'favorites': tweet.favorite_count,
'retweets': tweet.retweet_count,
'replies': tweet.reply_count if hasattr(tweet, 'reply_count') else 0,
'impressions': tweet.impression_count if hasattr(tweet, 'impression_count') else 0
},
'engagement_rate': self._calculate_engagement_rate(tweet)
})
except Exception as e:
return self._format_error_response(
e,
{
'content_id': content_id,
'start_date': start_date,
'end_date': end_date
}
)
async def validate_content(
self,
content: Dict[str, Any]
) -> Dict[str, Any]:
"""Validate content before publishing."""
try:
# Check text length
text = content.get('text', '')
if len(text) > 280:
return self._format_error_response(
ValueError("Tweet text exceeds 280 characters"),
{'content': content}
)
# Check media attachments
media = content.get('media', [])
if len(media) > 4:
return self._format_error_response(
ValueError("Maximum 4 media attachments allowed"),
{'content': content}
)
return self._format_success_response({
'valid': True,
'content': content
})
except Exception as e:
return self._format_error_response(
e,
{'content': content}
)
async def get_optimal_publish_time(
self,
content_type: str,
@@ -245,19 +523,6 @@ class TwitterAdapter(PlatformAdapter):
except Exception as e:
return self._format_error_response(e)
def _calculate_engagement_rate(self, tweet: Status) -> float:
"""Calculate engagement rate for a tweet."""
try:
total_engagement = (
tweet.favorite_count +
tweet.retweet_count +
(tweet.reply_count if hasattr(tweet, 'reply_count') else 0)
)
followers = tweet.user.followers_count
return (total_engagement / followers * 100) if followers > 0 else 0.0
except Exception:
return 0.0
def _upload_media(self, media: Dict[str, Any]) -> Optional[str]:
"""Upload media to Twitter."""
try:

337
lib/integrations/twitter_auth_bridge.py Normal file
View File

@@ -0,0 +1,337 @@
"""
Twitter Authentication Bridge
Connects the platform adapter with the UI authentication system for secure Twitter integration.
"""
import streamlit as st
import tweepy
import json
import os
from typing import Dict, Any, Optional, Tuple
from datetime import datetime, timedelta
from pathlib import Path
import hashlib
import base64
from cryptography.fernet import Fernet
import logging
from .platform_adapters.twitter import TwitterAdapter
logger = logging.getLogger(__name__)
class TwitterAuthBridge:
"""Bridge between Twitter authentication and platform adapter."""
def __init__(self):
self.config_dir = Path("config/twitter")
self.config_dir.mkdir(parents=True, exist_ok=True)
self.encryption_key = self._get_or_create_encryption_key()
def _get_or_create_encryption_key(self) -> bytes:
"""Get or create encryption key for secure credential storage."""
key_file = self.config_dir / "encryption.key"
if key_file.exists():
with open(key_file, 'rb') as f:
return f.read()
else:
key = Fernet.generate_key()
with open(key_file, 'wb') as f:
f.write(key)
return key
def encrypt_credentials(self, credentials: Dict[str, str]) -> str:
"""Encrypt Twitter credentials for secure storage."""
try:
fernet = Fernet(self.encryption_key)
credentials_json = json.dumps(credentials)
encrypted_data = fernet.encrypt(credentials_json.encode())
return base64.b64encode(encrypted_data).decode()
except Exception as e:
logger.error(f"Failed to encrypt credentials: {str(e)}")
raise
def decrypt_credentials(self, encrypted_data: str) -> Dict[str, str]:
"""Decrypt Twitter credentials from secure storage."""
try:
fernet = Fernet(self.encryption_key)
encrypted_bytes = base64.b64decode(encrypted_data.encode())
decrypted_data = fernet.decrypt(encrypted_bytes)
return json.loads(decrypted_data.decode())
except Exception as e:
logger.error(f"Failed to decrypt credentials: {str(e)}")
raise
def save_credentials(self, user_id: str, credentials: Dict[str, str]) -> bool:
"""Save encrypted Twitter credentials to file."""
try:
# Create user-specific credentials file
user_hash = hashlib.sha256(user_id.encode()).hexdigest()[:16]
creds_file = self.config_dir / f"user_{user_hash}.enc"
# Add timestamp and validation
credentials_with_meta = {
**credentials,
'created_at': datetime.now().isoformat(),
'user_id_hash': user_hash
}
# Encrypt and save
encrypted_data = self.encrypt_credentials(credentials_with_meta)
with open(creds_file, 'w') as f:
f.write(encrypted_data)
logger.info(f"Credentials saved for user {user_hash}")
return True
except Exception as e:
logger.error(f"Failed to save credentials: {str(e)}")
return False
def load_credentials(self, user_id: str) -> Optional[Dict[str, str]]:
"""Load and decrypt Twitter credentials from file."""
try:
user_hash = hashlib.sha256(user_id.encode()).hexdigest()[:16]
creds_file = self.config_dir / f"user_{user_hash}.enc"
if not creds_file.exists():
logger.warning(f"No credentials found for user {user_hash}")
return None
# Load and decrypt
with open(creds_file, 'r') as f:
encrypted_data = f.read()
credentials = self.decrypt_credentials(encrypted_data)
# Validate credentials are not expired (optional)
created_at = datetime.fromisoformat(credentials.get('created_at', ''))
if datetime.now() - created_at > timedelta(days=365): # 1 year expiry
logger.warning(f"Credentials expired for user {user_hash}")
return None
# Remove metadata before returning
clean_credentials = {k: v for k, v in credentials.items()
if k not in ['created_at', 'user_id_hash']}
return clean_credentials
except Exception as e:
logger.error(f"Failed to load credentials: {str(e)}")
return None
def delete_credentials(self, user_id: str) -> bool:
"""Delete stored Twitter credentials."""
try:
user_hash = hashlib.sha256(user_id.encode()).hexdigest()[:16]
creds_file = self.config_dir / f"user_{user_hash}.enc"
if creds_file.exists():
creds_file.unlink()
logger.info(f"Credentials deleted for user {user_hash}")
return True
except Exception as e:
logger.error(f"Failed to delete credentials: {str(e)}")
return False
def validate_credentials(self, credentials: Dict[str, str]) -> Tuple[bool, str]:
"""Validate Twitter API credentials."""
try:
# Check required fields
required_fields = ['api_key', 'api_secret', 'access_token', 'access_token_secret']
missing_fields = [field for field in required_fields if not credentials.get(field)]
if missing_fields:
return False, f"Missing required fields: {', '.join(missing_fields)}"
# Test connection
auth = tweepy.OAuthHandler(
credentials['api_key'],
credentials['api_secret']
)
auth.set_access_token(
credentials['access_token'],
credentials['access_token_secret']
)
api = tweepy.API(auth)
user = api.verify_credentials()
if user:
return True, f"Valid credentials for @{user.screen_name}"
else:
return False, "Failed to verify credentials"
except tweepy.Unauthorized:
return False, "Invalid API credentials"
except tweepy.Forbidden:
return False, "Access forbidden - check API permissions"
except tweepy.TooManyRequests:
return False, "Rate limit exceeded - try again later"
except Exception as e:
return False, f"Connection error: {str(e)}"
def get_twitter_adapter(self, user_id: str) -> Optional[TwitterAdapter]:
"""Get configured Twitter adapter for user."""
try:
# First check session state
if 'twitter_adapter' in st.session_state:
return st.session_state.twitter_adapter
# Load credentials
credentials = self.load_credentials(user_id)
if not credentials:
return None
# Validate credentials
is_valid, message = self.validate_credentials(credentials)
if not is_valid:
logger.error(f"Invalid credentials: {message}")
return None
# Create adapter
adapter = TwitterAdapter(credentials)
# Cache in session state
st.session_state.twitter_adapter = adapter
return adapter
except Exception as e:
logger.error(f"Failed to get Twitter adapter: {str(e)}")
return None
def get_user_info(self, user_id: str) -> Optional[Dict[str, Any]]:
"""Get Twitter user information."""
try:
adapter = self.get_twitter_adapter(user_id)
if not adapter:
return None
# Get user info from Twitter
user = adapter.client.verify_credentials()
user_info = {
'id': user.id_str,
'screen_name': user.screen_name,
'name': user.name,
'description': user.description,
'followers_count': user.followers_count,
'friends_count': user.friends_count,
'statuses_count': user.statuses_count,
'profile_image_url': user.profile_image_url_https,
'profile_banner_url': getattr(user, 'profile_banner_url', ''),
'verified': user.verified,
'created_at': user.created_at.isoformat(),
'location': user.location or '',
'url': user.url or ''
}
return user_info
except Exception as e:
logger.error(f"Failed to get user info: {str(e)}")
return None
def setup_session_state(self, user_id: str) -> bool:
"""Setup session state with Twitter authentication."""
try:
# Load credentials
credentials = self.load_credentials(user_id)
if not credentials:
return False
# Get user info
user_info = self.get_user_info(user_id)
if not user_info:
return False
# Setup session state
st.session_state.twitter_authenticated = True
st.session_state.twitter_user_id = user_id
st.session_state.twitter_user_info = user_info
st.session_state.twitter_config = credentials
return True
except Exception as e:
logger.error(f"Failed to setup session state: {str(e)}")
return False
def clear_session_state(self) -> None:
"""Clear Twitter authentication from session state."""
keys_to_clear = [
'twitter_authenticated',
'twitter_user_id',
'twitter_user_info',
'twitter_config',
'twitter_adapter'
]
for key in keys_to_clear:
if key in st.session_state:
del st.session_state[key]
def is_authenticated(self) -> bool:
"""Check if user is authenticated with Twitter."""
return (
st.session_state.get('twitter_authenticated', False) and
st.session_state.get('twitter_user_info') is not None and
st.session_state.get('twitter_config') is not None
)
def get_rate_limit_status(self, user_id: str) -> Optional[Dict[str, Any]]:
"""Get current rate limit status."""
try:
adapter = self.get_twitter_adapter(user_id)
if not adapter:
return None
rate_limits = adapter.client.get_rate_limit_status()
# Extract relevant rate limits
relevant_limits = {
'tweets': rate_limits['resources']['statuses']['/statuses/update'],
'user_timeline': rate_limits['resources']['statuses']['/statuses/user_timeline'],
'verify_credentials': rate_limits['resources']['account']['/account/verify_credentials']
}
return relevant_limits
except Exception as e:
logger.error(f"Failed to get rate limit status: {str(e)}")
return None
# Global instance
twitter_auth = TwitterAuthBridge()
# Convenience functions for UI
def save_twitter_credentials(user_id: str, credentials: Dict[str, str]) -> bool:
"""Save Twitter credentials (convenience function)."""
return twitter_auth.save_credentials(user_id, credentials)
def load_twitter_credentials(user_id: str) -> Optional[Dict[str, str]]:
"""Load Twitter credentials (convenience function)."""
return twitter_auth.load_credentials(user_id)
def get_twitter_adapter(user_id: str) -> Optional[TwitterAdapter]:
"""Get Twitter adapter (convenience function)."""
return twitter_auth.get_twitter_adapter(user_id)
def is_twitter_authenticated() -> bool:
"""Check if Twitter is authenticated (convenience function)."""
return twitter_auth.is_authenticated()
def setup_twitter_session(user_id: str) -> bool:
"""Setup Twitter session (convenience function)."""
return twitter_auth.setup_session_state(user_id)
def clear_twitter_session() -> None:
"""Clear Twitter session (convenience function)."""
twitter_auth.clear_session_state()
def validate_twitter_credentials(credentials: Dict[str, str]) -> Tuple[bool, str]:
"""Validate Twitter credentials (convenience function)."""
return twitter_auth.validate_credentials(credentials)

4
lib/utils/ui_setup.py
View File

@@ -11,6 +11,7 @@ from lib.utils.alwrity_utils import ai_social_writer
from lib.alwrity_ui.seo_tools_dashboard import ai_seo_tools
from lib.alwrity_ui.settings_page import render_settings_page
from lib.alwrity_ui.navigation_styles import apply_navigation_styles, apply_compact_layout
from lib.alwrity_ui.content_generation.content_generation_dashboard import render_content_generation_dashboard
from loguru import logger
# Import social media writer functions
@@ -36,7 +37,7 @@ def setup_alwrity_ui():
# Initialize session state for active tab if not exists
if 'active_tab' not in st.session_state:
st.session_state.active_tab = "Content Planning"
st.session_state.active_tab = "Content Generation"
logger.info(f"Initialized active_tab to: {st.session_state.active_tab}")
# Initialize session state for active sub-tab if not exists
@@ -46,6 +47,7 @@ def setup_alwrity_ui():
# Define the navigation items with their icons and functions
nav_items = {
"Content Generation": ("🎯", render_content_generation_dashboard),
"AI Writers": ("📝", get_ai_writers),
"Content Planning": ("📅", content_planning_tools),
"AI SEO Tools": ("🔍", ai_seo_tools),

1
twitter_encryption.key Normal file
View File

@@ -0,0 +1 @@
LCEVv7Szzr01caP-RvZD1KRQYqxrNOdg5RKJIk6fdOg=