Update app.py

app.py

@@ -4,22 +4,27 @@ import logging
 from typing import Optional, List, Union, Literal
 from pathlib import Path
 from pydantic import BaseModel, Field
-from gradio import Interface, Blocks, Component
+from gradio import Interface, Blocks
+from gradio.components import Textbox, Image
 from gradio.data_classes import FileData, GradioModel, GradioRootModel
 from transformers import pipeline
 from diffusers import DiffusionPipeline
 import torch
 import gradio as gr
 
-# Load gated image model
+# Load gated image model securely
+hf_token = os.getenv("HUGGINGFACE_TOKEN")
+if not hf_token:
+    raise RuntimeError("Missing HUGGINGFACE_TOKEN env var for gated model access.")
+
 image_model = DiffusionPipeline.from_pretrained(
     "black-forest-labs/FLUX.1-dev",
     torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
-    use_auth_token=os.getenv("HUGGINGFACE_TOKEN")
+    use_auth_token=hf_token
 )
 image_model.enable_model_cpu_offload()
 
-# Define data models
+# Data models
 class FileDataDict(BaseModel):
     path: str
     url: Optional[str] = None
@@ -31,7 +36,7 @@ class FileDataDict(BaseModel):
         arbitrary_types_allowed = True
 
 class MessageDict(BaseModel):
-    content: Union[str, FileDataDict, tuple, Component]
+    content: Union[str, FileDataDict, tuple, str]
     role: Literal["user", "assistant", "system"]
     metadata: Optional[dict] = None
     options: Optional[List[dict]] = None
@@ -40,7 +45,7 @@ class MessageDict(BaseModel):
 
 class ChatMessage(GradioModel):
     role: Literal["user", "assistant", "system"]
-    content: Union[str, FileData, Component]
+    content: Union[str, FileData, str]
     metadata: dict = Field(default_factory=dict)
     options: Optional[List[dict]] = None
     class Config:
@@ -49,31 +54,15 @@ class ChatMessage(GradioModel):
 class ChatbotDataMessages(GradioRootModel):
     root: List[ChatMessage]
 
-# Universal Reasoning Aggregator
+# Reasoning Engine
 class UniversalReasoning:
     def __init__(self, config):
         self.config = config
         self.context_history = []
         self.sentiment_analyzer = pipeline("sentiment-analysis")
-
-        self.deepseek_model = pipeline(
-            "text-classification",
-            model="distilbert-base-uncased-finetuned-sst-2-english",
-            truncation=True
-        )
-
-        self.davinci_model = pipeline(
-            "text2text-generation",
-            model="t5-small",
-            truncation=True
-        )
-
-        self.additional_model = pipeline(
-            "text-generation",
-            model="EleutherAI/gpt-neo-125M",
-            truncation=True
-        )
-
+        self.deepseek_model = pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english")
+        self.davinci_model = pipeline("text2text-generation", model="t5-small")
+        self.additional_model = pipeline("text-generation", model="EleutherAI/gpt-neo-125M")
         self.image_model = image_model
 
     async def generate_response(self, question: str) -> str:
@@ -87,7 +76,7 @@ class UniversalReasoning:
             f"Sentiment score: {sentiment_score}",
             f"DeepSeek Response: {deepseek_response}",
             f"T5 Response: {davinci_response}",
-            f"Additional Model Response: {additional_response}"
+            f"GPT-Neo Response: {additional_response}"
         ]
         return "\n\n".join(responses)
 
@@ -98,7 +87,6 @@ class UniversalReasoning:
             width=1024,
             guidance_scale=3.5,
             num_inference_steps=50,
-            max_sequence_length=512,
             generator=torch.Generator('cpu').manual_seed(0)
         ).images[0]
         image.save("flux-dev.png")
@@ -109,63 +97,39 @@ class UniversalReasoning:
         logging.info(f"Sentiment analysis result: {sentiment_score}")
         return sentiment_score
 
-# Main Component
-class MultimodalChatbot(Component):
-    def __init__(
-        self,
-        value: Optional[List[MessageDict]] = None,
-        label: Optional[str] = None,
-        render: bool = True,
-        log_file: Optional[Path] = None,
-    ):
-        value = value or []
-        super().__init__(label=label, value=value)
-        self.log_file = log_file
-        self.render = render
-        self.data_model = ChatbotDataMessages
-        self.universal_reasoning = UniversalReasoning({})
-
-    def preprocess(self, payload: Optional[ChatbotDataMessages]) -> List[MessageDict]:
-        return payload.root if payload else []
-
-    def postprocess(self, messages: Optional[List[MessageDict]]) -> ChatbotDataMessages:
-        messages = messages or []
-        return ChatbotDataMessages(root=messages)
-
-# Gradio Interface
+# Main Gradio App
 class HuggingFaceChatbot:
     def __init__(self):
-        self.chatbot = MultimodalChatbot(value=[])
+        self.universal_reasoning = UniversalReasoning(config={})
 
     def setup_interface(self):
         async def chatbot_logic(input_text: str) -> str:
-            return await self.chatbot.universal_reasoning.generate_response(input_text)
+            return await self.universal_reasoning.generate_response(input_text)
 
         def image_logic(prompt: str):
-            return self.chatbot.universal_reasoning.generate_image(prompt)
+            return self.universal_reasoning.generate_image(prompt)
 
-        interface = Interface(
+        text_interface = Interface(
             fn=chatbot_logic,
-            inputs="text",
-            outputs="text",
-            title="Hugging Face Multimodal Chatbot",
+            inputs=Textbox(label="Ask anything"),
+            outputs=Textbox(label="Reasoned Answer"),
+            title="🧠 Codettes-BlackForest Chatbot"
         )
 
         image_interface = Interface(
             fn=image_logic,
-            inputs="text",
-            outputs="image",
-            title="Image Generator",
+            inputs=Textbox(label="Describe an image"),
+            outputs=Image(label="Generated Image"),
+            title="🎨 Image Generator (FLUX.1-dev)"
         )
 
-        return Blocks([interface, image_interface])
+        return Blocks([text_interface, image_interface])
 
     def launch(self):
-        interface = self.setup_interface()
-        interface.launch()
+        app = self.setup_interface()
+        app.launch()
 
-# Standalone launch
+# Launch the app
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-    chatbot = HuggingFaceChatbot()
-    chatbot.launch()
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+    HuggingFaceChatbot().launch()