Update app.py

app.py

@@ -1,4 +1,3 @@
-#import streamlit as st
 import ffmpeg
 import os
 import time
@@ -17,28 +16,27 @@ import asyncio
 from threading import Thread
 import nest_asyncio
 
-# برای اجرای همزمان FastAPI و Streamlit
+# Apply nest_asyncio for concurrent execution
 nest_asyncio.apply()
 
 app = FastAPI(title="Video Conversion API")
 
-# Add CORS middleware to handle cross-origin requests
+# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with specific domains
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
 # Supported formats
-supported_formats = [data.upper() for data in (sorted(['3GP', 'ASF', 'AVI', 'DIVX', 'FLV', 'M2TS', 'M4V', 'MKV', 'MOV', 'MP4', 'MPEG', 'MPG', 'MTS', 'TS', 'VOB', 'WEBM', 'WMV', 'XVID'])) if data not in ['3GP', 'DIVX', 'XVID']]
-audio_formats = [data.upper() for data in (sorted(['MP3', 'WAV', 'AAC', 'FLAC', 'OGG', 'M4A', 'ALAC', 'WMA', 'AIFF', 'OPUS', 'APE', 'CAF', 'PCM', 'DTS', 'TTA', 'AMR', 'MID', 'SPX', 'WV', 'RA', 'TAK'])) if data not in ['ALC', 'AMR', 'APE', 'DTS', 'MID', 'PCM', 'RA', 'TAK']]
+supported_formats = ['ASF', 'AVI', 'FLV', 'M2TS', 'M4V', 'MKV', 'MOV', 'MP4', 'MPEG', 'MPG', 'MTS', 'TS', 'VOB', 'WEBM', 'WMV']
+audio_formats = ['AAC', 'AIFF', 'ALAC', 'CAF', 'FLAC', 'M4A', 'MP3', 'OGG', 'OPUS', 'SPX', 'TTA', 'WAV', 'WMA', 'WV']
 gif_formats = ['GIF']
-image_formats = [data.upper() for data in sorted(Image.SAVE.keys() or ['BLP', 'BMP', 'BUFR', 'DDS', 'DIB', 'EPS', 'GIF', 'GRIB', 'HDF5', 'ICNS', 'ICO', 'IM',
-                                              'JPEG', 'JPEG2000', 'MPO', 'MSP', 'PALM', 'PCX', 'PDF', 'PNG', 'PPM', 'SGI', 'SPIDER', 
-                                              'TGA', 'TIFF', 'WEBP', 'WMX', 'XBM'])]
+image_formats = ['BMP', 'DIB', 'EPS', 'GIF', 'ICNS', 'ICO', 'IM', 'JPEG', 'JPEG2000', 'MPO', 'MSP', 'PALM', 'PCX', 'PDF', 'PNG', 'PPM', 'SGI', 'SPIDER', 'TGA', 'TIFF', 'WEBP', 'WMX', 'XBM']
 
+# Create cache directory
 CACHE_DIR = tempfile.mkdtemp()
 
 # Audio codec mapping
@@ -79,9 +77,19 @@ VIDEO_CODECS = {
 
 def delete_temp_dir(directory, delay=900):
     """Delete temporary directory after delay"""
-    timer = threading.Timer(delay, shutil.rmtree, [directory])
+    def cleanup():
+        try:
+            if os.path.exists(directory):
+                shutil.rmtree(directory)
+                print(f"Cleaned up temporary directory: {directory}")
+        except Exception as e:
+            print(f"Error cleaning up directory {directory}: {e}")
+    
+    timer = threading.Timer(delay, cleanup)
+    timer.daemon = True
     timer.start()
 
+# Schedule cleanup
 delete_temp_dir(CACHE_DIR, delay=900)
 
 def sanitize_filename(filename):
@@ -239,7 +247,8 @@ def convert_video(video_path, target_format, conversion_type, time_in_seconds=No
                             img.save(output_file, format=target_format.upper())
                 
                 # Remove temporary PNG file
-                os.remove(temp_png_file)
+                if os.path.exists(temp_png_file):
+                    os.remove(temp_png_file)
                 return output_file
                 
             except Exception as pil_error:
@@ -382,152 +391,35 @@ async def stcore_host_config():
         }
     }
 
-@app.get("/health/_stcore/health")
-async def health_stcore_health():
-    return {"status": "healthy"}
-
-@app.get("/health/_stcore/host-config")
-async def health_stcore_host_config():
-    return {
-        "version": "1.0",
-        "config": {
-            "enableCors": False,
-            "enableXsrfProtection": False
-        }
-    }
-
-@app.get("/convert/_stcore/health")
-async def convert_stcore_health():
-    return {"status": "healthy"}
-
-@app.get("/convert/_stcore/host-config")
-async def convert_stcore_host_config():
-    return {
-        "version": "1.0",
-        "config": {
-            "enableCors": False,
-            "enableXsrfProtection": False
-        }
-    }
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "message": "Video Conversion API is running"}
 
 @app.get("/")
 async def root():
-    return {"message": "Video Conversion API is running", "docs": "/docs"}
-
-# # Streamlit UI
-# def streamlit_app():
-#     st.set_page_config(layout="wide", page_title="Video Conversion Tool")
-
-#     st.title("🎬 Video Conversion Tool")
-#     st.write("Convert videos to audio, GIFs, images, or other formats with optimized codecs for best quality.")
-
-#     # Create two columns
-#     col1, col2 = st.columns([1, 1])
-
-#     with col1:
-#         video_file = st.file_uploader("Upload a Video", type=[ext.lower() for ext in supported_formats])
-#         if video_file:
-#             st.video(video_file)
-
-#     with col2:
-#         if video_file:
-#             # Save uploaded video to cache
-#             temp_video_path = os.path.join(CACHE_DIR, video_file.name)
-#             with open(temp_video_path, "wb") as f:
-#                 f.write(video_file.getbuffer())
-
-#             # Get video duration
-#             video_duration = get_video_duration(temp_video_path)
-
-#             # Select conversion type
-#             conversion_type = st.selectbox(
-#                 "Select Conversion Type", 
-#                 ['Video to Video', 'Video to Audio', 'Video to GIF', 'Video to Image']
-#             )
-
-#             # Update format choices
-#             def update_format_choices(conversion_type):
-#                 if conversion_type == 'Video to Video':
-#                     return supported_formats
-#                 elif conversion_type == 'Video to Audio':
-#                     return audio_formats
-#                 elif conversion_type == 'Video to GIF':
-#                     return gif_formats
-#                 elif conversion_type == 'Video to Image':
-#                     return image_formats
-#                 return []
-
-#             target_format_choices = update_format_choices(conversion_type)
-#             target_format = st.selectbox("Select Target Format", target_format_choices)
-
-#             # Show codec info for supported formats
-#             if conversion_type == 'Video to Audio' and target_format.upper() in AUDIO_CODECS:
-#                 codec_info = AUDIO_CODECS[target_format.upper()]
-#                 st.info(f"🎵 Audio Codec: {codec_info.get('acodec', 'default')}")
-#             elif conversion_type == 'Video to Video' and target_format.upper() in VIDEO_CODECS:
-#                 codec_info = VIDEO_CODECS[target_format.upper()]
-#                 st.info(f"🎬 Video Codec: {codec_info.get('vcodec', 'default')} | Audio Codec: {codec_info.get('acodec', 'default')}")
-
-#             if conversion_type == 'Video to Image':
-#                 time_in_seconds = st.slider(
-#                     "Time (in seconds) for image extraction",
-#                     0, int(video_duration), 0, 1
-#                 )
-#             else:
-#                 time_in_seconds = None
-
-#             if st.button("🚀 Convert", type="primary"):
-#                 with st.spinner("Converting with optimized codecs..."):
-#                     try:
-#                         output_file = convert_video(temp_video_path, target_format, conversion_type, time_in_seconds)
-                        
-#                         st.success("✅ Conversion Successful!")
-                        
-#                         # Show file size
-#                         file_size = os.path.getsize(output_file) / (1024 * 1024)  # MB
-#                         st.info(f"📁 File size: {file_size:.2f} MB")
-                        
-#                         with open(output_file, "rb") as f:
-#                             st.download_button(
-#                                 "⬇️ Download Converted File",
-#                                 f,
-#                                 file_name=os.path.basename(output_file),
-#                                 type="primary"
-#                             )
-#                     except Exception as e:
-#                         st.error(f"❌ Error: {str(e)}")
-
-    # API Info & Supported Codecs
-    st.sidebar.header("🔧 API Information")
-    st.sidebar.info("""
-    **API Endpoints:**
-    - `POST /api/convert` - Convert video files
-    - `GET /api/formats` - Get supported formats
-    
-    **WordPress Integration:**
-    Configure the Hugging Face Space URL in WordPress settings.
+    return {"message": "Video Conversion API is running", "docs": "/docs", "status": "healthy"}
+
+# Main function to run the app
+def main():
+    print("Starting Video Conversion API...")
+    print(f"Cache directory: {CACHE_DIR}")
+    print(f"Supported video formats: {supported_formats}")
+    print(f"Supported audio formats: {audio_formats}")
     
-    **Test API:**
-    Visit `/docs` for interactive API documentation.
-    """)
+    # Get port from environment variable (Hugging Face Spaces uses specific port)
+    port = int(os.environ.get("PORT", 7860))
+    host = "0.0.0.0"
     
-    # Show supported codecs
-    with st.sidebar.expander("🎵 Supported Audio Codecs"):
-        for format_name, codec_info in AUDIO_CODECS.items():
-            st.write(f"**{format_name}:** {codec_info.get('acodec', 'default')}")
+    print(f"Starting server on {host}:{port}")
     
-    with st.sidebar.expander("🎬 Supported Video Codecs"):
-        for format_name, codec_info in VIDEO_CODECS.items():
-            st.write(f"**{format_name}:** {codec_info.get('vcodec', 'default')}")
+    # Configure uvicorn with proper settings for Hugging Face Spaces
+    uvicorn.run(
+        app, 
+        host=host, 
+        port=port,
+        log_level="info",
+        access_log=True
+    )
 
-def run_fastapi():
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-
-# Run both applications
 if __name__ == "__main__":
-    # Run FastAPI in background
-    fastapi_thread = Thread(target=run_fastapi, daemon=True)
-    fastapi_thread.start()
-    
-    # # Run Streamlit
-    # streamlit_app()
+    main()