Update app.py

app.py

@@ -1,168 +1,3 @@
-'''
-import gradio as gr
-import os
-import time
-import tempfile
-import requests
-from PIL import Image
-from io import BytesIO
-import re
-from datetime import datetime
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-# Hugging Face configuration
-HF_TOKEN = os.getenv("HF_TOKEN")
-TEXT_API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
-IMAGE_API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
-
-def generate_blog_content(topic, tone="professional", length="medium"):
-    try:
-        current_date = datetime.now().strftime("%B %d, %Y")
-        reading_time = {"short": "5-8", "medium": "8-12", "long": "15-20"}[length]
-
-        prompt = f"""<s>[INST] Write a {tone} blog post about {topic} with:
-        - Title and subtitle
-        - Introduction with statistics
-        - 2 main sections with subsections
-        - Conclusion
-        - Markdown formatting
-        - Published date: {current_date}
-        - Reading time: {reading_time} minutes [/INST]</s>"""
-
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": 1024,
-                "temperature": 0.7,
-                "return_full_text": False
-            }
-        }
-
-        response = requests.post(TEXT_API_URL, headers=HEADERS, json=payload)
-        
-        if response.status_code == 503:
-            estimate = response.json().get('estimated_time', 30)
-            time.sleep(estimate)
-            response = requests.post(TEXT_API_URL, headers=HEADERS, json=payload)
-            
-        response.raise_for_status()
-        return response.json()[0]['generated_text']
-        
-    except Exception as e:
-        return f"Error generating content: {str(e)}"
-
-def generate_featured_image(topic):
-    try:
-        prompt = f"Professional digital illustration for blog about {topic}, high quality"
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "height": 512,
-                "width": 768,
-                "num_inference_steps": 25
-            }
-        }
-
-        response = requests.post(IMAGE_API_URL, headers=HEADERS, json=payload)
-        response.raise_for_status()
-        
-        image = Image.open(BytesIO(response.content))
-        temp_img = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-        image.save(temp_img.name)
-        return temp_img.name, None  # Return path and no error
-        
-    except Exception as e:
-        return None, f"Image error: {str(e)}"
-
-def create_download_file(content, title, author):
-    try:
-        temp_file = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".md", encoding="utf-8")
-        full_content = content + f"\n\n**About the Author**  \n{author}"
-        temp_file.write(full_content)
-        temp_file.close()
-        
-        sanitized_title = re.sub(r'[^\w\-_ ]', '_', title)[:50]
-        return temp_file.name  # Return only the file path
-        
-    except Exception as e:
-        return None
-
-def generate_blog(topic, tone, length, author_name, publish_option, linkedin_user=None, linkedin_pass=None, hf_token=None):
-    status_updates = []
-    blog_content = ""
-    title = ""
-    file_path = None
-    
-    try:
-        # Generate content
-        status_updates.append("🚀 Starting blog generation...")
-        blog_content = generate_blog_content(topic, tone, length)
-        
-        if "Error" in blog_content:
-            return blog_content, "", "\n".join(status_updates), None
-        
-        # Extract title
-        title_match = re.search(r'^#\s+(.+)$', blog_content, re.MULTILINE)
-        title = title_match.group(1).strip() if title_match else topic
-        
-        # Generate image
-        status_updates.append("🖼️ Generating featured image...")
-        image_path, image_error = generate_featured_image(topic)
-        if image_error:
-            status_updates.append(image_error)
-        else:
-            status_updates.append("✅ Image generated!")
-        
-        # Create downloadable file
-        status_updates.append("📥 Preparing download...")
-        file_path = create_download_file(blog_content, title, author_name)
-        status_updates.append("✅ Download ready!")
-        
-        return blog_content, title, "\n".join(status_updates), file_path
-        
-    except Exception as e:
-        status_updates.append(f"❌ Critical error: {str(e)}")
-        return blog_content, title, "\n".join(status_updates), None
-
-# Gradio interface
-with gr.Blocks(title="AI Blog Generator", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 📝 AI Blog Generator")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            topic_input = gr.Textbox(label="Blog Topic")
-            tone_input = gr.Dropdown(
-                ["professional", "casual", "technical", "storytelling"],
-                label="Writing Style",
-                value="professional"
-            )
-            length_input = gr.Dropdown(
-                ["short", "medium", "long"],
-                label="Article Length",
-                value="medium"
-            )
-            author_input = gr.Textbox(label="Author Name")
-            generate_btn = gr.Button("Generate", variant="primary")
-
-        with gr.Column(scale=2):
-            title_output = gr.Textbox(label="Generated Title")
-            blog_output = gr.Markdown()
-            status_output = gr.Textbox(label="Status")
-            download_output = gr.File(label="Download")
-
-    generate_btn.click(
-        generate_blog,
-        inputs=[topic_input, tone_input, length_input, author_input, gr.Radio(["none"], visible=False)],
-        outputs=[blog_output, title_output, status_output, download_output]
-    )
-
-if __name__ == "__main__":
-    app.launch(share=False)'''
-
 '''import gradio as gr
 import os
 import time
@@ -181,184 +16,6 @@ HF_TOKEN = os.getenv("HF_TOKEN")
 HF_USERNAME = "jsakshi"
 HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
 
-def generate_blog_content(topic):
-    try:
-        prompt = f"""Create a professional blog post about {topic} including:
-        - Title and subtitle
-        - 3 sections with subsections
-        - 2 image placeholders [IMAGE1][IMAGE2]
-        - Data points and examples
-        - Conclusion
-        Use markdown formatting"""
-        
-        response = requests.post(
-            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2",
-            headers=HEADERS,
-            json={"inputs": prompt, "parameters": {"max_length": 2000}}
-        )
-        
-        if response.status_code != 200:
-            return None, f"API Error: {response.text}"
-            
-        return response.json()[0]['generated_text'], None
-        
-    except Exception as e:
-        return None, f"Error: {str(e)}"
-
-def create_hosted_blog(topic):
-    try:
-        # Generate blog content first
-        content, error = generate_blog_content(topic)
-        if error or not content:
-            return f"Error generating content: {error}", ""
-            
-        # Create unique space
-        space_id = f"blog-{uuid.uuid4().hex[:8]}"
-        space_name = f"{HF_USERNAME}/{space_id}"
-        
-        # Initialize Hub API
-        api = HfApi(token=HF_TOKEN)
-        api.create_repo(
-            repo_id=space_name,
-            repo_type="space",
-            space_sdk="static",
-            private=False
-        )
-
-        # Generate and upload images
-        image_paths = []
-        for idx in range(2):
-            response = requests.post(
-                "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0",
-                headers=HEADERS,
-                json={"inputs": f"Professional illustration about {topic}, clean design"}
-            )
-            if response.status_code == 200:
-                upload_file(
-                    path_or_fileobj=response.content,
-                    path_in_repo=f"image_{idx}.png",
-                    repo_id=space_name,
-                    repo_type="space"
-                )
-                image_paths.append(f"image_{idx}.png")
-            time.sleep(1)
-
-        # Replace image placeholders
-        if content:
-            updated_content = content.replace("[IMAGE1]", f'![Image 1]({image_paths[0]})').replace("[IMAGE2]", f'![Image 2]({image_paths[1]})')
-        else:
-            return "Error: No content generated", ""
-
-        # Create HTML template
-        html_content = f"""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>{topic}</title>
-    <style>
-        body {{
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 40px;
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            line-height: 1.6;
-            color: #333;
-        }}
-        .header {{
-            text-align: center;
-            padding: 40px 0;
-            border-bottom: 1px solid #eee;
-            margin-bottom: 40px;
-        }}
-        h1 {{
-            color: #2c3e50;
-            font-size: 2.5em;
-            margin-bottom: 10px;
-        }}
-        img {{
-            width: 100%;
-            height: auto;
-            margin: 25px 0;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }}
-        .content {{
-            background: white;
-            padding: 30px;
-            border-radius: 8px;
-        }}
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>{topic}</h1>
-        <p>Published on {datetime.now().strftime("%B %d, %Y")}</p>
-    </div>
-    <div class="content">
-        {markdown.markdown(updated_content)}
-    </div>
-</body>
-</html>
-        """
-
-        # Upload HTML file
-        upload_file(
-            path_or_fileobj=html_content.encode(),
-            path_in_repo="index.html",
-            repo_id=space_name,
-            repo_type="space"
-        )
-
-        return f"https://huggingface.co/spaces/{space_name}", content
-        
-    except Exception as e:
-        return f"Error: {str(e)}", ""
-
-# Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 📄 Professional Blog Generator")
-    
-    with gr.Row():
-        with gr.Column():
-            topic_input = gr.Textbox(label="Enter Blog Topic", 
-                                   placeholder="e.g., Future of AI in Healthcare")
-            generate_btn = gr.Button("Generate Blog", variant="primary")
-            
-        with gr.Column():
-            gr.Markdown("### Generated Content")
-            blog_output = gr.Markdown()
-            gr.Markdown("### Blog URL")
-            blog_link = gr.Markdown("Your blog link will appear here...")
-            status = gr.Textbox(label="Status", interactive=False)
-
-    generate_btn.click(
-        fn=create_hosted_blog,
-        inputs=topic_input,
-        outputs=[blog_link, blog_output]
-    )
-
-if __name__ == "__main__":
-    app.launch(share=True)'''
-
-
-import gradio as gr
-import os
-import time
-import requests
-import re
-import uuid
-import markdown
-from datetime import datetime
-from dotenv import load_dotenv
-from huggingface_hub import HfApi, upload_file
-
-load_dotenv()
-
-# Configuration
-HF_TOKEN = os.getenv("HF_TOKEN")
-HF_USERNAME = "jsakshi"
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
-
 def generate_blog_content(topic):
     try:
         prompt = f"""Create a detailed, professional blog post about {topic} including:
@@ -807,5 +464,250 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         outputs=[blog_link, blog_output]
     )
 
+if __name__ == "__main__":
+    app.launch(share=True)'''
+
+import gradio as gr
+import os
+import time
+import requests
+import re
+import uuid
+import markdown
+from datetime import datetime
+from dotenv import load_dotenv
+from huggingface_hub import HfApi, upload_file
+import json
+from functools import partial
+
+load_dotenv()
+
+# Configuration
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_USERNAME = "jsakshi"
+HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+
+# Simulated user authentication (in practice, use a proper auth system)
+AUTHORIZED_USERS = {"admin": "password123"}  # username: password
+
+# Store edit history for undo/redo
+edit_history = []
+current_history_index = -1
+
+def generate_initial_content(topic):
+    # Same as original generate_blog_content but simplified for example
+    prompt = f"Create a blog post about {topic} with title, subtitle, introduction, 3 sections, and conclusion."
+    response = requests.post(
+        "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2",
+        headers=HEADERS,
+        json={"inputs": prompt, "parameters": {"max_length": 2000}}
+    )
+    if response.status_code == 200:
+        return response.json()[0]['generated_text']
+    return f"# {topic}\n## Subtitle\nIntro text\n## Section 1\nText\n## Section 2\nText\n## Section 3\nText\n## Conclusion\nText"
+
+def create_or_update_space(content_data, space_name=None, images=[]):
+    api = HfApi(token=HF_TOKEN)
+    
+    if not space_name:
+        space_id = f"blog-{uuid.uuid4().hex[:8]}"
+        space_name = f"{HF_USERNAME}/{space_id}"
+        api.create_repo(repo_id=space_name, repo_type="space", space_sdk="static", private=False)
+    
+    # Generate HTML with contenteditable attributes
+    sections = re.split(r'(## .+)', content_data)
+    html_content = '<div class="editable-container">'
+    current_section = ""
+    
+    for part in sections:
+        if part.strip():
+            if part.startswith('## '):
+                if current_section:
+                    html_content += f'<div class="section-content" contenteditable="true">{markdown.markdown(current_section)}</div></div>'
+                html_content += f'<div class="section"><h2 class="editable-header" contenteditable="true">{part[3:]}</h2>'
+                current_section = ""
+            else:
+                current_section += part
+    if current_section:
+        html_content += f'<div class="section-content" contenteditable="true">{markdown.markdown(current_section)}</div></div>'
+    html_content += '</div>'
+    
+    # Add images
+    for i, img in enumerate(images):
+        html_content += f'<div class="image-container" draggable="true" data-index="{i}"><img src="{img}" class="editable-image" /><button class="delete-image">Delete</button></div>'
+    
+    complete_html = f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Editable Blog</title>
+    <style>
+        .editable-container {{ max-width: 800px; margin: 20px auto; padding: 20px; }}
+        .editable-header {{ font-size: 1.5em; margin: 20px 0 10px; cursor: text; }}
+        .section-content {{ margin-bottom: 20px; cursor: text; }}
+        .image-container {{ position: relative; margin: 20px 0; }}
+        .editable-image {{ width: 100%; max-width: 500px; cursor: move; }}
+        .delete-image {{ position: absolute; top: 5px; right: 5px; }}
+        .editing-tools {{ position: fixed; top: 10px; left: 10px; background: white; padding: 10px; border: 1px solid #ccc; }}
+        [contenteditable]:focus {{ outline: 2px solid #2D68C4; }}
+    </style>
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+</head>
+<body>
+    <div class="editing-tools" id="tools" style="display: none;">
+        <button onclick="document.execCommand('bold')">B</button>
+        <button onclick="document.execCommand('italic')">I</button>
+        <select onchange="document.execCommand('formatBlock', false, this.value)">
+            <option value="">Normal</option>
+            <option value="h1">H1</option>
+            <option value="h2">H2</option>
+            <option value="h3">H3</option>
+        </select>
+        <button onclick="saveChanges()">Save</button>
+        <button onclick="preview()">Preview</button>
+        <button onclick="undo()">Undo</button>
+        <button onclick="redo()">Redo</button>
+    </div>
+    {html_content}
+    <script>
+        let currentSpace = "{space_name}";
+        let images = {json.dumps(images)};
+        
+        function saveChanges() {{
+            const content = document.querySelector('.editable-container').innerHTML;
+            fetch('/update', {{
+                method: 'POST',
+                headers: {{ 'Content-Type': 'application/json' }},
+                body: JSON.stringify({{ space: currentSpace, content: content, images: images }})
+            }}).then(() => alert('Saved!'));
+            addToHistory(content);
+        }}
+        
+        function preview() {{
+            const content = document.querySelector('.editable-container').innerHTML;
+            const previewWindow = window.open('', '_blank');
+            previewWindow.document.write('<html><body>' + marked.parse(content) + '</body></html>');
+        }}
+        
+        function addToHistory(content) {{
+            if (window.historyIndex < window.history.length - 1) {{
+                window.history.splice(window.historyIndex + 1);
+            }}
+            window.history.push(content);
+            window.historyIndex = window.history.length - 1;
+            localStorage.setItem('editHistory', JSON.stringify(window.history));
+            localStorage.setItem('historyIndex', window.historyIndex);
+        }}
+        
+        window.history = JSON.parse(localStorage.getItem('editHistory') || '[]');
+        window.historyIndex = parseInt(localStorage.getItem('historyIndex') || '-1');
+        
+        function undo() {{
+            if (window.historyIndex > 0) {{
+                window.historyIndex--;
+                document.querySelector('.editable-container').innerHTML = window.history[window.historyIndex];
+                localStorage.setItem('historyIndex', window.historyIndex);
+            }}
+        }}
+        
+        function redo() {{
+            if (window.historyIndex < window.history.length - 1) {{
+                window.historyIndex++;
+                document.querySelector('.editable-container').innerHTML = window.history[window.historyIndex];
+                localStorage.setItem('historyIndex', window.historyIndex);
+            }}
+        }}
+        
+        // Drag and drop
+        document.querySelectorAll('.image-container').forEach(container => {{
+            container.addEventListener('dragstart', e => {{
+                e.dataTransfer.setData('text/plain', container.dataset.index);
+            }});
+            container.addEventListener('dragover', e => e.preventDefault());
+            container.addEventListener('drop', e => {{
+                e.preventDefault();
+                const fromIndex = e.dataTransfer.getData('text/plain');
+                const toIndex = container.dataset.index;
+                if (fromIndex !== toIndex) {{
+                    const temp = images[fromIndex];
+                    images[fromIndex] = images[toIndex];
+                    images[toIndex] = temp;
+                    saveChanges();
+                    location.reload();
+                }}
+            }});
+        }});
+        
+        // Delete image
+        document.querySelectorAll('.delete-image').forEach(btn => {{
+            btn.addEventListener('click', () => {{
+                const index = btn.parentElement.dataset.index;
+                images.splice(index, 1);
+                saveChanges();
+                location.reload();
+            }});
+        }});
+        
+        // Autosave every 30 seconds
+        setInterval(saveChanges, 30000);
+        
+        // Show tools on edit
+        document.querySelectorAll('[contenteditable]').forEach(el => {{
+            el.addEventListener('focus', () => document.getElementById('tools').style.display = 'block');
+        }});
+    </script>
+</body>
+</html>"""
+    
+    upload_file(
+        path_or_fileobj=complete_html.encode(),
+        path_in_repo="index.html",
+        repo_id=space_name,
+        repo_type="space"
+    )
+    return f"https://huggingface.co/spaces/{space_name}"
+
+def authenticate(username, password):
+    return username in AUTHORIZED_USERS and AUTHORIZED_USERS[username] == password
+
+def generate_and_edit(topic, username, password):
+    if not authenticate(username, password):
+        return "Authentication failed", "", ""
+    
+    initial_content = generate_initial_content(topic)
+    space_url = create_or_update_space(initial_content)
+    return space_url, initial_content, "Blog generated successfully"
+
+# Mock update endpoint (in practice, this would be a server-side API)
+def update_content(space, content, images):
+    create_or_update_space(content, space, images)
+    return "Updated successfully"
+
+# Gradio interface
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 📝 Blog Editor")
+    gr.Markdown("Generate and edit professional blog posts with an intuitive interface")
+    
+    with gr.Row():
+        with gr.Column():
+            username = gr.Textbox(label="Username", placeholder="admin")
+            password = gr.Textbox(label="Password", type="password")
+            topic_input = gr.Textbox(label="Blog Topic", placeholder="e.g., Future of AI")
+            generate_btn = gr.Button("Generate & Edit", variant="primary")
+        
+        with gr.Column():
+            status = gr.Textbox(label="Status", interactive=False)
+            blog_link = gr.Markdown("Blog link will appear here...")
+            blog_preview = gr.Markdown(label="Preview", value="Content preview will appear here...")
+    
+    # Update function (simulated)
+    update_btn = gr.Button("Update Content", visible=False)
+    
+    generate_btn.click(
+        fn=generate_and_edit,
+        inputs=[topic_input, username, password],
+        outputs=[blog_link, blog_preview, status]
+    )
+
 if __name__ == "__main__":
     app.launch(share=True)