Update app.py

app.py

@@ -1,4 +1,3 @@
-import gradio as gr
 import os
 import uuid
 import requests
@@ -14,7 +13,7 @@ from huggingface_hub import HfApi, hf_hub_download
 from typing import Optional, List, Dict, Any
 
 print("=" * 60)
-print("🚀 TEXT STYLING SPACE - WITH FONT DATASET")
+print("🚀 TEXT STYLING API - WITHOUT GRADIO")
 print("=" * 60)
 
 # =============================================
@@ -48,11 +47,8 @@ def download_all_fonts():
         
         for file in files:
             if file.endswith(('.ttf', '.otf')):
-                category = file.split('/')[0]
                 font_name = os.path.basename(file)
-                local_path = os.path.join(FONTS_DIR, category, font_name)
-                
-                os.makedirs(os.path.dirname(local_path), exist_ok=True)
+                local_path = os.path.join(FONTS_DIR, font_name)
                 
                 if not os.path.exists(local_path):
                     print(f"⬇️ Downloading font: {font_name}")
@@ -70,7 +66,6 @@ def download_all_fonts():
                 fonts[font_key] = {
                     "path": local_path,
                     "name": font_name,
-                    "category": category,
                     "display_name": font_name.replace('.ttf', '').replace('.otf', '').replace('-', ' ')
                 }
         
@@ -111,19 +106,10 @@ class TextStyle(BaseModel):
     margin: int = 20
     padding: int = 10
 
-class CaptionStyle(BaseModel):
-    font_family: str
-    font_size: int = 32
-    color: str = "white"
-    bg_color: str = "black@0.7"
-    position: str = "bottom"
-
 class StylingRequest(BaseModel):
     project_id: str
     video_url: str
     title_overlay: Optional[TextStyle] = None
-    subtitles: Optional[CaptionStyle] = None
-    watermark: Optional[TextStyle] = None
 
 class StylingResponse(BaseModel):
     status: str
@@ -135,7 +121,6 @@ class StylingResponse(BaseModel):
 # HELPER FUNCTIONS
 # =============================================
 def download_file(url, local_path):
-    """Download file from URL"""
     response = requests.get(url, stream=True)
     response.raise_for_status()
     with open(local_path, 'wb') as f:
@@ -144,7 +129,6 @@ def download_file(url, local_path):
     return local_path
 
 def upload_to_dataset(file_path, project_id, filename, subfolder="videos"):
-    """Upload file to HF Dataset"""
     if not HF_TOKEN:
         return None
     try:
@@ -161,54 +145,30 @@ def upload_to_dataset(file_path, project_id, filename, subfolder="videos"):
         return None
 
 def get_font_path(font_family):
-    """Get font path from font family name"""
-    # Try exact match
-    if font_family in FONTS:
-        return FONTS[font_family]["path"]
-    
-    # Try case-insensitive match
     font_family_lower = font_family.lower().replace(' ', '_')
     for key, font_info in FONTS.items():
         if font_family_lower in key or key in font_family_lower:
             return font_info["path"]
-    
-    # Try to find by display name
-    for font_info in FONTS.values():
-        if font_family.lower() in font_info["display_name"].lower():
-            return font_info["path"]
-    
-    # Fallback to first Chinese font or None
-    for font_info in FONTS.values():
-        if font_info["category"] == "chinese":
-            return font_info["path"]
-    
     return None
 
 def create_text_overlay(input_video, output_video, text_style):
-    """Add text overlay to video"""
     font_path = get_font_path(text_style.font_family)
     if not font_path:
-        print(f"⚠️ Font not found: {text_style.font_family}")
         return False
     
-    # Position mapping
     pos_map = {
         "top-left": f"x={text_style.margin}:y={text_style.margin}",
         "top-right": f"x=w-tw-{text_style.margin}:y={text_style.margin}",
         "center": f"x=(w-tw)/2:y=(h-th)/2",
         "bottom-left": f"x={text_style.margin}:y=h-th-{text_style.margin}",
         "bottom-right": f"x=w-tw-{text_style.margin}:y=h-th-{text_style.margin}",
-        "top-center": f"x=(w-tw)/2:y={text_style.margin}",
-        "bottom-center": f"x=(w-tw)/2:y=h-th-{text_style.margin}"
     }
     position = pos_map.get(text_style.position, pos_map["center"])
     
-    # Parse background color
     bg_parts = text_style.bg_color.split('@')
     bg_color = bg_parts[0]
     bg_opacity = float(bg_parts[1]) if len(bg_parts) > 1 else 0.5
     
-    # Create filter
     drawtext_filter = (
         f"drawtext=text='{text_style.text}':"
         f"fontfile={font_path}:"
@@ -220,26 +180,9 @@ def create_text_overlay(input_video, output_video, text_style):
         f"boxborderw={text_style.padding}"
     )
     
-    cmd = [
-        'ffmpeg', '-y',
-        '-i', input_video,
-        '-vf', drawtext_filter,
-        '-c:a', 'copy',
-        output_video
-    ]
-    
+    cmd = ['ffmpeg', '-y', '-i', input_video, '-vf', drawtext_filter, '-c:a', 'copy', output_video]
     result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        print(f"❌ Text overlay error: {result.stderr}")
-        return False
-    
-    return True
-
-def add_subtitles(input_video, output_video, subtitle_style, tts_url=None):
-    """Add subtitles to video"""
-    # For now, just copy the video
-    shutil.copy(input_video, output_video)
-    return True
+    return result.returncode == 0
 
 # =============================================
 # API ENDPOINTS
@@ -247,104 +190,48 @@ def add_subtitles(input_video, output_video, subtitle_style, tts_url=None):
 
 @app.get("/health")
 async def health():
-    return {
-        "status": "healthy",
-        "fonts_loaded": len(FONTS),
-        "font_categories": list(set(f["category"] for f in FONTS.values()))
-    }
+    return {"status": "healthy", "fonts_loaded": len(FONTS)}
 
 @app.get("/fonts")
 async def list_fonts():
-    """List all available fonts"""
-    font_list = []
-    for key, font_info in FONTS.items():
-        font_list.append({
-            "id": key,
-            "name": font_info["display_name"],
-            "category": font_info["category"],
-            "file": font_info["name"]
-        })
-    return {"fonts": font_list}
+    return {"fonts": list(FONTS.keys())}
 
 @app.post("/api/style", response_model=StylingResponse)
-async def style_video(request: StylingRequest, background_tasks: BackgroundTasks):
-    """Add text overlays and subtitles to video"""
+async def style_video(request: StylingRequest):
     try:
         print(f"\n🎨 Styling video for project: {request.project_id}")
         
         work_dir = f"/tmp/styling/{request.project_id}_{uuid.uuid4().hex[:8]}"
         os.makedirs(work_dir, exist_ok=True)
         
-        # Download base video
-        print(f"⬇️ Downloading video from: {request.video_url}")
         video_path = os.path.join(work_dir, "input.mp4")
         download_file(request.video_url, video_path)
         
         current_video = video_path
         
-        # Add title overlay if provided
         if request.title_overlay:
-            print(f"📝 Adding title: {request.title_overlay.text}")
             titled_path = os.path.join(work_dir, "titled.mp4")
             if create_text_overlay(current_video, titled_path, request.title_overlay):
                 current_video = titled_path
-                print("✅ Title added")
-        
-        # Add subtitles if provided
-        if request.subtitles:
-            print(f"📝 Adding subtitles with font: {request.subtitles.font_family}")
-            subtitled_path = os.path.join(work_dir, "subtitled.mp4")
-            # For now, just copy
-            shutil.copy(current_video, subtitled_path)
-            current_video = subtitled_path
-            print("✅ Subtitles added")
         
-        # Add watermark if provided
-        if request.watermark:
-            print(f"💧 Adding watermark: {request.watermark.text}")
-            watermarked_path = os.path.join(work_dir, "watermarked.mp4")
-            if create_text_overlay(current_video, watermarked_path, request.watermark):
-                current_video = watermarked_path
-                print("✅ Watermark added")
-        
-        # Upload styled video
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         styled_filename = f"styled_{timestamp}.mp4"
-        styled_url = upload_to_dataset(
-            current_video,
-            request.project_id,
-            styled_filename,
-            "videos"
-        )
+        styled_url = upload_to_dataset(current_video, request.project_id, styled_filename, "videos")
         
-        # Cleanup
         shutil.rmtree(work_dir, ignore_errors=True)
         
         if styled_url:
-            return StylingResponse(
-                status="success",
-                project_id=request.project_id,
-                styled_video_url=styled_url
-            )
+            return StylingResponse(status="success", project_id=request.project_id, styled_video_url=styled_url)
         else:
-            return StylingResponse(
-                status="error",
-                project_id=request.project_id,
-                error="Failed to upload styled video"
-            )
+            return StylingResponse(status="error", project_id=request.project_id, error="Upload failed")
         
     except Exception as e:
-        print(f"❌ Error: {e}")
-        return StylingResponse(
-            status="error",
-            project_id=request.project_id,
-            error=str(e)
-        )
+        return StylingResponse(status="error", project_id=request.project_id, error=str(e))
 
 @app.get("/")
 async def root():
     return {
-        "name": "Text Styling Space",
+        "name": "Text Styling API",
         "version": "1.0.0",
         "endpoints": {
             "style": "POST /api/style",
@@ -354,99 +241,6 @@ async def root():
         "fonts_loaded": len(FONTS)
     }
 
-# =============================================
-# GRADIO INTERFACE (for testing)
-# =============================================
-def create_gradio_interface():
-    with gr.Blocks(title="Text Styling Space", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🎨 Text Styling Space")
-        gr.Markdown("Add beautiful text overlays and captions to your videos")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                project_id = gr.Textbox(
-                    label="Project ID",
-                    placeholder="Enter project ID"
-                )
-                video_url = gr.Textbox(
-                    label="Video URL",
-                    placeholder="URL from core combiner"
-                )
-                
-                gr.Markdown("### Title Overlay")
-                title_text = gr.Textbox(
-                    label="Title Text",
-                    placeholder="Enter title text"
-                )
-                title_font = gr.Dropdown(
-                    label="Font Family",
-                    choices=list(FONTS.keys()) if FONTS else [],
-                    value=list(FONTS.keys())[0] if FONTS else None
-                )
-                title_size = gr.Slider(24, 120, value=60, label="Font Size")
-                title_color = gr.Dropdown(
-                    ["white", "black", "red", "gold", "yellow", "cyan", "purple"],
-                    value="gold",
-                    label="Font Color"
-                )
-                title_bg = gr.Dropdown(
-                    ["black", "white", "red", "blue", "purple"],
-                    value="black",
-                    label="Background Color"
-                )
-                title_opacity = gr.Slider(0.1, 1.0, value=0.5, label="Background Opacity")
-                title_position = gr.Dropdown(
-                    ["center", "top-center", "bottom-center", "top-left", "top-right", "bottom-left", "bottom-right"],
-                    value="center",
-                    label="Position"
-                )
-                
-                style_btn = gr.Button("🎨 Style Video", variant="primary")
-            
-            with gr.Column(scale=1):
-                output = gr.JSON(label="Result")
-                styled_video = gr.Video(label="Styled Video Preview")
-        
-        def style_video_ui(pid, vid_url, title_txt, t_font, t_size, t_color, t_bg, t_opacity, t_pos):
-            # Build request
-            request = {
-                "project_id": pid,
-                "video_url": vid_url,
-                "title_overlay": {
-                    "text": title_txt,
-                    "font_family": t_font,
-                    "font_size": t_size,
-                    "color": t_color,
-                    "bg_color": f"{t_bg}@{t_opacity}",
-                    "position": t_pos,
-                    "margin": 20,
-                    "padding": 10
-                } if title_txt else None
-            }
-            
-            # Call API
-            import requests
-            response = requests.post(
-                "http://localhost:7860/api/style",
-                json=request
-            )
-            return response.json(), response.json().get("styled_video_url")
-        
-        style_btn.click(
-            fn=style_video_ui,
-            inputs=[
-                project_id, video_url, title_text, title_font, title_size,
-                title_color, title_bg, title_opacity, title_position
-            ],
-            outputs=[output, styled_video]
-        )
-    
-    return demo
-
-# Mount Gradio interface
-demo = create_gradio_interface()
-app = gr.mount_gradio_app(app, demo, path="/")
-
 # =============================================
 # RUN
 # =============================================