Update app.py

app.py

@@ -1,121 +1,71 @@
 import gradio as gr
 import spaces
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
 
-print("[App] Starting application...")
-print("[App] Spaces imported successfully")
-
-# Global variables
-_model = None
-_tokenizer = None
-_model_name = "microsoft/DialoGPT-small"
-
-def initialize_tokenizer():
-    """Initialize tokenizer"""
-    global _tokenizer
-    if _tokenizer is None:
-        print("[App] Loading tokenizer...")
-        _tokenizer = AutoTokenizer.from_pretrained(_model_name)
-        if _tokenizer.pad_token is None:
-            _tokenizer.pad_token = _tokenizer.eos_token
-        print("[App] Tokenizer loaded successfully.")
-    return _tokenizer
+# Import the service - this should trigger GPU function registration
+from minimal_service import service, generate_text_gpu
 
+# Additional GPU function at app level for extra safety
 @spaces.GPU
-def generate_text_gpu(prompt: str, max_tokens: int = 50):
-    """GPU function for text generation - this should be detected by Spaces"""
-    global _model, _tokenizer
-    
-    print("[App] GPU function called")
-    
-    # Initialize tokenizer
-    if _tokenizer is None:
-        initialize_tokenizer()
-    
-    # Load model in GPU context
-    if _model is None:
-        print("[App] Loading model in GPU context...")
-        _model = AutoModelForCausalLM.from_pretrained(
-            _model_name,
-            torch_dtype=torch.float16,
-            device_map="auto"
-        )
-        print("[App] Model loaded successfully.")
-    
-    # Simple generation
-    inputs = _tokenizer.encode(prompt, return_tensors="pt")
-    device = next(_model.parameters()).device
-    inputs = inputs.to(device)
-    
-    with torch.no_grad():
-        outputs = _model.generate(
-            inputs,
-            max_new_tokens=max_tokens,
-            temperature=0.7,
-            do_sample=True,
-            pad_token_id=_tokenizer.eos_token_id
-        )
-    
-    response = _tokenizer.decode(outputs[0], skip_special_tokens=True)
-    print("[App] Generation completed")
-    return response
+def app_gpu_test():
+    """Test GPU function at app level"""
+    return "App GPU function works"
 
-# Print confirmation that GPU function is available
-print(f"[App] GPU function registered: {generate_text_gpu.__name__}")
+print("[App] GPU functions imported successfully")
+print(f"[App] Service GPU function: {generate_text_gpu.__name__}")
+print(f"[App] App GPU function: {app_gpu_test.__name__}")
+
+# ADD FASTAPI - Step 2 change
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
 
 def generate_response(user_input):
-    """Generate response using GPU function"""
+    """Generate response using the service"""
     if not user_input.strip():
         return "Please enter some text!"
     
     try:
-        print(f"[App] Processing input: {user_input}")
-        response = generate_text_gpu(user_input)
+        response = service.generate(user_input)
         return f"Generated: {response}"
     except Exception as e:
-        print(f"[App] Error: {e}")
         return f"Error: {str(e)}"
 
-# Initialize tokenizer at startup (lightweight operation)
-try:
-    initialize_tokenizer()
-    print("[App] Initial setup completed")
-except Exception as e:
-    print(f"[App] Setup error: {e}")
-
 # Create Gradio interface
-with gr.Blocks(title="GPU Test", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 GPU Function Test")
-    gr.Markdown("Testing if Spaces can detect the GPU function properly.")
+with gr.Blocks(title="Minimal GPU Test with FastAPI") as demo:
+    gr.Markdown("# Minimal GPU Test with FastAPI")
+    gr.Markdown("Testing if adding FastAPI breaks GPU detection.")
     
     with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(
-                label="Enter text",
-                placeholder="Type something...",
-                value="Hello, how are you today?"
-            )
-            generate_btn = gr.Button("Generate with GPU", variant="primary")
-        
-        with gr.Column():
-            output_text = gr.Textbox(
-                label="Generated response",
-                interactive=False,
-                lines=5
-            )
+        input_text = gr.Textbox(
+            label="Enter text",
+            placeholder="Type something...",
+            value="Hello, how are you?"
+        )
+        output_text = gr.Textbox(
+            label="Generated response",
+            interactive=False
+        )
+    
+    generate_btn = gr.Button("Generate", variant="primary")
     
     generate_btn.click(
         fn=generate_response,
         inputs=[input_text],
         outputs=[output_text]
     )
-    
-    gr.Markdown("---")
-    gr.Markdown("**Note:** If this works, the GPU function is being detected properly.")
 
-print("[App] Gradio interface created")
+# ADD FASTAPI MOUNTING - Step 2 change
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    return RedirectResponse(url="/gradio")
+
+# Mount Gradio on FastAPI
+app = gr.mount_gradio_app(app, demo, path="/gradio")
+
+print("[App] FastAPI + Gradio setup completed")
 
 if __name__ == "__main__":
-    print("[App] Launching demo...")
-    demo.launch()
+    print("[App] Starting application...")
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)