salman/igny8
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removeed ifeadea generaetion fucntion

Browse Source
This commit is contained in:
alorig
2025-11-10 00:18:50 +05:00
parent 9fe6153c22
commit 71487575bd
3 changed files with 6 additions and 941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

457
backend/igny8_core/modules/planner/tasks.py
View File

@@ -7,7 +7,6 @@ from typing import List
from django.db import transaction
from igny8_core.modules.planner.models import Keywords, Clusters, ContentIdeas
from igny8_core.utils.ai_processor import ai_processor
from igny8_core.ai.functions.generate_ideas import generate_ideas_core
from igny8_core.ai.tracker import ConsoleStepTracker
logger = logging.getLogger(__name__)
@@ -729,456 +728,8 @@ def auto_cluster_keywords_task(self, keyword_ids: List[int], sector_id: int = No
return error_dict
@shared_task(bind=True, max_retries=3)
def auto_generate_ideas_task(self, cluster_ids: List[int], account_id: int = None):
"""
Celery task to generate content ideas for clusters using AI.
Args:
cluster_ids: List of cluster IDs
account_id: Account ID for account isolation
"""
import sys
print("=" * 80, flush=True, file=sys.stdout)
print("[CELERY TASK] auto_generate_ideas_task STARTED", flush=True, file=sys.stdout)
print(f"[CELERY TASK] Task ID: {self.request.id}", flush=True, file=sys.stdout)
print(f"[CELERY TASK] cluster_ids: {cluster_ids}", flush=True, file=sys.stdout)
print(f"[CELERY TASK] account_id: {account_id}", flush=True, file=sys.stdout)
print("=" * 80, flush=True, file=sys.stdout)
account_id = account_id
logger.info("=" * 80)
logger.info("auto_generate_ideas_task STARTED")
logger.info(f" - Task ID: {self.request.id}")
logger.info(f" - cluster_ids: {cluster_ids}")
logger.info(f" - account_id: {account_id}")
logger.info("=" * 80)
try:
from django.db import models
from django.db import connection
# Log database connection status
try:
connection.ensure_connection()
logger.info("Database connection: OK")
except Exception as db_error:
logger.error(f"Database connection error: {type(db_error).__name__}: {str(db_error)}")
raise
# Initialize progress
logger.info("Initializing task progress state...")
self.update_state(
state='PROGRESS',
meta={
'current': 0,
'total': len(cluster_ids),
'percentage': 0,
'message': 'Initializing content ideas generation...',
'phase': 'initializing'
}
)
# Get clusters with keywords and relationships (including site)
logger.info(f"Querying clusters with IDs: {cluster_ids}")
try:
clusters_queryset = Clusters.objects.filter(id__in=cluster_ids)
logger.info(f"Initial queryset count: {clusters_queryset.count()}")
if account_id:
clusters_queryset = clusters_queryset.filter(account_id=account_id)
logger.info(f"After account filter count: {clusters_queryset.count()}")
logger.info("Loading clusters with select_related...")
clusters = list(clusters_queryset.select_related('sector', 'account', 'site', 'sector__site'))
logger.info(f"Successfully loaded {len(clusters)} clusters")
# Log each cluster's details
for c in clusters:
account = getattr(c, 'account', None)
logger.info(f" Cluster {c.id}: name='{c.name}', account_id={account.id if account else 'None'}, site_id={c.site_id if c.site else 'None'}, sector_id={c.sector_id if c.sector else 'None'}")
except Exception as query_error:
logger.error(f"Error querying clusters: {type(query_error).__name__}: {str(query_error)}", exc_info=True)
raise
if not clusters:
logger.warning(f"No clusters found: {cluster_ids}")
return {'success': False, 'error': 'No clusters found'}
total_clusters = len(clusters)
# Update progress: Preparing clusters (0-10%)
self.update_state(
state='PROGRESS',
meta={
'current': 0,
'total': total_clusters,
'percentage': 5,
'message': f'Preparing {total_clusters} clusters for idea generation...',
'phase': 'preparing'
}
)
# Format cluster data for AI
cluster_data = []
for idx, cluster in enumerate(clusters):
# Get keywords for this cluster
keywords = Keywords.objects.filter(cluster=cluster).values_list('keyword', flat=True)
keywords_list = list(keywords)
cluster_item = {
'id': cluster.id,
'name': cluster.name,
'description': cluster.description or '',
'keywords': keywords_list,
}
cluster_data.append(cluster_item)
# Log cluster data being sent to AI
logger.info(f"Cluster {idx + 1}/{total_clusters} data for AI:")
logger.info(f" - ID: {cluster_item['id']}")
logger.info(f" - Name: {cluster_item['name']}")
logger.info(f" - Description: {cluster_item['description'][:100] if cluster_item['description'] else '(empty)'}...")
logger.info(f" - Keywords count: {len(keywords_list)}")
logger.info(f" - Keywords: {keywords_list[:5]}{'...' if len(keywords_list) > 5 else ''}")
account = getattr(cluster, 'account', None)
logger.info(f" - Cluster account: {account.id if account else 'None'}")
logger.info(f" - Cluster site: {cluster.site_id if cluster.site else 'None'}")
logger.info(f" - Cluster sector: {cluster.sector_id if cluster.sector else 'None'}")
# Update progress for each cluster preparation
progress_pct = 5 + int((idx / total_clusters) * 5)
self.update_state(
state='PROGRESS',
meta={
'current': idx + 1,
'total': total_clusters,
'percentage': progress_pct,
'message': f"Preparing cluster '{cluster.name}' ({idx + 1} of {total_clusters})...",
'phase': 'preparing',
'current_item': cluster.name
}
)
# Log clean request data before sending to AI
logger.info("=" * 80)
logger.info("CLEAN REQUEST DATA FOR AI (before sending request):")
logger.info("=" * 80)
import json
clean_data = {
'total_clusters': len(cluster_data),
'clusters': [
{
'id': c['id'],
'name': c['name'],
'description': c['description'][:200] if c['description'] else '(empty)',
'keywords_count': len(c['keywords']),
'keywords': c['keywords'],
}
for c in cluster_data
]
}
logger.info(json.dumps(clean_data, indent=2))
logger.info("=" * 80)
# Update progress: Generating ideas with AI (10-80%)
self.update_state(
state='PROGRESS',
meta={
'current': 0,
'total': total_clusters,
'percentage': 10,
'message': 'Generating content ideas with AI...',
'phase': 'generating'
}
)
# Use new AI framework with proper logging
account = clusters[0].account if clusters else None
account_id = account.id if account else None
# Process each cluster using the new framework
from igny8_core.ai.functions.generate_ideas import generate_ideas_core
from igny8_core.ai.tasks import run_ai_task
ideas_created = 0
all_ideas = []
# Process each cluster individually using the new framework
for idx, cluster in enumerate(clusters):
cluster_id = cluster.id
logger.info(f"Processing cluster {idx + 1}/{total_clusters}: {cluster_id}")
# Update progress
progress_pct = 10 + int((idx / total_clusters) * 70)
self.update_state(
state='PROGRESS',
meta={
'current': idx + 1,
'total': total_clusters,
'percentage': progress_pct,
'message': f'Generating idea for cluster "{cluster.name}" ({idx + 1} of {total_clusters})...',
'phase': 'generating',
'current_item': cluster.name
}
)
# Use new framework - always use generate_ideas_core for proper console logging
try:
import sys
print(f"[CELERY TASK] Calling generate_ideas_core for cluster {cluster_id}...", flush=True, file=sys.stdout)
# Use generate_ideas_core which has ConsoleStepTracker built in
result = generate_ideas_core(cluster_id, account_id=account_id)
print(f"[CELERY TASK] generate_ideas_core returned: success={result.get('success')}, error={result.get('error')}", flush=True, file=sys.stdout)
if result.get('success'):
ideas_created += result.get('idea_created', 0)
logger.info(f"✓ Successfully generated idea for cluster {cluster_id}")
print(f"[CELERY TASK] ✓ Successfully generated idea for cluster {cluster_id}", flush=True, file=sys.stdout)
else:
error_msg = result.get('error', 'Unknown error')
logger.error(f"✗ Failed to generate idea for cluster {cluster_id}: {error_msg}")
print(f"[CELERY TASK] ✗ Failed to generate idea for cluster {cluster_id}: {error_msg}", flush=True, file=sys.stdout)
# Update task state with error for this cluster
self.update_state(
state='PROGRESS',
meta={
'current': idx + 1,
'total': total_clusters,
'percentage': progress_pct,
'message': f'Error generating idea for cluster "{cluster.name}": {error_msg}',
'phase': 'error',
'current_item': cluster.name,
'error': error_msg,
'error_type': result.get('error_type', 'GenerationError')
}
)
except Exception as e:
import sys
import traceback
error_msg = str(e)
error_type = type(e).__name__
print("=" * 80, flush=True, file=sys.stdout)
print(f"[CELERY TASK] EXCEPTION in generate_ideas_core call: {error_type}: {error_msg}", flush=True, file=sys.stdout)
print("[CELERY TASK] Full traceback:", flush=True, file=sys.stdout)
traceback.print_exc(file=sys.stdout)
print("=" * 80, flush=True, file=sys.stdout)
logger.error(f"✗ Error generating idea for cluster {cluster_id}: {error_msg}", exc_info=True)
# Update task state with exception
self.update_state(
state='PROGRESS',
meta={
'current': idx + 1,
'total': total_clusters,
'percentage': progress_pct,
'message': f'Exception generating idea for cluster "{cluster.name}": {error_msg}',
'phase': 'error',
'current_item': cluster.name,
'error': error_msg,
'error_type': error_type
}
)
# Ideas are already saved by the new framework, just log results
logger.info("=" * 80)
logger.info(f"IDEAS GENERATION COMPLETE: {ideas_created} ideas created")
logger.info("=" * 80)
if ideas_created == 0:
logger.warning("No ideas were created")
self.update_state(
state='FAILURE',
meta={
'error': 'No ideas created',
'message': 'No ideas were created'
}
)
return {'success': False, 'error': 'No ideas created'}
# Final progress update
final_message = f"Ideas generation complete: {ideas_created} ideas created for {total_clusters} clusters"
logger.info(final_message)
return {
'success': True,
'ideas_created': ideas_created,
'message': final_message,
}
except Exception as e:
logger.error(f"Error in auto_generate_ideas_task: {str(e)}", exc_info=True)
self.update_state(
state='FAILURE',
meta={
'error': str(e),
'message': f'Error: {str(e)}'
}
)
raise
def _generate_single_idea_core(cluster_id: int, account_id: int = None, progress_callback=None):
"""
Core logic for generating a single content idea for a cluster. Can be called with or without Celery.
Args:
cluster_id: Cluster ID to generate idea for
account_id: Account ID for account isolation
progress_callback: Optional function to call for progress updates (for Celery tasks)
"""
account_id = account_id
try:
# Initialize progress if callback provided
if progress_callback:
progress_callback(
state='PROGRESS',
meta={
'current': 0,
'total': 1,
'percentage': 0,
'message': 'Initializing single idea generation...',
'phase': 'initializing'
}
)
# Get cluster with keywords and relationships
clusters_queryset = Clusters.objects.filter(id=cluster_id)
if account_id:
clusters_queryset = clusters_queryset.filter(account_id=account_id)
clusters = list(clusters_queryset.select_related('sector', 'account', 'site').prefetch_related('keywords'))
if not clusters:
logger.warning(f"Cluster not found: {cluster_id}")
return {'success': False, 'error': 'Cluster not found'}
cluster = clusters[0]
# Update progress: Preparing cluster (0-10%)
if progress_callback:
progress_callback(
state='PROGRESS',
meta={
'current': 0,
'total': 1,
'percentage': 5,
'message': f'Preparing cluster "{cluster.name}"...',
'phase': 'preparing',
'current_item': cluster.name
}
)
# Get keywords for this cluster
keywords = Keywords.objects.filter(cluster=cluster).values_list('keyword', flat=True)
# Format cluster data for AI
cluster_data = [{
'id': cluster.id,
'name': cluster.name,
'description': cluster.description or '',
'keywords': list(keywords),
}]
# Update progress: Generating idea with AI (10-80%)
if progress_callback:
progress_callback(
state='PROGRESS',
meta={
'current': 0,
'total': 1,
'percentage': 10,
'message': 'Generating content idea with AI...',
'phase': 'generating'
}
)
# Use new AI framework with proper logging
account = getattr(cluster, 'account', None)
account_id = account.id if account else None
# Use new framework with proper console logging
from igny8_core.ai.functions.generate_ideas import generate_ideas_core
# Use generate_ideas_core which has ConsoleStepTracker built in
try:
result = generate_ideas_core(cluster_id, account_id=account_id, progress_callback=progress_callback)
except Exception as e:
logger.error(f"Error generating idea: {str(e)}", exc_info=True)
return {'success': False, 'error': str(e)}
if not result.get('success'):
error_msg = result.get('error', 'Unknown error')
logger.error(f"AI idea generation error: {error_msg}")
return {'success': False, 'error': error_msg}
idea_created = result.get('idea_created', 0) or result.get('ideas_created', 0)
if progress_callback:
progress_callback(
state='PROGRESS',
meta={
'current': 1,
'total': 1,
'percentage': 95,
'message': 'Idea generation complete',
'phase': 'complete'
}
)
# Ideas are already saved by the new framework (generate_ideas_core or run_ai_task)
# No need to save again here
# Final progress update
final_message = f"Idea generation complete: {idea_created} idea(s) created"
logger.info(final_message)
if progress_callback:
progress_callback(
state='SUCCESS',
meta={
'current': 1,
'total': 1,
'percentage': 100,
'message': final_message,
'phase': 'completed'
}
)
return {
'success': True,
'idea_created': idea_created,
'message': final_message,
}
except Exception as e:
logger.error(f"Error in _generate_single_idea_core: {str(e)}", exc_info=True)
if progress_callback:
progress_callback(
state='FAILURE',
meta={
'error': str(e),
'message': f'Error: {str(e)}'
}
)
return {'success': False, 'error': str(e)}
@shared_task(bind=True, max_retries=3)
def generate_single_idea_task(self, cluster_id: int, account_id: int = None):
"""
Celery task to generate a single content idea for a cluster using AI.
Args:
cluster_id: Cluster ID
account_id: Account ID for account isolation
"""
def progress_callback(state, meta):
self.update_state(state=state, meta=meta)
return _generate_single_idea_core(cluster_id, account_id, progress_callback)
# REMOVED: All idea generation functions removed
# - auto_generate_ideas_task
# - _generate_single_idea_core
# - generate_single_idea_task

187
backend/igny8_core/modules/planner/views.py
View File

@@ -714,99 +714,7 @@ class ClusterViewSet(SiteSectorModelViewSet):
# Save with all required fields explicitly
serializer.save(account=account, site=site, sector=sector)
@action(detail=False, methods=['post'], url_path='auto_generate_ideas', url_name='auto_generate_ideas')
def auto_generate_ideas(self, request):
"""Generate content ideas for clusters using AI"""
ids = request.data.get('ids', [])
if not ids:
return Response({'error': 'No cluster IDs provided'}, status=status.HTTP_400_BAD_REQUEST)
if len(ids) > 5:
return Response({'error': 'Maximum 5 clusters allowed for idea generation'}, status=status.HTTP_400_BAD_REQUEST)
# Get account - handle RelatedObjectDoesNotExist
account = None
account_id = None
try:
account = getattr(request, 'account', None)
if account:
# Access pk directly instead of id to avoid potential relationship access
account_id = getattr(account, 'pk', None) or getattr(account, 'id', None)
except Exception as e:
import logging
logger = logging.getLogger(__name__)
logger.error(f"Error getting account: {type(e).__name__}: {e}", exc_info=True)
account_id = None
# Try to queue Celery task, fall back to synchronous if Celery not available
try:
import logging
logger = logging.getLogger(__name__)
logger.info(f"auto_generate_ideas called with ids={ids}, account_id={account_id}")
from .tasks import auto_generate_ideas_task
from kombu.exceptions import OperationalError as KombuOperationalError
if hasattr(auto_generate_ideas_task, 'delay'):
try:
# Celery is available - queue async task
logger.info("Queuing Celery task...")
task = auto_generate_ideas_task.delay(ids, account_id=account_id)
logger.info(f"Task queued successfully: {task.id}")
return Response({
'success': True,
'task_id': str(task.id),
'message': 'Idea generation started'
}, status=status.HTTP_200_OK)
except (KombuOperationalError, ConnectionError) as e:
# Celery connection failed - execute synchronously
logger.warning(f"Celery connection failed, executing synchronously: {e}")
result = auto_generate_ideas_task(ids, account_id=account_id)
if result.get('success'):
return Response({
'success': True,
'ideas_created': result.get('ideas_created', 0),
'message': 'Ideas generated successfully'
}, status=status.HTTP_200_OK)
else:
return Response({
'success': False,
'error': result.get('error', 'Idea generation failed')
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
# Celery not available - execute synchronously
logger.info("Celery not available, executing synchronously")
result = auto_generate_ideas_task(ids, account_id=account_id)
if result.get('success'):
return Response({
'success': True,
'ideas_created': result.get('ideas_created', 0),
'message': 'Ideas generated successfully'
}, status=status.HTTP_200_OK)
else:
return Response({
'success': False,
'error': result.get('error', 'Idea generation failed')
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ImportError as e:
import logging
logger = logging.getLogger(__name__)
logger.error(f"ImportError in auto_generate_ideas: {e}", exc_info=True)
return Response({
'success': False,
'error': 'AI tasks module not available'
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as e:
import logging
logger = logging.getLogger(__name__)
error_type = type(e).__name__
error_msg = str(e)
logger.error(f"Error in auto_generate_ideas: {error_type}: {error_msg}", exc_info=True)
return Response({
'success': False,
'error': f'Unexpected error: {error_msg}'
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
# REMOVED: auto_generate_ideas action - idea generation function removed
def list(self, request, *args, **kwargs):
"""
@@ -938,95 +846,4 @@ class ContentIdeasViewSet(SiteSectorModelViewSet):
'message': f'Successfully queued {len(created_tasks)} ideas to writer'
}, status=status.HTTP_200_OK)
@action(detail=True, methods=['post'], url_path='generate_idea', url_name='generate_idea')
def generate_idea(self, request, pk=None):
"""Generate a single content idea for a cluster using AI"""
import logging
logger = logging.getLogger(__name__)
try:
cluster_id = request.data.get('cluster_id')
if not cluster_id:
return Response({'error': 'cluster_id is required'}, status=status.HTTP_400_BAD_REQUEST)
# Get account - handle RelatedObjectDoesNotExist
account = None
account_id = None
try:
account = getattr(request, 'account', None)
if account:
account_id = getattr(account, 'pk', None) or getattr(account, 'id', None)
except Exception as e:
logger.error(f"Error getting account: {type(e).__name__}: {e}", exc_info=True)
account_id = None
# Try to queue Celery task, fall back to synchronous if Celery not available
try:
from .tasks import generate_single_idea_task
from kombu.exceptions import OperationalError as KombuOperationalError
if hasattr(generate_single_idea_task, 'delay'):
try:
# Celery is available - queue async task
task = generate_single_idea_task.delay(cluster_id, account_id=account_id)
return Response({
'success': True,
'task_id': str(task.id),
'message': 'Idea generation started'
}, status=status.HTTP_200_OK)
except (KombuOperationalError, ConnectionError) as e:
# Celery connection failed - execute synchronously
logger.warning(f"Celery connection failed, executing synchronously: {e}")
from igny8_core.ai.functions.generate_ideas import generate_ideas_core
result = generate_ideas_core(cluster_id, account_id=account_id, progress_callback=None)
if result.get('success'):
return Response({
'success': True,
'idea_created': result.get('idea_created', 0),
'message': 'Idea generated successfully'
}, status=status.HTTP_200_OK)
else:
return Response({
'success': False,
'error': result.get('error', 'Idea generation failed')
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
# Celery not available - execute synchronously
logger.info("Celery not available, executing synchronously")
from .tasks import _generate_single_idea_core
result = _generate_single_idea_core(cluster_id, account_id=account_id, progress_callback=None)
if result.get('success'):
return Response({
'success': True,
'idea_created': result.get('idea_created', 0),
'message': 'Idea generated successfully'
}, status=status.HTTP_200_OK)
else:
return Response({
'success': False,
'error': result.get('error', 'Idea generation failed')
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ImportError as e:
error_type = type(e).__name__
error_msg = str(e)
logger.error(f"Error importing tasks module: {error_type}: {error_msg}", exc_info=True)
return Response({
'success': False,
'error': 'AI tasks module not available'
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as e:
error_type = type(e).__name__
error_msg = str(e)
logger.error(f"Error in generate_idea: {error_type}: {error_msg}", exc_info=True)
return Response({
'success': False,
'error': f'Unexpected error: {error_msg}'
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as e:
error_type = type(e).__name__
error_msg = str(e)
logger.error(f"Unexpected error in generate_idea: {error_type}: {error_msg}", exc_info=True)
return Response({
'success': False,
'error': f'Unexpected error: {error_msg}'
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
# REMOVED: generate_idea action - idea generation function removed