Update app.py

app.py

@@ -167,117 +167,151 @@ if __name__ == "__main__":
 import gradio as gr
 import os
 import time
-import tempfile
-import zipfile
 import requests
 import re
-from pathlib import Path
-from PIL import Image
-from io import BytesIO
+from datetime import datetime
 from dotenv import load_dotenv
+from huggingface_hub import HfApi, Repository
 
-# Load environment variables
 load_dotenv()
 
-class MultiAIBlogger:
+class BlogCreator:
     def __init__(self):
         self.hf_token = os.getenv("HF_TOKEN")
+        self.api = HfApi(token=self.hf_token)
         self.headers = {"Authorization": f"Bearer {self.hf_token}"}
+
+    def generate_blog(self, topic):
+        # Generate blog content
+        blog_text = self._generate_text(topic)
         
-        # Configure models
-        self.text_url = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
-        self.image_url = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+        # Generate images
+        image_urls = self._generate_images(blog_text)
         
-    def generate_blog(self, topic):
-        # Generate text content
-        text_prompt = f"""Create a comprehensive blog post about {topic} including:
-        - SEO-optimized title
-        - 3-5 sections with subtitles
-        - 2-4 image placeholders [IMAGE:description]
-        - Bullet points and statistics
-        - Conclusion with call-to-action
-        Use markdown formatting"""
+        # Create hosted space
+        space_url = self._create_hosted_blog(topic, blog_text, image_urls)
         
-        text_response = requests.post(
-            self.text_url,
+        return blog_text, space_url
+
+    def _generate_text(self, topic):
+        response = requests.post(
+            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2",
             headers=self.headers,
-            json={"inputs": text_prompt, "parameters": {"max_length": 2000}}
+            json={
+                "inputs": f"Write a comprehensive blog about {topic} with markdown formatting and 3 image placeholders [IMAGE1], [IMAGE2], [IMAGE3]",
+                "parameters": {"max_length": 2000}
+            }
         )
+        return response.json()[0]['generated_text']
+
+    def _generate_images(self, content):
+        image_prompts = re.findall(r'\[IMAGE\d+\]', content)
+        image_urls = []
         
-        if text_response.status_code != 200:
-            return f"Text generation failed: {text_response.text}", None
-            
-        raw_content = text_response.json()[0]['generated_text']
-        
-        # Generate images
-        image_descriptions = re.findall(r'\[IMAGE:(.*?)\]', raw_content)
-        images = {}
-        temp_dir = tempfile.mkdtemp()
-        
-        for idx, desc in enumerate(image_descriptions):
-            img_prompt = f"Blog image: {desc}, digital art, 8k resolution, trending on artstation"
-            img_response = requests.post(
-                self.image_url,
+        for idx, _ in enumerate(image_prompts):
+            response = requests.post(
+                "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0",
                 headers=self.headers,
-                json={"inputs": img_prompt}
+                json={"inputs": f"Professional blog image about {content[:100]}, digital art, 4k"}
+            )
+            img_url = f"https://huggingface.co/datasets/username/blogs/raw/main/image_{idx}.png"
+            self.api.upload_file(
+                path_or_fileobj=response.content,
+                path_in_repo=f"image_{idx}.png",
+                repo_id="username/blogs",
+                repo_type="dataset"
             )
+            image_urls.append(img_url)
+            time.sleep(1)
             
-            if img_response.status_code == 200:
-                image = Image.open(BytesIO(img_response.content))
-                img_path = Path(temp_dir) / f"image_{idx+1}.png"
-                image.save(img_path)
-                images[desc] = str(img_path)
-                raw_content = raw_content.replace(f"[IMAGE:{desc}]", f"![{desc}](image_{idx+1}.png)")
-                time.sleep(1)  # Rate limit protection
+        return image_urls
 
-        # Create zip package
-        zip_path = self.create_package(raw_content, temp_dir)
-        return raw_content, zip_path
+    def _create_hosted_blog(self, topic, content, image_urls):
+        # Create formatted HTML
+        repo_name = f"blog-{topic.lower().replace(' ', '-')}-{int(time.time())}"
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>{topic}</title>
+            <style>
+                body {{ max-width: 800px; margin: 0 auto; padding: 20px; font-family: Arial, sans-serif; }}
+                img {{ width: 100%; border-radius: 10px; margin: 20px 0; }}
+                h1 {{ color: #2c3e50; }}
+                .header {{ text-align: center; padding: 40px 0; }}
+            </style>
+        </head>
+        <body>
+            <div class="header">
+                <h1>{topic}</h1>
+                <p>Generated on {datetime.now().strftime("%B %d, %Y")}</p>
+            </div>
+            {self._format_content(content, image_urls)}
+        </body>
+        </html>
+        """
+        
+        # Create and host Space
+        self.api.create_repo(
+            repo_id=repo_name,
+            repo_type="space",
+            space_sdk="static"
+        )
+        
+        self.api.upload_file(
+            path_or_fileobj=html_content.encode(),
+            path_in_repo="index.html",
+            repo_id=f"username/{repo_name}",
+            repo_type="space"
+        )
+        
+        return f"https://huggingface.co/spaces/username/{repo_name}"
 
-    def create_package(self, content, temp_dir):
-        # Save markdown
-        md_path = Path(temp_dir) / "blog.md"
-        with open(md_path, "w") as f:
-            f.write(content)
-            
-        # Create zip file
-        zip_path = "blog_package.zip"
-        with zipfile.ZipFile(zip_path, "w") as zipf:
-            for file in Path(temp_dir).iterdir():
-                zipf.write(file, file.name)
-                
-        return zip_path
+    def _format_content(self, content, image_urls):
+        # Replace image placeholders with actual URLs
+        for idx, url in enumerate(image_urls):
+            content = content.replace(f"[IMAGE{idx+1}]", f'<img src="{url}" alt="Blog Image {idx+1}">')
+        
+        # Convert markdown to HTML
+        content = content.replace("\n", "<br>")
+        content = re.sub(r"### (.*?)", r"<h3>\1</h3>", content)
+        content = re.sub(r"## (.*?)", r"<h2>\1</h2>", content)
+        content = re.sub(r"\*\*(.*?)\*\*", r"<strong>\1</strong>", content)
+        
+        return content
 
-# Initialize blogger
-blogger = MultiAIBlogger()
+# Initialize blog creator
+creator = BlogCreator()
 
-# Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🚀 AI Blog Creator")
+    gr.Markdown("# 🌐 AI Blog Publisher")
     
     with gr.Row():
         with gr.Column():
             topic_input = gr.Textbox(label="Blog Topic", placeholder="Enter your topic...")
-            generate_btn = gr.Button("Generate Blog", variant="primary")
+            generate_btn = gr.Button("Generate & Publish", variant="primary")
             
         with gr.Column():
-            gr.Markdown("## Preview & Download")
-            content_preview = gr.Markdown(label="Blog Preview")
-            download_output = gr.File(label="Download Package")
-            status = gr.Textbox(label="Generation Status", interactive=False)
+            gr.Markdown("## Generated Content")
+            blog_preview = gr.Markdown()
+            space_link = gr.Markdown("**Hosted Blog URL:** Waiting for generation...")
+            status = gr.Textbox(label="Status")
 
-    def process_blog(topic):
+    def process_request(topic):
         try:
-            content, package = blogger.generate_blog(topic)
-            return content, package, "Generation complete!"
+            blog_text, url = creator.generate_blog(topic)
+            return (
+                blog_text,
+                f"**Hosted Blog URL:** [Click to View]({url})",
+                "✅ Blog published successfully!"
+            )
         except Exception as e:
-            return "", None, f"Error: {str(e)}"
+            return "", "❌ Error generating blog", str(e)
 
     generate_btn.click(
-        fn=process_blog,
+        fn=process_request,
         inputs=topic_input,
-        outputs=[content_preview, download_output, status],
-        api_name="generate_blog"
+        outputs=[blog_preview, space_link, status]
     )
 
 if __name__ == "__main__":