Prepare Flask backend for Hugging Face Spaces deployment

.dockerignore

@@ -0,0 +1,6 @@
+__pycache__
+*.pyc
+.git
+.vscode
+*.log
+tests

.gitignore

@@ -0,0 +1,124 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+pipenv.lock
+
+# poetry
+poetry.lock
+
+# env files
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# C extensions
+*.so
+
+# VS Code settings
+.vscode/
+
+# PyCharm settings
+.idea/

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy and install requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+
+# Set environment variables for AI models
+ENV TRANSFORMERS_CACHE=/tmp/model_cache
+ENV HF_HOME=/tmp/model_cache
+ENV TOKENIZERS_PARALLELISM=false
+ENV OMP_NUM_THREADS=1
+
+# Create cache directory
+RUN mkdir -p /tmp/model_cache
+
+# Copy application
+COPY . .
+
+# ✅ Expose correct port for Hugging Face Spaces
+EXPOSE 7860
+
+# ✅ Run app on correct port
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--timeout", "120", "app:app"]

README.md

@@ -1,10 +0,0 @@
----
-title: TestCaseGenerator
-emoji: 💻
-colorFrom: red
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,273 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from model.generate import generate_test_cases, get_generator, monitor_memory
+import os
+import logging
+import gc
+import psutil
+from functools import wraps
+import time
+import threading
+
+# Configure logging for Railway
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+# Configuration for Railway
+app.config['JSON_SORT_KEYS'] = False
+app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False  # Reduce response size
+
+# Thread-safe initialization
+_init_lock = threading.Lock()
+_initialized = False
+
+def init_model():
+    """Initialize model on startup"""
+    try:
+        # Skip AI model loading in low memory environments
+        memory_mb = psutil.Process().memory_info().rss / 1024 / 1024
+        if memory_mb > 200 or os.environ.get('RAILWAY_ENVIRONMENT'):
+            logger.info("⚠️ Skipping AI model loading due to memory constraints")
+            logger.info("🔧 Using template-based generation mode")
+            return True
+
+        logger.info("🚀 Initializing AI model...")
+        generator = get_generator()
+        model_info = generator.get_model_info()
+        logger.info(f"✅ Model initialized: {model_info['model_name']} | Memory: {model_info['memory_usage']}")
+        return True
+    except Exception as e:
+        logger.error(f"❌ Model initialization failed: {e}")
+        logger.info("🔧 Falling back to template-based generation")
+        return False
+
+def check_health():
+    """Check system health"""
+    try:
+        memory_mb = psutil.Process().memory_info().rss / 1024 / 1024
+        return {
+            "status": "healthy" if memory_mb < 450 else "warning",
+            "memory_usage": f"{memory_mb:.1f}MB",
+            "memory_limit": "512MB"
+        }
+    except Exception:
+        return {"status": "unknown", "memory_usage": "unavailable"}
+
+def smart_memory_monitor(func):
+    """Enhanced memory monitoring with automatic cleanup"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            initial_memory = psutil.Process().memory_info().rss / 1024 / 1024
+            logger.info(f"🔍 {func.__name__} started | Memory: {initial_memory:.1f}MB")
+
+            if initial_memory > 400:
+                logger.warning("⚠️ High memory detected, forcing cleanup...")
+                gc.collect()
+
+            result = func(*args, **kwargs)
+            return result
+        except Exception as e:
+            logger.error(f"❌ Error in {func.__name__}: {str(e)}")
+            return jsonify({
+                "error": "Internal server error occurred",
+                "message": "Please try again or contact support"
+            }), 500
+        finally:
+            final_memory = psutil.Process().memory_info().rss / 1024 / 1024
+            execution_time = time.time() - start_time
+
+            logger.info(f"✅ {func.__name__} completed | Memory: {final_memory:.1f}MB | Time: {execution_time:.2f}s")
+
+            if final_memory > 450:
+                logger.warning("🧹 High memory usage, forcing aggressive cleanup...")
+                gc.collect()
+                post_cleanup_memory = psutil.Process().memory_info().rss / 1024 / 1024
+                logger.info(f"🧹 Post-cleanup memory: {post_cleanup_memory:.1f}MB")
+    return wrapper
+
+def ensure_initialized():
+    """Ensure model is initialized (thread-safe)"""
+    global _initialized
+    if not _initialized:
+        with _init_lock:
+            if not _initialized:
+                logger.info("🚀 Flask app starting up on Railway...")
+                success = init_model()
+                if success:
+                    logger.info("✅ Startup completed successfully")
+                else:
+                    logger.warning("⚠️ Model initialization failed, using template mode")
+                _initialized = True
+
+@app.before_request
+def before_request():
+    """Initialize model on first request (Flask 2.2+ compatible)"""
+    ensure_initialized()
+
+@app.route('/')
+def home():
+    """Health check endpoint with system status"""
+    health_data = check_health()
+    try:
+        generator = get_generator()
+        model_info = generator.get_model_info()
+    except Exception:
+        model_info = {
+            "model_name": "Template-Based Generator",
+            "status": "template_mode",
+            "optimization": "memory_safe"
+        }
+
+    return jsonify({
+        "message": "AI Test Case Generator Backend is running",
+        "status": health_data["status"],
+        "memory_usage": health_data["memory_usage"],
+        "model": {
+            "name": model_info["model_name"],
+            "status": model_info["status"],
+            "optimization": model_info.get("optimization", "standard")
+        },
+        "version": "1.0.0-railway-optimized"
+    })
+
+@app.route('/health')
+def health():
+    """Dedicated health check for Railway monitoring"""
+    health_status = check_health()
+    try:
+        generator = get_generator()
+        model_info = generator.get_model_info()
+        model_loaded = model_info["status"] == "loaded"
+    except Exception:
+        model_loaded = False
+
+    return jsonify({
+        "status": health_status["status"],
+        "memory": health_status["memory_usage"],
+        "model_loaded": model_loaded,
+        "uptime": "ok"
+    })
+
+@app.route('/generate_test_cases', methods=['POST'])
+@smart_memory_monitor
+def generate():
+    """Generate test cases with enhanced error handling"""
+    if not request.is_json:
+        return jsonify({"error": "Request must be JSON"}), 400
+
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "No JSON data provided"}), 400
+
+    srs_text = data.get('srs', '').strip()
+
+    if not srs_text:
+        return jsonify({"error": "No SRS or prompt content provided"}), 400
+
+    if len(srs_text) > 5000:
+        logger.warning(f"SRS text truncated from {len(srs_text)} to 5000 characters")
+        srs_text = srs_text[:5000]
+
+    try:
+        logger.info(f"🎯 Generating test cases for input ({len(srs_text)} chars)")
+        test_cases = generate_test_cases(srs_text)
+
+        if not test_cases or len(test_cases) == 0:
+            logger.error("No test cases generated")
+            return jsonify({"error": "Failed to generate test cases"}), 500
+
+        try:
+            generator = get_generator()
+            model_info = generator.get_model_info()
+            model_used = model_info.get("model_name", "Unknown Model")
+            generation_method = model_info.get("status", "unknown")
+        except Exception:
+            model_used = "Template-Based Generator"
+            generation_method = "template_mode"
+
+        if model_used == "Template-Based Generator":
+            model_algorithm = "Rule-based Template"
+            model_reason = "Used rule-based generation due to memory constraints or fallback condition."
+        elif "distilgpt2" in model_used:
+            model_algorithm = "Transformer-based LM"
+            model_reason = "Used DistilGPT2 for balanced performance and memory efficiency."
+        elif "DialoGPT" in model_used:
+            model_algorithm = "Transformer-based LM"
+            model_reason = "Used DialoGPT-small as it fits within memory limits and handles conversational input well."
+        else:
+            model_algorithm = "Transformer-based LM"
+            model_reason = "Used available Hugging Face causal LM due to sufficient resources."
+
+        logger.info(f"✅ Successfully generated {len(test_cases)} test cases")
+
+        return jsonify({
+            "test_cases": test_cases,
+            "count": len(test_cases),
+            "model_used": model_used,
+            "generation_method": generation_method,
+            "model_algorithm": model_algorithm,
+            "model_reason": model_reason
+        })
+
+    except Exception as e:
+        logger.error(f"❌ Test case generation failed: {str(e)}")
+        return jsonify({
+            "error": "Failed to generate test cases",
+            "message": "Please try again with different input"
+        }), 500
+
+@app.route('/model_info')
+def model_info():
+    """Get current model information"""
+    try:
+        generator = get_generator()
+        info = generator.get_model_info()
+        health_data = check_health()
+
+        return jsonify({
+            "model": info,
+            "system": health_data
+        })
+    except Exception as e:
+        logger.error(f"Error getting model info: {e}")
+        return jsonify({"error": "Unable to get model information"}), 500
+
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({"error": "Endpoint not found"}), 404
+
+@app.errorhandler(405)
+def method_not_allowed(error):
+    return jsonify({"error": "Method not allowed"}), 405
+
+@app.errorhandler(500)
+def internal_error(error):
+    logger.error(f"Internal server error: {error}")
+    return jsonify({"error": "Internal server error"}), 500
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 5000))
+    debug_mode = os.environ.get("FLASK_ENV") == "development"
+
+    logger.info(f"🚀 Starting Flask app on port {port}")
+    logger.info(f"🔧 Debug mode: {debug_mode}")
+    logger.info(f"🖥️ Environment: {'Railway' if os.environ.get('RAILWAY_ENVIRONMENT') else 'Local'}")
+
+    if not os.environ.get('RAILWAY_ENVIRONMENT'):
+        ensure_initialized()
+
+    app.run(
+        host='0.0.0.0',
+        port=port,
+        debug=debug_mode,
+        threaded=True,
+        use_reloader=False
+    )

model/generate.py

@@ -0,0 +1,262 @@
+import os
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import logging
+import psutil
+import re
+import gc
+
+# Initialize logger
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# List of memory-optimized models
+MEMORY_OPTIMIZED_MODELS = [
+    "gpt2",  # ~500MB
+    "distilgpt2",  # ~250MB
+    "microsoft/DialoGPT-small",  # ~250MB
+    "huggingface/CodeBERTa-small-v1",  # Code tasks
+]
+
+# Singleton state
+_generator_instance = None
+
+def get_optimal_model_for_memory():
+    """Select the best model based on available memory."""
+    available_memory = psutil.virtual_memory().available / (1024 * 1024)  # MB
+    logger.info(f"Available memory: {available_memory:.1f}MB")
+
+    if available_memory < 300:
+        return None  # Use template fallback
+    elif available_memory < 600:
+        return "microsoft/DialoGPT-small"
+    else:
+        return "distilgpt2"
+
+def load_model_with_memory_optimization(model_name):
+    """Load model with low memory settings."""
+    try:
+        logger.info(f"Loading {model_name} with memory optimizations...")
+
+        tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side='left', use_fast=True)
+
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map="cpu",
+            low_cpu_mem_usage=True,
+            use_cache=False,
+        )
+
+        model.eval()
+        model.gradient_checkpointing_enable()
+        logger.info(f"✅ Model {model_name} loaded successfully")
+        return tokenizer, model
+
+    except Exception as e:
+        logger.error(f"❌ Failed to load model {model_name}: {e}")
+        return None, None
+
+def extract_keywords(text):
+    common_keywords = [
+        'login', 'authentication', 'user', 'password', 'database', 'data',
+        'interface', 'api', 'function', 'feature', 'requirement', 'system',
+        'input', 'output', 'validation', 'error', 'security', 'performance'
+    ]
+    words = re.findall(r'\b\w+\b', text.lower())
+    return [word for word in words if word in common_keywords]
+
+def generate_template_based_test_cases(srs_text):
+    keywords = extract_keywords(srs_text)
+    test_cases = []
+
+    if any(word in keywords for word in ['login', 'authentication', 'user', 'password']):
+        test_cases.extend([
+            {
+                "id": "TC_001",
+                "title": "Valid Login Test",
+                "description": "Test login with valid credentials",
+                "steps": ["Enter valid username", "Enter valid password", "Click login"],
+                "expected": "User should be logged in successfully"
+            },
+            {
+                "id": "TC_002",
+                "title": "Invalid Login Test",
+                "description": "Test login with invalid credentials",
+                "steps": ["Enter invalid username", "Enter invalid password", "Click login"],
+                "expected": "Error message should be displayed"
+            }
+        ])
+
+    if any(word in keywords for word in ['database', 'data', 'store', 'save']):
+        test_cases.append({
+            "id": "TC_003",
+            "title": "Data Storage Test",
+            "description": "Test data storage functionality",
+            "steps": ["Enter data", "Save data", "Verify storage"],
+            "expected": "Data should be stored correctly"
+        })
+
+    if not test_cases:
+        test_cases = [
+            {
+                "id": "TC_001",
+                "title": "Basic Functionality Test",
+                "description": "Test basic system functionality",
+                "steps": ["Access the system", "Perform basic operations", "Verify results"],
+                "expected": "System should work as expected"
+            }
+        ]
+
+    return test_cases
+
+def parse_generated_test_cases(generated_text):
+    lines = generated_text.split('\n')
+    test_cases = []
+    current_case = {}
+    case_counter = 1
+
+    for line in lines:
+        line = line.strip()
+        if line.startswith(('1.', '2.', '3.', 'TC', 'Test')):
+            if current_case:
+                test_cases.append(current_case)
+            current_case = {
+                "id": f"TC_{case_counter:03d}",
+                "title": line,
+                "description": line,
+                "steps": ["Execute the test"],
+                "expected": "Test should pass"
+            }
+            case_counter += 1
+
+    if current_case:
+        test_cases.append(current_case)
+
+    if not test_cases:
+        return [{
+            "id": "TC_001",
+            "title": "Generated Test Case",
+            "description": "Auto-generated test case based on requirements",
+            "steps": ["Review requirements", "Execute test", "Verify results"],
+            "expected": "Requirements should be met"
+        }]
+
+    return test_cases
+
+def generate_with_ai_model(srs_text, tokenizer, model):
+    max_input_length = 200
+    if len(srs_text) > max_input_length:
+        srs_text = srs_text[:max_input_length]
+
+    prompt = f"""Generate test cases for this software requirement:
+{srs_text}
+
+Test Cases:
+1."""
+
+    try:
+        inputs = tokenizer.encode(
+            prompt,
+            return_tensors="pt",
+            max_length=150,
+            truncation=True
+        )
+
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs,
+                max_new_tokens=100,
+                num_return_sequences=1,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                use_cache=False,
+            )
+
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        del inputs, outputs
+        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        return parse_generated_test_cases(generated_text)
+
+    except Exception as e:
+        logger.error(f"❌ AI generation failed: {e}")
+        raise
+
+def generate_with_fallback(srs_text):
+    model_name = get_optimal_model_for_memory()
+
+    if model_name:
+        tokenizer, model = load_model_with_memory_optimization(model_name)
+        if tokenizer and model:
+            try:
+                test_cases = generate_with_ai_model(srs_text, tokenizer, model)
+                reason = get_algorithm_reason(model_name)
+                return test_cases, model_name, "transformer (causal LM)", reason
+            except Exception as e:
+                logger.warning(f"AI generation failed: {e}, falling back to templates")
+
+    logger.info("⚠️ Using fallback template-based generation")
+    test_cases = generate_template_based_test_cases(srs_text)
+    return test_cases, "Template-Based Generator", "rule-based", "Low memory - fallback to rule-based generation"
+
+# ✅ Function exposed to app.py
+def generate_test_cases(srs_text):
+    return generate_with_fallback(srs_text)[0]
+
+def get_generator():
+    global _generator_instance
+    if _generator_instance is None:
+        class Generator:
+            def __init__(self):
+                self.model_name = get_optimal_model_for_memory()
+                self.tokenizer = None
+                self.model = None
+                if self.model_name:
+                    self.tokenizer, self.model = load_model_with_memory_optimization(self.model_name)
+
+            def get_model_info(self):
+                mem = psutil.Process().memory_info().rss / 1024 / 1024
+                return {
+                    "model_name": self.model_name if self.model_name else "Template-Based Generator",
+                    "status": "loaded" if self.model else "template_mode",
+                    "memory_usage": f"{mem:.1f}MB",
+                    "optimization": "low_memory"
+                }
+
+        _generator_instance = Generator()
+
+    return _generator_instance
+
+def monitor_memory():
+    mem = psutil.Process().memory_info().rss / 1024 / 1024
+    logger.info(f"Memory usage: {mem:.1f}MB")
+    if mem > 450:
+        gc.collect()
+        logger.info("Memory cleanup triggered")
+
+# ✅ NEW FUNCTION for enhanced output: test cases + model info + reason
+def generate_test_cases_and_info(input_text):
+    test_cases, model_name, algorithm_used, reason = generate_with_fallback(input_text)
+    return {
+        "model": model_name,
+        "algorithm": algorithm_used,
+        "reason": reason,
+        "test_cases": test_cases
+    }
+
+# ✅ Explain why each algorithm is selected
+def get_algorithm_reason(model_name):
+    if model_name == "microsoft/DialoGPT-small":
+        return "Selected due to low memory availability; DialoGPT-small provides conversational understanding in limited memory environments."
+    elif model_name == "distilgpt2":
+        return "Selected for its balance between performance and low memory usage. Ideal for small environments needing causal language modeling."
+    elif model_name == "gpt2":
+        return "Chosen for general-purpose text generation with moderate memory headroom."
+    elif model_name is None:
+        return "No model used due to insufficient memory. Rule-based template generation chosen instead."
+    else:
+        return "Model selected based on best tradeoff between memory usage and language generation capability."