app.py

from flask import Flask, render_template, request, jsonify
from flask_cors import CORS
from nlp_processor import NLPProcessor
from utils.logger import ProcessingLogger
import time
import json

app = Flask(__name__)
CORS(app)

# Initialize global instances
processor = None
logger = None

def get_processor():
    global processor, logger
    if processor is None:
        processor = NLPProcessor()
        logger = processor.logger
    return processor, logger

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/process', methods=['POST'])
def process_text():
    try:
        processor, logger = get_processor()
        
        data = request.get_json()
        text = data.get('text', '').strip()
        tasks = data.get('tasks', {})
        thresholds = data.get('thresholds', {})
        target_language = data.get('target_language', 'es')
        
        if not text:
            return jsonify({'error': 'No text provided'}), 400
        
        # Validate text length
        if len(text) < 10:
            return jsonify({'error': 'Text too short (minimum 10 characters)'}), 400
        
        # Update processor configuration
        processor.update_thresholds(thresholds)
        
        # Clear previous logs
        logger.clear_logs()
        
        # Process selected tasks
        results = {}
        processing_times = {}
        
        for task_name, enabled in tasks.items():
            if enabled:
                start_time = time.time()
                
                try:
                    if task_name == "Summarization":
                        result = processor.summarize(text)
                    elif task_name == "Text Generation":
                        result = processor.generate(text)
                    elif task_name == "Translation":
                        result = processor.translate(text, target_language)
                    elif task_name == "Sentiment Analysis":
                        result = processor.analyze_sentiment(text)
                    elif task_name == "Entity Extraction":
                        result = processor.extract_entities(text)
                    else:
                        continue
                    
                    processing_times[task_name] = time.time() - start_time
                    results[task_name] = result
                    
                except Exception as task_error:
                    processing_times[task_name] = time.time() - start_time
                    results[task_name] = {
                        'success': False,
                        'error': str(task_error),
                        'confidence': 0.0,
                        'model_used': 'error'
                    }
        
        return jsonify({
            'success': True,
            'results': results,
            'processing_times': processing_times,
            'logs': logger.get_logs()
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/logs')
def get_logs():
    processor, logger = get_processor()
    return jsonify(logger.get_logs())

@app.route('/api/config')
def get_config():
    return jsonify({
        'supported_languages': ['es', 'fr', 'de', 'it', 'pt', 'ru', 'zh', 'ja', 'ko', 'hi', 'ar'],
        'default_thresholds': {
            'summarization': 0.7,
            'generation': 0.6,
            'translation': 0.8,
            'sentiment': 0.75,
            'entity': 0.7
        }
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)