hello

Dockerfile

@@ -53,7 +53,7 @@ EXPOSE 7860
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=30s --start-period=300s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
+    CMD curl -f https://cronjob-python-chatbot.hf.space/health || exit 1
 
 # Run FastAPI application
 CMD ["python", "main.py"]

chat_routes.py

@@ -0,0 +1,45 @@
+from fastapi import APIRouter, HTTPException
+from models import ChatRequest, ChatResponse, HealthResponse
+from model_service import (
+    generate_response, model_loaded, MODEL_NAME, CACHE_DIR, startup_time, is_model_cached
+)
+import torch
+
+router = APIRouter()
+
+@router.get("/")
+def root():
+    return {"message": "FastAPI Chatbot API", "status": "running"}
+
+@router.get("/health", response_model=HealthResponse)
+def health():
+    return HealthResponse(
+        status="healthy" if model_loaded else "initializing",
+        is_model_loaded=model_loaded,
+        model_name=MODEL_NAME,
+        cache_directory=CACHE_DIR,
+        startup_time=startup_time
+    )
+
+@router.post("/chat", response_model=ChatResponse)
+def chat(request: ChatRequest):
+    if not model_loaded:
+        raise HTTPException(status_code=503, detail="Model not loaded yet.")
+    if not request.message.strip():
+        raise HTTPException(status_code=400, detail="Message cannot be empty")
+
+    resp, time_taken = generate_response(
+        request.message, request.max_length, request.temperature, request.top_p
+    )
+    return ChatResponse(response=resp, model_name=MODEL_NAME, response_time=time_taken)
+
+@router.get("/model-info")
+def model_info():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    return {
+        "model_name": MODEL_NAME,
+        "model_loaded": model_loaded,
+        "device": device,
+        "cache_directory": CACHE_DIR,
+        "model_cached": is_model_cached(MODEL_NAME),
+    }

config.py

@@ -0,0 +1,11 @@
+import os
+from pathlib import Path
+
+# Model configuration
+MODEL_NAME = os.getenv("MODEL_NAME", "microsoft/DialoGPT-medium")
+CACHE_DIR = os.getenv("TRANSFORMERS_CACHE", "/app/model_cache")
+MAX_LENGTH = int(os.getenv("MAX_LENGTH", "100"))
+DEFAULT_TEMPERATURE = float(os.getenv("DEFAULT_TEMPERATURE", "0.7"))
+
+# Ensure cache directory exists
+Path(CACHE_DIR).mkdir(parents=True, exist_ok=True)

logger.py

@@ -0,0 +1,7 @@
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger("chatbot")

main.py

@@ -1,290 +1,27 @@
-import os
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-import torch
-import logging
+from chat_routes import router as chat_router
+from model_service import load_model
 import threading
 import uvicorn
-from pathlib import Path
-import time
+from logger import logger
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# FastAPI app
-app = FastAPI(
-    title="FastAPI Chatbot", 
-    description="Chatbot with FastAPI backend",
-    version="1.0.0"
-)
-
-# Add CORS middleware
+app = FastAPI(title="FastAPI Chatbot", version="1.0.0")
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"],
 )
 
-# Pydantic models with fixed namespace conflicts
-class ChatRequest(BaseModel):
-    message: str
-    max_length: int = 100
-    temperature: float = 0.7
-    top_p: float = 0.9
-
-    class Config:
-        protected_namespaces = ()
-
-class ChatResponse(BaseModel):
-    response: str
-    model_name: str
-    response_time: float
-
-    class Config:
-        protected_namespaces = ()
-
-class HealthResponse(BaseModel):
-    status: str
-    is_model_loaded: bool
-    model_name: str
-    cache_directory: str
-    startup_time: float
-
-    class Config:
-        protected_namespaces = ()
-
-# Global variables
-tokenizer = None
-model = None
-generator = None
-startup_time = time.time()
-model_loaded = False
-
-# Configuration
-MODEL_NAME = os.getenv("MODEL_NAME", "microsoft/DialoGPT-medium")
-CACHE_DIR = os.getenv("TRANSFORMERS_CACHE", "/app/model_cache")
-MAX_LENGTH = int(os.getenv("MAX_LENGTH", "100"))
-DEFAULT_TEMPERATURE = float(os.getenv("DEFAULT_TEMPERATURE", "0.7"))
-
-def ensure_cache_dir():
-    """Ensure cache directory exists"""
-    Path(CACHE_DIR).mkdir(parents=True, exist_ok=True)
-    logger.info(f"Cache directory: {CACHE_DIR}")
-
-def is_model_cached(model_name: str) -> bool:
-    """Check if model is already cached"""
-    try:
-        model_path = Path(CACHE_DIR) / f"models--{model_name.replace('/', '--')}"
-        is_cached = model_path.exists() and any(model_path.iterdir())
-        logger.info(f"Model cached: {is_cached}")
-        return is_cached
-    except Exception as e:
-        logger.error(f"Error checking cache: {e}")
-        return False
-
-def load_model():
-    """Load the Hugging Face model with caching"""
-    global tokenizer, model, generator, model_loaded
-    
-    try:
-        ensure_cache_dir()
-        
-        logger.info(f"Loading model: {MODEL_NAME}")
-        logger.info(f"Cache dir: {CACHE_DIR}")
-        logger.info(f"CUDA available: {torch.cuda.is_available()}")
-        
-        start_time = time.time()
-        
-        # Load tokenizer first
-        logger.info("Loading tokenizer...")
-        tokenizer = AutoTokenizer.from_pretrained(
-            MODEL_NAME,
-            cache_dir=CACHE_DIR,
-            local_files_only=False
-        )
-        
-        # Add padding token if it doesn't exist
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        # Load model
-        logger.info("Loading model...")
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME,
-            cache_dir=CACHE_DIR,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto" if torch.cuda.is_available() else None,
-            low_cpu_mem_usage=True,
-            local_files_only=False
-        )
-        
-        # Create text generation pipeline
-        logger.info("Creating pipeline...")
-        device = 0 if torch.cuda.is_available() else -1
-        generator = pipeline(
-            "text-generation",
-            model=model,
-            tokenizer=tokenizer,
-            device=device,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-        )
-        
-        load_time = time.time() - start_time
-        model_loaded = True
-        logger.info(f"✅ Model loaded successfully in {load_time:.2f} seconds!")
-        logger.info(f"Model device: {model.device}")
-        
-        return True
-        
-    except Exception as e:
-        logger.error(f"❌ Error loading model: {str(e)}", exc_info=True)
-        return False
-
-def generate_response(message: str, max_length: int = 100, temperature: float = 0.7, top_p: float = 0.9) -> str:
-    """Generate response using the loaded model"""
-    if not generator:
-        return "❌ Model not loaded. Please wait for initialization...", 0.0
-    
-    try:
-        start_time = time.time()
-        
-        # Generate response with parameters
-        response = generator(
-            message,
-            max_length=max_length,
-            temperature=temperature,
-            top_p=top_p,
-            num_return_sequences=1,
-            pad_token_id=tokenizer.eos_token_id,
-            do_sample=True,
-            truncation=True,
-            repetition_penalty=1.1
-        )
-        
-        # Extract generated text
-        generated_text = response[0]['generated_text']
-        
-        # Clean up response
-        if generated_text.startswith(message):
-            bot_response = generated_text[len(message):].strip()
-        else:
-            bot_response = generated_text.strip()
-        
-        # Fallback if empty response
-        if not bot_response:
-            bot_response = "I'm not sure how to respond to that. Could you try rephrasing?"
-        
-        response_time = time.time() - start_time
-        logger.info(f"Generated response in {response_time:.2f}s")
-        
-        return bot_response, response_time
-        
-    except Exception as e:
-        logger.error(f"Error generating response: {str(e)}", exc_info=True)
-        return f"❌ Error generating response: {str(e)}", 0.0
-
-# FastAPI endpoints
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {"message": "FastAPI Chatbot API", "status": "running"}
-
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint with detailed information"""
-    return HealthResponse(
-        status="healthy" if model_loaded else "initializing",
-        is_model_loaded=model_loaded,
-        model_name=MODEL_NAME,
-        cache_directory=CACHE_DIR,
-        startup_time=time.time() - startup_time
-    )
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(request: ChatRequest):
-    """Chat endpoint for API access"""
-    if not model_loaded:
-        raise HTTPException(
-            status_code=503, 
-            detail="Model not loaded yet. Please wait for initialization."
-        )
-    
-    # Validate input
-    if not request.message.strip():
-        raise HTTPException(status_code=400, detail="Message cannot be empty")
-    
-    if len(request.message) > 1000:
-        raise HTTPException(status_code=400, detail="Message too long (max 1000 characters)")
-    
-    # Generate response
-    response_text, response_time = generate_response(
-        request.message.strip(), 
-        request.max_length, 
-        request.temperature,
-        request.top_p
-    )
-    
-    return ChatResponse(
-        response=response_text,
-        model_name=MODEL_NAME,
-        response_time=response_time
-    )
-
-@app.get("/model-info")
-async def get_model_info():
-    """Get detailed model information"""
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    if model and hasattr(model, 'device'):
-        device = str(model.device)
-    
-    return {
-        "model_name": MODEL_NAME,
-        "model_loaded": model_loaded,
-        "device": device,
-        "cache_directory": CACHE_DIR,
-        "model_cached": is_model_cached(MODEL_NAME),
-        "parameters": {
-            "max_length": MAX_LENGTH,
-            "default_temperature": DEFAULT_TEMPERATURE
-        }
-    }
+app.include_router(chat_router)
 
 @app.on_event("startup")
-async def startup_event():
-    """Load model on startup"""
-    logger.info("🚀 Starting FastAPI Chatbot...")
-    logger.info("📦 Loading model...")
-    
-    # Load model in background thread to not block startup
-    def load_model_background():
-        global model_loaded
-        model_loaded = load_model()
-        if model_loaded:
-            logger.info("✅ Model loaded successfully!")
-        else:
-            logger.error("❌ Failed to load model.")
-    
-    # Start model loading in background
-    threading.Thread(target=load_model_background, daemon=True).start()
-
-def run_fastapi():
-    """Run FastAPI server"""
-    uvicorn.run(
-        app, 
-        host="0.0.0.0", 
-        port=7860,  # Changed to 7860 for HuggingFace
-        log_level="info",
-        access_log=True
-    )
+def startup():
+    def load_in_bg():
+        success = load_model()
+        if success: logger.info("Model loaded on startup.")
+        else: logger.error("Model failed to load.")
+    threading.Thread(target=load_in_bg, daemon=True).start()
 
 if __name__ == "__main__":
-    run_fastapi()
+    uvicorn.run("app.main:app", host="0.0.0.0", port=7860, reload=False)

model_service.py

@@ -0,0 +1,84 @@
+import time
+from pathlib import Path
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import torch
+from logger import logger
+from config import CACHE_DIR, MODEL_NAME
+
+
+tokenizer = None
+model = None
+generator = None
+model_loaded = False
+startup_time = time.time()
+
+def is_model_cached(model_name: str) -> bool:
+    try:
+        model_path = Path(CACHE_DIR) / f"models--{model_name.replace('/', '--')}"
+        return model_path.exists() and any(model_path.iterdir())
+    except Exception as e:
+        logger.error(f"Error checking cache: {e}")
+        return False
+
+def load_model():
+    global tokenizer, model, generator, model_loaded
+
+    try:
+        logger.info(f"Loading model: {MODEL_NAME}")
+        logger.info(f"CUDA available: {torch.cuda.is_available()}")
+        start = time.time()
+
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, cache_dir=CACHE_DIR)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            cache_dir=CACHE_DIR,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else None,
+            low_cpu_mem_usage=True,
+        )
+
+        device = 0 if torch.cuda.is_available() else -1
+        generator = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tokenizer,
+            device=device,
+        )
+
+        model_loaded = True
+        logger.info(f"✅ Model loaded in {time.time()-start:.2f}s on {model.device}")
+        return True
+
+    except Exception as e:
+        logger.error(f"❌ Error loading model: {e}", exc_info=True)
+        model_loaded = False
+        return False
+
+def generate_response(message: str, max_length: int, temperature: float, top_p: float):
+    if not generator:
+        return "❌ Model not loaded yet", 0.0
+
+    start = time.time()
+    try:
+        result = generator(
+            message,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p,
+            num_return_sequences=1,
+            pad_token_id=tokenizer.eos_token_id,
+            do_sample=True,
+            repetition_penalty=1.1
+        )
+        text = result[0]['generated_text']
+        reply = text[len(message):].strip() if text.startswith(message) else text.strip()
+        if not reply:
+            reply = "I'm not sure how to respond to that."
+        return reply, time.time()-start
+
+    except Exception as e:
+        logger.error(f"Generation error: {e}", exc_info=True)
+        return f"❌ Error: {e}", 0.0

models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+
+class ChatRequest(BaseModel):
+    message: str
+    max_length: int = 100
+    temperature: float = 0.7
+    top_p: float = 0.9
+    class Config:
+        protected_namespaces = ()
+
+class ChatResponse(BaseModel):
+    response: str
+    model_name: str
+    response_time: float
+    class Config:
+        protected_namespaces = ()
+
+class HealthResponse(BaseModel):
+    status: str
+    is_model_loaded: bool
+    model_name: str
+    cache_directory: str
+    startup_time: float
+    class Config:
+        protected_namespaces = ()