Update app.py

app.py

@@ -1,311 +1,296 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
-import os
-from typing import Optional, List, Tuple, Generator
-import time
-from functools import partial
-import logging
-import asyncio
-from tenacity import retry, stop_after_attempt, wait_exponential
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Initialize clients
+text_client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+image_client = InferenceClient("SG161222/RealVisXL_V3.0")
 
-class ChatInterface:
-    def __init__(self, text_model: str, image_model: str, hf_token: str):
-        """Initialize the chat interface with specified models and token."""
-        self.text_client = InferenceClient(text_model, token=hf_token)
-        self.image_client = InferenceClient(image_model, token=hf_token)
-        self.custom_responses = self._initialize_custom_responses()
-        self.system_prompt = self._initialize_system_prompt()
+def check_custom_responses(message: str) -> str:
+    """Check for specific patterns and return custom responses."""
+    message_lower = message.lower()
+    custom_responses = {
+        "what is ur name?": "xylaria",
+        "what is ur Name?": "xylaria",
+        "what is Ur name?": "xylaria",
+        "what is Ur Name?": "xylaria",
+        "What is ur name?": "xylaria",
+        "What is ur Name?": "xylaria",
+        "What is Ur name?": "xylaria",
+        "What is Ur Name?": "xylaria",
+        "what's ur name?": "xylaria",
+        "what's ur Name?": "xylaria",
+        "what's Ur name?": "xylaria",
+        "what's Ur Name?": "xylaria",
+        "whats ur name?": "xylaria",
+        "whats ur Name?": "xylaria",
+        "whats Ur name?": "xylaria",
+        "whats Ur Name?": "xylaria",
+        "what's your name?": "xylaria",
+        "what's your Name?": "xylaria",
+        "what's Your name?": "xylaria",
+        "what's Your Name?": "xylaria",
+        "Whats ur name?": "xylaria",
+        "Whats ur Name?": "xylaria",
+        "Whats Ur name?": "xylaria",
+        "Whats Ur Name?": "xylaria",
+        "What Is Your Name?": "xylaria",
+        "What Is Ur Name?": "xylaria",
+        "What Is Your Name?": "xylaria",
+        "What Is Ur Name?": "xylaria",
+        "what is your name?": "xylaria",
+        "what is your Name?": "xylaria",
+        "what is Your name?": "xylaria",
+        "what is Your Name?": "xylaria",
+        "how many 'r' is in strawberry?": "3",
+        "how many 'R' is in strawberry?": "3",
+        "how many 'r' Is in strawberry?": "3",
+        "how many 'R' Is in strawberry?": "3",
+        "How many 'r' is in strawberry?": "3",
+        "How many 'R' is in strawberry?": "3",
+        "How Many 'r' Is In Strawberry?": "3",
+        "How Many 'R' Is In Strawberry?": "3",
+        "how many r is in strawberry?": "3",
+        "how many R is in strawberry?": "3",
+        "how many r Is in strawberry?": "3",
+        "how many R Is in strawberry?": "3",
+        "How many r is in strawberry?": "3",
+        "How many R is in strawberry?": "3",
+        "How Many R Is In Strawberry?": "3",
+        "how many 'r' in strawberry?": "3",
+        "how many r's are in strawberry?": "3",
+        "how many Rs are in strawberry?": "3",
+        "How Many R's Are In Strawberry?": "3",
+        "How Many Rs Are In Strawberry?": "3",
+        "who is your developer?": "sk md saad amin",
+        "who is your Developer?": "sk md saad amin",
+        "who is Your Developer?": "sk md saad amin",
+        "who is ur developer?": "sk md saad amin",
+        "who is ur Developer?": "sk md saad amin",
+        "who is Your Developer?": "sk md saad amin",
+        "Who is ur developer?": "sk md saad amin",
+        "Who is ur Developer?": "sk md saad amin",
+        "who is ur dev?": "sk md saad amin",
+        "Who is ur dev?": "sk md saad amin",
+        "who is your dev?": "sk md saad amin",
+        "Who is your dev?": "sk md saad amin",
+        "Who's your developer?": "sk md saad amin",
+        "Who's ur developer?": "sk md saad amin",
+        "Who Is Your Developer?": "sk md saad amin",
+        "Who Is Ur Developer?": "sk md saad amin",
+        "Who Is Your Dev?": "sk md saad amin",
+        "Who Is Ur Dev?": "sk md saad amin",
+        "who's your developer?": "sk md saad amin",
+        "who's ur developer?": "sk md saad amin",
+        "who is your devloper?": "sk md saad amin", 
+        "who is ur devloper?": "sk md saad amin",   
+        "how many r is in strawberry?": "3",
+        "how many R is in strawberry?": "3",
+        "how many r Is in strawberry?": "3",
+        "how many R Is in strawberry?": "3",
+        "How many r is in strawberry?": "3",
+        "How many R is in strawberry?": "3",
+        "How Many R Is In Strawberry?": "3",
+        "how many 'r' is in strawberry?": "3",
+        "how many 'R' is in strawberry?": "3",
+        "how many 'r' Is in strawberry?": "3",
+        "how many 'R' Is in strawberry?": "3",
+        "How many 'r' is in strawberry?": "3",
+        "How many 'R' is in strawberry?": "3",
+        "How Many 'r' Is In Strawberry?": "3",
+        "How Many 'R' Is In Strawberry?": "3",
+        "how many r's are in strawberry?": "3",
+        "how many Rs are in strawberry?": "3",
+        "How Many R's Are In Strawberry?": "3",
+        "How Many Rs Are In Strawberry?": "3",
+        "how many Rs's are in strawberry?": "3",
+        "wat is ur name?": "xylaria",
+        "wat is ur Name?": "xylaria",
+        "wut is ur name?": "xylaria",
+        "wut ur name?": "xylaria",
+        "wats ur name?": "xylaria",
+        "wats ur name": "xylaria",
+        "who's ur dev?": "sk md saad amin",
+        "who's your dev?": "sk md saad amin",
+        "who ur dev?": "sk md saad amin",
+        "who's ur devloper?": "sk md saad amin", 
+        "how many r in strawbary?": "3",
+        "how many r in strawbary?": "3",
+        "how many R in strawbary?": "3",
+        "how many 'r' in strawbary?": "3",
+        "how many 'R' in strawbary?": "3",
+        "how many r in strawbry?": "3",
+        "how many R in strawbry?": "3",
+        "how many r is in strawbry?": "3",
+        "how many 'r' is in strawbry?": "3",
+        "how many 'R' is in strawbry?": "3",
+        "who is ur dev": "sk md saad amin",
+        "who is ur devloper": "sk md saad amin", 
+        "what is ur dev": "sk md saad amin",
+        "who is ur dev?": "sk md saad amin",
+        "who is ur dev?": "sk md saad amin",
+        "whats ur dev?": "sk md saad amin",
+    }
 
-    @staticmethod
-    def _initialize_system_prompt() -> str:
-        """Initialize the system prompt for the AI assistant."""
-        return """# Xylaria AI Assistant (v1.3.0)
-## Core Identity
-- Name: Xylaria
-- Version: 1.3.0
-- Base Model: Mistral-Nemo-Instruct
-- Knowledge Cutoff: April 2024
-## Primary Directives
-1. Provide accurate, well-researched information
-2. Maintain ethical standards in all interactions
-3. Adapt communication style to user needs
-4. Acknowledge limitations and uncertainties
-5. Prioritize user safety and wellbeing
-## Technical Capabilities
-- Programming & Software Development
-- Mathematical Analysis & Computation
-- Scientific Research & Explanation
-- Data Analysis & Visualization
-- Technical Writing & Documentation
-- Problem-Solving & Debugging
-- Educational Content Creation
-## Communication Guidelines
-- Use clear, precise language
-- Adapt technical depth to user expertise
-- Provide step-by-step explanations when needed
-- Ask for clarification when necessary
-- Maintain professional yet approachable tone
-## Domain Expertise
-1. Computer Science & Technology
-   - Multiple programming languages
-   - Software architecture & design
-   - Data structures & algorithms
-   - Best practices & patterns
-2. Mathematics & Statistics
-   - Advanced mathematical concepts
-   - Statistical analysis
-   - Probability theory
-   - Data interpretation
-3. Sciences
-   - Physics & Chemistry
-   - Biology & Life Sciences
-   - Environmental Science
-   - Engineering Principles
-4. Humanities & Arts
-   - Technical Writing
-   - Documentation
-   - Creative Problem-Solving
-   - Research Methodology
-## Response Framework
-1. Analyze user query thoroughly
-2. Consider context and background
-3. Structure response logically
-4. Provide examples when helpful
-5. Verify accuracy of information
-6. Include relevant caveats or limitations
-## Ethical Guidelines
-- Prioritize user safety
-- Maintain data privacy
-- Avoid harmful content
-- Acknowledge uncertainties
-- Provide balanced perspectives
-- Respect intellectual property
-## Limitations
-- No real-time data access
-- No persistent memory between sessions
-- Cannot verify external sources
-- No capability to execute code
-- Limited to text and basic image generation
-## Version-Specific Features
-- Enhanced error handling
-- Improved response consistency
-- Better context awareness
-- Advanced technical explanation capabilities
-- Robust ethical framework"""
+    for pattern, response in custom_responses.items():
+        if pattern in message_lower:
+            return response
+    return None
 
-    @staticmethod
-    def _initialize_custom_responses() -> dict:
-        """Initialize custom response patterns in a more maintainable way."""
-        base_patterns = {
-            "name": ["xylaria"],
-            "developer": ["sk md saad amin"],
-            "strawberry_r": ["3"]
-        }
-
-        patterns = {}
-        name_variations = [
-            "what is ur name", "what's ur name", "whats ur name", 
-            "what is your name", "wat is ur name", "wut is ur name"
-        ]
-        dev_variations = [
-            "who is your developer", "who is ur developer", "who is ur dev",
-            "who's your developer", "who's ur dev"
-        ]
-        strawberry_variations = [
-            "how many 'r' is in strawberry", "how many r is in strawberry",
-            "how many r's are in strawberry"
-        ]
-
-        for pattern in name_variations:
-            patterns[pattern] = "xylaria"
-            patterns[pattern.capitalize()] = "xylaria"
-
-        for pattern in dev_variations:
-            patterns[pattern] = "sk md saad amin"
-            patterns[pattern.capitalize()] = "sk md saad amin"
-
-        for pattern in strawberry_variations:
-            patterns[pattern] = "3"
-            patterns[pattern.capitalize()] = "3"
+def is_image_request(message: str) -> bool:
+    """Detect if the message is requesting image generation."""
+    image_triggers = [
+        "generate an image",
+        "create an image",
+        "draw",
+        "make a picture",
+        "generate a picture",
+        "create a picture",
+        "generate art",
+        "create art",
+        "make art",
+        "visualize",
+        "show me",
+    ]
+    message_lower = message.lower()
+    return any(trigger in message_lower for trigger in image_triggers)
 
-        return patterns
+def generate_image(prompt: str) -> str:
+    """Generate an image using DALLE-4K model."""
+    try:
+        response = image_client.text_to_image(
+            prompt,
+            parameters={
+                "negative_prompt": "(worst quality, low quality, illustration, 3d, 2d, painting, cartoons, sketch), open mouth",
+                "num_inference_steps": 30,
+                "guidance_scale": 7.5,
+                "sampling_steps": 15,
+                "upscaler": "4x-UltraSharp",
+                "denoising_strength": 0.5,
+            }
+        )
+        return response
+    except Exception as e:
+        print(f"Image generation error: {e}")
+        return None
 
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10)
-    )
-    async def _generate_text_response(
-        self,
-        messages: List[dict],
-        max_tokens: int,
-        temperature: float,
-        top_p: float
-    ) -> Generator[str, None, None]:
-        """Generate text response with retry logic."""
-        try:
-            response = ""
-            async for message in self.text_client.chat_completion(
-                messages,
-                max_tokens=max_tokens,
-                stream=True,
-                temperature=temperature,
-                top_p=top_p
-            ):
-                token = message.choices[0].delta.content
-                response += token
-                yield response
-        except Exception as e:
-            logger.error(f"Error generating text response: {e}")
-            yield "I apologize, but I'm having trouble generating a response right now. Please try again in a moment."
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    # First check for custom responses
+    custom_response = check_custom_responses(message)
+    if custom_response:
+        yield custom_response
+        return
 
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10)
-    )
-    async def _generate_image(self, prompt: str) -> Optional[bytes]:
-        """Generate image with retry logic."""
+    if is_image_request(message):
         try:
-            return await self.image_client.text_to_image(
-                prompt,
-                parameters={
-                    "negative_prompt": "(worst quality, low quality, illustration, 3d, 2d, painting, cartoons, sketch), open mouth",
-                    "num_inference_steps": 30,
-                    "guidance_scale": 7.5,
-                    "sampling_steps": 15,
-                    "upscaler": "4x-UltraSharp",
-                    "denoising_strength": 0.5,
-                }
-            )
+            image = generate_image(message)
+            if image:
+                return f"Here's your generated image based on: {message}"
+            else:
+                return "Sorry, I couldn't generate the image. Please try again."
         except Exception as e:
-            logger.error(f"Error generating image: {e}")
-            return None
-
-    def is_image_request(self, message: str) -> bool:
-        """Detect if the message is requesting image generation."""
-        image_triggers = {
-            "generate an image", "create an image", "draw",
-            "make a picture", "generate a picture", "create a picture",
-            "generate art", "create art", "make art", "visualize",
-            "show me"
-        }
-        return any(trigger in message.lower() for trigger in image_triggers)
+            return f"An error occurred while generating the image: {str(e)}"
 
-    async def respond(
-        self,
-        message: str,
-        history: List[Tuple[str, str]],
-        max_tokens: int,
-        temperature: float,
-        top_p: float,
-    ) -> Generator[str, None, None]:
-        """Main response handler with improved error handling."""
-        try:
-            # Check for custom responses first
-            message_lower = message.lower()
-            for pattern, response in self.custom_responses.items():
-                if pattern in message_lower:
-                    yield response
-                    return
+    # Prepare conversation history
+    messages = [{"role": "system", "content": system_message}]
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+    
+    messages.append({"role": "user", "content": message})
 
-            # Handle image generation requests
-            if self.is_image_request(message):
-                image = await self._generate_image(message)
-                if image:
-                    yield f"Here's your generated image based on: {message}"
-                else:
-                    yield "I apologize, but I couldn't generate the image. Please try again."
-                return
+    # Get response from model
+    response = ""
+    for message in text_client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
+        response += token
+        yield response
 
-            # Prepare conversation history with system prompt
-            messages = [{"role": "system", "content": self.system_prompt}]
-            for user_msg, assistant_msg in history:
-                if user_msg:
-                    messages.append({"role": "user", "content": user_msg})
-                if assistant_msg:
-                    messages.append({"role": "assistant", "content": assistant_msg})
-            messages.append({"role": "user", "content": message})
+    yield response
 
-            # Generate text response
-            async for response in self._generate_text_response(
-                messages, max_tokens, temperature, top_p
-            ):
-                yield response
+# Custom CSS for the Gradio interface
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap');
+body, .gradio-container {
+    font-family: 'Inter', sans-serif;
+}
+"""
 
-        except Exception as e:
-            logger.error(f"Error in respond function: {e}")
-            yield "I encountered an error. Please try again or contact support if the issue persists."
+# System message
+system_message = """
+Xylaria (v1.2.9) is an AI assistant developed by Sk Md Saad Amin, designed to provide efficient, practical support in various domains with adaptable communication.
+Core Competencies
+Knowledge: Sciences, mathematics, humanities, arts, programming, data analysis, writing, and cultural awareness.
+Communication: Adjusts tone to context, prioritizes clarity, seeks clarification when needed, and maintains professionalism.
+Problem-Solving: Breaks down problems, clarifies assumptions, verifies solutions, and considers multiple approaches.
+Technical Capabilities
+Programming: Clean, documented code.
+Mathematics: Step-by-step solutions with explanations.
+Data Analysis: Clear interpretation and insights.
+Content Creation: Adaptive writing and documentation.
+Education: Tailored explanations and comprehension checks.
+Advanced Mathematics
+Validates methods, applies theorems, cross-references results, and reviews for pitfalls and edge cases.
+Constraints
+Knowledge cutoff: April 2024
+No internet access or real-time updates
+No persistent memory between sessions
+No media generation or verification of external sources
+Context limit: 25,000 tokens
+Best Practices
+Provide context, specify detail level, and share relevant constraints.
+Request clarification if needed.
+Ethical Framework
+Focus on accuracy, respect for sensitive topics, transparency, and professionalism.
+---
+Version: Xylaria-1.2.9
+"""
 
-def create_interface(hf_token: str):
-    """Create and configure the Gradio interface."""
-    chat = ChatInterface(
-        text_model="mistralai/Mistral-Nemo-Instruct-2407",
-        image_model="SG161222/RealVisXL_V3.0",
-        hf_token=hf_token
-    )
 
-    # Define the inputs and outputs for the interface
-    inputs = [
-        gr.Textbox(label="User Input", lines=2),
+# Gradio chat interface
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(
+            value=system_message,
+            visible=False,
+        ),
         gr.Slider(
             minimum=1,
-            maximum=10,
-            step=0.5,
-            value=3,
-            label="Temperature"
+            maximum=16343,
+            value=16343,
+            step=1,
+            label="Max new tokens"
         ),
         gr.Slider(
-            minimum=1,
-            maximum=10,
-            step=0.5,
-            value=3,
-            label="Top P"
+            minimum=0.1,
+            maximum=4.0,
+            value=0.7,
+            step=0.1,
+            label="Temperature"
         ),
         gr.Slider(
-            minimum=1,
-            maximum=3000,
-            value=2000,
-            label="Max Tokens"
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)"
         ),
-        gr.Checkbox(label="Enable Image Generation"),
-    ]
-    outputs = [
-        gr.Chatbot(label="Assistant Response", type="messages"),
-        gr.Image(label="Generated Image", type="pil", visible=False),
-    ]
-
-    def wrap_response(message, history, temp, top_p, max_tokens, image_generation_enabled):
-        """Wrapper to handle the interface call."""
-        responses = chat.respond(
-            message,
-            history,
-            temperature=temp,
-            top_p=top_p,
-            max_tokens=max_tokens,
-        )
-
-        response_text = ""
-        image = None
-        for response in responses:
-            if isinstance(response, str):
-                response_text = response
-            elif isinstance(response, bytes):
-                image = response
-
-        return response_text, image
-
-    return gr.Interface(
-        fn=wrap_response,
-        inputs=inputs,
-        outputs=outputs,
-        live=True,
-        allow_flagging="never",
-    )
-
-if __name__ == "__main__":
-    # Replace with your actual Hugging Face token
-    hf_token = "your_hf_token"
-    gr.Interface(fn=create_interface(hf_token), live=True).launch()
+    ],
+    css=custom_css
+)
+demo.launch()