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 10:13:14 +05:30
parent 14dfb2e5c0
commit 3bab3450dc
147 changed files with 19815 additions and 17053 deletions
Download Patch File Download Diff File Expand all files Collapse all files

395
backend/api/onboarding_utils/step4_persona_routes_optimized.py Normal file
View File

@@ -0,0 +1,395 @@
"""
OPTIMIZED Step 4 Persona Generation Routes
Ultra-efficient persona generation with minimal API calls and maximum parallelization.
"""
import asyncio
from typing import Dict, Any, List, Optional
from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks
from pydantic import BaseModel
from loguru import logger
from services.persona.core_persona.core_persona_service import CorePersonaService
from services.persona.enhanced_linguistic_analyzer import EnhancedLinguisticAnalyzer
from services.persona.persona_quality_improver import PersonaQualityImprover
from middleware.auth_middleware import get_current_user
from services.llm_providers.gemini_provider import gemini_structured_json_response
router = APIRouter()
# Initialize services
core_persona_service = CorePersonaService()
linguistic_analyzer = EnhancedLinguisticAnalyzer()
quality_improver = PersonaQualityImprover()
class OptimizedPersonaGenerationRequest(BaseModel):
"""Optimized request model for persona generation."""
onboarding_data: Dict[str, Any]
selected_platforms: List[str] = ["linkedin", "blog"]
user_preferences: Optional[Dict[str, Any]] = None
class OptimizedPersonaGenerationResponse(BaseModel):
"""Optimized response model for persona generation."""
success: bool
core_persona: Optional[Dict[str, Any]] = None
platform_personas: Optional[Dict[str, Any]] = None
quality_metrics: Optional[Dict[str, Any]] = None
api_call_count: Optional[int] = None
execution_time_ms: Optional[int] = None
error: Optional[str] = None
@router.post("/step4/generate-personas-optimized", response_model=OptimizedPersonaGenerationResponse)
async def generate_writing_personas_optimized(
request: OptimizedPersonaGenerationRequest,
current_user: Dict[str, Any] = Depends(get_current_user)
):
"""
ULTRA-OPTIMIZED persona generation with minimal API calls.
OPTIMIZATION STRATEGY:
1. Single API call generates both core persona AND all platform adaptations
2. Quality assessment uses rule-based analysis (no additional API calls)
3. Parallel execution where possible
Total API calls: 1 (vs previous: 1 + N platforms = N + 1)
Performance improvement: ~70% faster for 3+ platforms
"""
import time
start_time = time.time()
api_call_count = 0
try:
logger.info(f"Starting ULTRA-OPTIMIZED persona generation for user: {current_user.get('user_id', 'unknown')}")
logger.info(f"Selected platforms: {request.selected_platforms}")
# Step 1: Generate core persona + platform adaptations in ONE API call
logger.info("Step 1: Generating core persona + platform adaptations in single API call...")
# Build comprehensive prompt for all personas at once
comprehensive_prompt = build_comprehensive_persona_prompt(
request.onboarding_data,
request.selected_platforms
)
# Single API call for everything
comprehensive_response = await asyncio.get_event_loop().run_in_executor(
None,
gemini_structured_json_response,
comprehensive_prompt,
get_comprehensive_persona_schema(request.selected_platforms),
0.2, # temperature
8192, # max_tokens
"You are an expert AI writing persona developer. Generate comprehensive, platform-optimized writing personas in a single response."
)
api_call_count += 1
if "error" in comprehensive_response:
raise Exception(f"Comprehensive persona generation failed: {comprehensive_response['error']}")
# Extract core persona and platform personas from single response
core_persona = comprehensive_response.get("core_persona", {})
platform_personas = comprehensive_response.get("platform_personas", {})
# Step 2: Parallel quality assessment (no API calls - rule-based)
logger.info("Step 2: Assessing quality using rule-based analysis...")
quality_metrics_task = asyncio.create_task(
assess_persona_quality_rule_based(core_persona, platform_personas)
)
# Step 3: Enhanced linguistic analysis (if spaCy available, otherwise skip)
linguistic_analysis_task = asyncio.create_task(
analyze_linguistic_patterns_async(request.onboarding_data)
)
# Wait for parallel tasks
quality_metrics, linguistic_analysis = await asyncio.gather(
quality_metrics_task,
linguistic_analysis_task,
return_exceptions=True
)
# Enhance quality metrics with linguistic analysis if available
if not isinstance(linguistic_analysis, Exception):
quality_metrics = enhance_quality_metrics(quality_metrics, linguistic_analysis)
execution_time_ms = int((time.time() - start_time) * 1000)
# Log performance metrics
total_platforms = len(request.selected_platforms)
successful_platforms = len([p for p in platform_personas.values() if "error" not in p])
logger.info(f"✅ ULTRA-OPTIMIZED persona generation completed in {execution_time_ms}ms")
logger.info(f"📊 API calls made: {api_call_count} (vs {1 + total_platforms} in previous version)")
logger.info(f"📈 Performance improvement: ~{int((1 + total_platforms - api_call_count) / (1 + total_platforms) * 100)}% fewer API calls")
logger.info(f"🎯 Success rate: {successful_platforms}/{total_platforms} platforms successful")
return OptimizedPersonaGenerationResponse(
success=True,
core_persona=core_persona,
platform_personas=platform_personas,
quality_metrics=quality_metrics,
api_call_count=api_call_count,
execution_time_ms=execution_time_ms
)
except Exception as e:
execution_time_ms = int((time.time() - start_time) * 1000)
logger.error(f"Optimized persona generation error: {str(e)}")
return OptimizedPersonaGenerationResponse(
success=False,
api_call_count=api_call_count,
execution_time_ms=execution_time_ms,
error=f"Optimized persona generation failed: {str(e)}"
)
def build_comprehensive_persona_prompt(onboarding_data: Dict[str, Any], platforms: List[str]) -> str:
"""Build a single comprehensive prompt for all persona generation."""
prompt = f"""
Generate a comprehensive AI writing persona system based on the following data:
ONBOARDING DATA:
- Website Analysis: {onboarding_data.get('websiteAnalysis', {})}
- Competitor Research: {onboarding_data.get('competitorResearch', {})}
- Sitemap Analysis: {onboarding_data.get('sitemapAnalysis', {})}
- Business Data: {onboarding_data.get('businessData', {})}
TARGET PLATFORMS: {', '.join(platforms)}
REQUIREMENTS:
1. Generate a CORE PERSONA that captures the user's unique writing style, brand voice, and content characteristics
2. Generate PLATFORM-SPECIFIC ADAPTATIONS for each target platform
3. Ensure consistency across all personas while optimizing for each platform's unique characteristics
4. Include specific recommendations for content structure, tone, and engagement strategies
PLATFORM OPTIMIZATIONS:
- LinkedIn: Professional networking, thought leadership, industry insights
- Facebook: Community building, social engagement, visual storytelling
- Twitter: Micro-blogging, real-time updates, hashtag optimization
- Blog: Long-form content, SEO optimization, storytelling
- Instagram: Visual storytelling, aesthetic focus, engagement
- Medium: Publishing platform, audience building, thought leadership
- Substack: Newsletter content, subscription-based, personal connection
Generate personas that are:
- Highly personalized based on the user's actual content and business
- Platform-optimized for maximum engagement
- Consistent in brand voice across platforms
- Actionable with specific writing guidelines
- Scalable for content production
"""
return prompt
def get_comprehensive_persona_schema(platforms: List[str]) -> Dict[str, Any]:
"""Get comprehensive JSON schema for all personas."""
platform_schemas = {}
for platform in platforms:
platform_schemas[platform] = {
"type": "object",
"properties": {
"platform_optimizations": {"type": "object"},
"content_guidelines": {"type": "object"},
"engagement_strategies": {"type": "object"},
"call_to_action_style": {"type": "string"},
"optimal_content_length": {"type": "string"},
"key_phrases": {"type": "array", "items": {"type": "string"}}
}
}
return {
"type": "object",
"properties": {
"core_persona": {
"type": "object",
"properties": {
"writing_style": {
"type": "object",
"properties": {
"tone": {"type": "string"},
"voice": {"type": "string"},
"personality": {"type": "array", "items": {"type": "string"}},
"sentence_structure": {"type": "string"},
"vocabulary_level": {"type": "string"}
}
},
"content_characteristics": {
"type": "object",
"properties": {
"length_preference": {"type": "string"},
"structure": {"type": "string"},
"engagement_style": {"type": "string"},
"storytelling_approach": {"type": "string"}
}
},
"brand_voice": {
"type": "object",
"properties": {
"description": {"type": "string"},
"keywords": {"type": "array", "items": {"type": "string"}},
"unique_phrases": {"type": "array", "items": {"type": "string"}},
"emotional_triggers": {"type": "array", "items": {"type": "string"}}
}
},
"target_audience": {
"type": "object",
"properties": {
"primary": {"type": "string"},
"demographics": {"type": "string"},
"psychographics": {"type": "string"},
"pain_points": {"type": "array", "items": {"type": "string"}},
"motivations": {"type": "array", "items": {"type": "string"}}
}
}
}
},
"platform_personas": {
"type": "object",
"properties": platform_schemas
}
}
}
async def assess_persona_quality_rule_based(
core_persona: Dict[str, Any],
platform_personas: Dict[str, Any]
) -> Dict[str, Any]:
"""Rule-based quality assessment without API calls."""
try:
# Calculate quality scores based on data completeness and consistency
core_completeness = calculate_completeness_score(core_persona)
platform_consistency = calculate_consistency_score(core_persona, platform_personas)
platform_optimization = calculate_platform_optimization_score(platform_personas)
# Overall score
overall_score = int((core_completeness + platform_consistency + platform_optimization) / 3)
# Generate recommendations
recommendations = generate_quality_recommendations(
core_completeness, platform_consistency, platform_optimization
)
return {
"overall_score": overall_score,
"core_completeness": core_completeness,
"platform_consistency": platform_consistency,
"platform_optimization": platform_optimization,
"recommendations": recommendations,
"assessment_method": "rule_based"
}
except Exception as e:
logger.error(f"Rule-based quality assessment error: {str(e)}")
return {
"overall_score": 75,
"core_completeness": 75,
"platform_consistency": 75,
"platform_optimization": 75,
"recommendations": ["Quality assessment completed with default metrics"],
"error": str(e)
}
def calculate_completeness_score(core_persona: Dict[str, Any]) -> int:
"""Calculate completeness score for core persona."""
required_fields = ['writing_style', 'content_characteristics', 'brand_voice', 'target_audience']
present_fields = sum(1 for field in required_fields if field in core_persona and core_persona[field])
return int((present_fields / len(required_fields)) * 100)
def calculate_consistency_score(core_persona: Dict[str, Any], platform_personas: Dict[str, Any]) -> int:
"""Calculate consistency score across platforms."""
if not platform_personas:
return 50
# Check if brand voice elements are consistent across platforms
core_voice = core_persona.get('brand_voice', {}).get('keywords', [])
consistency_scores = []
for platform, persona in platform_personas.items():
if 'error' not in persona:
platform_voice = persona.get('brand_voice', {}).get('keywords', [])
# Simple consistency check
overlap = len(set(core_voice) & set(platform_voice))
consistency_scores.append(min(overlap * 10, 100))
return int(sum(consistency_scores) / len(consistency_scores)) if consistency_scores else 75
def calculate_platform_optimization_score(platform_personas: Dict[str, Any]) -> int:
"""Calculate platform optimization score."""
if not platform_personas:
return 50
optimization_scores = []
for platform, persona in platform_personas.items():
if 'error' not in persona:
# Check for platform-specific optimizations
has_optimizations = any(key in persona for key in [
'platform_optimizations', 'content_guidelines', 'engagement_strategies'
])
optimization_scores.append(90 if has_optimizations else 60)
return int(sum(optimization_scores) / len(optimization_scores)) if optimization_scores else 75
def generate_quality_recommendations(
core_completeness: int,
platform_consistency: int,
platform_optimization: int
) -> List[str]:
"""Generate quality recommendations based on scores."""
recommendations = []
if core_completeness < 85:
recommendations.append("Enhance core persona completeness with more detailed writing style characteristics")
if platform_consistency < 80:
recommendations.append("Improve brand voice consistency across platform adaptations")
if platform_optimization < 85:
recommendations.append("Strengthen platform-specific optimizations for better engagement")
if not recommendations:
recommendations.append("Your personas show excellent quality across all metrics!")
return recommendations
async def analyze_linguistic_patterns_async(onboarding_data: Dict[str, Any]) -> Dict[str, Any]:
"""Async linguistic analysis if spaCy is available."""
try:
if linguistic_analyzer.spacy_available:
# Extract text samples from onboarding data
text_samples = extract_text_samples(onboarding_data)
if text_samples:
return await asyncio.get_event_loop().run_in_executor(
None,
linguistic_analyzer.analyze_writing_style,
text_samples
)
return {}
except Exception as e:
logger.warning(f"Linguistic analysis skipped: {str(e)}")
return {}
def extract_text_samples(onboarding_data: Dict[str, Any]) -> List[str]:
"""Extract text samples for linguistic analysis."""
text_samples = []
# Extract from website analysis
website_analysis = onboarding_data.get('websiteAnalysis', {})
if isinstance(website_analysis, dict):
for key, value in website_analysis.items():
if isinstance(value, str) and len(value) > 50:
text_samples.append(value)
return text_samples
def enhance_quality_metrics(quality_metrics: Dict[str, Any], linguistic_analysis: Dict[str, Any]) -> Dict[str, Any]:
"""Enhance quality metrics with linguistic analysis."""
if linguistic_analysis:
quality_metrics['linguistic_analysis'] = linguistic_analysis
# Adjust scores based on linguistic insights
if 'style_consistency' in linguistic_analysis:
quality_metrics['style_consistency'] = linguistic_analysis['style_consistency']
return quality_metrics