Update app.py

app.py

@@ -7,57 +7,11 @@ import queue
 import threading
 import os
 
-analysis_text = """
-Stage 1: Ground-Based Spin-Up and Launch Initiation
-• Concept:
-A large, energy‑efficient, electrically powered centrifuge is built on the ground. This “spin launcher” uses renewable energy (for example, solar‐assisted electricity) to accelerate a specially designed payload assembly along a rotating arm or in a long circular tunnel.
-• Benefits:
-Because most of the kinetic energy is imparted mechanically (rather than via chemical propellant), the system drastically reduces the need for traditional, polluting rocket propellants. This stage is also relatively low‑cost because the “engine” is essentially an electromagnetic drive rather than a rocket motor.
-
-Stage 2: Controlled Payload Release and Orbital Injection
-• Concept:
-At a pre‑calculated high tangential velocity, the payload is released from the spin launcher. A very short, minimal‐burn liquid or electric thruster (if needed) “tunes” the trajectory so that the payload enters a stable, low‑Earth orbit.
-• Benefits:
-The primary acceleration is mechanical, so only a tiny amount of propellant is required for orbital insertion. This greatly cuts both cost and the environmental impact typically associated with rocket launches.
-
-Stage 3: Autonomous On-Orbit Stabilization and Despinning
-• Concept:
-Once in orbit, the payload’s onboard guidance and control systems (such as small reaction control thrusters or a yo-yo de-spin mechanism) despin and stabilize the payload. Integrated sensors and attitude-control software adjust the payload’s orientation and gently circularize the orbit.
-• Benefits:
-Autonomous stabilization minimizes additional propellant use and prepares the payload for a safe, predictable rendezvous. The controlled despinning ensures that the payload’s docking adapter remains in the proper orientation for subsequent attachment.
-
-Stage 4: Rendezvous and Docking with the Manned Vehicle
-• Concept:
-A separately launched or pre‑positioned manned spacecraft (or space station) maneuvers to intercept the payload. The payload is equipped with a dedicated docking adapter (for instance, a magnetic or mechanical latch system engineered for high-precision contact under low‑g conditions).
-• Benefits:
-This phase uses conventional low‑delta‑V maneuvers that are far less expensive than a full chemical orbital insertion burn. The docking system is designed to absorb minor mismatches in velocity or attitude, allowing the crew to safely “hook on” to the payload. This minimizes extra propellant usage during the rendezvous phase.
-
-Stage 5: Integrated Mission Operations and Continued Space Activity
-• Concept:
-Once docked, the combined system—the manned vehicle with the attached spin-delivered payload—continues its mission. The payload might provide additional resources (such as extra fuel, scientific instruments, or habitat modules) that augment the manned vehicle’s capabilities.
-• Benefits:
-With the payload permanently attached, mission operations (such as orbital adjustments, inter-station transfers, or even on-orbit assembly of larger structures) proceed with enhanced capabilities. The system’s reliance on mechanical acceleration for the bulk of the launch cut both launch costs and the environmental footprint, leaving only minor orbital maneuvers to be performed with conventional thrusters.
-
-Summary
-This five-stage system marries a ground-based spin acceleration concept with in-space docking and integration to achieve a “propellant-light” method for delivering payloads into orbit. By using a spin launcher to achieve high velocity on the ground (Stage 1) and minimizing onboard chemical propellant (Stage 2), the payload is inserted into orbit economically and with reduced environmental impact. On-orbit stabilization (Stage 3) prepares it for rendezvous with a manned vehicle (Stage 4), after which the combined system carries out the mission (Stage 5).
-
-"""
-
-summary_txt = """
-
-Summary
-This five-stage system marries a ground-based spin acceleration concept with in-space docking and integration to achieve a “propellant-light” method for delivering payloads into orbit. By using a spin launcher to achieve high velocity on the ground (Stage 1) and minimizing onboard chemical propellant (Stage 2), the payload is inserted into orbit economically and with reduced environmental impact. On-orbit stabilization (Stage 3) prepares it for rendezvous with a manned vehicle (Stage 4), after which the combined system carries out the mission (Stage 5).
-
-
-"""
-
 class AgentMessageQueue:
     def __init__(self):
         self.message_queue = queue.Queue()
-        self.last_agent = None
 
     def add_message(self, message: Dict):
-        print(f"Adding message to queue: {message}")  # Debug print
         self.message_queue.put(message)
 
     def get_messages(self) -> List[Dict]:
@@ -66,15 +20,14 @@ class AgentMessageQueue:
             messages.append(self.message_queue.get())
         return messages
 
-class ArticleCrew:
+class PressReleaseCrew:
     def __init__(self, api_key: str = None):
         self.api_key = api_key
         self.message_queue = AgentMessageQueue()
-        self.planner = None
+        self.researcher = None
         self.writer = None
         self.editor = None
         self.current_agent = None
-        self.final_article = None
 
     def initialize_agents(self, topic: str):
         if not self.api_key:
@@ -83,95 +36,88 @@ class ArticleCrew:
         os.environ["OPENAI_API_KEY"] = self.api_key
         llm = ChatOpenAI(temperature=0.7, model="gpt-4")
 
-        self.planner = Agent(
-            role="Content Planner",
-            goal=f"Plan engaging and factually accurate content on {topic}",
-            backstory="Expert content planner with focus on creating engaging outlines",
+        self.researcher = Agent(
+            role="News Researcher",
+            goal=f"Gather critical details and facts for a press release about {topic}",
+            backstory="An experienced journalist who specializes in gathering news and structuring press releases.",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
         self.writer = Agent(
-            role="Content Writer",
-            goal=f"Write insightful and factually accurate piece about {topic}",
-            backstory="Expert content writer with focus on engaging articles",
+            role="Press Release Writer",
+            goal=f"Draft a compelling and structured press release about {topic}",
+            backstory="A seasoned news writer with expertise in crafting clear and engaging press releases.",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
         self.editor = Agent(
-            role="Editor",
-            goal="Polish and refine the article",
-            backstory="Expert editor with eye for detail and clarity",
+            role="News Editor",
+            goal="Refine and finalize the press release for accuracy and professionalism.",
+            backstory="A skilled editor with an eye for clarity, conciseness, and journalistic integrity.",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
     def create_tasks(self, topic: str) -> List[Task]:
-        planner_task = Task(
-            description=f"""Create a detailed content plan for an article about {topic} by:
-1. Prioritizing the latest trends, key players, and noteworthy news
-2. Identifying the target audience, considering their interests and pain points
-3. Developing a detailed content outline including introduction, key points, and call to action
-4. Including SEO keywords and relevant data or sources""",
-            expected_output="A comprehensive content plan with outline, keywords, and target audience analysis",
-            agent=self.planner
+        researcher_task = Task(
+            description=f"""As a news researcher, compile essential details for a press release on {topic} by:
+1. Identifying key facts, statistics, and industry trends
+2. Structuring the information into a brief, clear outline
+3. Suggesting a compelling press release headline""",
+            expected_output="A structured summary with key facts, statistics, and a proposed headline.",
+            agent=self.researcher
         )
 
         writer_task = Task(
-            description="""Based on the provided content plan:
-1. Use the content plan to craft a compelling blog post
-2. Incorporate SEO keywords naturally
-3. Ensure sections/subtitles are properly named in an engaging manner
-4. Create proper structure with introduction, body, and conclusion
-5. Proofread for grammatical errors""",
-            expected_output="A well-written article draft following the content plan",
+            description="""Using the research provided:
+1. Write a clear and engaging press release following a journalistic structure
+2. Ensure it includes a compelling headline, subheading, lead paragraph, supporting details, and a boilerplate
+3. Maintain a professional and neutral tone""",
+            expected_output="A structured press release draft ready for editing.",
             agent=self.writer
         )
 
         editor_task = Task(
-            description="""Review the written article by:
-1. Checking for clarity and coherence
-2. Correcting any grammatical errors and typos
-3. Ensuring consistent tone and style
-4. Verifying proper formatting and structure""",
-            expected_output="A polished, final version of the article ready for publication",
+            description="""Review and refine the press release by:
+1. Checking for clarity, conciseness, and accuracy
+2. Ensuring proper journalistic tone and structure
+3. Correcting any grammatical or formatting issues""",
+            expected_output="A polished, publication-ready press release.",
             agent=self.editor
         )
 
-        return [planner_task, writer_task, editor_task]
+        return [researcher_task, writer_task, editor_task]
 
-    async def process_article(self, topic: str) -> Generator[List[Dict], None, None]:
-        def add_agent_messages(agent_name: str, tasks: str, emoji: str = "🤖"):
-            # Add agent header
+    async def process_press_release(self, topic: str) -> Generator[List[Dict], None, None]:
+        def add_agent_messages(agent_name: str, tasks: str, emoji: str = "📰"):
             self.message_queue.add_message({
                 "role": "assistant",
                 "content": agent_name,
                 "metadata": {"title": f"{emoji} {agent_name}"}
             })
-            
-            # Add task description
             self.message_queue.add_message({
                 "role": "assistant",
                 "content": tasks,
-                "metadata": {"title": f"🚀 Task for {agent_name}"}
+                "metadata": {"title": f"📄 Task for {agent_name}"}
             })
 
         def setup_next_agent(current_agent: str) -> None:
             agent_sequence = {
-                "Content Planner": ("Content Writer", """1. Use the content plan to craft a compelling blog post
-2. Incorporate SEO keywords naturally
-3. Ensure sections/subtitles are properly named in an engaging manner
-4. Create proper structure with introduction, body, and conclusion
-5. Proofread for grammatical errors"""),
+                "News Researcher": ("Press Release Writer", """Write a structured and engaging press release including:
+1. A compelling headline and subheading
+2. A strong lead paragraph
+3. Supporting details and key statistics
+4. A conclusion with a call to action or company statement"""),
                 
-                "Content Writer": ("Editor", """1. Review the article for clarity and coherence
-2. Check for grammatical errors and typos
-3. Ensure consistent tone and style
-4. Verify proper formatting and structure""")
+                "Press Release Writer": ("News Editor", """Review and refine the press release for:
+1. Clarity and conciseness
+2. Proper journalistic tone and structure
+3. Grammatical accuracy and formatting""")
             }
 
             if current_agent in agent_sequence:
@@ -179,78 +125,48 @@ class ArticleCrew:
                 self.current_agent = next_agent
                 add_agent_messages(next_agent, tasks)
 
-
         def task_callback(task_output) -> None:
-            print(f"Task callback received: {task_output}")  # Debug print
+            raw_output = task_output.raw.strip()
             
-            # Extract content from raw output
-            raw_output = task_output.raw
-            if "## Final Answer:" in raw_output:
-                content = raw_output.split("## Final Answer:")[1].strip()
-            else:
-                content = raw_output.strip()
-            
-            # Handle the output based on current agent
-            if self.current_agent == "Editor":
-                # Don't show editor's output with metadata
-                # Instead, show completion message and final article
+            if self.current_agent == "News Editor":
                 self.message_queue.add_message({
                     "role": "assistant",
-                    "content": "Final article is ready!",
-                    "metadata": {"title": "📝 Final Article"}
+                    "content": "Final press release is ready!",
+                    "metadata": {"title": "📝 Final Press Release"}
                 })
-                
-                # Convert common markdown patterns to Gradio-compatible markdown
-                formatted_content = content
-                # Ensure proper spacing for headers
-                formatted_content = formatted_content.replace("\n#", "\n\n#")
-                # Ensure proper spacing for lists
-                formatted_content = formatted_content.replace("\n-", "\n\n-")
-                formatted_content = formatted_content.replace("\n*", "\n\n*")
-                formatted_content = formatted_content.replace("\n1.", "\n\n1.")
-                # Ensure proper spacing for paragraphs
-                formatted_content = formatted_content.replace("\n\n\n", "\n\n")
-                
-                # Add the final article content without metadata
                 self.message_queue.add_message({
                     "role": "assistant",
-                    "content": formatted_content
+                    "content": raw_output
                 })
             else:
-                # For other agents, show their output with metadata
                 self.message_queue.add_message({
                     "role": "assistant",
-                    "content": content,
-                    "metadata": {"title": f"✨ Output from {self.current_agent}"}
+                    "content": raw_output,
+                    "metadata": {"title": f"📰 Output from {self.current_agent}"}
                 })
-                # Setup next agent
                 setup_next_agent(self.current_agent)
 
         def step_callback(output: Any) -> None:
-            print(f"Step callback received: {output}")  # Debug print
-            # We'll only use step_callback for logging purposes now
             pass
 
         try:
             self.initialize_agents(topic)
-            self.current_agent = "Content Planner"
+            self.current_agent = "News Researcher"
 
-            # Start process
             yield [{
                 "role": "assistant",
-                "content": "Starting work on your launch article...",
-                "metadata": {"title": "🚀 Process Started"}
+                "content": "Starting press release preparation...",
+                "metadata": {"title": "🚀 Press Release Process Started"}
             }]
 
-            # Initialize first agent
-            add_agent_messages("Content Planner", 
-                """1. Prioritize the latest trends, key players, and noteworthy news
-2. Identify the target audience, considering their interests and pain points
-3. Develop a detailed content outline including introduction, key points, and call to action
-4. Include SEO keywords and relevant data or sources""")
+            add_agent_messages("News Researcher", 
+                """Gather essential details for a press release:
+1. Identify key facts, statistics, and industry trends
+2. Structure information into a brief outline
+3. Suggest a compelling headline""")
 
             crew = Crew(
-                agents=[self.planner, self.writer, self.editor],
+                agents=[self.researcher, self.writer, self.editor],
                 tasks=self.create_tasks(topic),
                 verbose=True,
                 step_callback=step_callback,
@@ -261,7 +177,6 @@ class ArticleCrew:
                 try:
                     crew.kickoff()
                 except Exception as e:
-                    print(f"Error in crew execution: {str(e)}")  # Debug print
                     self.message_queue.add_message({
                         "role": "assistant",
                         "content": f"An error occurred: {str(e)}",
@@ -274,99 +189,58 @@ class ArticleCrew:
             while thread.is_alive() or not self.message_queue.message_queue.empty():
                 messages = self.message_queue.get_messages()
                 if messages:
-                    print(f"Yielding messages: {messages}")  # Debug print
                     yield messages
                 await asyncio.sleep(0.1)
 
         except Exception as e:
-            print(f"Error in process_article: {str(e)}")  # Debug print
             yield [{
                 "role": "assistant",
                 "content": f"An error occurred: {str(e)}",
                 "metadata": {"title": "❌ Error"}
             }]
 
-# [Rest of the code remains the same]
-
-
 def create_demo():
-    article_crew = None
+    press_release_crew = None
 
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🚀 AI Space Launch Crew")
+        gr.Markdown("# 📰 AI Newsroom - Press Release Generator")
         
         openai_api_key = gr.Textbox(
             label='OpenAI API Key',
             type='password',
-            placeholder='Enter your OpenAI API key...',
-            interactive=True
+            placeholder='Enter your OpenAI API key...'
         )
 
         chatbot = gr.Chatbot(
-            label="Writing Process",
+            label="Press Release Process",
             height=700,
             type="messages",
-            show_label=True,
-            visible=False,
-            avatar_images=(None, "https://avatars.githubusercontent.com/u/170677839?v=4"),
-            render_markdown=True  # Enable markdown rendering
+            show_label=True
         )
 
-        with gr.Row(equal_height=True):
-            topic = gr.Textbox(
-                label="Launch Topic",
-                placeholder="Enter topic...",
-                scale=4,
-                visible=False
-            )
-            btn = gr.Button("Write Article", variant="primary", scale=1, visible=False)
+        topic = gr.Textbox(
+            label="Press Release Topic",
+            placeholder="Enter topic..."
+        )
+        btn = gr.Button("Generate Press Release", variant="primary")
 
         async def process_input(topic, history, api_key):
-            nonlocal article_crew
+            nonlocal press_release_crew
             if not api_key:
-                history = history or []
-                history.append({
-                    "role": "assistant",
-                    "content": "Please provide an OpenAI API key.",
-                    "metadata": {"title": "❌ Error"}
-                })
-                yield history
+                yield history + [{"role": "assistant", "content": "Please provide an OpenAI API key."}]
                 return
 
-            if article_crew is None:
-                article_crew = ArticleCrew(api_key=api_key)
-
-            history = history or []
-            history.append({"role": "user", "content": f"Write an article about: {topic}"})
-            yield history
+            if press_release_crew is None:
+                press_release_crew = PressReleaseCrew(api_key=api_key)
 
-            try:
-                async for messages in article_crew.process_article(topic):
-                    history.extend(messages)
-                    yield history
-            except Exception as e:
-                history.append({
-                    "role": "assistant",
-                    "content": f"An error occurred: {str(e)}",
-                    "metadata": {"title": "❌ Error"}
-                })
-                yield history
-
-        def show_interface():
-            return {
-                openai_api_key: gr.Textbox(visible=False),
-                chatbot: gr.Chatbot(visible=True),
-                topic: gr.Textbox(visible=True),
-                btn: gr.Button(visible=True)
-            }
+            async for messages in press_release_crew.process_press_release(topic):
+                yield messages
 
-        openai_api_key.submit(show_interface, None, [openai_api_key, chatbot, topic, btn])
         btn.click(process_input, [topic, chatbot, openai_api_key], [chatbot])
-        topic.submit(process_input, [topic, chatbot, openai_api_key], [chatbot])
 
     return demo
 
 if __name__ == "__main__":
     demo = create_demo()
     demo.queue()
-    demo.launch(debug=True)
+    demo.launch(debug=True)