Create app.py

app.py

@@ -0,0 +1,767 @@
+import requests
+import re
+import json
+from datetime import datetime
+from PIL import Image
+import io
+import os
+from dotenv import load_dotenv
+import gradio as gr
+import base64
+from io import BytesIO
+
+# ========== LOAD ENVIRONMENT VARIABLES ==========
+def load_environment_variables():
+    try:
+        load_dotenv(dotenv_path='rank_cd.env')
+        return {
+            'url': os.getenv('WORDPRESS_URL', 'https://cdgarment.com'),
+            'username': os.getenv('WORDPRESS_USERNAME', ''),
+            'password': os.getenv('WORDPRESS_APP_PASSWORD', ''),
+            'status': os.getenv('DEFAULT_STATUS', 'draft')
+        }
+    except Exception as e:
+        print(f"Could not load rank_cd.env: {str(e)}")
+        return {
+            'url': 'https://cdgarment.com',
+            'username': '',
+            'password': '',
+            'status': 'draft'
+        }
+
+# ========== FUNCTIONS ==========
+def parse_gemini_content(content, post_status='draft'):
+    """Parse Gemini content for cdgarment.com with Rank Math"""
+    data = {
+        'seo_title': '',
+        'primary_keyword': '',
+        'meta_description': '',
+        'tags': [],
+        'article_title': '',
+        'content': '',
+        'url_slug': '',
+        'rank_math_meta': {}
+    }
+    
+    try:
+        # Extract SEO Title
+        seo_title_match = re.search(r'SEO Title:\s*(.+?)(?=\n)', content)
+        if seo_title_match:
+            data['seo_title'] = seo_title_match.group(1).strip()
+        
+        # Extract Primary Keyword
+        keyword_match = re.search(r'Primary Keyword:\s*(.+?)(?=\n)', content)
+        if keyword_match:
+            data['primary_keyword'] = keyword_match.group(1).strip()
+        
+        # Extract Meta Description
+        meta_match = re.search(r'Meta Description:\s*(.+?)(?=\n)', content)
+        if meta_match:
+            data['meta_description'] = meta_match.group(1).strip()
+        
+        # Extract Tags
+        tags_match = re.search(r'Tags:\s*(.+?)(?=\n\|📝)', content)
+        if tags_match:
+            tags_str = tags_match.group(1).strip()
+            data['tags'] = [tag.strip() for tag in re.split(r'[,;]', tags_str) if tag.strip()]
+        
+        # Extract Article Content
+        article_match = re.search(r'(?:📝\|▶\|●\|◆).*?(?:Article\|Content)[:\-]?\s*(.+)', content, re.DOTALL)
+        if article_match:
+            full_content = article_match.group(1).strip()
+            lines = full_content.split('\n')
+            if lines:
+                data['article_title'] = lines[0].strip()
+                data['content'] = '\n'.join(lines[1:])
+        
+        # Generate URL slug
+        if data['seo_title']:
+            slug = data['seo_title'].lower()
+            slug = re.sub(r'[^\w\s-]', '', slug)
+            slug = re.sub(r'[-\s]+', '-', slug)
+            data['url_slug'] = slug[:100]
+        
+        # Fallback title
+        if not data['seo_title'] and data['article_title']:
+            data['seo_title'] = data['article_title']
+        
+        # Prepare Rank Math meta fields (based on your screenshot)
+        data['rank_math_meta'] = {
+            'rank_math_title': data['seo_title'],
+            'rank_math_description': data['meta_description'],
+            'rank_math_robots': ['index'] if post_status == 'publish' else ['noindex'],
+            'rank_math_news_sitemap_robots': 'index',
+            'rank_math_facebook_title': data['seo_title'],
+            'rank_math_facebook_description': data['meta_description'],
+            'rank_math_twitter_title': data['seo_title'],
+            'rank_math_twitter_description': data['meta_description'],
+            'rank_math_canonical_url': '',
+        }
+        
+        # If we have primary keyword, add it (though not in your screenshot)
+        if data['primary_keyword']:
+            data['rank_math_meta']['rank_math_focus_keyword'] = data['primary_keyword']
+        
+        return data
+        
+    except Exception as e:
+        return {'error': f"Error parsing: {str(e)}"}
+
+def upload_image_to_wordpress(image_file, wp_config, filename_slug):
+    """Upload image to WordPress with auto-naming"""
+    try:
+        # Handle Gradio image input (can be PIL Image or path)
+        if hasattr(image_file, 'name'):  # It's a file object
+            file_extension = image_file.name.split('.')[-1].lower()
+            image_data = image_file.read()
+        elif isinstance(image_file, str):  # It's a file path
+            file_extension = image_file.split('.')[-1].lower()
+            with open(image_file, 'rb') as f:
+                image_data = f.read()
+        else:  # Assume it's already bytes
+            image_data = image_file
+        
+        # Generate filename from slug
+        filename = f"{filename_slug}.{file_extension}"
+        
+        # Prepare image data
+        files = {
+            'file': (filename, image_data, f'image/{file_extension}')
+        }
+        
+        auth = (wp_config['username'], wp_config['password'])
+        
+        # Upload to WordPress
+        response = requests.post(
+            f"{wp_config['url']}/wp-json/wp/v2/media",
+            auth=auth,
+            files=files
+        )
+        
+        if response.status_code == 201:
+            media_data = response.json()
+            
+            # Update alt text with SEO title
+            update_response = requests.post(
+                f"{wp_config['url']}/wp-json/wp/v2/media/{media_data['id']}",
+                auth=auth,
+                json={
+                    'alt_text': filename_slug.replace('-', ' ').title(),
+                    'caption': filename_slug.replace('-', ' ').title(),
+                    'description': f"Featured image for: {filename_slug.replace('-', ' ').title()}"
+                }
+            )
+            
+            return media_data['id']
+        else:
+            return None
+            
+    except Exception as e:
+        print(f"Error uploading image: {str(e)}")
+        return None
+
+def create_wordpress_post(parsed_data, wp_config, media_id=None, post_status='draft'):
+    """Create WordPress post with Rank Math meta"""
+    try:
+        # Base post data
+        post_data = {
+            'title': parsed_data['seo_title'],
+            'content': parsed_data['content'],
+            'slug': parsed_data['url_slug'],
+            'status': post_status,
+            'meta': parsed_data['rank_math_meta']
+        }
+        
+        # Add tags if available
+        if parsed_data['tags']:
+            post_data['tags'] = parsed_data['tags']
+        
+        # Add category (default to uncategorized)
+        post_data['categories'] = [1]
+        
+        # Add featured image
+        if media_id:
+            post_data['featured_media'] = media_id
+            
+            # Try to set social images
+            try:
+                # Get media URL
+                media_response = requests.get(
+                    f"{wp_config['url']}/wp-json/wp/v2/media/{media_id}",
+                    auth=(wp_config['username'], wp_config['password'])
+                )
+                if media_response.status_code == 200:
+                    media_url = media_response.json().get('source_url')
+                    post_data['meta']['rank_math_facebook_image'] = media_url
+                    post_data['meta']['rank_math_twitter_image'] = media_url
+            except:
+                pass
+        
+        # Send to WordPress
+        response = requests.post(
+            f"{wp_config['url']}/wp-json/wp/v2/posts",
+            auth=(wp_config['username'], wp_config['password']),
+            json=post_data,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 201:
+            # Update canonical URL with actual post URL
+            post_result = response.json()
+            update_data = {
+                'meta': {
+                    'rank_math_canonical_url': post_result['link']
+                }
+            }
+            
+            update_response = requests.post(
+                f"{wp_config['url']}/wp-json/wp/v2/posts/{post_result['id']}",
+                auth=(wp_config['username'], wp_config['password']),
+                json=update_data
+            )
+            
+            return post_result
+        else:
+            return None
+            
+    except Exception as e:
+        print(f"Error creating post: {str(e)}")
+        return None
+
+# ========== GRADIO UI FUNCTIONS ==========
+def parse_content(gemini_content, post_status):
+    """Parse Gemini content and return preview"""
+    if not gemini_content.strip():
+        return "Please paste content first", "", "", "", "", "", {}
+    
+    parsed = parse_gemini_content(gemini_content, post_status)
+    
+    if 'error' in parsed:
+        return parsed['error'], "", "", "", "", "", {}
+    
+    # Format tags for display
+    tags_display = ", ".join(parsed['tags'][:6])
+    
+    # Format meta description preview
+    meta_preview = parsed['meta_description'][:100] + "..." if len(parsed['meta_description']) > 100 else parsed['meta_description']
+    
+    # Create rank math preview text
+    rank_math_preview = "\n".join([f"{key}: {value}" for key, value in parsed['rank_math_meta'].items()][:5])
+    
+    return (
+        f"✅ Parsed: {parsed['seo_title']}",
+        parsed['seo_title'],
+        parsed['url_slug'],
+        meta_preview,
+        parsed['primary_keyword'],
+        tags_display,
+        f"Content Length: {len(parsed['content'])} chars"
+    ), parsed
+
+def publish_post(parsed_data, wp_config, image_file, post_status, wp_url, wp_username, wp_password):
+    """Publish post to WordPress"""
+    if not parsed_data:
+        return "❌ No parsed content available. Please parse content first.", None
+    
+    # Use stored config or provided inputs
+    if not wp_config:
+        wp_config = {
+            'url': wp_url.rstrip('/') if wp_url else '',
+            'username': wp_username,
+            'password': wp_password,
+            'status': post_status
+        }
+    
+    # Validate config
+    if not all([wp_config['url'], wp_config['username'], wp_config['password']]):
+        return "❌ WordPress configuration incomplete. Please provide URL, username, and password.", None
+    
+    try:
+        yield "🖼️ Uploading image to WordPress...", None
+        
+        # Step 1: Upload image
+        media_id = None
+        if image_file:
+            media_id = upload_image_to_wordpress(
+                image_file,
+                wp_config,
+                parsed_data['url_slug']
+            )
+        
+        yield "📤 Creating post with Rank Math meta...", None
+        
+        # Step 2: Create post
+        result = create_wordpress_post(
+            parsed_data,
+            wp_config,
+            media_id,
+            post_status
+        )
+        
+        if result:
+            # Create download data
+            export_data = {
+                'post_id': result['id'],
+                'title': result['title']['rendered'],
+                'link': result['link'],
+                'status': result['status'],
+                'slug': result['slug'],
+                'published_at': datetime.now().isoformat()
+            }
+            
+            # Save JSON to file
+            json_file = f"post_{result['id']}.json"
+            with open(json_file, 'w') as f:
+                json.dump(export_data, f, indent=2)
+            
+            success_msg = f"""
+            ✅ Post published successfully!
+            
+            Post ID: {result['id']}
+            Status: {result['status']}
+            Date: {result['date'][:10]}
+            Link: {result['link']}
+            
+            Click the download button to get post data.
+            """
+            
+            yield success_msg, json_file
+        else:
+            yield "❌ Failed to publish post. Check WordPress configuration and try again.", None
+            
+    except Exception as e:
+        yield f"❌ Error: {str(e)}", None
+
+def clear_all():
+    """Clear all inputs"""
+    return (
+        "",  # gemini_content
+        None,  # image
+        "https://cdgarment.com",  # wp_url
+        "",  # wp_username
+        "",  # wp_password
+        "draft",  # post_status
+        "",  # parse_status
+        "",  # seo_title
+        "",  # url_slug
+        "",  # meta_description
+        "",  # primary_keyword
+        "",  # tags
+        "",  # content_length
+        "",  # publish_status
+        None,  # download_file
+    )
+
+# ========== GRADIO UI ==========
+with gr.Blocks(
+    title="CdGarment WordPress Publisher",
+    theme=gr.themes.Soft(
+        primary_hue="purple",
+        secondary_hue="green",
+    ),
+    css="""
+    .gradio-container {
+        max-width: 1400px !important;
+    }
+    .container {
+        padding: 20px;
+    }
+    .header {
+        text-align: center;
+        margin-bottom: 20px;
+    }
+    .header h1 {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-size: 2.5rem;
+        font-weight: 800;
+        margin-bottom: 10px;
+    }
+    .badge {
+        background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+        color: #991B1B;
+        padding: 8px 16px;
+        border-radius: 20px;
+        font-weight: 600;
+        display: inline-block;
+        margin-bottom: 20px;
+    }
+    .paste-box {
+        border: 2px solid #3B82F6;
+        border-radius: 10px;
+        padding: 20px;
+        background-color: #F8FAFC;
+        min-height: 500px;
+    }
+    .preview-box {
+        background-color: #f8f9fa;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+    }
+    .status-indicator {
+        display: inline-block;
+        padding: 5px 10px;
+        border-radius: 5px;
+        font-weight: bold;
+        margin: 2px;
+    }
+    .success {
+        background-color: #d1fae5;
+        color: #065f46;
+    }
+    .warning {
+        background-color: #fef3c7;
+        color: #92400e;
+    }
+    .error {
+        background-color: #fee2e2;
+        color: #991b1b;
+    }
+    """
+) as demo:
+    
+    # State variables
+    parsed_data_state = gr.State(None)
+    wp_config_state = gr.State(None)
+    
+    # Header
+    gr.HTML("""
+    <div class="header">
+        <h1>🏭 CdGarment WordPress Publisher</h1>
+        <div class="badge">✓ Optimized for Rank Math SEO</div>
+    </div>
+    """)
+    
+    # Two main columns
+    with gr.Row():
+        with gr.Column(scale=2):
+            with gr.Group():
+                gr.Markdown("### 📋 Paste Gemini Content")
+                gr.Markdown("Include SEO package and article")
+                
+                # Example content
+                example_content = """SEO Toolkit: Article #20
+Element Suggestion
+Primary Keyword: Apparel ODM Design Services
+SEO Title: The Creative Engine: Inside CdGarment's Powerful R&D Team for ODM Success
+Meta Description: Elevate your brand with CdGarment's R&D team. We provide expert ODM services, from trend analysis to prototype development, ensuring your vision becomes reality.
+Tags: apparel ODM partner, fashion R&D team, original design manufacturer, garment prototype development, CdGarment R&D, fashion trend development
+📝 Article #20: Full Content
+The Creative Engine: How CdGarment's R&D Team Powers Global ODM Success...
+
+[Paste your complete Gemini output here]"""
+                
+                gemini_content = gr.Textbox(
+                    label="Gemini Content",
+                    value=example_content,
+                    lines=20,
+                    placeholder="Paste your complete Gemini output here with all formatting",
+                    elem_classes="paste-box"
+                )
+                
+                with gr.Row():
+                    parse_btn = gr.Button("🔍 Parse Content", variant="primary", scale=2)
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", scale=1)
+        
+        with gr.Column(scale=1):
+            # Image upload section
+            with gr.Group():
+                gr.Markdown("### 🖼️ Image & Upload")
+                image_input = gr.File(
+                    label="Upload Image",
+                    file_types=["image"],
+                    type="filepath"
+                )
+                image_preview = gr.Image(
+                    label="Image Preview",
+                    height=200,
+                    visible=False
+                )
+                image_description = gr.Textbox(
+                    label="Image Description",
+                    placeholder="Auto-generated description will appear here",
+                    lines=3
+                )
+            
+            # WordPress settings section
+            with gr.Group():
+                gr.Markdown("### ⚙️ WordPress Settings")
+                
+                # Load environment variables
+                env_config = load_environment_variables()
+                
+                wp_url = gr.Textbox(
+                    label="WordPress URL",
+                    value=env_config['url'],
+                    placeholder="https://cdgarment.com"
+                )
+                wp_username = gr.Textbox(
+                    label="Username",
+                    value=env_config['username'],
+                    placeholder="admin"
+                )
+                wp_password = gr.Textbox(
+                    label="Application Password",
+                    value=env_config['password'],
+                    type="password",
+                    placeholder="••••••••"
+                )
+                post_status = gr.Radio(
+                    label="Post Status",
+                    choices=["draft", "publish"],
+                    value=env_config['status']
+                )
+                
+                save_config_btn = gr.Button("💾 Save Configuration", variant="secondary")
+    
+    # Parse status and preview
+    parse_status = gr.Textbox(label="Parse Status", visible=False)
+    
+    with gr.Row(visible=False) as preview_row:
+        with gr.Column():
+            seo_title = gr.Textbox(label="SEO Title")
+            url_slug = gr.Textbox(label="URL Slug")
+        
+        with gr.Column():
+            meta_description = gr.Textbox(label="Meta Description")
+            primary_keyword = gr.Textbox(label="Primary Keyword")
+        
+        with gr.Column():
+            tags = gr.Textbox(label="Tags")
+            content_length = gr.Textbox(label="Content Length")
+    
+    # Publish section
+    gr.Markdown("---")
+    gr.Markdown("### 🚀 Ready to Publish")
+    
+    # Status indicators
+    with gr.Row():
+        content_status = gr.HTML("<span class='status-indicator warning'>❌ Content</span>")
+        image_status = gr.HTML("<span class='status-indicator warning'>⚠️ Image Optional</span>")
+        wp_status = gr.HTML("<span class='status-indicator warning'>❌ WordPress</span>")
+        status_indicator = gr.HTML("<span class='status-indicator'>📊 Status: DRAFT</span>")
+    
+    publish_btn = gr.Button("🚀 PUSH TO WORDPRESS", variant="primary", size="lg")
+    
+    # Publish results
+    publish_status = gr.Textbox(label="Publish Status", lines=5)
+    download_file = gr.File(label="Download Post Data", visible=False)
+    
+    # Footer
+    gr.Markdown("---")
+    gr.Markdown(f"CdGarment WordPress Publisher • {datetime.now().year}")
+    
+    # ========== EVENT HANDLERS ==========
+    
+    def update_status_indicators(has_content, has_image, has_wp_config, post_status_value):
+        """Update status indicators"""
+        content_html = f"<span class='status-indicator success'>✅ Content</span>" if has_content else f"<span class='status-indicator error'>❌ Content</span>"
+        image_html = f"<span class='status-indicator success'>✅ Image</span>" if has_image else f"<span class='status-indicator warning'>⚠️ Image Optional</span>"
+        wp_html = f"<span class='status-indicator success'>✅ WordPress</span>" if has_wp_config else f"<span class='status-indicator error'>❌ WordPress</span>"
+        status_html = f"<span class='status-indicator'>📊 Status: {post_status_value.upper()}</span>"
+        
+        return content_html, image_html, wp_html, status_html
+    
+    def check_wp_config(wp_url_val, wp_username_val, wp_password_val):
+        """Check if WordPress config is complete"""
+        return all([wp_url_val, wp_username_val, wp_password_val])
+    
+    # Image upload handler
+    def update_image_preview(image_file):
+        if image_file:
+            return gr.update(visible=True, value=image_file), True
+        return gr.update(visible=False), False
+    
+    # Parse button handler
+    def on_parse_click(gemini_content_val, post_status_val):
+        if not gemini_content_val.strip():
+            return (
+                gr.update(value="Please paste content first", visible=True),
+                gr.update(visible=False),
+                "", "", "", "", "",
+                None,
+                *update_status_indicators(False, False, False, post_status_val)
+            )
+        
+        result, parsed = parse_content(gemini_content_val, post_status_val)
+        
+        if isinstance(result, tuple):
+            parse_status_val, seo_title_val, url_slug_val, meta_desc_val, keyword_val, tags_val, content_len_val = result
+            return (
+                gr.update(value=parse_status_val, visible=True),
+                gr.update(visible=True),
+                seo_title_val,
+                url_slug_val,
+                meta_desc_val,
+                keyword_val,
+                tags_val,
+                content_len_val,
+                parsed,
+                *update_status_indicators(True, False, False, post_status_val)
+            )
+        else:
+            return (
+                gr.update(value=result, visible=True),
+                gr.update(visible=False),
+                "", "", "", "", "",
+                None,
+                *update_status_indicators(False, False, False, post_status_val)
+            )
+    
+    # Save config handler
+    def on_save_config(wp_url_val, wp_username_val, wp_password_val, post_status_val):
+        if all([wp_url_val, wp_username_val, wp_password_val]):
+            wp_config = {
+                'url': wp_url_val.rstrip('/'),
+                'username': wp_username_val,
+                'password': wp_password_val,
+                'status': post_status_val
+            }
+            return (
+                gr.update(value="✅ Configuration saved!"),
+                wp_config,
+                *update_status_indicators(False, False, True, post_status_val)
+            )
+        return (
+            gr.update(value="⚠️ Please fill all WordPress configuration fields"),
+            None,
+            *update_status_indicators(False, False, False, post_status_val)
+        )
+    
+    # Publish button handler
+    def on_publish_click(parsed_data, wp_config, image_file, post_status_val, wp_url_val, wp_username_val, wp_password_val):
+        if not parsed_data:
+            yield (
+                gr.update(value="❌ No parsed content available. Please parse content first"),
+                gr.update(visible=False),
+                *update_status_indicators(False, bool(image_file), bool(wp_config), post_status_val)
+            )
+            return
+        
+        wp_config_to_use = wp_config or {
+            'url': wp_url_val.rstrip('/') if wp_url_val else '',
+            'username': wp_username_val,
+            'password': wp_password_val,
+            'status': post_status_val
+        }
+        
+        # Update status during processing
+        yield (
+            gr.update(value="🖼️ Uploading image to WordPress..."),
+            gr.update(visible=False),
+            *update_status_indicators(True, bool(image_file), True, post_status_val)
+        )
+        
+        # Simulate progress (Gradio doesn't have built-in progress bars for streaming)
+        import time
+        time.sleep(1)
+        
+        # Call the publish function
+        publish_result = list(publish_post(parsed_data, wp_config_to_use, image_file, post_status_val, wp_url_val, wp_username_val, wp_password_val))
+        
+        if len(publish_result) > 1:
+            status_msg, download_file_val = publish_result[-1]
+            if download_file_val:
+                yield (
+                    gr.update(value=status_msg),
+                    gr.update(value=download_file_val, visible=True),
+                    *update_status_indicators(True, bool(image_file), True, post_status_val)
+                )
+            else:
+                yield (
+                    gr.update(value=status_msg),
+                    gr.update(visible=False),
+                    *update_status_indicators(True, bool(image_file), True, post_status_val)
+                )
+    
+    # Update status indicators when inputs change
+    def update_indicators_on_change(gemini_content_val, image_file, wp_url_val, wp_username_val, wp_password_val, post_status_val, parsed_data):
+        has_content = bool(parsed_data) or bool(gemini_content_val and gemini_content_val.strip())
+        has_image = bool(image_file)
+        has_wp = check_wp_config(wp_url_val, wp_username_val, wp_password_val)
+        return update_status_indicators(has_content, has_image, has_wp, post_status_val)
+    
+    # ========== BIND EVENT HANDLERS ==========
+    
+    # Image upload
+    image_input.change(
+        update_image_preview,
+        inputs=[image_input],
+        outputs=[image_preview, image_status]
+    )
+    
+    # Parse button
+    parse_btn.click(
+        on_parse_click,
+        inputs=[gemini_content, post_status],
+        outputs=[
+            parse_status,
+            preview_row,
+            seo_title,
+            url_slug,
+            meta_description,
+            primary_keyword,
+            tags,
+            content_length,
+            parsed_data_state,
+            content_status,
+            image_status,
+            wp_status,
+            status_indicator
+        ]
+    )
+    
+    # Save config button
+    save_config_btn.click(
+        on_save_config,
+        inputs=[wp_url, wp_username, wp_password, post_status],
+        outputs=[parse_status, wp_config_state, content_status, image_status, wp_status, status_indicator]
+    )
+    
+    # Publish button
+    publish_btn.click(
+        on_publish_click,
+        inputs=[parsed_data_state, wp_config_state, image_input, post_status, wp_url, wp_username, wp_password],
+        outputs=[publish_status, download_file, content_status, image_status, wp_status, status_indicator]
+    )
+    
+    # Clear button
+    clear_btn.click(
+        clear_all,
+        outputs=[
+            gemini_content,
+            image_input,
+            wp_url,
+            wp_username,
+            wp_password,
+            post_status,
+            parse_status,
+            seo_title,
+            url_slug,
+            meta_description,
+            primary_keyword,
+            tags,
+            content_length,
+            publish_status,
+            download_file
+        ]
+    )
+    
+    # Update status indicators on input changes
+    for input_component in [gemini_content, image_input, wp_url, wp_username, wp_password, post_status]:
+        input_component.change(
+            update_indicators_on_change,
+            inputs=[gemini_content, image_input, wp_url, wp_username, wp_password, post_status, parsed_data_state],
+            outputs=[content_status, image_status, wp_status, status_indicator]
+        )
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )