Upload app.py with huggingface_hub

app.py

@@ -6,6 +6,9 @@ Lightweight CPU-based implementation for Hugging Face Spaces
 import os
 import time
 import uuid
+import logging
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
 from typing import List, Optional, Union
 from contextlib import asynccontextmanager
 
@@ -18,6 +21,46 @@ from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStream
 from threading import Thread
 import json
 
+# ============== Logging Configuration ==============
+LOG_DIR = "/tmp/logs"
+os.makedirs(LOG_DIR, exist_ok=True)
+LOG_FILE = os.path.join(LOG_DIR, "api.log")
+
+# Create formatters
+log_format = logging.Formatter(
+    '%(asctime)s | %(levelname)-8s | %(name)s | %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+# File handler with rotation (10MB max, keep 5 backups)
+file_handler = RotatingFileHandler(
+    LOG_FILE,
+    maxBytes=10*1024*1024,
+    backupCount=5,
+    encoding='utf-8'
+)
+file_handler.setFormatter(log_format)
+file_handler.setLevel(logging.DEBUG)
+
+# Console handler
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(log_format)
+console_handler.setLevel(logging.INFO)
+
+# Root logger
+logging.basicConfig(level=logging.DEBUG, handlers=[file_handler, console_handler])
+logger = logging.getLogger("anthropic-api")
+
+# Also capture uvicorn logs
+for uvicorn_logger in ["uvicorn", "uvicorn.error", "uvicorn.access"]:
+    uv_log = logging.getLogger(uvicorn_logger)
+    uv_log.handlers = [file_handler, console_handler]
+
+logger.info("=" * 60)
+logger.info(f"Application Startup at {datetime.now().isoformat()}")
+logger.info(f"Log file: {LOG_FILE}")
+logger.info("=" * 60)
+
 # ============== Configuration ==============
 MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"  # Ultra-lightweight 135M model
 MAX_TOKENS_DEFAULT = 1024
@@ -31,21 +74,29 @@ tokenizer = None
 async def lifespan(app: FastAPI):
     """Load model on startup"""
     global model, tokenizer
-    print(f"Loading model: {MODEL_ID}")
-
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-    model = AutoModelForCausalLM.from_pretrained(
-        MODEL_ID,
-        torch_dtype=torch.float32,
-        device_map=DEVICE,
-        low_cpu_mem_usage=True
-    )
-    model.eval()
-    print("Model loaded successfully!")
+    logger.info(f"Loading model: {MODEL_ID}")
+
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+        logger.info("Tokenizer loaded successfully")
+
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_ID,
+            torch_dtype=torch.float32,
+            device_map=DEVICE,
+            low_cpu_mem_usage=True
+        )
+        model.eval()
+        logger.info("Model loaded successfully!")
+        logger.info(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")
+    except Exception as e:
+        logger.error(f"Failed to load model: {e}", exc_info=True)
+        raise
 
     yield
 
     # Cleanup
+    logger.info("Shutting down, cleaning up model...")
     del model, tokenizer
 
 app = FastAPI(
@@ -64,6 +115,24 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Request logging middleware
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    request_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+
+    logger.info(f"[{request_id}] {request.method} {request.url.path} - Started")
+
+    try:
+        response = await call_next(request)
+        duration = (time.time() - start_time) * 1000
+        logger.info(f"[{request_id}] {request.method} {request.url.path} - {response.status_code} ({duration:.2f}ms)")
+        return response
+    except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        logger.error(f"[{request_id}] {request.method} {request.url.path} - Error: {e} ({duration:.2f}ms)")
+        raise
+
 # ============== Pydantic Models (Anthropic-Compatible) ==============
 
 class ContentBlock(BaseModel):
@@ -143,16 +212,19 @@ def generate_id() -> str:
 @app.get("/")
 async def root():
     """Health check endpoint"""
+    logger.debug("Root endpoint accessed")
     return {
         "status": "healthy",
         "model": MODEL_ID,
         "api_version": "2023-06-01",
-        "compatibility": "anthropic-messages-api"
+        "compatibility": "anthropic-messages-api",
+        "log_file": LOG_FILE
     }
 
 @app.get("/v1/models")
 async def list_models():
     """List available models (Anthropic-compatible)"""
+    logger.debug("Models list requested")
     return {
         "object": "list",
         "data": [
@@ -166,6 +238,22 @@ async def list_models():
         ]
     }
 
+@app.get("/logs")
+async def get_logs(lines: int = 100):
+    """Get recent log entries"""
+    try:
+        with open(LOG_FILE, 'r') as f:
+            all_lines = f.readlines()
+            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+            return {
+                "log_file": LOG_FILE,
+                "total_lines": len(all_lines),
+                "returned_lines": len(recent_lines),
+                "logs": "".join(recent_lines)
+            }
+    except FileNotFoundError:
+        return {"error": "Log file not found", "log_file": LOG_FILE}
+
 @app.post("/v1/messages")
 async def create_message(
     request: MessageRequest,
@@ -175,18 +263,25 @@ async def create_message(
     """
     Create a message (Anthropic Messages API compatible)
     """
+    message_id = generate_id()
+    logger.info(f"[{message_id}] Creating message - model: {request.model}, max_tokens: {request.max_tokens}, stream: {request.stream}")
+
     try:
         # Format the prompt
         prompt = format_messages(request.messages, request.system)
+        logger.debug(f"[{message_id}] Prompt length: {len(prompt)} chars")
 
         # Tokenize
         inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
         input_token_count = inputs.input_ids.shape[1]
+        logger.info(f"[{message_id}] Input tokens: {input_token_count}")
 
         if request.stream:
-            return await stream_response(request, inputs, input_token_count)
+            logger.info(f"[{message_id}] Starting streaming response")
+            return await stream_response(request, inputs, input_token_count, message_id)
 
         # Generate
+        gen_start = time.time()
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
@@ -198,15 +293,19 @@ async def create_message(
                 pad_token_id=tokenizer.eos_token_id,
                 eos_token_id=tokenizer.eos_token_id,
             )
+        gen_time = time.time() - gen_start
 
         # Decode only new tokens
         generated_tokens = outputs[0][input_token_count:]
         generated_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
         output_token_count = len(generated_tokens)
 
+        tokens_per_sec = output_token_count / gen_time if gen_time > 0 else 0
+        logger.info(f"[{message_id}] Generated {output_token_count} tokens in {gen_time:.2f}s ({tokens_per_sec:.1f} tok/s)")
+
         # Build response
         response = MessageResponse(
-            id=generate_id(),
+            id=message_id,
             content=[ContentBlock(type="text", text=generated_text.strip())],
             model=request.model,
             stop_reason="end_turn",
@@ -219,13 +318,12 @@ async def create_message(
         return response
 
     except Exception as e:
+        logger.error(f"[{message_id}] Error creating message: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
 
-async def stream_response(request: MessageRequest, inputs, input_token_count: int):
+async def stream_response(request: MessageRequest, inputs, input_token_count: int, message_id: str):
     """Stream response using SSE (Server-Sent Events)"""
 
-    message_id = generate_id()
-
     async def generate():
         # Send message_start event
         start_event = {
@@ -267,6 +365,7 @@ async def stream_response(request: MessageRequest, inputs, input_token_count: in
         }
 
         # Run generation in a thread
+        gen_start = time.time()
         thread = Thread(target=model.generate, kwargs=generation_kwargs)
         thread.start()
 
@@ -282,6 +381,9 @@ async def stream_response(request: MessageRequest, inputs, input_token_count: in
                 yield f"event: content_block_delta\ndata: {json.dumps(delta_event)}\n\n"
 
         thread.join()
+        gen_time = time.time() - gen_start
+        tokens_per_sec = output_tokens / gen_time if gen_time > 0 else 0
+        logger.info(f"[{message_id}] Stream completed: {output_tokens} tokens in {gen_time:.2f}s ({tokens_per_sec:.1f} tok/s)")
 
         # Send content_block_stop
         block_stop = {"type": "content_block_stop", "index": 0}
@@ -314,13 +416,14 @@ async def count_tokens(request: MessageRequest):
     """Count tokens for a message request"""
     prompt = format_messages(request.messages, request.system)
     tokens = tokenizer.encode(prompt)
+    logger.debug(f"Token count request: {len(tokens)} tokens")
     return {"input_tokens": len(tokens)}
 
 # Health check
 @app.get("/health")
 async def health():
-    return {"status": "ok", "model_loaded": model is not None}
+    return {"status": "ok", "model_loaded": model is not None, "log_file": LOG_FILE}
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_config=None)