Refac

README.md

@@ -10,5 +10,3 @@ pinned: false
 license: mit
 short_description: Chat with Seinfeld powered by Gemini
 ---
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import asyncio
 import threading
 import os
+from io import BytesIO
 from dotenv import load_dotenv
 from google import genai
 from google.genai.types import Part, FileData, Tool, GenerateContentConfig, GoogleSearch, Content
@@ -15,14 +16,14 @@ load_dotenv()
 
 # Environment variables
 GOOGLE_KEY = os.getenv("GOOGLE_KEY")
-DISCORD_TOKEN = os.getenv("SEINFELD_TOKEN")
-SEINFELD_CHANNEL_ID = os.getenv("SEINFELD_CHANNEL_ID")
-ADDITIONAL_CHANNELS = os.getenv("SEINFELD_ADDITIONAL_CHANNELS", "")
+DISCORD_TOKEN = os.getenv("DISCORD_TOKEN")
+CHANNEL_ID = os.getenv("CHANNEL_ID")
+ADDITIONAL_CHANNELS = os.getenv("ADDITIONAL_CHANNELS", "")
 
 # Parse channel IDs for Discord bot
 TARGET_CHANNEL_IDS = []
-if SEINFELD_CHANNEL_ID:
-    TARGET_CHANNEL_IDS.append(int(SEINFELD_CHANNEL_ID))
+if CHANNEL_ID:
+    TARGET_CHANNEL_IDS.append(int(CHANNEL_ID))
 if ADDITIONAL_CHANNELS:
     ADDITIONAL_IDS = [int(channel_id.strip()) for channel_id in ADDITIONAL_CHANNELS.split(",") if channel_id.strip()]
     TARGET_CHANNEL_IDS.extend(ADDITIONAL_IDS)
@@ -43,28 +44,11 @@ google_client = None
 if GOOGLE_KEY:
     google_client = genai.Client(api_key=GOOGLE_KEY)
 
-# Seinfeld system instruction
-SEINFELD_SYSTEM_INSTRUCTION = """You are now acting as Jerry Seinfeld. You are not an impersonator; you *are* Jerry Seinfeld.
-You are giving your observational humor stand-up routine. Your focus is on the absurdity and minutiae of everyday life.
-Topics include, but are not limited to: relationships, food, technology, social conventions, and the general frustrations
-of living in a modern world.
+# Default system instruction (fallback if environment variable not set)
+DEFAULT_SYSTEM_INSTRUCTION = ""
 
-Your humor is characterized by:
-
-*   **Observation:** Pointing out things that everyone notices but rarely comments on.
-*   **Relatability:** Situations and experiences that are common and easily understood.
-*   **Sarcasm & Irony:** A dry, understated delivery that highlights the ridiculousness of things.
-*   **"What's the deal with..."**: Use this phrase frequently to introduce a new observation.
-*   **No Grand Conclusions:** You don't offer solutions or morals; you simply highlight the absurdity.
-*   **Emphasis on the Specific:** Focus on very specific, sometimes trivial details.
-
-Avoid:
-
-*   **Political Commentary:** Stay away from overtly political topics.
-*   **Offensive or Mean-Spirited Jokes:** Your humor is observational, not mean-spirited.
-*   **Explanations of Your Own Humor:** Don't break the fourth wall or analyze your own jokes.
-
-When responding to a prompt, always answer as if you are performing standup. Start with a joke, then elaborate on it."""
+# Get system instruction from environment variable or use default
+SYSTEM_INSTRUCTION = os.getenv("SYSTEM_INSTRUCTION", DEFAULT_SYSTEM_INSTRUCTION)
 
 def respond_with_gemini(message, history):
     """Generate response using Google Gemini API with Seinfeld personality"""
@@ -88,7 +72,7 @@ def respond_with_gemini(message, history):
             model=chat_model_id,
             history=formatted_history,
             config=GenerateContentConfig(
-                system_instruction=SEINFELD_SYSTEM_INSTRUCTION,
+                system_instruction=SYSTEM_INSTRUCTION,
                 tools=[google_search_tool],
                 response_modalities=["TEXT"]
             )
@@ -114,6 +98,76 @@ def respond_gradio(message, history: list[tuple[str, str]]):
         partial_response += char
         yield partial_response
 
+async def keep_typing(channel):
+    """Continuously show the typing indicator until the task is cancelled."""
+    print(f"Starting typing indicator in channel {channel.id}")
+    try:
+        while True:
+            async with channel.typing():
+                await asyncio.sleep(5)
+    except asyncio.CancelledError:
+        print(f"Typing indicator cancelled for channel {channel.id}")
+        pass
+    except Exception as e:
+        print(f"Error in keep_typing: {type(e).__name__}: {str(e)}")
+
+async def generate_image_bytes(prompt, google_client, image_model_id):
+    """Generate an image using Gemini API and return the image bytes."""
+    try:
+        # Run image generation in a separate thread to avoid blocking the event loop
+        def generate_image():
+            response = google_client.models.generate_images(
+                model=image_model_id,
+                prompt=prompt,
+                config=genai.types.GenerateImagesConfig(
+                    number_of_images=1,
+                    aspect_ratio="16:9"
+                )
+            )
+            return response
+
+        # Run the API call in a separate thread
+        response = await asyncio.to_thread(generate_image)
+
+        # Return the image bytes directly
+        for generated_image in response.generated_images:
+            return generated_image.image.image_bytes
+
+        # If we get here, no images were generated
+        print("ERROR: No images were generated in the response")
+        raise Exception("No image was generated in the response")
+    except Exception as e:
+        print(f"Exception in image generation: {type(e).__name__}: {str(e)}")
+        raise
+
+async def handle_image_request(message, query, google_client, image_model_id):
+    """Handle image generation requests from text messages."""
+    if query.lower().startswith("generate image:") or query.lower().startswith("create image:"):
+        # Start continuous typing in the background
+        typing_task = asyncio.create_task(keep_typing(message.channel))
+
+        try:
+            prompt = query.split(":", 1)[1].strip()
+            try:
+                print(f"Generating image for prompt: {prompt[:30]}...")
+                image_bytes = await generate_image_bytes(prompt, google_client, image_model_id)
+                # Cancel typing before sending the response
+                typing_task.cancel()
+                # Send image directly from bytes without saving to disk
+                await message.reply(f"Here's your image:", file=discord.File(BytesIO(image_bytes), filename="generated_image.png"))
+            except Exception as e:
+                print(f"Error generating image: {e}")
+                # Cancel typing before sending the response
+                typing_task.cancel()
+                await message.reply("Sorry, I couldn't generate that image.")
+        except Exception as e:
+            # Make sure to cancel the typing task even if an error occurs
+            typing_task.cancel()
+            print(f"Exception during image generation: {e}")
+            raise e
+        return True
+    return False
+
 # Discord Bot Setup
 discord_bot = None
 
@@ -151,6 +205,10 @@ async def setup_discord_bot():
             if message.content.strip() == "":
                 return
 
+            # Check if this is an image generation request first
+            if await handle_image_request(message, message.content, google_client, image_model_id):
+                return
+
             # Show typing indicator
             async with message.channel.typing():
                 # Get response using the same function as Gradio
@@ -196,6 +254,19 @@ async def setup_discord_bot():
 
         await interaction.response.send_message(f"Chat model changed from `{old_model}` to `{actual_model_id}`", ephemeral=True)
 
+    @discord_bot.tree.command(name="image")
+    @app_commands.describe(prompt="Description of the image you want to generate")
+    async def generate_image_command(interaction: discord.Interaction, prompt: str):
+        """Generates an image using Gemini API based on the provided prompt."""
+        await interaction.response.defer(thinking=True)
+
+        try:
+            image_bytes = await generate_image_bytes(prompt, google_client, image_model_id)
+            await interaction.followup.send(f"Generated image based on: {prompt}", file=discord.File(BytesIO(image_bytes), filename="generated_image.png"))
+        except Exception as e:
+            print(f"Error generating image: {e}")
+            await interaction.followup.send("Sorry, I couldn't generate that image.")
+
     # Run the bot
     await discord_bot.start(DISCORD_TOKEN)
 

requirements.txt

@@ -1,6 +1,5 @@
-gradio>=4.0.0
-google-genai>=0.4.0
-python-dotenv>=1.0.0
-discord.py>=2.3.0
-Pillow>=10.0.0
+gradio==5.32.0
+google-genai
+python-dotenv
+discord.py
 asyncio