kk

APSCHEDULER_SETUP.md

@@ -0,0 +1,165 @@
+# APScheduler Scheduling Setup Guide
+
+This guide explains how to set up and use the APScheduler scheduling system with your Lin application.
+
+## Overview
+
+The updated `start_app.py` now automatically starts the Flask application with APScheduler integrated. This ensures that your scheduled tasks will execute properly without requiring external dependencies like Redis.
+
+## Prerequisites
+
+### 1. Python Dependencies
+Install the required packages:
+```bash
+pip install -r backend/requirements.txt
+```
+
+## Starting the Application
+
+### Using start_app.py (Recommended)
+```bash
+python start_app.py
+```
+
+This will:
+1. Start the Flask application with APScheduler integrated
+2. APScheduler will automatically load schedules from the database every 5 minutes
+3. Schedules will be executed according to their defined times
+
+## Configuration
+
+### Environment Variables
+Make sure these are set in your `.env` file:
+
+```env
+# Supabase configuration
+SUPABASE_URL="your_supabase_url"
+SUPABASE_KEY="your_supabase_key"
+
+# Scheduler configuration
+SCHEDULER_ENABLED=True
+```
+
+### APScheduler Configuration
+The scheduler configuration is in `backend/scheduler/apscheduler_service.py`:
+
+```python
+# APScheduler will run every 5 minutes as a backup
+scheduler.add_job(
+    func=self.load_schedules,
+    trigger=CronTrigger(minute='*/5'),  # Every 5 minutes
+    id='load_schedules',
+    name='Load schedules from database',
+    replace_existing=True
+)
+```
+
+## How Scheduling Works
+
+### 1. Schedule Loading
+- **Immediate Updates**: When you create or delete a schedule via the API, APScheduler is updated immediately
+- **Periodic Updates**: APScheduler also runs every 5 minutes as a backup
+- Fetches schedules from Supabase database
+- Creates individual periodic tasks for each schedule
+
+### 2. Task Execution
+- **Content Generation**: Runs 5 minutes before scheduled time
+- **Post Publishing**: Runs at the scheduled time
+
+### 3. Database Integration
+- Uses Supabase for schedule storage
+- Automatically creates tasks based on schedule data
+- Handles social network authentication
+
+## Monitoring and Debugging
+
+### Checking Scheduler Status
+The scheduler runs in the same process as the Flask application, so you can check the console output for logs.
+
+### Viewing Logs
+- **Flask Application**: Check console output
+- **Scheduler**: Look for scheduler process logs in the same console
+
+### Common Issues
+
+**1. Tasks Not Executing**
+- Check if the Flask application is running
+- Verify schedule data in the database
+- Check the console logs for any errors
+
+**2. Schedule Not Loading**
+- Check Supabase database connection
+- Verify schedule data in database
+- Check task registration in APScheduler
+
+## Testing the Scheduling System
+
+### Manual Testing
+```python
+# Test schedule loading
+from backend.scheduler.apscheduler_service import APSchedulerService
+scheduler = APSchedulerService()
+result = scheduler.load_schedules()
+print(result)
+```
+
+### API Testing (Recommended)
+1. **Create a schedule via the API**:
+   ```bash
+   curl -X POST http://localhost:5000/api/schedules/ \
+     -H "Content-Type: application/json" \
+     -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+     -d '{
+       "social_network": "1",
+       "schedule_time": "09:00",
+       "days": ["Monday", "Wednesday", "Friday"]
+     }'
+   ```
+   
+2. **Check the response**: You should see a message indicating the scheduler was updated immediately
+
+3. **Verify in Logs**: Check if the individual tasks were created in the console logs
+
+### Database Testing
+1. Add a schedule directly in the Supabase database
+2. Wait 5 minutes for the loader task to run (or trigger via API)
+3. Check if individual tasks were created
+4. Verify task execution times
+
+## Production Deployment
+
+### Using Docker (Recommended for Hugging Face Spaces)
+```bash
+# Build the Docker image
+docker build -t lin-app .
+
+# Run the container
+docker run -p 7860:7860 lin-app
+
+# For Hugging Face Spaces deployment:
+# 1. Update your Dockerfile (already done above)
+# 2. Push to Hugging Face Spaces
+# 3. The container will automatically start your app with APScheduler
+```
+
+### Using Docker Compose (Not Required)
+Since APScheduler doesn't require external dependencies like Redis, you don't need Docker Compose for the scheduler.
+
+## Troubleshooting Checklist
+
+1. ✅ All Python dependencies are installed
+2. ✅ Environment variables are set correctly
+3. ✅ Supabase database connection works
+4. ✅ Schedule data exists in database
+5. ✅ Flask application is running
+6. ✅ Scheduler is properly initialized
+
+## Support
+
+If you encounter issues:
+1. Check this guide first
+2. Review the logs for error messages
+3. Verify all prerequisites are met
+4. Test components individually
+
+For additional help, refer to the APScheduler documentation at: https://apscheduler.readthedocs.io/

GEMINI.md

@@ -96,6 +96,7 @@ pip install -r requirements.txt
 - Uses Supabase for authentication and database
 - Implements JWT for token-based authentication
 - Uses SQLAlchemy for database operations
+- Uses APScheduler for task scheduling
 - Follows REST API design principles
 
 ### UI Components
@@ -111,8 +112,9 @@ The application features several key UI components:
 1. **Authentication**: Login and registration functionality with JWT tokens
 2. **LinkedIn Integration**: OAuth integration for connecting LinkedIn accounts
 3. **Content Management**: Create, edit, and schedule posts
-4. **Analytics**: Dashboard with overview and analytics
-5. **Responsive UI**: Mobile-friendly design with optimized touch interactions
+4. **Automated Scheduling**: Uses APScheduler for reliable task scheduling
+5. **Analytics**: Dashboard with overview and analytics
+6. **Responsive UI**: Mobile-friendly design with optimized touch interactions
 
 ## Environment Setup
 
@@ -151,7 +153,7 @@ cp .env.example .env
 - `JWT_SECRET_KEY` - Secret key for JWT token generation
 - `SECRET_KEY` - Flask secret key
 - `DEBUG` - Debug mode (True/False)
-- `SCHEDULER_ENABLED` - Enable/disable task scheduler (True/False)
+- `SCHEDULER_ENABLED` - Enable/disable APScheduler (True/False)
 - `PORT` - Port to run the application on (default: 5000)
 
 ## Development URLs

MIGRATION_TO_APSCHEDULER.md

@@ -0,0 +1,84 @@
+# Migrating from Celery to APScheduler
+
+This guide explains how to migrate from Celery to APScheduler in the Lin application.
+
+## Why Migrate to APScheduler?
+
+1. **Simplified Architecture**: APScheduler runs within the Flask application process, eliminating the need for separate worker processes
+2. **No External Dependencies**: Unlike Celery which requires Redis or RabbitMQ, APScheduler uses in-memory storage by default
+3. **Easier Deployment**: Simplifies deployment since there are fewer components to manage
+4. **Reduced Resource Usage**: Uses less memory and CPU compared to running separate Celery processes
+
+## Changes Made
+
+### 1. Removed Dependencies
+- Removed `celery` and `redis` from `requirements.txt`
+- Kept `apscheduler` as the scheduling library
+
+### 2. New Scheduler Service
+- Created `backend/scheduler/apscheduler_service.py` to handle all scheduling tasks
+- Implemented content generation and post publishing as APScheduler jobs
+
+### 3. Updated Flask Application
+- Modified `backend/app.py` to initialize APScheduler instead of Celery
+- Added scheduler initialization when `SCHEDULER_ENABLED` is True
+
+### 4. Updated API Endpoints
+- Modified `backend/api/schedules.py` to trigger APScheduler updates instead of Celery tasks
+- Removed all references to Celery task IDs in responses
+
+### 5. Simplified Startup Script
+- Updated `start_app.py` to remove Celery component initialization
+- The application now starts with just Flask and APScheduler
+
+### 6. Removed Files
+- Removed `backend/celery_app.py`
+- Removed `backend/celery_config.py`
+- Removed `backend/celery_tasks/` directory
+- Removed `backend/start_celery.py`
+
+## Migration Steps
+
+### 1. Update Dependencies
+```bash
+# Update requirements
+pip install -r backend/requirements.txt
+```
+
+### 2. Update Environment Variables
+No changes needed for basic setup. The scheduler is enabled by default.
+
+### 3. Remove Old Components
+The old Celery components have been removed from the codebase.
+
+### 4. Verify Functionality
+1. Start the application:
+   ```bash
+   python start_app.py
+   ```
+
+2. Create a test schedule via the API
+
+3. Check the console logs to verify that schedules are being loaded and tasks are being created
+
+## Benefits of the Migration
+
+1. **Simpler Setup**: No need to install and configure Redis
+2. **Easier Debugging**: All logs are in one place
+3. **Reduced Complexity**: Fewer moving parts to manage
+4. **Better Resource Usage**: Lower memory and CPU footprint
+5. **Simplified Deployment**: Single process deployment
+
+## Potential Considerations
+
+1. **Scalability**: For high-volume applications, Celery with multiple workers might be more appropriate
+2. **Persistence**: APScheduler uses in-memory storage by default, which means schedules are lost on application restart (this is mitigated by reloading from the database every 5 minutes)
+3. **Task Isolation**: All tasks run in the same process, so a long-running task could block others
+
+## Support
+
+If you encounter issues during migration:
+1. Check the application logs for error messages
+2. Verify that all dependencies are correctly installed
+3. Ensure the Supabase connection is working
+4. Test creating and deleting schedules via the API

backend/api/schedules.py

@@ -1,7 +1,6 @@
 from flask import Blueprint, request, jsonify, current_app
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.schedule_service import ScheduleService
-from backend.celery_tasks.schedule_loader import load_schedules_task
 
 schedules_bp = Blueprint('schedules', __name__)
 
@@ -132,19 +131,20 @@ def create_schedule():
         result = schedule_service.create_schedule(user_id, social_network, schedule_time, days)
         
         if result['success']:
-            # Trigger immediate Celery Beat schedule update
+            # Trigger immediate APScheduler update
             try:
-                print("[INFO] Triggering immediate Celery Beat schedule update...")
-                # Execute the schedule loader task immediately to update Celery Beat
-                celery_result = load_schedules_task.apply_async(queue='scheduler')
-                print(f"[INFO] Celery Beat update task queued: {celery_result.id}")
-                
-                # Add the task ID to the response for tracking
-                result['celery_update_task_id'] = celery_result.id
-                result['message'] += ' (Scheduler updated immediately)'
+                print("[INFO] Triggering immediate APScheduler update...")
+                if hasattr(current_app, 'scheduler'):
+                    scheduler_updated = current_app.scheduler.trigger_immediate_update()
+                    if scheduler_updated:
+                        result['message'] += ' (Scheduler updated immediately)'
+                    else:
+                        result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
+                else:
+                    result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             except Exception as e:
-                print(f"[WARNING] Failed to trigger immediate Celery update: {str(e)}")
-                # Don't fail the schedule creation if Celery update fails
+                print(f"[WARNING] Failed to trigger immediate scheduler update: {str(e)}")
+                # Don't fail the schedule creation if scheduler update fails
                 result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             
             # Add CORS headers to success response
@@ -225,19 +225,20 @@ def delete_schedule(schedule_id):
         result = schedule_service.delete_schedule(schedule_id)
         
         if result['success']:
-            # Trigger immediate Celery Beat schedule update
+            # Trigger immediate APScheduler update
             try:
-                print("[INFO] Triggering immediate Celery Beat schedule update after deletion...")
-                # Execute the schedule loader task immediately to update Celery Beat
-                celery_result = load_schedules_task.apply_async(queue='scheduler')
-                print(f"[INFO] Celery Beat update task queued: {celery_result.id}")
-                
-                # Add the task ID to the response for tracking
-                result['celery_update_task_id'] = celery_result.id
-                result['message'] += ' (Scheduler updated immediately)'
+                print("[INFO] Triggering immediate APScheduler update after deletion...")
+                if hasattr(current_app, 'scheduler'):
+                    scheduler_updated = current_app.scheduler.trigger_immediate_update()
+                    if scheduler_updated:
+                        result['message'] += ' (Scheduler updated immediately)'
+                    else:
+                        result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
+                else:
+                    result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             except Exception as e:
-                print(f"[WARNING] Failed to trigger immediate Celery update: {str(e)}")
-                # Don't fail the schedule deletion if Celery update fails
+                print(f"[WARNING] Failed to trigger immediate scheduler update: {str(e)}")
+                # Don't fail the schedule deletion if scheduler update fails
                 result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             
             # Add CORS headers to success response

backend/app.py

@@ -13,8 +13,8 @@ from backend.config import Config
 from backend.utils.database import init_supabase
 from backend.utils.cookies import setup_secure_cookies, configure_jwt_with_cookies
 
-# Celery imports
-from backend.celery_app import celery
+# APScheduler imports
+from backend.scheduler.apscheduler_service import APSchedulerService
 
 def setup_unicode_environment():
     """Setup Unicode environment for proper character handling."""
@@ -115,9 +115,14 @@ def create_app():
     app.job_store = {}
     
     # Initialize a ThreadPoolExecutor for running background tasks
-    # In production, you'd use a proper task queue like Celery
+    # In production, you'd use a proper task scheduler like APScheduler
     app.executor = ThreadPoolExecutor(max_workers=4)
     
+    # Initialize APScheduler
+    if app.config.get('SCHEDULER_ENABLED', True):
+        scheduler = APSchedulerService(app)
+        app.scheduler = scheduler
+    
     # Register blueprints
     from backend.api.auth import auth_bp
     from backend.api.sources import sources_bp

backend/celery_app.py

@@ -1,36 +0,0 @@
-import os
-from celery import Celery
-# Use relative import for the Config class to work with Hugging Face Spaces
-from backend.config import Config
-
-def make_celery(app_name=__name__):
-    """Create and configure the Celery application."""
-    # Create Celery instance
-    celery = Celery(app_name)
-    
-    # Configure Celery with broker and result backend from environment variables
-    celery.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
-    celery.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
-    
-    # Additional Celery configuration
-    celery.conf.update(
-        task_serializer='json',
-        accept_content=['json'],
-        result_serializer='json',
-        timezone='UTC',
-        enable_utc=True,
-        task_routes={
-            'celery_tasks.content_tasks.generate_content': {'queue': 'content'},
-            'celery_tasks.publish_tasks.publish_post': {'queue': 'publish'},
-        },
-        worker_prefetch_multiplier=1,
-        task_acks_late=True,
-    )
-    
-    return celery
-
-# Create the Celery instance
-celery = make_celery()
-
-if __name__ == '__main__':
-    celery.start()

backend/celery_beat_config.py

@@ -1,24 +0,0 @@
-from celery import Celery
-from celery.schedules import crontab
-import os
-
-# Import the task function
-from backend.celery_tasks.schedule_loader import load_schedules_task
-
-# Create Celery instance for Beat scheduler
-celery_beat = Celery('lin_scheduler')
-
-# Configure Celery Beat
-celery_beat.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
-celery_beat.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
-
-# Configure schedules
-celery_beat.conf.beat_schedule = {
-    # This task will run every 5 minutes to load schedules from the database
-    'load-schedules': {
-        'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
-        'schedule': crontab(minute='*/5'),
-    },
-}
-
-celery_beat.conf.timezone = 'UTC'

backend/celery_config.py

@@ -1,75 +0,0 @@
-"""
-Unified Celery configuration for the Lin application.
-This centralizes all Celery configuration to avoid conflicts.
-"""
-
-import os
-from celery import Celery
-from celery.schedules import crontab
-from backend.config import Config
-
-# Create Celery instance
-celery_app = Celery('lin_app')
-
-# Configure Celery with broker and result backend
-celery_app.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
-celery_app.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
-
-# Additional Celery configuration
-celery_app.conf.update(
-    # Task serialization
-    task_serializer='json',
-    accept_content=['json'],
-    result_serializer='json',
-    timezone='UTC',
-    enable_utc=True,
-    
-    # Task routing
-    task_routes={
-        'backend.celery_tasks.content_tasks.generate_content_task': {'queue': 'content'},
-        'backend.celery_tasks.content_tasks.publish_post_task': {'queue': 'publish'},
-        'backend.celery_tasks.schedule_loader.load_schedules_task': {'queue': 'scheduler'},
-    },
-    
-    # Worker configuration
-    worker_prefetch_multiplier=1,
-    task_acks_late=True,
-    worker_max_tasks_per_child=100,
-    
-    # Beat schedule configuration (scheduler itself will be default)
-    # beat_scheduler is not set, so it defaults to 'celery.beat:PersistentScheduler'
-    beat_schedule={
-        # This task will run every 5 minutes to load schedules from the database
-        'load-schedules': {
-            'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
-            'schedule': crontab(minute='*/5'),
-        },
-    },
-    
-    # Task result expiration
-    result_expires=3600,  # 1 hour
-    
-    # Task time limits
-    task_soft_time_limit=300,  # 5 minutes
-    task_time_limit=600,  # 10 minutes
-    
-    # Rate limiting
-    task_annotations=(
-        ('backend.celery_tasks.content_tasks.generate_content_task', {'rate_limit': '10/h'}),
-        ('backend.celery_tasks.content_tasks.publish_post_task', {'rate_limit': '30/h'}),
-    ),
-    
-    # Error handling
-    task_reject_on_worker_lost=True,
-    worker_disable_rate_limits=False,
-    
-    # Security
-    result_backend_transport_options={'visibility': 'hidden'},
-    broker_connection_max_retries=3,
-    broker_connection_retry_delay=5,
-)
-
-# Import tasks to ensure they're registered
-from backend import celery_tasks
-
-__all__ = ['celery_app']

backend/celery_tasks/__init__.py

@@ -1,6 +0,0 @@
-# Initialize the celery_tasks package
-from . import content_tasks
-from . import schedule_loader
-
-# Import all tasks to ensure they are registered with Celery
-__all__ = ['content_tasks', 'schedule_loader']

backend/celery_tasks/content_tasks.py

@@ -1,193 +0,0 @@
-from celery import current_task
-from backend.services.content_service import ContentService
-from backend.services.linkedin_service import LinkedInService
-from backend.utils.database import init_supabase
-from backend.celery_config import celery_app
-
-# Configure logging
-import logging
-logger = logging.getLogger(__name__)
-
-@celery_app.task(bind=True)
-def generate_content_task(self, user_id: str, schedule_id: str, supabase_client_config: dict):
-    """
-    Celery task to generate content for a scheduled post.
-    
-    Args:
-        user_id (str): User ID
-        schedule_id (str): Schedule ID
-        supabase_client_config (dict): Supabase client configuration
-        
-    Returns:
-        dict: Result of content generation
-    """
-    try:
-        print(f"[CONTENT TASK] Starting content generation for schedule {schedule_id}")
-        logger.info(f"Starting content generation for schedule {schedule_id}")
-        
-        # Update task state
-        self.update_state(state='PROGRESS', meta={'status': 'Generating content...'})
-        
-        # Initialize content service
-        content_service = ContentService()
-        
-        # Generate content using content service
-        generated_content = content_service.generate_post_content(user_id)
-        
-        # Initialize Supabase client from config
-        from backend.utils.database import init_supabase
-        supabase_client = init_supabase(
-            supabase_client_config['SUPABASE_URL'], 
-            supabase_client_config['SUPABASE_KEY']
-        )
-        
-        # Store generated content in database
-        # We need to get the social account ID from the schedule
-        schedule_response = (
-            supabase_client
-            .table("Scheduling")
-            .select("id_social")
-            .eq("id", schedule_id)
-            .execute()
-        )
-        
-        if not schedule_response.data:
-            raise Exception(f"Schedule {schedule_id} not found")
-            
-        social_account_id = schedule_response.data[0]['id_social']
-        
-        # Store the generated content
-        response = (
-            supabase_client
-            .table("Post_content")
-            .insert({
-                "social_account_id": social_account_id,
-                "Text_content": generated_content,
-                "is_published": False,
-                "sched": schedule_id
-            })
-            .execute()
-        )
-        
-        if response.data:
-            logger.info(f"Content generated and stored for schedule {schedule_id}")
-            return {
-                'status': 'success',
-                'message': f'Content generated for schedule {schedule_id}',
-                'post_id': response.data[0]['id']
-            }
-        else:
-            logger.error(f"Failed to store generated content for schedule {schedule_id}")
-            return {
-                'status': 'failure',
-                'message': f'Failed to store generated content for schedule {schedule_id}'
-            }
-            
-    except Exception as e:
-        logger.error(f"Error in content generation task for schedule {schedule_id}: {str(e)}")
-        return {
-            'status': 'failure',
-            'message': f'Error in content generation: {str(e)}'
-        }
-
-@celery_app.task(bind=True)
-def publish_post_task(self, schedule_id: str, supabase_client_config: dict):
-    """
-    Celery task to publish a scheduled post.
-    
-    Args:
-        schedule_id (str): Schedule ID
-        supabase_client_config (dict): Supabase client configuration
-        
-    Returns:
-        dict: Result of post publishing
-    """
-    try:
-        print(f"[PUBLISH TASK] Starting post publishing for schedule {schedule_id}")
-        logger.info(f"Starting post publishing for schedule {schedule_id}")
-        
-        # Update task state
-        self.update_state(state='PROGRESS', meta={'status': 'Publishing post...'})
-        
-        # Initialize Supabase client from config
-        from backend.utils.database import init_supabase
-        supabase_client = init_supabase(
-            supabase_client_config['SUPABASE_URL'], 
-            supabase_client_config['SUPABASE_KEY']
-        )
-        
-        # Fetch the post to publish
-        response = (
-            supabase_client
-            .table("Post_content")
-            .select("*")
-            .eq("sched", schedule_id)
-            .eq("is_published", False)
-            .order("created_at", desc=True)
-            .limit(1)
-            .execute()
-        )
-        
-        if not response.data:
-            logger.info(f"No unpublished posts found for schedule {schedule_id}")
-            return {
-                'status': 'info',
-                'message': f'No unpublished posts found for schedule {schedule_id}'
-            }
-        
-        post = response.data[0]
-        post_id = post.get('id')
-        text_content = post.get('Text_content')
-        image_url = post.get('image_content_url')
-        
-        # Get social network credentials
-        schedule_response = (
-            supabase_client
-            .table("Scheduling")
-            .select("Social_network(token, sub)")
-            .eq("id", schedule_id)
-            .execute()
-        )
-        
-        if not schedule_response.data:
-            raise Exception(f"Schedule {schedule_id} not found")
-            
-        social_network = schedule_response.data[0].get('Social_network', {})
-        access_token = social_network.get('token')
-        user_sub = social_network.get('sub')
-        
-        if not access_token or not user_sub:
-            logger.error(f"Missing social network credentials for schedule {schedule_id}")
-            return {
-                'status': 'failure',
-                'message': f'Missing social network credentials for schedule {schedule_id}'
-            }
-        
-        # Publish to LinkedIn
-        linkedin_service = LinkedInService()
-        publish_response = linkedin_service.publish_post(
-            access_token, user_sub, text_content, image_url
-        )
-        
-        # Update post status in database
-        update_response = (
-            supabase_client
-            .table("Post_content")
-            .update({"is_published": True})
-            .eq("id", post_id)
-            .execute()
-        )
-        
-        logger.info(f"Post published successfully for schedule {schedule_id}")
-        return {
-            'status': 'success',
-            'message': f'Post published successfully for schedule {schedule_id}',
-            'linkedin_response': publish_response
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in publishing task for schedule {schedule_id}: {str(e)}")
-        return {
-            'status': 'failure',
-            'message': f'Error in publishing post: {str(e)}'
-        }

backend/celery_tasks/schedule_loader.py

@@ -1,209 +0,0 @@
-from celery import current_app
-from celery.schedules import crontab
-from datetime import datetime
-import logging
-from backend.utils.database import init_supabase
-from backend.config import Config
-from backend.celery_tasks.scheduler import schedule_content_generation, schedule_post_publishing
-from backend.celery_config import celery_app
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-def get_supabase_config():
-    """Get Supabase configuration from environment."""
-    return {
-        'SUPABASE_URL': Config.SUPABASE_URL,
-        'SUPABASE_KEY': Config.SUPABASE_KEY
-    }
-
-def parse_schedule_time(schedule_time):
-    """
-    Parse schedule time string into crontab format.
-    
-    Args:
-        schedule_time (str): Schedule time in format "Day HH:MM"
-        
-    Returns:
-        dict: Crontab parameters
-    """
-    try:
-        print(f"[CELERY BEAT] Parsing schedule time: {schedule_time}")
-        day_name, time_str = schedule_time.split()
-        hour, minute = map(int, time_str.split(':'))
-        
-        # Map day names to crontab format
-        day_map = {
-            'Monday': 1,
-            'Tuesday': 2,
-            'Wednesday': 3,
-            'Thursday': 4,
-            'Friday': 5,
-            'Saturday': 6,
-            'Sunday': 0
-        }
-        
-        day_of_week = day_map.get(day_name, '*')
-        result = {
-            'minute': minute,
-            'hour': hour,
-            'day_of_week': day_of_week
-        }
-        print(f"[CELERY BEAT] Parsed schedule time result: {result}")
-        return result
-    except Exception as e:
-        logger.error(f"Error parsing schedule time {schedule_time}: {str(e)}")
-        # Default to every minute for error cases
-        return {
-            'minute': '*',
-            'hour': '*',
-            'day_of_week': '*'
-        }
-
-@celery_app.task(bind=True)
-def load_schedules_task(self):
-    """
-    Celery task to load schedules from the database and create periodic tasks.
-    This task runs every 5 minutes to check for new or updated schedules.
-    """
-    try:
-        print(f"[CELERY BEAT] Loading schedules from database at {datetime.now()}...")
-        logger.info("Loading schedules from database...")
-        
-        # Get Supabase configuration
-        supabase_config = get_supabase_config()
-        print(f"[CELERY BEAT] Supabase config: URL={supabase_config['SUPABASE_URL'][:50]}...")
-        
-        # Initialize Supabase client
-        supabase_client = init_supabase(
-            supabase_config['SUPABASE_URL'],
-            supabase_config['SUPABASE_KEY']
-        )
-        
-        # Fetch all schedules from Supabase
-        print("[CELERY BEAT] Executing database query...")
-        response = (
-            supabase_client
-            .table("Scheduling")
-            .select("*, Social_network(id_utilisateur, token, sub)")
-            .execute()
-        )
-        
-        print(f"[CELERY BEAT] Database query response: {type(response)}")
-        print(f"[CELERY BEAT] Response data: {response.data if response.data else 'None'}")
-        
-        schedules = response.data if response.data else []
-        print(f"[CELERY BEAT] Found {len(schedules)} schedules in database")
-        logger.info(f"Found {len(schedules)} schedules")
-        
-        # Log details of each schedule for debugging
-        for i, schedule in enumerate(schedules):
-            print(f"[CELERY BEAT] Schedule {i}: {schedule}")
-            schedule_id = schedule.get('id')
-            schedule_time = schedule.get('schedule_time')
-            adjusted_time = schedule.get('adjusted_time')
-            social_network = schedule.get('Social_network', {})
-            print(f"[CELERY BEAT] Schedule {schedule_id} - schedule_time: {schedule_time}, adjusted_time: {adjusted_time}, social_network: {social_network}")
-        
-        # Get current beat schedule
-        current_schedule = celery_app.conf.beat_schedule
-        
-        # Remove existing scheduled jobs (except the loader job)
-        # In a production environment, you might want to be more selective about this
-        loader_job = current_schedule.get('load-schedules', {})
-        new_schedule = {'load-schedules': loader_job}
-        
-        # Create jobs for each schedule
-        for schedule in schedules:
-            try:
-                schedule_id = schedule.get('id')
-                schedule_time = schedule.get('schedule_time')
-                adjusted_time = schedule.get('adjusted_time')
-                
-                print(f"[CELERY BEAT] Processing schedule {schedule_id}: schedule_time={schedule_time}, adjusted_time={adjusted_time}")
-                
-                if not schedule_time or not adjusted_time:
-                    logger.warning(f"Invalid schedule format for schedule {schedule_id}")
-                    print(f"[CELERY BEAT] WARNING: Invalid schedule format for schedule {schedule_id}")
-                    continue
-                
-                # Parse schedule times
-                content_gen_time = parse_schedule_time(adjusted_time)
-                publish_time = parse_schedule_time(schedule_time)
-                
-                print(f"[CELERY BEAT] Parsed times - Content gen: {content_gen_time}, Publish: {publish_time}")
-                
-                # Create content generation job (5 minutes before publishing)
-                gen_job_id = f"gen_{schedule_id}"
-                task_schedule = crontab(
-                    minute=content_gen_time['minute'],
-                    hour=content_gen_time['hour'],
-                    day_of_week=content_gen_time['day_of_week']
-                )
-                print(f"[CELERY BEAT] Creating content task - ID: {gen_job_id}")
-                print(f"[CELERY BEAT] Content task schedule: minute={content_gen_time['minute']}, hour={content_gen_time['hour']}, day_of_week={content_gen_time['day_of_week']}")
-                args = (
-                    schedule.get('Social_network', {}).get('id_utilisateur'),
-                    schedule_id,
-                    supabase_config
-                )
-                print(f"[CELERY BEAT] Content task args: {args}")
-                new_schedule[gen_job_id] = {
-                    'task': 'backend.celery_tasks.content_tasks.generate_content_task',
-                    'schedule': task_schedule,
-                    'args': (
-                        schedule.get('Social_network', {}).get('id_utilisateur'),
-                        schedule_id,
-                        supabase_config
-                    )
-                }
-                logger.info(f"Created content generation job: {gen_job_id}")
-                print(f"[CELERY BEAT] Created content generation job: {gen_job_id}")
-                
-                # Create publishing job
-                pub_job_id = f"pub_{schedule_id}"
-                task_schedule = crontab(
-                    minute=publish_time['minute'],
-                    hour=publish_time['hour'],
-                    day_of_week=publish_time['day_of_week']
-                )
-                print(f"[CELERY BEAT] Creating publish task - ID: {pub_job_id}")
-                print(f"[CELERY BEAT] Publish task schedule: minute={publish_time['minute']}, hour={publish_time['hour']}, day_of_week={publish_time['day_of_week']}")
-                args = (
-                    schedule_id,
-                    supabase_config
-                )
-                print(f"[CELERY BEAT] Publish task args: {args}")
-                new_schedule[pub_job_id] = {
-                    'task': 'backend.celery_tasks.content_tasks.publish_post_task',
-                    'schedule': task_schedule,
-                    'args': (
-                        schedule_id,
-                        supabase_config
-                    )
-                }
-                logger.info(f"Created publishing job: {pub_job_id}")
-                print(f"[CELERY BEAT] Created publishing job: {pub_job_id}")
-                
-            except Exception as e:
-                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
-        
-        # Update the beat schedule
-        print(f"[CELERY BEAT] Current schedule keys before update: {list(current_app.conf.beat_schedule.keys())}")
-        print(f"[CELERY BEAT] New schedule keys: {list(new_schedule.keys())}")
-        current_app.conf.beat_schedule = new_schedule
-        print(f"[CELERY BEAT] Successfully updated Celery Beat schedule with {len(new_schedule)} jobs")
-        logger.info("Updated Celery Beat schedule")
-        
-        return {
-            'status': 'success',
-            'message': f'Loaded {len(schedules)} schedules',
-            'schedules_count': len(schedules)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error loading schedules: {str(e)}")
-        return {
-            'status': 'error',
-            'message': f'Error loading schedules: {str(e)}'
-        }

backend/celery_tasks/scheduler.py

@@ -1,105 +0,0 @@
-from datetime import datetime, timedelta
-from celery import chain
-import logging
-from backend.celery_config import celery_app
-from backend.celery_tasks.content_tasks import generate_content_task, publish_post_task
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def init_celery_scheduler(supabase_client):
-    """
-    Initialize the Celery-based task scheduler.
-    
-    Args:
-        supabase_client: Supabase client instance
-    """
-    logger.info("Initializing Celery scheduler")
-    # In a Celery-based approach, we don't need to initialize a scheduler here
-    # Tasks will be scheduled through Celery Beat or called directly
-    
-def schedule_content_generation(schedule: dict, supabase_client_config: dict):
-    """
-    Schedule content generation task using Celery.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client_config (dict): Supabase client configuration
-        
-    Returns:
-        dict: Celery task result
-    """
-    schedule_id = schedule.get('id')
-    user_id = schedule.get('Social_network', {}).get('id_utilisateur')
-    
-    if not user_id:
-        logger.warning(f"No user ID found for schedule {schedule_id}")
-        return None
-    
-    logger.info(f"Scheduling content generation for schedule {schedule_id}")
-    
-    # Schedule the content generation task
-    task = generate_content_task.delay(user_id, schedule_id, supabase_client_config)
-    return {
-        'task_id': task.id,
-        'status': 'scheduled',
-        'message': f'Content generation scheduled for schedule {schedule_id}'
-    }
-
-def schedule_post_publishing(schedule: dict, supabase_client_config: dict):
-    """
-    Schedule post publishing task using Celery.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client_config (dict): Supabase client configuration
-        
-    Returns:
-        dict: Celery task result
-    """
-    schedule_id = schedule.get('id')
-    logger.info(f"Scheduling post publishing for schedule {schedule_id}")
-    
-    # Schedule the post publishing task
-    task = publish_post_task.delay(schedule_id, supabase_client_config)
-    return {
-        'task_id': task.id,
-        'status': 'scheduled',
-        'message': f'Post publishing scheduled for schedule {schedule_id}'
-    }
-
-def schedule_content_and_publish(schedule: dict, supabase_client_config: dict):
-    """
-    Schedule both content generation and post publishing as a chain.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client_config (dict): Supabase client configuration
-        
-    Returns:
-        dict: Celery task result
-    """
-    schedule_id = schedule.get('id')
-    user_id = schedule.get('Social_network', {}).get('id_utilisateur')
-    
-    if not user_id:
-        logger.warning(f"No user ID found for schedule {schedule_id}")
-        return None
-    
-    logger.info(f"Scheduling content generation and publishing chain for schedule {schedule_id}")
-    
-    # Create a chain of tasks: generate content first, then publish
-    task_chain = chain(
-        generate_content_task.s(user_id, schedule_id, supabase_client_config),
-        publish_post_task.s(supabase_client_config)
-    )
-    
-    # Apply the chain asynchronously
-    result = task_chain.apply_async()
-    
-    return {
-        'task_id': result.id,
-        'status': 'scheduled',
-        'message': f'Content generation and publishing chain scheduled for schedule {schedule_id}'
-    }

backend/requirements.txt

@@ -27,10 +27,6 @@ supabase>=2.16.0
 # Security
 bcrypt>=4.3.0
 
-# Task queue
-celery>=5.5.3
-redis>=6.4.0
-
 # Testing
 pytest>=8.4.1
 pytest-cov>=6.2.1

backend/scheduler/__init__.py

@@ -0,0 +1 @@
+"""Scheduler package for the Lin application."""

backend/scheduler/apscheduler_service.py

@@ -0,0 +1,345 @@
+"""APS Scheduler service for the Lin application."""
+
+import logging
+from datetime import datetime, timedelta
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+from apscheduler.jobstores.memory import MemoryJobStore
+from apscheduler.executors.pool import ThreadPoolExecutor
+from backend.services.content_service import ContentService
+from backend.services.linkedin_service import LinkedInService
+from backend.utils.database import init_supabase
+from backend.config import Config
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class APSchedulerService:
+    """Service for managing APScheduler tasks."""
+    
+    def __init__(self, app=None):
+        self.app = app
+        self.scheduler = None
+        self.supabase_client = None
+        
+        # Initialize scheduler if app is provided
+        if app is not None:
+            self.init_app(app)
+    
+    def init_app(self, app):
+        """Initialize the scheduler with the Flask app."""
+        self.app = app
+        
+        # Initialize Supabase client
+        self.supabase_client = init_supabase(
+            app.config['SUPABASE_URL'],
+            app.config['SUPABASE_KEY']
+        )
+        
+        # Configure job stores and executors
+        jobstores = {
+            'default': MemoryJobStore()
+        }
+        
+        executors = {
+            'default': ThreadPoolExecutor(20),
+        }
+        
+        job_defaults = {
+            'coalesce': False,
+            'max_instances': 3
+        }
+        
+        # Create scheduler
+        self.scheduler = BackgroundScheduler(
+            jobstores=jobstores,
+            executors=executors,
+            job_defaults=job_defaults,
+            timezone='UTC'
+        )
+        
+        # Add the scheduler to the app
+        app.scheduler = self
+        
+        # Start the scheduler
+        self.scheduler.start()
+        
+        # Add the periodic job to load schedules from database
+        self.scheduler.add_job(
+            func=self.load_schedules,
+            trigger=CronTrigger(minute='*/5'),  # Every 5 minutes
+            id='load_schedules',
+            name='Load schedules from database',
+            replace_existing=True
+        )
+        
+        logger.info("APS Scheduler initialized and started")
+    
+    def load_schedules(self):
+        """Load schedules from the database and create jobs."""
+        try:
+            logger.info("Loading schedules from database...")
+            
+            if not self.supabase_client:
+                logger.error("Supabase client not initialized")
+                return
+            
+            # Fetch all schedules from Supabase
+            response = (
+                self.supabase_client
+                .table("Scheduling")
+                .select("*, Social_network(id_utilisateur, token, sub)")
+                .execute()
+            )
+            
+            schedules = response.data if response.data else []
+            logger.info(f"Found {len(schedules)} schedules in database")
+            
+            # Remove existing scheduled jobs (except the loader job)
+            jobs_to_remove = []
+            for job in self.scheduler.get_jobs():
+                if job.id != 'load_schedules':
+                    jobs_to_remove.append(job.id)
+            
+            for job_id in jobs_to_remove:
+                try:
+                    self.scheduler.remove_job(job_id)
+                    logger.info(f"Removed job: {job_id}")
+                except Exception as e:
+                    logger.warning(f"Failed to remove job {job_id}: {str(e)}")
+            
+            # Create jobs for each schedule
+            for schedule in schedules:
+                try:
+                    schedule_id = schedule.get('id')
+                    schedule_time = schedule.get('schedule_time')
+                    adjusted_time = schedule.get('adjusted_time')
+                    
+                    if not schedule_time or not adjusted_time:
+                        logger.warning(f"Invalid schedule format for schedule {schedule_id}")
+                        continue
+                    
+                    # Parse schedule times
+                    content_gen_cron = self._parse_schedule_time(adjusted_time)
+                    publish_cron = self._parse_schedule_time(schedule_time)
+                    
+                    # Create content generation job (5 minutes before publishing)
+                    gen_job_id = f"gen_{schedule_id}"
+                    self.scheduler.add_job(
+                        func=self.generate_content_task,
+                        trigger=CronTrigger(
+                            minute=content_gen_cron['minute'],
+                            hour=content_gen_cron['hour'],
+                            day_of_week=content_gen_cron['day_of_week']
+                        ),
+                        id=gen_job_id,
+                        name=f"Content generation for schedule {schedule_id}",
+                        args=[schedule.get('Social_network', {}).get('id_utilisateur'), schedule_id],
+                        replace_existing=True
+                    )
+                    logger.info(f"Created content generation job: {gen_job_id}")
+                    
+                    # Create publishing job
+                    pub_job_id = f"pub_{schedule_id}"
+                    self.scheduler.add_job(
+                        func=self.publish_post_task,
+                        trigger=CronTrigger(
+                            minute=publish_cron['minute'],
+                            hour=publish_cron['hour'],
+                            day_of_week=publish_cron['day_of_week']
+                        ),
+                        id=pub_job_id,
+                        name=f"Post publishing for schedule {schedule_id}",
+                        args=[schedule_id],
+                        replace_existing=True
+                    )
+                    logger.info(f"Created publishing job: {pub_job_id}")
+                    
+                except Exception as e:
+                    logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
+            
+            logger.info("Updated APScheduler schedule")
+            
+        except Exception as e:
+            logger.error(f"Error loading schedules: {str(e)}")
+    
+    def _parse_schedule_time(self, schedule_time):
+        """
+        Parse schedule time string into cron format.
+        
+        Args:
+            schedule_time (str): Schedule time in format "Day HH:MM"
+            
+        Returns:
+            dict: Cron parameters
+        """
+        try:
+            day_name, time_str = schedule_time.split()
+            hour, minute = map(int, time_str.split(':'))
+            
+            # Map day names to cron format
+            day_map = {
+                'Monday': 0,
+                'Tuesday': 1,
+                'Wednesday': 2,
+                'Thursday': 3,
+                'Friday': 4,
+                'Saturday': 5,
+                'Sunday': 6
+            }
+            
+            day_of_week = day_map.get(day_name, '*')
+            return {
+                'minute': minute,
+                'hour': hour,
+                'day_of_week': day_of_week
+            }
+        except Exception as e:
+            logger.error(f"Error parsing schedule time {schedule_time}: {str(e)}")
+            # Default to every minute for error cases
+            return {
+                'minute': '*',
+                'hour': '*',
+                'day_of_week': '*'
+            }
+    
+    def generate_content_task(self, user_id: str, schedule_id: str):
+        """
+        APScheduler task to generate content for a scheduled post.
+        
+        Args:
+            user_id (str): User ID
+            schedule_id (str): Schedule ID
+        """
+        try:
+            logger.info(f"Starting content generation for schedule {schedule_id}")
+            
+            # Initialize content service
+            content_service = ContentService()
+            
+            # Generate content using content service
+            generated_content = content_service.generate_post_content(user_id)
+            
+            # Store generated content in database
+            # We need to get the social account ID from the schedule
+            schedule_response = (
+                self.supabase_client
+                .table("Scheduling")
+                .select("id_social")
+                .eq("id", schedule_id)
+                .execute()
+            )
+            
+            if not schedule_response.data:
+                raise Exception(f"Schedule {schedule_id} not found")
+                
+            social_account_id = schedule_response.data[0]['id_social']
+            
+            # Store the generated content
+            response = (
+                self.supabase_client
+                .table("Post_content")
+                .insert({
+                    "social_account_id": social_account_id,
+                    "Text_content": generated_content,
+                    "is_published": False,
+                    "sched": schedule_id
+                })
+                .execute()
+            )
+            
+            if response.data:
+                logger.info(f"Content generated and stored for schedule {schedule_id}")
+            else:
+                logger.error(f"Failed to store generated content for schedule {schedule_id}")
+                
+        except Exception as e:
+            logger.error(f"Error in content generation task for schedule {schedule_id}: {str(e)}")
+    
+    def publish_post_task(self, schedule_id: str):
+        """
+        APScheduler task to publish a scheduled post.
+        
+        Args:
+            schedule_id (str): Schedule ID
+        """
+        try:
+            logger.info(f"Starting post publishing for schedule {schedule_id}")
+            
+            # Fetch the post to publish
+            response = (
+                self.supabase_client
+                .table("Post_content")
+                .select("*")
+                .eq("sched", schedule_id)
+                .eq("is_published", False)
+                .order("created_at", desc=True)
+                .limit(1)
+                .execute()
+            )
+            
+            if not response.data:
+                logger.info(f"No unpublished posts found for schedule {schedule_id}")
+                return
+            
+            post = response.data[0]
+            post_id = post.get('id')
+            text_content = post.get('Text_content')
+            image_url = post.get('image_content_url')
+            
+            # Get social network credentials
+            schedule_response = (
+                self.supabase_client
+                .table("Scheduling")
+                .select("Social_network(token, sub)")
+                .eq("id", schedule_id)
+                .execute()
+            )
+            
+            if not schedule_response.data:
+                raise Exception(f"Schedule {schedule_id} not found")
+                
+            social_network = schedule_response.data[0].get('Social_network', {})
+            access_token = social_network.get('token')
+            user_sub = social_network.get('sub')
+            
+            if not access_token or not user_sub:
+                logger.error(f"Missing social network credentials for schedule {schedule_id}")
+                return
+            
+            # Publish to LinkedIn
+            linkedin_service = LinkedInService()
+            publish_response = linkedin_service.publish_post(
+                access_token, user_sub, text_content, image_url
+            )
+            
+            # Update post status in database
+            update_response = (
+                self.supabase_client
+                .table("Post_content")
+                .update({"is_published": True})
+                .eq("id", post_id)
+                .execute()
+            )
+            
+            logger.info(f"Post published successfully for schedule {schedule_id}")
+            
+        except Exception as e:
+            logger.error(f"Error in publishing task for schedule {schedule_id}: {str(e)}")
+    
+    def trigger_immediate_update(self):
+        """Trigger immediate schedule update."""
+        try:
+            logger.info("Triggering immediate schedule update...")
+            self.load_schedules()
+            logger.info("Immediate schedule update completed")
+            return True
+        except Exception as e:
+            logger.error(f"Error triggering immediate schedule update: {str(e)}")
+            return False
+    
+    def shutdown(self):
+        """Shutdown the scheduler."""
+        if self.scheduler:
+            self.scheduler.shutdown()
+            logger.info("APS Scheduler shutdown")

backend/scheduler/task_scheduler.py

@@ -1,270 +0,0 @@
-import logging
-from datetime import datetime, timedelta
-from celery import current_app
-from celery.schedules import crontab
-from backend.services.content_service import ContentService
-from backend.services.linkedin_service import LinkedInService
-# Use relative import for the Config class to work with Hugging Face Spaces
-from backend.config import Config
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def get_supabase_config():
-    """Get Supabase configuration from environment."""
-    return {
-        'SUPABASE_URL': Config.SUPABASE_URL,
-        'SUPABASE_KEY': Config.SUPABASE_KEY
-    }
-
-def init_scheduler(supabase_client):
-    """
-    Initialize the Celery-based task scheduler.
-    
-    Args:
-        supabase_client: Supabase client instance
-    """
-    logger.info("Initializing Celery scheduler")
-    # In a Celery-based approach, we don't need to initialize a scheduler here
-    # Tasks will be scheduled through Celery Beat or called directly
-
-def parse_schedule_time(schedule_time):
-    """
-    Parse schedule time string into crontab format.
-    
-    Args:
-        schedule_time (str): Schedule time in format "Day HH:MM"
-        
-    Returns:
-        dict: Crontab parameters
-    """
-    try:
-        day_name, time_str = schedule_time.split()
-        hour, minute = map(int, time_str.split(':'))
-        
-        # Map day names to crontab format
-        day_map = {
-            'Monday': 1,
-            'Tuesday': 2,
-            'Wednesday': 3,
-            'Thursday': 4,
-            'Friday': 5,
-            'Saturday': 6,
-            'Sunday': 0
-        }
-        
-        day_of_week = day_map.get(day_name, '*')
-        
-        return {
-            'minute': minute,
-            'hour': hour,
-            'day_of_week': day_of_week
-        }
-    except Exception as e:
-        logger.error(f"Error parsing schedule time {schedule_time}: {str(e)}")
-        # Default to every minute for error cases
-        return {
-            'minute': '*',
-            'hour': '*',
-            'day_of_week': '*'
-        }
-
-def load_schedules(supabase_client):
-    """
-    Load schedules from the database and create periodic tasks.
-    This function is called by the Celery Beat scheduler.
-    
-    Args:
-        supabase_client: Supabase client instance
-    """
-    try:
-        logger.info("Loading schedules from database...")
-        
-        # Get Supabase configuration
-        supabase_config = get_supabase_config()
-        
-        # Fetch all schedules from Supabase
-        response = (
-            supabase_client
-            .table("Scheduling")
-            .select("*, Social_network(id_utilisateur, token, sub)")
-            .execute()
-        )
-        
-        schedules = response.data if response.data else []
-        logger.info(f"Found {len(schedules)} schedules")
-        
-        # Get current beat schedule
-        current_schedule = current_app.conf.beat_schedule
-        
-        # Remove existing scheduled jobs (except the loader job)
-        # In a production environment, you might want to be more selective about this
-        loader_job = current_schedule.get('load-schedules', {})
-        new_schedule = {'load-schedules': loader_job}
-        
-        # Create jobs for each schedule
-        for schedule in schedules:
-            try:
-                schedule_id = schedule.get('id')
-                schedule_time = schedule.get('schedule_time')
-                adjusted_time = schedule.get('adjusted_time')
-                
-                if not schedule_time or not adjusted_time:
-                    logger.warning(f"Invalid schedule format for schedule {schedule_id}")
-                    continue
-                
-                # Parse schedule times
-                content_gen_time = parse_schedule_time(adjusted_time)
-                publish_time = parse_schedule_time(schedule_time)
-                
-                # Create content generation job (5 minutes before publishing)
-                gen_job_id = f"gen_{schedule_id}"
-                new_schedule[gen_job_id] = {
-                    'task': 'celery_tasks.content_tasks.generate_content_task',
-                    'schedule': crontab(
-                        minute=content_gen_time['minute'],
-                        hour=content_gen_time['hour'],
-                        day_of_week=content_gen_time['day_of_week']
-                    ),
-                    'args': (
-                        schedule.get('Social_network', {}).get('id_utilisateur'),
-                        schedule_id,
-                        supabase_config
-                    )
-                }
-                logger.info(f"Created content generation job: {gen_job_id}")
-                
-                # Create publishing job
-                pub_job_id = f"pub_{schedule_id}"
-                new_schedule[pub_job_id] = {
-                    'task': 'celery_tasks.content_tasks.publish_post_task',
-                    'schedule': crontab(
-                        minute=publish_time['minute'],
-                        hour=publish_time['hour'],
-                        day_of_week=publish_time['day_of_week']
-                    ),
-                    'args': (
-                        schedule_id,
-                        supabase_config
-                    )
-                }
-                logger.info(f"Created publishing job: {pub_job_id}")
-                
-            except Exception as e:
-                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
-        
-        # Update the beat schedule
-        current_app.conf.beat_schedule = new_schedule
-        logger.info("Updated Celery Beat schedule")
-        
-    except Exception as e:
-        logger.error(f"Error loading schedules: {str(e)}")
-
-def generate_content_job(schedule: dict, supabase_client):
-    """
-    Job to generate content for a scheduled post.
-    This function is kept for backward compatibility but should be replaced with Celery tasks.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client: Supabase client instance
-    """
-    try:
-        schedule_id = schedule.get('id')
-        user_id = schedule.get('Social_network', {}).get('id_utilisateur')
-        
-        if not user_id:
-            logger.warning(f"No user ID found for schedule {schedule_id}")
-            return
-        
-        logger.info(f"Generating content for schedule {schedule_id}")
-        
-        # Generate content using content service
-        content_service = ContentService()
-        generated_content = content_service.generate_post_content(user_id)
-        
-        # Store generated content in database
-        social_account_id = schedule.get('id_social')
-        
-        response = (
-            supabase_client
-            .table("Post_content")
-            .insert({
-                "social_account_id": social_account_id,
-                "Text_content": generated_content,
-                "is_published": False,
-                "sched": schedule_id
-            })
-            .execute()
-        )
-        
-        if response.data:
-            logger.info(f"Content generated and stored for schedule {schedule_id}")
-        else:
-            logger.error(f"Failed to store generated content for schedule {schedule_id}")
-            
-    except Exception as e:
-        logger.error(f"Error in content generation job for schedule {schedule.get('id')}: {str(e)}")
-
-def publish_post_job(schedule: dict, supabase_client):
-    """
-    Job to publish a scheduled post.
-    This function is kept for backward compatibility but should be replaced with Celery tasks.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client: Supabase client instance
-    """
-    try:
-        schedule_id = schedule.get('id')
-        logger.info(f"Publishing post for schedule {schedule_id}")
-        
-        # Fetch the post to publish
-        response = (
-            supabase_client
-            .table("Post_content")
-            .select("*")
-            .eq("sched", schedule_id)
-            .eq("is_published", False)
-            .order("created_at", desc=True)
-            .limit(1)
-            .execute()
-        )
-        
-        if not response.data:
-            logger.info(f"No unpublished posts found for schedule {schedule_id}")
-            return
-        
-        post = response.data[0]
-        post_id = post.get('id')
-        text_content = post.get('Text_content')
-        image_url = post.get('image_content_url')
-        
-        # Get social network credentials
-        access_token = schedule.get('Social_network', {}).get('token')
-        user_sub = schedule.get('Social_network', {}).get('sub')
-        
-        if not access_token or not user_sub:
-            logger.error(f"Missing social network credentials for schedule {schedule_id}")
-            return
-        
-        # Publish to LinkedIn
-        linkedin_service = LinkedInService()
-        publish_response = linkedin_service.publish_post(
-            access_token, user_sub, text_content, image_url
-        )
-        
-        # Update post status in database
-        update_response = (
-            supabase_client
-            .table("Post_content")
-            .update({"is_published": True})
-            .eq("id", post_id)
-            .execute()
-        )
-        
-        logger.info(f"Post published successfully for schedule {schedule_id}")
-        
-    except Exception as e:
-        logger.error(f"Error in publishing job for schedule {schedule.get('id')}: {str(e)}")

backend/scheduler/task_scheduler.py.bak

@@ -1,252 +0,0 @@
-from apscheduler.schedulers.background import BackgroundScheduler
-from apscheduler.triggers.cron import CronTrigger
-from datetime import datetime, timedelta
-import logging
-from services.content_service import ContentService
-from services.linkedin_service import LinkedInService
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def init_scheduler(scheduler: BackgroundScheduler, supabase_client):
-    """
-    Initialize the task scheduler with jobs.
-    
-    Args:
-        scheduler (BackgroundScheduler): The scheduler instance
-        supabase_client: Supabase client instance
-    """
-    # Add a job to load schedules from database
-    scheduler.add_job(
-        func=load_schedules,
-        trigger=CronTrigger(minute='*/5'),  # Run every 5 minutes
-        id='load_schedules',
-        name='Load schedules from database',
-        args=[scheduler, supabase_client]
-    )
-    
-    # Load initial schedules
-    load_schedules(scheduler, supabase_client)
-
-def load_schedules(scheduler: BackgroundScheduler, supabase_client):
-    """
-    Load schedules from the database and create jobs.
-    
-    Args:
-        scheduler (BackgroundScheduler): The scheduler instance
-        supabase_client: Supabase client instance
-    """
-    try:
-        logger.info("Loading schedules from database...")
-        
-        # Fetch all schedules from Supabase
-        response = (
-            supabase_client
-            .table("Scheduling")
-            .select("*, Social_network(id_utilisateur, token, sub)")
-            .execute()
-        )
-        
-        schedules = response.data if response.data else []
-        logger.info(f"Found {len(schedules)} schedules")
-        
-        # Remove existing scheduled jobs (except the loader job)
-        job_ids = [job.id for job in scheduler.get_jobs() if job.id != 'load_schedules']
-        for job_id in job_ids:
-            scheduler.remove_job(job_id)
-            logger.info(f"Removed job: {job_id}")
-        
-        # Create jobs for each schedule
-        for schedule in schedules:
-            try:
-                create_scheduling_jobs(scheduler, schedule, supabase_client)
-            except Exception as e:
-                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
-                
-    except Exception as e:
-        logger.error(f"Error loading schedules: {str(e)}")
-
-def create_scheduling_jobs(scheduler: BackgroundScheduler, schedule: dict, supabase_client):
-    """
-    Create jobs for a specific schedule.
-    
-    Args:
-        scheduler (BackgroundScheduler): The scheduler instance
-        schedule (dict): Schedule data
-        supabase_client: Supabase client instance
-    """
-    schedule_id = schedule.get('id')
-    schedule_time = schedule.get('schedule_time')
-    adjusted_time = schedule.get('adjusted_time')
-    
-    if not schedule_time or not adjusted_time:
-        logger.warning(f"Invalid schedule format for schedule {schedule_id}")
-        return
-    
-    # Parse schedule times
-    try:
-        # Parse main schedule time (publishing)
-        day_name, time_str = schedule_time.split()
-        hour, minute = map(int, time_str.split(':'))
-        
-        # Parse adjusted time (content generation)
-        adj_day_name, adj_time_str = adjusted_time.split()
-        adj_hour, adj_minute = map(int, adj_time_str.split(':'))
-        
-        # Map day names to cron format
-        day_map = {
-            'Monday': 'mon',
-            'Tuesday': 'tue',
-            'Wednesday': 'wed',
-            'Thursday': 'thu',
-            'Friday': 'fri',
-            'Saturday': 'sat',
-            'Sunday': 'sun'
-        }
-        
-        if day_name not in day_map or adj_day_name not in day_map:
-            logger.warning(f"Invalid day name in schedule {schedule_id}")
-            return
-        
-        day_cron = day_map[day_name]
-        adj_day_cron = day_map[adj_day_name]
-        
-        # Create content generation job (5 minutes before publishing)
-        gen_job_id = f"gen_{schedule_id}"
-        scheduler.add_job(
-            func=generate_content_job,
-            trigger=CronTrigger(
-                day_of_week=adj_day_cron,
-                hour=adj_hour,
-                minute=adj_minute
-            ),
-            id=gen_job_id,
-            name=f"Generate content for schedule {schedule_id}",
-            args=[schedule, supabase_client]
-        )
-        logger.info(f"Created content generation job: {gen_job_id}")
-        
-        # Create publishing job
-        pub_job_id = f"pub_{schedule_id}"
-        scheduler.add_job(
-            func=publish_post_job,
-            trigger=CronTrigger(
-                day_of_week=day_cron,
-                hour=hour,
-                minute=minute
-            ),
-            id=pub_job_id,
-            name=f"Publish post for schedule {schedule_id}",
-            args=[schedule, supabase_client]
-        )
-        logger.info(f"Created publishing job: {pub_job_id}")
-        
-    except Exception as e:
-        logger.error(f"Error creating jobs for schedule {schedule_id}: {str(e)}")
-
-def generate_content_job(schedule: dict, supabase_client):
-    """
-    Job to generate content for a scheduled post.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client: Supabase client instance
-    """
-    try:
-        schedule_id = schedule.get('id')
-        user_id = schedule.get('Social_network', {}).get('id_utilisateur')
-        
-        if not user_id:
-            logger.warning(f"No user ID found for schedule {schedule_id}")
-            return
-        
-        logger.info(f"Generating content for schedule {schedule_id}")
-        
-        # Generate content using content service
-        content_service = ContentService()
-        generated_content = content_service.generate_post_content(user_id)
-        
-        # Store generated content in database
-        social_account_id = schedule.get('id_social')
-        
-        response = (
-            supabase_client
-            .table("Post_content")
-            .insert({
-                "social_account_id": social_account_id,
-                "Text_content": generated_content,
-                "is_published": False,
-                "sched": schedule_id
-            })
-            .execute()
-        )
-        
-        if response.data:
-            logger.info(f"Content generated and stored for schedule {schedule_id}")
-        else:
-            logger.error(f"Failed to store generated content for schedule {schedule_id}")
-            
-    except Exception as e:
-        logger.error(f"Error in content generation job for schedule {schedule.get('id')}: {str(e)}")
-
-def publish_post_job(schedule: dict, supabase_client):
-    """
-    Job to publish a scheduled post.
-    
-    Args:
-        schedule (dict): Schedule data
-        supabase_client: Supabase client instance
-    """
-    try:
-        schedule_id = schedule.get('id')
-        logger.info(f"Publishing post for schedule {schedule_id}")
-        
-        # Fetch the post to publish
-        response = (
-            supabase_client
-            .table("Post_content")
-            .select("*")
-            .eq("sched", schedule_id)
-            .eq("is_published", False)
-            .order("created_at", desc=True)
-            .limit(1)
-            .execute()
-        )
-        
-        if not response.data:
-            logger.info(f"No unpublished posts found for schedule {schedule_id}")
-            return
-        
-        post = response.data[0]
-        post_id = post.get('id')
-        text_content = post.get('Text_content')
-        image_url = post.get('image_content_url')
-        
-        # Get social network credentials
-        access_token = schedule.get('Social_network', {}).get('token')
-        user_sub = schedule.get('Social_network', {}).get('sub')
-        
-        if not access_token or not user_sub:
-            logger.error(f"Missing social network credentials for schedule {schedule_id}")
-            return
-        
-        # Publish to LinkedIn
-        linkedin_service = LinkedInService()
-        publish_response = linkedin_service.publish_post(
-            access_token, user_sub, text_content, image_url
-        )
-        
-        # Update post status in database
-        update_response = (
-            supabase_client
-            .table("Post_content")
-            .update({"is_published": True})
-            .eq("id", post_id)
-            .execute()
-        )
-        
-        logger.info(f"Post published successfully for schedule {schedule_id}")
-        
-    except Exception as e:
-        logger.error(f"Error in publishing job for schedule {schedule.get('id')}: {str(e)}")

backend/start_celery.bat

@@ -1,44 +0,0 @@
-@echo off
-REM Script to start Celery components on Windows
-
-REM Check if we're in the right directory
-if not exist "app.py" (
-    echo Please run this script from the backend directory
-    pause
-    exit /b 1
-)
-
-REM Function to start Celery worker
-:start_worker
-echo Starting Celery worker...
-start "Celery Worker" cmd /k "python start_celery.py worker"
-echo Celery worker started
-goto :eof
-
-REM Function to start Celery Beat scheduler
-:start_beat
-echo Starting Celery Beat scheduler...
-start "Celery Beat" cmd /k "python start_celery.py beat"
-echo Celery Beat scheduler started
-goto :eof
-
-REM Main script logic
-if "%1"=="worker" (
-    call :start_worker
-) else if "%1"=="beat" (
-    call :start_beat
-) else if "%1"=="all" (
-    call :start_worker
-    call :start_beat
-) else if "%1"=="check" (
-    echo Checking system requirements...
-    python start_celery.py check
-) else (
-    echo Usage: %0 {worker^|beat^|all^|check}
-    echo   worker - Start Celery worker
-    echo   beat   - Start Celery Beat scheduler
-    echo   all    - Start both worker and scheduler
-    echo   check  - Check system requirements
-    pause
-    exit /b 1
-)

backend/start_celery.py

@@ -1,129 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to start Celery components for the Lin application.
-This script provides a unified way to start Celery worker and beat scheduler.
-"""
-
-import os
-import sys
-import subprocess
-import platform
-from pathlib import Path
-
-# Add the backend directory to Python path
-backend_dir = Path(__file__).parent
-sys.path.insert(0, str(backend_dir))
-
-def check_redis():
-    """Check if Redis is running."""
-    try:
-        import redis
-        client = redis.Redis(host='localhost', port=6379, db=0)
-        client.ping()
-        print("✓ Redis connection successful")
-        return True
-    except Exception as e:
-        print(f"✗ Redis connection failed: {e}")
-        print("Please start Redis server first:")
-        print("  Windows: redis-server")
-        print("  Linux/Mac: sudo systemctl start redis")
-        return False
-
-def start_worker():
-    """Start Celery worker."""
-    print("Starting Celery worker...")
-    # Add project root to PYTHONPATH
-    project_root = backend_dir.parent.resolve()
-    env = os.environ.copy()
-    current_pythonpath = env.get('PYTHONPATH', '')
-    env['PYTHONPATH'] = str(project_root) + os.pathsep + current_pythonpath if current_pythonpath else str(project_root)
-    
-    cmd = [
-        sys.executable, "-m", "celery",
-        "-A", "celery_config:celery_app",
-        "worker",
-        "--loglevel=debug",
-        "--pool=solo",
-        "--max-tasks-per-child=100",
-        "--events"  # Enable task events for monitoring
-    ]
-    
-    if platform.system() == "Windows":
-        subprocess.Popen(cmd, cwd=backend_dir, env=env)
-    else:
-        subprocess.Popen(cmd, cwd=backend_dir, env=env)
-    
-    print("Celery worker started")
-
-def start_beat():
-    """Start Celery Beat scheduler."""
-    print("Starting Celery Beat scheduler...")
-    # Add project root to PYTHONPATH
-    project_root = backend_dir.parent.resolve()
-    env = os.environ.copy()
-    current_pythonpath = env.get('PYTHONPATH', '')
-    env['PYTHONPATH'] = str(project_root) + os.pathsep + current_pythonpath if current_pythonpath else str(project_root)
-    
-    cmd = [
-        sys.executable, "-m", "celery",
-        "-A", "celery_config:celery_app",
-        "beat",
-        "--loglevel=debug",
-        "--schedule=/tmp/celerybeat-schedule" # Specify writable location for schedule file
-    ]
-    
-    if platform.system() == "Windows":
-        subprocess.Popen(cmd, cwd=backend_dir, env=env)
-    else:
-        subprocess.Popen(cmd, cwd=backend_dir, env=env)
-    
-    print("Celery Beat scheduler started")
-
-def start_all():
-    """Start both worker and beat."""
-    if not check_redis():
-        return False
-    
-    print("Starting all Celery components...")
-    start_worker()
-    start_beat()
-    print("All Celery components started")
-    return True
-
-def main():
-    """Main function."""
-    if len(sys.argv) < 2:
-        print("Usage: python start_celery.py <command>")
-        print("Commands:")
-        print("  worker    - Start Celery worker only")
-        print("  beat      - Start Celery Beat scheduler only")
-        print("  all       - Start both worker and beat")
-        print("  check     - Check system requirements")
-        sys.exit(1)
-    
-    command = sys.argv[1].lower()
-    
-    if command == "worker":
-        if not check_redis():
-            sys.exit(1)
-        start_worker()
-    elif command == "beat":
-        if not check_redis():
-            sys.exit(1)
-        start_beat()
-    elif command == "all":
-        if not start_all():
-            sys.exit(1)
-    elif command == "check":
-        print("Checking system requirements...")
-        if check_redis():
-            print("✓ All requirements met")
-        else:
-            print("✗ Some requirements not met")
-            sys.exit(1)
-    else:
-        print(f"Unknown command: {command}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

backend/start_celery.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-# Script to start Celery components
-
-# Check if we're in the right directory
-if [ ! -f "app.py" ]; then
-    echo "Please run this script from the backend directory"
-    exit 1
-fi
-
-# Function to start Celery worker
-start_worker() {
-    echo "Starting Celery worker..."
-    python start_celery.py worker &
-    echo "Celery worker started with PID $!"
-}
-
-# Function to start Celery Beat scheduler
-start_beat() {
-    echo "Starting Celery Beat scheduler..."
-    python start_celery.py beat &
-    echo "Celery Beat scheduler started with PID $!"
-}
-
-# Function to start both worker and beat
-start_all() {
-    start_worker
-    start_beat
-}
-
-# Function to check system requirements
-check_requirements() {
-    echo "Checking system requirements..."
-    python start_celery.py check
-}
-
-# Main script logic
-case "$1" in
-    worker)
-        start_worker
-        ;;
-    beat)
-        start_beat
-        ;;
-    all)
-        start_all
-        ;;
-    check)
-        check_requirements
-        ;;
-    *)
-        echo "Usage: $0 {worker|beat|all|check}"
-        echo "  worker - Start Celery worker"
-        echo "  beat   - Start Celery Beat scheduler"
-        echo "  all    - Start both worker and scheduler"
-        echo "  check  - Check system requirements"
-        exit 1
-        ;;
-esac

start_app.py

@@ -1,82 +1,12 @@
 #!/usr/bin/env python
 """
 Entry point for the Lin application.
-This script starts both the Flask application and Celery scheduler components.
+This script starts the Flask application with APScheduler.
 """
 import os
 import sys
-import subprocess
-import platform
-import time
 from pathlib import Path
 
-def check_redis():
-    """Check if Redis is running."""
-    try:
-        import redis
-        client = redis.Redis(host='localhost', port=6379, db=0)
-        client.ping()
-        print("✓ Redis connection successful")
-        return True
-    except Exception as e:
-        print(f"✗ Redis connection failed: {e}")
-        print("Please start Redis server first:")
-        print("  Windows: redis-server")
-        print("  Linux/Mac: sudo systemctl start redis")
-        return False
-
-def start_celery_components():
-    """Start Celery worker and beat scheduler in background processes."""
-    print("Starting Celery components...")
-    
-    project_root = Path(__file__).parent.resolve() # Get the project root directory
-    backend_dir = project_root / "backend"
-    
-    # Prepare the environment with updated PYTHONPATH
-    env = os.environ.copy()
-    # Prepend the project root to PYTHONPATH so 'backend' package can be found
-    current_pythonpath = env.get('PYTHONPATH', '')
-    env['PYTHONPATH'] = str(project_root) + os.pathsep + current_pythonpath if current_pythonpath else str(project_root)
-
-    # Start Celery worker
-    worker_cmd = [
-        sys.executable, "-m", "celery",
-        "-A", "celery_config:celery_app",
-        "worker",
-        "--loglevel=debug",
-        "--pool=solo",
-        "--max-tasks-per-child=100",
-        "--events",  # Enable task events for monitoring
-        "-Q", "content,publish,scheduler"  # Listen to all queues
-    ]
-    
-    # Start Celery beat
-    beat_cmd = [
-        sys.executable, "-m", "celery",
-        "-A", "celery_config:celery_app",
-        "beat",
-        "--loglevel=debug",
-        "--schedule=/tmp/celerybeat-schedule" # Specify writable location for schedule file
-    ]
-    
-    if platform.system() == "Windows":
-        # Windows: Use subprocess to start background processes with visible logs
-        subprocess.Popen(worker_cmd, cwd=backend_dir, env=env, # Pass the modified env
-                        stdout=sys.stdout, stderr=sys.stderr,
-                        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
-        subprocess.Popen(beat_cmd, cwd=backend_dir, env=env, # Pass the modified env
-                        stdout=sys.stdout, stderr=sys.stderr,
-                        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
-    else:
-        # Linux/Mac: Use subprocess with visible logs
-        subprocess.Popen(worker_cmd, cwd=backend_dir, env=env, # Pass the modified env
-                        stdout=sys.stdout, stderr=sys.stderr)
-        subprocess.Popen(beat_cmd, cwd=backend_dir, env=env, # Pass the modified env
-                        stdout=sys.stdout, stderr=sys.stderr)
-    
-    print("Celery worker and beat scheduler started in background")
-    time.sleep(2)  # Give Celery components time to start
-
 if __name__ == "__main__":
     # Set the port for Hugging Face Spaces
     port = os.environ.get('PORT', '7860')
@@ -85,16 +15,7 @@ if __name__ == "__main__":
     print(f"Starting Lin application on port {port}...")
     print("=" * 60)
     
-    # Check if Redis is available
-    if not check_redis():
-        print("Warning: Redis not available. Celery may not function properly.")
-        print("Continuing with Flask app only...")
-        print("=" * 60)
-    
     try:
-        # Start Celery components first
-        start_celery_components()
-        
         # Import and run the backend Flask app directly
         from backend.app import create_app
         app = create_app()
@@ -115,6 +36,9 @@ if __name__ == "__main__":
         
     except KeyboardInterrupt:
         print("\nShutting down application...")
+        # Shutdown scheduler if it exists
+        if hasattr(app, 'scheduler'):
+            app.scheduler.shutdown()
         sys.exit(0)
     except Exception as e:
         print(f"Failed to start Lin application: {e}")