Revert: Back to original working app structure

Dockerfile

@@ -24,4 +24,4 @@ ENV PYTHONPATH=/code
 ENV TMPDIR=/tmp
 
 # Command to run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -1,177 +0,0 @@
-import shutil
-import os
-import uuid
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-# Embedded prediction function with model loading
-import sys
-import numpy as np
-import tensorflow as tf
-from tensorflow.keras.preprocessing import image
-from huggingface_hub import hf_hub_download
-
-# Model configuration
-MODEL_PATH = "app/model/efficientnetv2s.h5"
-REPO_ID = "Miguel764/efficientnetv2s-skin-cancer-classifier"
-FILENAME = "efficientnetv2s.h5"
-TEMPERATURE = 2.77
-
-class_names_mapping = {
-    0: "AKIEC",
-    1: "BCC", 
-    2: "BKL",
-    3: "DF",
-    4: "MEL",
-    5: "NV",
-    6: "VASC"
-}
-
-full_names = {
-    "AKIEC": "Actinic keratoses and intraepithelial carcinoma",
-    "BCC": "Basal cell carcinoma",
-    "BKL": "Benign keratosis-like lesions", 
-    "DF": "Dermatofibroma",
-    "MEL": "Melanoma",
-    "NV": "Melanocytic nevi",
-    "VASC": "Vascular lesions"
-}
-
-# Global model variable
-model = None
-
-def load_model():
-    global model
-    try:
-        if not os.path.exists(MODEL_PATH):
-            print("Model not found locally. Downloading from Hugging Face...")
-            os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
-            hf_hub_download(
-                repo_id=REPO_ID,
-                filename=FILENAME,
-                local_dir="app/model"
-            )
-        else:
-            print("Model already exists locally.")
-        
-        print("Loading TensorFlow model...")
-        model = tf.keras.models.load_model(MODEL_PATH)
-        print("Model loaded successfully!")
-        return model
-    except Exception as e:
-        print(f"Error loading model: {e}")
-        return None
-
-def predict_image(image_path):
-    global model
-    try:
-        if model is None:
-            model = load_model()
-            if model is None:
-                return "Error: Model not loaded", 0.0, [{"label": "Error", "confidence": 0.0}]
-        
-        # Load and preprocess image
-        img = image.load_img(image_path, target_size=(224, 224))
-        img_array = image.img_to_array(img)
-        img_array = np.expand_dims(img_array, axis=0)
-        img_array = tf.keras.applications.imagenet_utils.preprocess_input(img_array)
-        
-        # Make prediction
-        logits = model.predict(img_array)
-        scaled_logits = logits / TEMPERATURE
-        scaled_probs = tf.nn.softmax(scaled_logits).numpy()[0]
-        
-        class_idx = int(np.argmax(scaled_probs))
-        top_label = full_names[class_names_mapping[class_idx]]
-        top_confidence = float(scaled_probs[class_idx])
-        
-        all_predictions = [
-            {"label": class_names_mapping[i], "confidence": float(pred)}
-            for i, pred in enumerate(scaled_probs)
-        ]
-        
-        return top_label, top_confidence, all_predictions
-        
-    except Exception as e:
-        print(f"Prediction error: {e}")
-        return f"Error: {str(e)}", 0.0, [{"label": "Error", "confidence": 0.0}]
-
-app = FastAPI(
-    title="GP-Tea Skin Analysis API",
-    description="AI-powered skin condition analysis service",
-    version="1.0.0"
-)
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Create uploads directory in tmp (writable in containers)
-import tempfile
-UPLOAD_DIR = tempfile.mkdtemp()
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-
-@app.get("/")
-async def root():
-    return {"message": "GP-Tea Skin Analysis API", "status": "running"}
-
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "service": "gp-tea-skin-analysis"}
-
-@app.post("/analyze_image")
-async def analyze_image(file: UploadFile = File(...)):
-    """Analyze skin image for medical conditions"""
-    try:
-        if not file.content_type or not file.content_type.startswith('image/'):
-            raise HTTPException(status_code=400, detail="File must be an image")
-        
-        unique_filename = f"{uuid.uuid4().hex}_{file.filename}"
-        file_path = os.path.join(UPLOAD_DIR, unique_filename)
-        
-        with open(file_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-        
-        label, confidence, all_predictions = predict_image(file_path)
-        
-        # Clean up uploaded file
-        if os.path.exists(file_path):
-            os.remove(file_path)
-        
-        formatted_predictions = []
-        for pred in all_predictions:
-            formatted_predictions.append({
-                "label": pred["label"],
-                "confidence": float(pred["confidence"]),
-                "confidence_percent": f"{pred['confidence'] * 100:.2f}%"
-            })
-        
-        return JSONResponse(
-            status_code=200,
-            content={
-                "success": True,
-                "prediction": {
-                    "top_prediction": {
-                        "label": label,
-                        "confidence": float(confidence),
-                        "confidence_percent": f"{confidence * 100:.2f}%"
-                    },
-                    "all_predictions": formatted_predictions
-                }
-            }
-        )
-        
-    except Exception as e:
-        if 'file_path' in locals() and os.path.exists(file_path):
-            os.remove(file_path)
-        raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}")
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)