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

ALwrity + Wordpress + Wix + GSC integration

Browse Source
This commit is contained in:
ajaysi
2025-10-08 14:25:59 +05:30
parent 3bab3450dc
commit 5e3901c1c6
22 changed files with 2284 additions and 1222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

613
backend/start_alwrity_backend.py
View File

@@ -1,524 +1,25 @@
#!/usr/bin/env python3
"""
ALwrity Backend Server - Comprehensive Startup Script
Handles setup, dependency installation, and server startup.
ALwrity Backend Server - Modular Startup Script
Handles setup, dependency installation, and server startup using modular utilities.
Run this from the backend directory to set up and start the FastAPI server.
"""
import os
import sys
import subprocess
import time
import argparse
from pathlib import Path
def install_requirements():
"""Install required Python packages."""
print("📦 Installing required packages...")
requirements_file = Path(__file__).parent / "requirements.txt"
try:
subprocess.check_call([
sys.executable, "-m", "pip", "install", "-r", str(requirements_file)
])
print("[OK] All packages installed successfully!")
return True
except subprocess.CalledProcessError as e:
print(f"[ERROR] Error installing packages: {e}")
return False
# Import modular utilities
from alwrity_utils import (
DependencyManager,
EnvironmentSetup,
DatabaseSetup,
ProductionOptimizer
)
def create_env_file():
"""Create a .env file with default configuration."""
env_file = Path(__file__).parent / ".env"
if env_file.exists():
print("[INFO] .env file already exists")
return True
print("🔧 Creating .env file with default configuration...")
env_content = """# ALwrity Backend Configuration
# API Keys (Configure these in the onboarding process)
# OPENAI_API_KEY=your_openai_api_key_here
# GEMINI_API_KEY=your_gemini_api_key_here
# ANTHROPIC_API_KEY=your_anthropic_api_key_here
# MISTRAL_API_KEY=your_mistral_api_key_here
# Research API Keys (Optional)
# TAVILY_API_KEY=your_tavily_api_key_here
# SERPER_API_KEY=your_serper_api_key_here
# METAPHOR_API_KEY=your_metaphor_api_key_here
# FIRECRAWL_API_KEY=your_firecrawl_api_key_here
# Server Configuration
HOST=0.0.0.0
PORT=8000
DEBUG=true
# Logging
LOG_LEVEL=INFO
"""
try:
with open(env_file, 'w') as f:
f.write(env_content)
print("[OK] .env file created successfully!")
return True
except Exception as e:
print(f"[ERROR] Error creating .env file: {e}")
return False
def setup_monitoring_tables():
"""Set up API monitoring database tables."""
print("📊 Setting up API monitoring tables...")
try:
# Import and run the monitoring table creation
sys.path.append(str(Path(__file__).parent))
from scripts.create_monitoring_tables import create_monitoring_tables
if create_monitoring_tables():
print("[OK] API monitoring tables created successfully!")
return True
else:
print("[WARNING] Warning: Failed to create monitoring tables, continuing anyway...")
return True # Don't fail startup for monitoring issues
except Exception as e:
print(f"[WARNING] Warning: Could not set up monitoring tables: {e}")
print(" Monitoring will be disabled. Continuing startup...")
return True # Don't fail startup for monitoring issues
def setup_billing_tables():
"""Set up billing and subscription database tables."""
print("💳 Setting up billing and subscription tables...")
try:
# Import and run the billing table creation
sys.path.append(str(Path(__file__).parent))
from scripts.create_billing_tables import create_billing_tables, check_existing_tables
from services.database import DATABASE_URL
from sqlalchemy import create_engine
# Create engine to check existing tables
engine = create_engine(DATABASE_URL, echo=False)
# Check existing tables
if not check_existing_tables(engine):
print("[OK] Billing tables already exist, skipping creation")
return True
if create_billing_tables():
print("[OK] Billing and subscription tables created successfully!")
return True
else:
print("[WARNING] Warning: Failed to create billing tables, continuing anyway...")
return True # Don't fail startup for billing issues
except Exception as e:
print(f"[WARNING] Warning: Could not set up billing tables: {e}")
print(" Billing system will be disabled. Continuing startup...")
return True # Don't fail startup for billing issues
def setup_monitoring_middleware():
"""Set up monitoring middleware in app.py if not already present."""
print("🔍 Setting up API monitoring middleware...")
app_file = Path(__file__).parent / "app.py"
if not app_file.exists():
print("[WARNING] Warning: app.py not found, skipping middleware setup")
return True
try:
with open(app_file, 'r') as f:
content = f.read()
# Check if monitoring middleware is already set up
if "monitoring_middleware" in content:
print("[OK] Monitoring middleware already configured")
return True
# Add monitoring middleware import and setup
monitoring_import = "from middleware.monitoring_middleware import monitoring_middleware\n"
monitoring_setup = "app.middleware(\"http\")(monitoring_middleware)\n"
# Find the right place to add the import (after other imports)
lines = content.split('\n')
import_end_index = 0
for i, line in enumerate(lines):
if line.strip().startswith('import ') or line.strip().startswith('from '):
import_end_index = i + 1
elif line.strip() and not line.strip().startswith('#'):
break
# Insert monitoring import
lines.insert(import_end_index, monitoring_import)
# Find the right place to add middleware setup (after app creation)
app_creation_index = -1
for i, line in enumerate(lines):
if 'app = FastAPI(' in line or 'app = FastAPI()' in line:
app_creation_index = i
break
if app_creation_index != -1:
# Find the end of app configuration
setup_index = app_creation_index + 1
for i in range(app_creation_index + 1, len(lines)):
if lines[i].strip() and not lines[i].strip().startswith('#'):
setup_index = i + 1
break
lines.insert(setup_index, monitoring_setup)
# Write back to file
with open(app_file, 'w') as f:
f.write('\n'.join(lines))
print("[OK] Monitoring middleware configured successfully!")
return True
except Exception as e:
print(f"[WARNING] Warning: Could not set up monitoring middleware: {e}")
print(" Monitoring will be disabled. Continuing startup...")
return True # Don't fail startup for monitoring issues
def setup_spacy_model():
"""Set up spaCy English model for linguistic analysis."""
print("Setting up spaCy English model...")
try:
import spacy
# Check if en_core_web_sm model is already installed
model_name = "en_core_web_sm"
try:
# Try to load the model directly
nlp = spacy.load(model_name)
# Test the model with a simple sentence
test_doc = nlp("This is a test sentence.")
if test_doc and len(test_doc) > 0:
print(f"SUCCESS: spaCy model '{model_name}' is already installed and working")
print(f" Test: Processed {len(test_doc)} tokens successfully")
return True
else:
raise OSError("Model loaded but not functioning correctly")
except OSError:
print(f"INFO: spaCy model '{model_name}' not found or not working, downloading...")
# Try to download the model using subprocess
try:
print(f" Downloading {model_name}...")
result = subprocess.run([
sys.executable, "-m", "spacy", "download", model_name
], capture_output=True, text=True, timeout=300) # 5 minute timeout
if result.returncode == 0:
print(f" SUCCESS: Model download completed")
else:
print(f" WARNING: Download warning: {result.stderr}")
except subprocess.TimeoutExpired:
print(f" ERROR: Download timed out after 5 minutes")
return False
except subprocess.CalledProcessError as e:
print(f" ERROR: Download failed: {e}")
return False
# Verify the model was downloaded correctly
try:
nlp = spacy.load(model_name)
# Test the model
test_doc = nlp("This is a test sentence.")
if test_doc and len(test_doc) > 0:
print(f"SUCCESS: spaCy model '{model_name}' downloaded and verified successfully")
print(f" Test: Processed {len(test_doc)} tokens successfully")
return True
else:
print(f"ERROR: Model downloaded but not functioning correctly")
return False
except OSError as e:
print(f"ERROR: Model downloaded but failed to load: {e}")
return False
except subprocess.CalledProcessError as e:
print(f"ERROR: Error downloading spaCy model: {e}")
print(" Manual installation required:")
print(" 1. Install spaCy: pip install spacy>=3.7.0")
print(" 2. Download model: python -m spacy download en_core_web_sm")
print(" 3. Test setup: python -c \"import spacy; nlp=spacy.load('en_core_web_sm'); print('spaCy working!')\"")
print(" 4. Restart the backend")
return False
except ImportError as e:
print(f"ERROR: spaCy not installed: {e}")
print(" Manual installation required:")
print(" 1. Install spaCy: pip install spacy>=3.7.0")
print(" 2. Download model: python -m spacy download en_core_web_sm")
print(" 3. Test setup: python -c \"import spacy; nlp=spacy.load('en_core_web_sm'); print('spaCy working!')\"")
print(" 4. Restart the backend")
return False
except Exception as e:
print(f"ERROR: Error setting up spaCy model: {e}")
print(" Manual installation required:")
print(" 1. Install spaCy: pip install spacy>=3.7.0")
print(" 2. Download model: python -m spacy download en_core_web_sm")
print(" 3. Test setup: python -c \"import spacy; nlp=spacy.load('en_core_web_sm'); print('spaCy working!')\"")
print(" 4. Restart the backend")
return False
def setup_nltk_data():
"""Set up required NLTK data for linguistic analysis."""
print("Setting up NLTK data...")
try:
import nltk
# Required NLTK data packages
required_data = [
'punkt_tab', # Updated for newer NLTK versions
'stopwords',
'averaged_perceptron_tagger_eng', # Updated for newer NLTK versions
'wordnet',
'omw-1.4'
]
for data_package in required_data:
try:
nltk.data.find(f'tokenizers/{data_package}' if data_package in ['punkt', 'punkt_tab']
else f'corpora/{data_package}' if data_package in ['stopwords', 'wordnet', 'omw-1.4']
else f'taggers/{data_package}' if data_package in ['averaged_perceptron_tagger', 'averaged_perceptron_tagger_eng']
else f'corpora/{data_package}')
print(f" SUCCESS: {data_package}")
except LookupError:
print(f" INFO: Downloading {data_package}...")
nltk.download(data_package, quiet=True)
print(f" SUCCESS: {data_package} downloaded")
print("SUCCESS: All required NLTK data is available")
return True
except Exception as e:
print(f"ERROR: Error setting up NLTK data: {e}")
return False
def check_dependencies():
"""Check if required dependencies are installed."""
print("🔍 Checking dependencies...")
required_packages = [
'fastapi',
'uvicorn',
'pydantic',
'loguru',
'openai',
'google.generativeai',
'anthropic',
'mistralai',
'sqlalchemy',
'spacy', # Added spaCy to required packages
'nltk' # Added NLTK to required packages
]
missing_packages = []
for package in required_packages:
try:
__import__(package.replace('-', '_'))
print(f" [OK] {package}")
except ImportError:
print(f" [ERROR] {package} - MISSING")
missing_packages.append(package)
if missing_packages:
print(f"\n[ERROR] Missing packages: {', '.join(missing_packages)}")
print("Installing missing packages...")
return install_requirements()
else:
print("\n[OK] All dependencies are available!")
return True
def setup_environment():
"""Set up the environment for the backend."""
print("🔧 Setting up environment...")
# Create necessary directories
directories = [
"lib/workspace/alwrity_content",
"lib/workspace/alwrity_web_research",
"lib/workspace/alwrity_prompts",
"lib/workspace/alwrity_config"
]
for directory in directories:
Path(directory).mkdir(parents=True, exist_ok=True)
print(f" [OK] Created directory: {directory}")
# Create .env file if it doesn't exist
create_env_file()
# Set up monitoring
setup_monitoring_tables()
setup_monitoring_middleware()
# Set up billing and subscription system
setup_billing_tables()
# Set up persona tables
if setup_persona_tables():
# Verify persona tables were created successfully
verify_persona_tables()
else:
print("[WARNING] Warning: Persona tables setup failed, but continuing...")
# Set up linguistic analysis dependencies (Required for persona generation)
print("🧠 Setting up linguistic analysis dependencies...")
# Set up spaCy model (REQUIRED for persona generation)
if not setup_spacy_model():
print("[ERROR] CRITICAL: spaCy model setup failed - persona generation will not work!")
print(" Please ensure spaCy is installed and en_core_web_sm model is available")
return False
# Set up NLTK data (supplementary to spaCy)
if not setup_nltk_data():
print("[WARNING] Warning: NLTK data setup failed, but continuing...")
print("[OK] Environment setup complete")
return True
def setup_persona_tables():
"""Set up persona database tables."""
print("🔧 Setting up persona tables...")
try:
from services.database import engine
from models.persona_models import Base as PersonaBase
# Create persona tables
PersonaBase.metadata.create_all(bind=engine)
print("[OK] Persona tables created successfully")
# Verify tables were created
from sqlalchemy import inspect
inspector = inspect(engine)
tables = inspector.get_table_names()
persona_tables = [
'writing_personas',
'platform_personas',
'persona_analysis_results',
'persona_validation_results'
]
created_tables = [table for table in persona_tables if table in tables]
print(f"[OK] Verified persona tables created: {created_tables}")
if len(created_tables) != len(persona_tables):
missing = [table for table in persona_tables if table not in created_tables]
print(f"[WARNING] Warning: Missing persona tables: {missing}")
return False
return True
except Exception as e:
print(f"[ERROR] Error setting up persona tables: {e}")
return False
def verify_persona_tables():
"""Verify that persona tables exist and are accessible."""
print("🔍 Verifying persona tables...")
try:
from services.database import get_db_session
from models.persona_models import WritingPersona, PlatformPersona, PersonaAnalysisResult, PersonaValidationResult
session = get_db_session()
if session:
# Try to query all persona tables to verify they exist
session.query(WritingPersona).first()
session.query(PlatformPersona).first()
session.query(PersonaAnalysisResult).first()
session.query(PersonaValidationResult).first()
session.close()
print("[OK] All persona tables verified successfully")
return True
else:
print("[WARNING] Warning: Could not get database session")
return False
except Exception as e:
print(f"[WARNING] Warning: Could not verify persona tables: {e}")
return False
def verify_linguistic_analyzer():
"""Verify that the linguistic analyzer is working correctly."""
print("Verifying linguistic analyzer setup...")
try:
from services.persona.enhanced_linguistic_analyzer import EnhancedLinguisticAnalyzer
# Try to initialize the linguistic analyzer
analyzer = EnhancedLinguisticAnalyzer()
# Test with a sample text
test_texts = [
"This is a test sentence for linguistic analysis.",
"ALwrity provides high-quality AI writing assistance.",
"The persona generation system uses advanced NLP techniques."
]
# Perform a simple analysis
analysis_result = analyzer.analyze_writing_style(test_texts)
if analysis_result and 'basic_metrics' in analysis_result:
print("SUCCESS: Linguistic analyzer verified successfully")
print(f" Analyzed {len(test_texts)} text samples")
print(f" Analysis keys: {list(analysis_result.keys())}")
return True
else:
print("WARNING: Linguistic analyzer returned unexpected result")
print(f" Result: {analysis_result}")
return False
except Exception as e:
print(f"WARNING: Could not verify linguistic analyzer: {e}")
return False
def verify_billing_tables():
"""Verify that billing and subscription tables exist and are accessible."""
print("🔍 Verifying billing and subscription tables...")
try:
from services.database import get_db_session
from models.subscription_models import (
SubscriptionPlan, UserSubscription, APIUsageLog,
UsageSummary, APIProviderPricing, UsageAlert
)
session = get_db_session()
if session:
# Try to query all billing tables to verify they exist
session.query(SubscriptionPlan).first()
session.query(UserSubscription).first()
session.query(APIUsageLog).first()
session.query(UsageSummary).first()
session.query(APIProviderPricing).first()
session.query(UsageAlert).first()
session.close()
print("[OK] All billing and subscription tables verified successfully")
return True
else:
print("[WARNING] Warning: Could not get database session")
return False
except Exception as e:
print(f"[WARNING] Warning: Could not verify billing tables: {e}")
return False
def start_backend(enable_reload=False):
def start_backend(enable_reload=False, production_mode=False):
"""Start the backend server."""
print("🚀 Starting ALwrity Backend...")
@@ -527,7 +28,7 @@ def start_backend(enable_reload=False):
os.environ.setdefault("PORT", "8000")
# Set reload based on argument or environment variable
if enable_reload:
if enable_reload and not production_mode:
os.environ.setdefault("RELOAD", "true")
print(" 🔄 Development mode: Auto-reload enabled")
else:
@@ -553,26 +54,20 @@ def start_backend(enable_reload=False):
init_database()
print("[OK] Database initialized successfully")
# Verify persona tables exist
verify_persona_tables()
# Verify linguistic analyzer is working
verify_linguistic_analyzer()
# Verify billing tables exist
verify_billing_tables()
print("\n🌐 Backend is starting...")
print(" 📖 API Documentation: http://localhost:8000/api/docs")
print(" 🔍 Health Check: http://localhost:8000/health")
print(" 📊 ReDoc: http://localhost:8000/api/redoc")
print(" 📈 API Monitoring: http://localhost:8000/api/content-planning/monitoring/health")
print(" 💳 Billing Dashboard: http://localhost:8000/api/subscription/plans")
print(" 📊 Usage Tracking: http://localhost:8000/api/subscription/usage/demo")
if not production_mode:
print(" 📈 API Monitoring: http://localhost:8000/api/content-planning/monitoring/health")
print(" 💳 Billing Dashboard: http://localhost:8000/api/subscription/plans")
print(" 📊 Usage Tracking: http://localhost:8000/api/subscription/usage/demo")
print("\n[STOP] Press Ctrl+C to stop the server")
print("=" * 60)
print("\n💡 Usage:")
print(" Production mode (default): python start_alwrity_backend.py")
print(" Production mode: python start_alwrity_backend.py --production")
print(" Development mode: python start_alwrity_backend.py --dev")
print(" With auto-reload: python start_alwrity_backend.py --reload")
print("=" * 60)
@@ -606,7 +101,8 @@ def start_backend(enable_reload=False):
"temp/*",
"middleware/*",
"models/*",
"scripts/*"
"scripts/*",
"alwrity_utils/*"
],
reload_includes=[
"app.py",
@@ -624,16 +120,25 @@ def start_backend(enable_reload=False):
return True
def main():
"""Main function to set up and start the backend."""
# Parse command line arguments
parser = argparse.ArgumentParser(description="ALwrity Backend Server")
parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
parser.add_argument("--dev", action="store_true", help="Enable development mode (auto-reload)")
parser.add_argument("--production", action="store_true", help="Enable production mode (optimized for deployment)")
args = parser.parse_args()
# Determine mode
production_mode = args.production
enable_reload = (args.reload or args.dev) and not production_mode
print("ALwrity Backend Server")
print("=" * 40)
print(f"Mode: {'PRODUCTION' if production_mode else 'DEVELOPMENT'}")
print(f"Auto-reload: {'ENABLED' if enable_reload else 'DISABLED'}")
print("=" * 40)
# Check if we're in the right directory
if not os.path.exists("app.py"):
@@ -642,21 +147,63 @@ def main():
print(" Expected files:", [f for f in os.listdir('.') if f.endswith('.py')])
return False
# Initialize modular components
dependency_manager = DependencyManager()
environment_setup = EnvironmentSetup(production_mode=production_mode)
database_setup = DatabaseSetup(production_mode=production_mode)
production_optimizer = ProductionOptimizer()
# Apply production optimizations if needed
if production_mode:
if not production_optimizer.apply_production_optimizations():
print("[ERROR] Production optimization failed")
return False
# Check and install dependencies
if not check_dependencies():
print("[ERROR] Failed to install dependencies")
return False
critical_ok, missing_critical = dependency_manager.check_critical_dependencies()
if not critical_ok:
print("[ERROR] Critical dependencies missing, installing...")
if not dependency_manager.install_requirements():
print("[ERROR] Failed to install dependencies")
return False
# Check optional dependencies (non-critical)
dependency_manager.check_optional_dependencies()
# Setup environment
if not setup_environment():
print("[ERROR] Environment setup failed")
if not environment_setup.setup_directories():
print("[ERROR] Directory setup failed")
return False
# Start backend with reload option
enable_reload = args.reload or args.dev
return start_backend(enable_reload=enable_reload)
if not environment_setup.setup_environment_variables():
print("[ERROR] Environment variable setup failed")
return False
# Create .env file only in development
if not production_mode:
environment_setup.create_env_file()
# Setup database
if not database_setup.setup_essential_tables():
print("[WARNING] Database setup had issues, continuing...")
# Setup advanced features only in development
if not production_mode:
database_setup.setup_advanced_tables()
database_setup.verify_tables()
# Setup linguistic analysis (skip in production)
if not production_mode and not production_optimizer.skip_linguistic_setup():
if not production_optimizer.skip_spacy_setup():
dependency_manager.setup_spacy_model()
if not production_optimizer.skip_nltk_setup():
dependency_manager.setup_nltk_data()
# Start backend
return start_backend(enable_reload=enable_reload, production_mode=production_mode)
if __name__ == "__main__":
success = main()
if not success:
sys.exit(1)
sys.exit(1)