Update app.py

app.py

@@ -30,11 +30,16 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Configuration
-OCI_UPLOAD_API_URL = os.getenv("OCI_UPLOAD_API_URL", "https://yukee1992-oci-video-storage.hf.space")
+# Configuration - FIXED OCI URL HANDLING
+OCI_UPLOAD_API_URL = os.getenv("OCI_UPLOAD_API_URL", "").strip()
+if OCI_UPLOAD_API_URL:
+    # Remove trailing slash if present
+    OCI_UPLOAD_API_URL = OCI_UPLOAD_API_URL.rstrip('/')
+
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
 print(f"✅ Using device: {DEVICE}")
+print(f"🔧 OCI Upload URL: {OCI_UPLOAD_API_URL or 'Not configured - uploads will be local only'}")
 
 # Model configuration
 MODEL_REPO_ID = "coqui/XTTS-v2"
@@ -104,12 +109,17 @@ def clean_text(text):
 def upload_to_oci(file_path: str, filename: str, project_id: str, file_type="voiceover"):
     """Upload file to OCI using your existing API with subfolder support"""
     try:
-        if not OCI_UPLOAD_API_URL or OCI_UPLOAD_API_URL == "https://yukee1992-oci-video-storage.hf.space":
-            # If OCI API is not configured or is localhost, skip upload
-            print("⚠️ OCI upload skipped - no valid OCI_UPLOAD_API_URL configured")
+        # Check if OCI URL is properly configured
+        if not OCI_UPLOAD_API_URL:
+            print("⚠️ OCI upload skipped - OCI_UPLOAD_API_URL not configured")
             return {"status": "skipped", "message": "OCI upload disabled"}, None
         
+        # Validate URL format
+        if not OCI_UPLOAD_API_URL.startswith(('http://', 'https://')):
+            return None, f"Invalid OCI URL format: {OCI_UPLOAD_API_URL}"
+        
         url = f"{OCI_UPLOAD_API_URL}/api/upload"
+        print(f"🔗 Attempting upload to: {url}")
         
         with open(file_path, "rb") as f:
             files = {"file": (filename, f, "audio/wav")}
@@ -118,24 +128,55 @@ def upload_to_oci(file_path: str, filename: str, project_id: str, file_type="voi
                 "subfolder": "voiceover"
             }
             
-            # Increase timeout and add better error handling
-            response = requests.post(url, files=files, data=data, timeout=60)
+            # Add headers and better timeout handling
+            headers = {
+                "User-Agent": "TTS-API/1.0",
+                "Accept": "application/json"
+            }
+            
+            response = requests.post(
+                url, 
+                files=files, 
+                data=data, 
+                headers=headers,
+                timeout=30
+            )
+            
+            print(f"📡 Upload response status: {response.status_code}")
             
             if response.status_code == 200:
-                result = response.json()
-                if result.get("status") == "success":
-                    return result, None
-                else:
-                    return None, result.get("message", "Upload failed")
+                try:
+                    result = response.json()
+                    if result.get("status") == "success":
+                        print(f"✅ Upload successful: {result}")
+                        return result, None
+                    else:
+                        error_msg = result.get("message", "Upload failed - unknown error")
+                        print(f"❌ Upload failed: {error_msg}")
+                        return None, error_msg
+                except ValueError as e:
+                    return None, f"Invalid JSON response: {str(e)}"
             else:
-                return None, f"Upload failed with status {response.status_code}"
+                error_msg = f"Upload failed with status {response.status_code}: {response.text}"
+                print(f"❌ {error_msg}")
+                return None, error_msg
                 
     except requests.exceptions.Timeout:
-        return None, "OCI upload timeout - server took too long to respond"
+        error_msg = "OCI upload timeout - server took too long to respond"
+        print(f"❌ {error_msg}")
+        return None, error_msg
     except requests.exceptions.ConnectionError:
-        return None, "Cannot connect to OCI API - check if the server is running"
+        error_msg = f"Cannot connect to OCI API at {OCI_UPLOAD_API_URL} - check if the server is running and accessible"
+        print(f"❌ {error_msg}")
+        return None, error_msg
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Network error during upload: {str(e)}"
+        print(f"❌ {error_msg}")
+        return None, error_msg
     except Exception as e:
-        return None, f"Upload error: {str(e)}"
+        error_msg = f"Unexpected upload error: {str(e)}"
+        print(f"❌ {error_msg}")
+        return None, error_msg
 
 def upload_to_oci_with_retry(file_path: str, filename: str, project_id: str, file_type="voiceover", max_retries=3):
     """Upload file to OCI with retry logic"""
@@ -345,6 +386,62 @@ def load_tts_model(voice_style="default_female"):
     finally:
         model_loading = False
 
+# Health check endpoint
+@app.get("/")
+async def root():
+    return {
+        "status": "running", 
+        "service": "TTS API",
+        "model_loaded": model_loaded,
+        "current_model": current_model,
+        "device": DEVICE,
+        "oci_configured": bool(OCI_UPLOAD_API_URL)
+    }
+
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": model_loaded,
+        "current_model": current_model,
+        "device": DEVICE,
+        "timestamp": datetime.now().isoformat()
+    }
+
+@app.get("/api/oci-health")
+async def check_oci_health():
+    """Check if OCI upload service is available"""
+    if not OCI_UPLOAD_API_URL:
+        return {
+            "status": "not_configured",
+            "message": "OCI_UPLOAD_API_URL environment variable is not set"
+        }
+    
+    try:
+        # Test connection to OCI service
+        test_url = f"{OCI_UPLOAD_API_URL}/api/health"
+        response = requests.get(test_url, timeout=10)
+        
+        if response.status_code == 200:
+            return {
+                "status": "healthy",
+                "oci_url": OCI_UPLOAD_API_URL,
+                "message": "OCI service is reachable"
+            }
+        else:
+            return {
+                "status": "unhealthy", 
+                "oci_url": OCI_UPLOAD_API_URL,
+                "message": f"OCI service returned status {response.status_code}"
+            }
+    except Exception as e:
+        return {
+            "status": "error",
+            "oci_url": OCI_UPLOAD_API_URL,
+            "message": f"Cannot connect to OCI service: {str(e)}"
+        }
+
 # API endpoints with lazy loading
 @app.post("/api/tts")
 async def generate_tts(request: TTSRequest):
@@ -466,13 +563,14 @@ async def generate_tts(request: TTSRequest):
             print(f"❌ OCI upload failed: {error}")
             # Still return the local file path if upload fails
             return {
-                "status": "partial_success",
-                "message": f"TTS generated but upload failed: {error}",
+                "status": "success_local",
+                "message": f"TTS generated locally (upload failed: {error})",
                 "local_file": output_path,
                 "filename": filename,
                 "file_size": file_size,
                 "voice_style": request.voice_style,
-                "model_used": current_model
+                "model_used": current_model,
+                "oci_upload_error": error
             }
         
         print(f"✅ Upload successful: {filename}")
@@ -540,19 +638,16 @@ async def batch_generate_tts(request: BatchTTSRequest):
             print(f"   Processing text {i+1}/{len(request.texts)}")
             
             # Generate sequential filename
-            filename = f"voiceover_{i+1:02d}.wav"
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"voiceover_{timestamp}_{i+1:03d}.wav"
             output_path = f"/tmp/output/{filename}"
             
-            # Ensure output directory exists
-            os.makedirs(os.path.dirname(output_path), exist_ok=True)
-            
-            # Clean the text for each item
+            # Clean text
             cleaned_text = clean_text(text)
-            print(f"📝 Batch text {i+1}: '{text}' -> '{cleaned_text}'")
             
-            # Generate TTS based on model capabilities - WITH ERROR HANDLING
+            # Generate TTS
             try:
-                # Get the speaker for VITS models
+                # Get speaker for VITS models
                 speaker = None
                 if "vctk/vits" in current_model:
                     speaker_map = {
@@ -570,173 +665,97 @@ async def batch_generate_tts(request: BatchTTSRequest):
                         speaker=speaker
                     )
                 else:
-                    tts.tts_to_file(
-                        text=cleaned_text,
-                        file_path=output_path
-                    )
-            except Exception as tts_error:
-                print(f"❌ TTS generation failed for text {i+1}: {tts_error}")
-                # Try alternative approach
-                try:
-                    print("🔄 Trying alternative TTS generation method...")
-                    if speaker:
-                        audio = tts.tts(
-                            text=cleaned_text,
-                            speaker=speaker
-                        )
-                    else:
-                        audio = tts.tts(text=cleaned_text)
+                    tts.tts_to_file(text=cleaned_text, file_path=output_path)
+                
+                # Verify file was created
+                if not os.path.exists(output_path):
+                    raise Exception(f"Failed to create output file: {output_path}")
+                
+                file_size = os.path.getsize(output_path)
+                
+                # Upload to OCI
+                upload_result, error = upload_to_oci_with_retry(
+                    output_path, filename, request.project_id, "voiceover"
+                )
+                
+                if error:
+                    results.append({
+                        "status": "success_local",
+                        "filename": filename,
+                        "local_file": output_path,
+                        "file_size": file_size,
+                        "upload_error": error,
+                        "text_index": i
+                    })
+                else:
+                    # Clean up local file on successful upload
+                    try:
+                        os.remove(output_path)
+                    except:
+                        pass
                     
-                    # Save manually
-                    if not save_wav(audio, output_path):
-                        raise Exception("Failed to save audio file")
-                        
-                except Exception as alt_error:
-                    print(f"❌ Alternative method also failed: {alt_error}")
                     results.append({
-                        "text_index": i,
-                        "status": "error",
-                        "message": f"TTS generation failed: {str(alt_error)}",
-                        "filename": filename
+                        "status": "success",
+                        "filename": filename,
+                        "oci_path": upload_result.get("path", f"{request.project_id}/voiceover/{filename}"),
+                        "file_size": file_size,
+                        "text_index": i
                     })
-                    continue
-            
-            # Verify the file was created
-            if not os.path.exists(output_path):
+                    
+            except Exception as e:
                 results.append({
-                    "text_index": i,
                     "status": "error",
-                    "message": f"TTS failed to create output file: {output_path}",
-                    "filename": filename
-                })
-                continue
-            
-            file_size = os.path.getsize(output_path)
-            print(f"✅ TTS generated: {output_path} ({file_size} bytes)")
-            
-            # Upload to OCI
-            upload_result, error = upload_to_oci_with_retry(
-                output_path, filename, request.project_id, "voiceover"
-            )
-            
-            if error:
-                print(f"❌ OCI upload failed for {filename}: {error}")
-                results.append({
-                    "text_index": i,
-                    "status": "partial_success",
-                    "message": f"TTS generated but upload failed: {error}",
-                    "local_file": output_path,
-                    "filename": filename,
-                    "file_size": file_size
-                })
-            else:
-                print(f"✅ Upload successful: {filename}")
-                results.append({
-                    "text_index": i,
-                    "status": "success",
-                    "message": "TTS generated and uploaded successfully",
                     "filename": filename,
-                    "oci_path": upload_result.get("path", f"{request.project_id}/voiceover/{filename}"),
-                    "file_size": file_size
+                    "error": str(e),
+                    "text_index": i
                 })
-                
-                # Clean up local file
-                try:
-                    os.remove(output_path)
-                    print(f"🧹 Cleaned up local file: {output_path}")
-                except Exception as cleanup_error:
-                    print(f"⚠️ Could not clean up file: {cleanup_error}")
+        
+        # Count successes and errors
+        success_count = len([r for r in results if r["status"] in ["success", "success_local"]])
+        error_count = len([r for r in results if r["status"] == "error"])
         
         return {
             "status": "completed",
-            "project_id": request.project_id,
+            "message": f"Processed {len(request.texts)} texts: {success_count} successful, {error_count} errors",
             "results": results,
-            "model_used": current_model,
-            "voice_style": request.voice_style,
-            "voice_cloning": supports_voice_cloning() and request.voice_name != "default"
-        }
-        
-    except Exception as e:
-        print(f"❌ Batch TTS generation error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Batch TTS generation failed: {str(e)}")
-
-@app.post("/api/upload-voice")
-async def upload_voice_sample(
-    project_id: str = Form(...),
-    voice_name: str = Form(...),
-    file: UploadFile = File(...)
-):
-    """Upload a voice sample for cloning"""
-    try:
-        print(f"📥 Voice upload request: {voice_name} for project {project_id}")
-        
-        # Check if voice cloning is supported
-        if not supports_voice_cloning():
-            raise HTTPException(
-                status_code=400, 
-                detail="Voice cloning is not supported with the current model. Please use the XTTS model for voice cloning."
-            )
-        
-        # Validate file type
-        if not file.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
-            raise HTTPException(status_code=400, detail="Only audio files are allowed")
-        
-        # Save voice sample
-        voice_path = f"/tmp/voices/{voice_name}.wav"
-        with open(voice_path, "wb") as f:
-            content = await file.read()
-            f.write(content)
-        
-        print(f"✅ Voice sample saved: {voice_path}")
-        
-        return {
-            "status": "success",
-            "message": "Voice sample uploaded successfully",
-            "voice_name": voice_name,
-            "local_path": voice_path
+            "summary": {
+                "total": len(request.texts),
+                "successful": success_count,
+                "errors": error_count
+            }
         }
         
     except Exception as e:
-        print(f"❌ Voice upload error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Voice upload failed: {str(e)}")
+        print(f"❌ Batch TTS error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/api/clone-voice")
-async def api_clone_voice(
+async def clone_voice_endpoint(
     project_id: str = Form(...),
     voice_name: str = Form(...),
     description: str = Form(""),
     files: List[UploadFile] = File(...)
 ):
-    """API endpoint to clone a voice from multiple samples"""
+    """Clone a voice from uploaded audio samples"""
     try:
-        print(f"📥 Voice cloning request: {voice_name} for project {project_id}")
-        
-        # Check if voice cloning is supported
-        if not supports_voice_cloning():
-            raise HTTPException(
-                status_code=400, 
-                detail="Voice cloning is not supported with the current model. Please use the XTTS model for voice cloning."
-            )
+        if not files:
+            raise HTTPException(status_code=400, detail="No audio files provided")
         
         # Save uploaded files temporarily
         temp_files = []
-        for i, file in enumerate(files):
-            # Validate file type
-            if not file.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
-                raise HTTPException(status_code=400, detail="Only audio files are allowed")
+        for file in files:
+            if not file.filename.lower().endswith(('.wav', '.mp3', '.flac')):
+                raise HTTPException(status_code=400, detail="Only WAV, MP3, and FLAC files are supported")
             
-            # Save temporary file
             temp_path = f"/tmp/{uuid.uuid4()}_{file.filename}"
             with open(temp_path, "wb") as f:
-                content = await file.read()
-                f.write(content)
+                shutil.copyfileobj(file.file, f)
             temp_files.append(temp_path)
-            print(f"   Saved sample {i+1}: {temp_path}")
         
         # Clone voice
         success, message = clone_voice(voice_name, temp_files, description)
         
-        # Clean up temporary files
+        # Clean up temp files
         for temp_file in temp_files:
             try:
                 os.remove(temp_file)
@@ -747,235 +766,77 @@ async def api_clone_voice(
             return {
                 "status": "success",
                 "message": message,
-                "voice_name": voice_name
+                "voice_name": voice_name,
+                "samples_used": len(temp_files)
             }
         else:
             raise HTTPException(status_code=500, detail=message)
             
+    except HTTPException:
+        raise
     except Exception as e:
         print(f"❌ Voice cloning error: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Voice cloning failed: {str(e)}")
 
 @app.get("/api/voices")
 async def list_voices():
-    """List available voices"""
+    """List all available cloned voices"""
     try:
         voices_dir = Path("/tmp/voices")
-        voices = []
+        if not voices_dir.exists():
+            return {"voices": []}
         
-        for item in voices_dir.iterdir():
-            if item.is_dir():
-                # Count samples in voice directory
-                samples = list(item.glob("sample_*.wav"))
+        voices = []
+        for voice_dir in voices_dir.iterdir():
+            if voice_dir.is_dir():
+                samples = list(voice_dir.glob("sample_*.wav"))
                 voices.append({
-                    "name": item.name,
+                    "name": voice_dir.name,
                     "samples_count": len(samples),
-                    "created_at": datetime.fromtimestamp(item.stat().st_ctime).isoformat()
-                })
-            elif item.is_file() and item.suffix == ".wav":
-                # Single voice file (not cloned)
-                voices.append({
-                    "name": item.stem,
-                    "samples_count": 1,
-                    "created_at": datetime.fromtimestamp(item.stat().st_ctime).isoformat()
+                    "created_at": datetime.fromtimestamp(voice_dir.stat().st_mtime).isoformat()
                 })
         
-        return {
-            "status": "success",
-            "voices": voices,
-            "voice_cloning_supported": supports_voice_cloning()
-        }
-        
+        return {"voices": voices}
     except Exception as e:
-        print(f"❌ List voices error: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to list voices: {str(e)}")
 
-@app.get("/api/health")
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "tts_loaded": model_loaded,
-        "model": current_model,
-        "voice_style": current_voice_style,
-        "voice_cloning_supported": voice_cloning_supported,
-        "device": DEVICE,
-        "load_attempts": model_load_attempts,
-        "timestamp": datetime.now().isoformat()
-    }
-
-@app.post("/api/reload-model")
-async def reload_model():
-    """Force reload the TTS model"""
-    global tts, model_loaded, current_model, voice_cloning_supported
-    
-    # Clear current model
-    tts = None
-    model_loaded = False
-    current_model = ""
-    voice_cloning_supported = False
-    
-    # Try to reload
-    success = load_tts_model(current_voice_style)
-    
-    return {
-        "status": "success" if success else "error",
-        "message": "Model reloaded successfully" if success else "Failed to reload model",
-        "model_loaded": model_loaded,
-        "model": current_model,
-        "voice_style": current_voice_style
-    }
-
 @app.post("/api/change-voice")
-async def change_voice(request: ChangeVoiceRequest):
-    """Change the TTS voice style"""
-    global tts, model_loaded, current_model, current_voice_style
-    
+async def change_voice_style(request: ChangeVoiceRequest):
+    """Change the voice style (reloads model)"""
     try:
-        voice_options = {
-            "male_deep": "Deep male voice (VITS p225)",
-            "male_medium": "Medium male voice (VITS p226)", 
-            "female_1": "Female voice 1 (VITS p227)",
-            "female_2": "Female voice 2 (VITS p228)",
-            "default_female": "Default female voice (Tacotron2)",
-            "clear_male": "Clear male voice (Tacotron2)"
-        }
-        
-        if request.voice_style not in voice_options:
-            return {
-                "status": "error",
-                "message": f"Invalid voice style. Available: {list(voice_options.keys())}",
-                "available_voices": voice_options
-            }
+        global model_loaded
         
-        print(f"🔄 Changing voice to: {request.voice_style} - {voice_options[request.voice_style]}")
+        print(f"🔄 Changing voice style to: {request.voice_style}")
         
-        # Clear current model
-        tts = None
+        # Reset model loaded flag to force reload
         model_loaded = False
         
-        # Load new model with selected voice
-        success = load_tts_model(request.voice_style)
-        
-        if success:
+        if load_tts_model(request.voice_style):
             return {
                 "status": "success",
-                "message": f"Voice changed to {voice_options[request.voice_style]}",
-                "voice_style": request.voice_style,
-                "description": voice_options[request.voice_style]
+                "message": f"Voice style changed to {request.voice_style}",
+                "current_voice_style": current_voice_style,
+                "current_model": current_model
             }
         else:
-            return {
-                "status": "error",
-                "message": "Failed to change voice"
-            }
+            raise HTTPException(status_code=500, detail="Failed to load new voice style")
             
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Voice change failed: {str(e)}")
-
-@app.get("/api/available-voices")
-async def get_available_voices():
-    """Get list of available voice options"""
-    voice_options = {
-        "male_deep": "Deep male voice (VITS p225)",
-        "male_medium": "Medium male voice (VITS p226)",
-        "female_1": "Female voice 1 (VITS p227)", 
-        "female_2": "Female voice 2 (VITS p228)",
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/voice-styles")
+async def get_voice_styles():
+    """Get available voice styles"""
+    styles = {
+        "male_deep": "Deep male voice (VITS)",
+        "male_medium": "Medium male voice (VITS)",
+        "female_1": "Female voice 1 (VITS)",
+        "female_2": "Female voice 2 (VITS)",
         "default_female": "Default female voice (Tacotron2)",
         "clear_male": "Clear male voice (Tacotron2)"
     }
-    
-    return {
-        "status": "success",
-        "available_voices": voice_options,
-        "current_voice": current_voice_style,
-        "current_model": current_model
-    }
-
-@app.get("/api/download/{filename}")
-async def download_file(filename: str):
-    """Download generated audio file directly"""
-    try:
-        file_path = f"/tmp/output/{filename}"
-        
-        # Security check - only allow .wav files from output directory
-        if not filename.endswith('.wav') or '..' in filename or '/' in filename:
-            raise HTTPException(status_code=400, detail="Invalid filename")
-        
-        if not os.path.exists(file_path):
-            raise HTTPException(status_code=404, detail="File not found")
-        
-        # Get file info
-        file_size = os.path.getsize(file_path)
-        print(f"📥 Serving download: {filename} ({file_size} bytes)")
-        
-        # Return the audio file
-        from fastapi.responses import FileResponse
-        return FileResponse(
-            path=file_path,
-            media_type='audio/wav',
-            filename=filename
-        )
-        
-    except Exception as e:
-        print(f"❌ Download failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Download failed: {str(e)}")
-
-@app.get("/api/files")
-async def list_files():
-    """List all generated audio files"""
-    try:
-        files_dir = Path("/tmp/output")
-        files = []
-        
-        for file_path in files_dir.glob("*.wav"):
-            files.append({
-                "name": file_path.name,
-                "size": file_path.stat().st_size,
-                "created": datetime.fromtimestamp(file_path.stat().st_ctime).isoformat()
-            })
-        
-        # Sort by creation time, newest first
-        files.sort(key=lambda x: x["created"], reverse=True)
-        
-        return {
-            "status": "success", 
-            "files": files,
-            "count": len(files)
-        }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to list files: {str(e)}")
-
-@app.get("/")
-async def root():
-    """Root endpoint with API information"""
-    return {
-        "message": "TTS API with Coqui TTS and Voice Cloning",
-        "endpoints": {
-            "POST /api/tts": "Generate TTS for a single text",
-            "POST /api/batch-tts": "Generate TTS for multiple texts",
-            "POST /api/upload-voice": "Upload a voice sample for cloning",
-            "POST /api/clone-voice": "Clone a voice from multiple samples",
-            "GET /api/voices": "List available voices",
-            "GET /api/health": "Health check",
-            "POST /api/reload-model": "Reload TTS model",
-            "POST /api/change-voice": "Change voice style",
-            "GET /api/available-voices": "Get available voice options",
-            "GET /api/download/{filename}": "Download generated audio",
-            "GET /api/files": "List generated files"
-        },
-        "model_loaded": model_loaded,
-        "model_name": current_model if model_loaded else "None",
-        "current_voice_style": current_voice_style,
-        "voice_cloning_supported": supports_voice_cloning()
-    }
+    return {"voice_styles": styles}
 
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting TTS API with Coqui TTS and Voice Cloning...")
-    print("📊 API endpoints available at: http://localhost:7860/")
-    print("💡 Model will be loaded on first request to save memory")
-    print("🎙️ Voice selection feature enabled")
-    print("🔄 Use /api/reload-model to force reload if needed")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8000)