Update app.py

app.py

@@ -364,74 +364,69 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # Hugging Face configuration
-HF_TOKEN = os.getenv("HF_TOKEN")  # Make sure this matches your .env variable name
+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}"}  # Correct header format
+HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
 
 def generate_blog_content(topic, tone="professional", length="medium"):
-    current_date = datetime.now().strftime("%B %d, %Y")
-    reading_time = {"short": "5-8", "medium": "8-12", "long": "15-20"}[length]
+    try:
+        current_date = datetime.now().strftime("%B %d, %Y")
+        reading_time = {"short": "5-8", "medium": "8-12", "long": "15-20"}[length]
 
-    # Proper Mistral instruction format
-    prompt = f"""<s>[INST] Write a professional blog post about {topic} with this structure:
-    - Title and subtitle
-    - Introduction with statistics
-    - 2 main sections with subsections
-    - Conclusion
-    - Markdown formatting
-    - Published date: {current_date}
-    - Reading time: {reading_time} minutes
-    Use {tone} tone [/INST]</s>"""
+        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  # Important to exclude original prompt
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 1024,
+                "temperature": 0.7,
+                "return_full_text": False
+            }
         }
-    }
 
-    try:
         response = requests.post(TEXT_API_URL, headers=HEADERS, json=payload)
         
         if response.status_code == 503:
-            # Handle model loading
-            estimate = response.json()['estimated_time']
+            estimate = response.json().get('estimated_time', 30)
             time.sleep(estimate)
             response = requests.post(TEXT_API_URL, headers=HEADERS, json=payload)
             
         response.raise_for_status()
-        
-        result = response.json()
-        return result[0]['generated_text']
+        return response.json()[0]['generated_text']
         
     except Exception as e:
-        return f"Error: {str(e)} - {response.text if 'response' in locals() else ''}"
-
+        return f"Error generating content: {str(e)}"
 
 def generate_featured_image(topic):
-    prompt = f"Professional digital illustration for blog about {topic}, high quality, trending on artstation"
-    
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "height": 512,
-            "width": 768,
-            "num_inference_steps": 25
+    try:
+        prompt = f"Professional digital illustration for blog about {topic}, high quality"
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "height": 512,
+                "width": 768,
+                "num_inference_steps": 25
+            }
         }
-    }
 
-    try:
         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, "Image generated successfully"
+        return temp_img.name, None  # Return path and no error
+        
     except Exception as e:
-        return None, f"Error generating image: {str(e)}"
+        return None, f"Image error: {str(e)}"
 
 def create_download_file(content, title, author):
     try:
@@ -441,101 +436,79 @@ def create_download_file(content, title, author):
         temp_file.close()
         
         sanitized_title = re.sub(r'[^\w\-_ ]', '_', title)[:50]
-        new_filename = f"{sanitized_title}.md"
-        return temp_file.name, new_filename
+        return temp_file.name  # Return only the file path
+        
     except Exception as e:
-        return None, f"Error creating file: {str(e)}"
+        return None
 
-def generate_blog(topic, tone, length, author_name, publish_option, linkedin_username=None, linkedin_password=None, hf_token=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
-    download_filename = 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) if title_match else topic
+        title = title_match.group(1).strip() if title_match else topic
         
+        # Generate image
         status_updates.append("🖼️ Generating featured image...")
-        image_path, image_msg = generate_featured_image(topic)
-        status_updates.append(image_msg)
+        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, download_filename = create_download_file(blog_content, title, author_name)
+        file_path = create_download_file(blog_content, title, author_name)
         status_updates.append("✅ Download ready!")
         
-        if publish_option != "none":
-            status_updates.append(f"📮 Publishing to {publish_option}...")
-            # Add publishing logic here
+        return blog_content, title, "\n".join(status_updates), file_path
         
-        return blog_content, title, "\n".join(status_updates), (file_path, download_filename) if file_path else None
-    
     except Exception as e:
-        status_updates.append(f"❌ Error: {str(e)}")
-        return blog_content, title if 'title' in locals() else "", "\n".join(status_updates), None
+        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 & Publisher")
-    gr.Markdown("Generate professional blog posts with AI and export as Markdown")
+    gr.Markdown("# 📝 AI Blog Generator")
     
     with gr.Row():
         with gr.Column(scale=1):
-            topic_input = gr.Textbox(label="Blog Topic", placeholder="Enter your blog topic...")
+            topic_input = gr.Textbox(label="Blog Topic")
             tone_input = gr.Dropdown(
+                ["professional", "casual", "technical", "storytelling"],
                 label="Writing Style",
-                choices=["professional", "casual", "technical", "storytelling"],
                 value="professional"
             )
             length_input = gr.Dropdown(
+                ["short", "medium", "long"],
                 label="Article Length",
-                choices=["short", "medium", "long"],
                 value="medium"
             )
-            author_input = gr.Textbox(label="Author Name", placeholder="John Doe")
-            
-            with gr.Accordion("⚙️ Publishing Options", open=False):
-                publish_option = gr.Radio(
-                    label="Publish Destination",
-                    choices=["none", "linkedin", "huggingface", "both"],
-                    value="none"
-                )
-                linkedin_user = gr.Textbox(label="LinkedIn Email", visible=False)
-                linkedin_pass = gr.Textbox(label="LinkedIn Password", type="password", visible=False)
-                hf_token = gr.Textbox(label="Hugging Face Token", type="password", visible=False)
-                
-                def update_publish_fields(choice):
-                    linkedin_vis = choice in ["linkedin", "both"]
-                    hf_vis = choice in ["huggingface", "both"]
-                    return [
-                        gr.update(visible=linkedin_vis),
-                        gr.update(visible=linkedin_vis),
-                        gr.update(visible=hf_vis)
-                    ]
-                publish_option.change(update_publish_fields, publish_option, [linkedin_user, linkedin_pass, hf_token])
-            
-            generate_btn = gr.Button("Generate Blog", variant="primary")
+            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(label="Blog Content", show_label=False)
-            status_output = gr.Textbox(label="Status", interactive=False)
-            download_output = gr.File(
-                label="Download Blog",
-                visible=False,
-                file_types=[".md"],
-                file_count="single"
-            )
-    
+            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, publish_option, linkedin_user, linkedin_pass, hf_token],
+        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()
+    app.launch(share=False)