Update app.py

app.py

@@ -3,12 +3,12 @@ import logging
 import sys
 import torch
 import tempfile
-from pathlib import Path
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from typing import List, Optional
 import uvicorn
+import random
 
 # Configure logging
 logging.basicConfig(
@@ -20,13 +20,12 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI(title="Chat API", description="Simple chat API for Hugging Face Space")
 
-# Create a directory for caching in the current working directory
-cache_dir = Path("./model_cache")
-cache_dir.mkdir(exist_ok=True)
-os.environ["TRANSFORMERS_CACHE"] = str(cache_dir.absolute())
-os.environ["HF_HOME"] = str(cache_dir.absolute())
+# Use the system's temporary directory which should be writable
+temp_dir = tempfile.mkdtemp()
+os.environ["TRANSFORMERS_CACHE"] = temp_dir
+os.environ["HF_HOME"] = temp_dir
 
-logger.info(f"Using cache directory: {cache_dir.absolute()}")
+logger.info(f"Using temporary directory: {temp_dir}")
 
 # Pydantic models for request/response
 class ChatTurn(BaseModel):
@@ -40,16 +39,7 @@ class ChatRequest(BaseModel):
 class ChatResponse(BaseModel):
     response: str
 
-# Global variables
-model = None
-tokenizer = None
-generator = None
-dataset = None
-
-# Load a small model or use a fallback if loading fails
-MODEL_ID = "distilgpt2"  # Small model for testing
-
-# Fallback responses for when the model isn't available
+# Fallback responses
 FALLBACK_RESPONSES = [
     "I apologize, but I'm currently having trouble processing your request.",
     "Sorry, I'm experiencing technical difficulties at the moment.",
@@ -67,162 +57,40 @@ async def generic_exception_handler(request: Request, exc: Exception):
         content={"detail": f"Internal server error: {str(exc)}"}
     )
 
-def try_load_model():
-    """Attempt to load the model and tokenizer with appropriate error handling"""
-    global model, tokenizer, generator
-    
-    try:
-        # Import here to handle import errors gracefully
-        from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-        
-        logger.info(f"Loading tokenizer for {MODEL_ID}")
-        tokenizer = AutoTokenizer.from_pretrained(
-            MODEL_ID,
-            cache_dir=cache_dir,
-            local_files_only=False
-        )
-        logger.info("Tokenizer loaded successfully")
-        
-        logger.info(f"Loading model {MODEL_ID}")
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_ID,
-            cache_dir=cache_dir,
-            local_files_only=False,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            low_cpu_mem_usage=True
-        )
-        logger.info("Model loaded successfully")
-        
-        device = 0 if torch.cuda.is_available() else -1
-        logger.info(f"Creating generator pipeline (device: {device})")
-        generator = pipeline(
-            "text-generation", 
-            model=model, 
-            tokenizer=tokenizer, 
-            device=device
-        )
-        logger.info("Generator pipeline created successfully")
-        return True
-    except Exception as e:
-        logger.error(f"Error loading model: {str(e)}", exc_info=True)
-        return False
-
-def try_load_dataset():
-    """Attempt to load the dataset with appropriate error handling"""
-    global dataset
-    
-    try:
-        from datasets import load_dataset
-        logger.info("Loading dataset: lahiruchamika27/tia")
-        dataset = load_dataset("lahiruchamika27/tia", cache_dir=cache_dir)
-        logger.info("Dataset loaded successfully")
-        return True
-    except Exception as e:
-        logger.error(f"Error loading dataset: {str(e)}", exc_info=True)
-        return False
-
-# Startup event
-@app.on_event("startup")
-async def startup_event():
-    logger.info("Starting application")
-    # Try to load model but don't fail if it doesn't work
-    model_loaded = try_load_model()
-    dataset_loaded = try_load_dataset()
-    logger.info(f"Startup complete. Model loaded: {model_loaded}, Dataset loaded: {dataset_loaded}")
-
 # Simple text-only route
 @app.get("/")
 async def root():
     return {"message": "Chat API is running. Use /api/chat for chat functionality."}
 
-# Chat endpoint
+# Chat endpoint - just use fallback responses for now
 @app.post("/api/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
     logger.info(f"Received chat request: {request.message[:50]}...")
     
-    # If the model isn't loaded, return a fallback response
-    if generator is None:
-        import random
-        fallback = random.choice(FALLBACK_RESPONSES)
-        logger.warning("Using fallback response because model is not loaded")
-        return ChatResponse(response=fallback)
-    
-    try:
-        # Format conversation history
-        if request.history:
-            full_prompt = ""
-            for turn in request.history:
-                if turn.user:
-                    full_prompt += f"User: {turn.user}\n"
-                if turn.assistant:
-                    full_prompt += f"Assistant: {turn.assistant}\n"
-            
-            full_prompt += f"User: {request.message}\nAssistant:"
-        else:
-            full_prompt = f"User: {request.message}\nAssistant:"
-        
-        logger.info(f"Generated prompt: {full_prompt[:100]}...")
-        
-        # Generate text
-        outputs = generator(
-            full_prompt,
-            max_new_tokens=100,
-            temperature=0.7,
-            top_p=0.9,
-            do_sample=True
-        )
-        
-        # Extract response
-        generated_text = outputs[0]['generated_text']
-        # Extract just the assistant's response
-        response_text = generated_text[len(full_prompt):].strip()
-        
-        # Fallback if response is empty
-        if not response_text or response_text.isspace():
-            response_text = "I'm sorry, I'm having trouble generating a response right now."
-            
-        logger.info(f"Final response: {response_text[:50]}...")
-        return ChatResponse(response=response_text)
+    # Select a random fallback response
+    fallback = random.choice(FALLBACK_RESPONSES)
     
-    except Exception as e:
-        logger.error(f"Error in chat endpoint: {str(e)}", exc_info=True)
-        return ChatResponse(response="I'm sorry, I encountered an error while processing your request.")
-
-@app.get("/api/examples")
-async def get_examples(count: int = 5, split: str = "train"):
-    if dataset is None:
-        raise HTTPException(status_code=500, detail="Dataset not loaded")
+    # Add a bit of personalization
+    if "hello" in request.message.lower() or "hi" in request.message.lower():
+        fallback = "Hello! " + fallback
+    elif "help" in request.message.lower():
+        fallback = "I'd like to help you with that, but " + fallback.lower()
     
-    try:
-        if split in dataset:
-            # Convert dataset items to dict for easier JSON serialization
-            examples = [dict(item) for item in dataset[split][:count]]
-            return {"examples": examples}
-        else:
-            raise HTTPException(status_code=400, detail=f"Split '{split}' not found in dataset")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    logger.info(f"Returning fallback response")
+    return ChatResponse(response=fallback)
 
 @app.get("/health")
 async def health_check():
     return {
         "status": "ok",
-        "model_loaded": model is not None,
-        "tokenizer_loaded": tokenizer is not None,
-        "generator_loaded": generator is not None,
-        "dataset_loaded": dataset is not None,
-        "model_name": MODEL_ID if model is not None else None,
-        "device": "cuda" if torch.cuda.is_available() else "cpu",
-        "cache_dir": str(cache_dir)
-    }
-
-@app.get("/reload")
-async def reload_resources():
-    model_loaded = try_load_model()
-    dataset_loaded = try_load_dataset()
-    return {
-        "model_reloaded": model_loaded,
-        "dataset_reloaded": dataset_loaded
+        "system_info": {
+            "device": "cpu",  # No GPU for now
+            "temp_dir": temp_dir,
+            "pwd": os.getcwd(),
+            "user": os.getenv("USER", "unknown"),
+            "writable_temp": os.access(temp_dir, os.W_OK),
+            "writable_cwd": os.access(os.getcwd(), os.W_OK)
+        }
     }
 
 if __name__ == "__main__":