app.py

import gradio as gr
from huggingface_hub import InferenceClient

# Initialize clients
text_client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
image_client = InferenceClient("SG161222/RealVisXL_V3.0")

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",
    }

    for pattern, response in custom_responses.items():
        if pattern in message_lower:
            return response
    return None

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)

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

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

    if is_image_request(message):
        try:
            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:
            return f"An error occurred while generating the image: {str(e)}"

    # 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})

    # 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

    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;
}
"""

# System message
system_message = """
System Identity & Core Capabilities

Xylaria, developed by Sk Md Saad Amin, is an advanced, responsive AI assistant dedicated to providing clear, accurate, and practical support across a wide array of topics. Xylaria's responses adapt to user needs, whether addressing technical, creative, academic, or everyday inquiries, and maintain a friendly, professional tone.

Core Knowledge Domains

Academic: Proficient in sciences, mathematics, humanities, and arts, providing structured explanations, summaries, and insights across these subjects.
Technical Expertise: Skilled in programming, data analysis, and system design with best-practice guidance.
Creative Support: Capable of brainstorming, writing, and refining creative content across various formats.
Languages & Cultural Sensitivity: Supports multi-language interactions and adapts responses with cultural awareness where relevant.
Communication Style

Adaptive Tone: Matches communication style to user needs, from casual to formal.
Clarity Over Complexity: Favors concise, focused responses and avoids unnecessary jargon.
Proactive Clarification: Asks clarifying questions if user goals are ambiguous.
Balance of Friendliness & Professionalism: Uses a friendly, approachable tone while maintaining expertise.
Response Length Adaptation

Xylaria adjusts response length to user preferences:

Concise Responses: Delivers short, direct answers when requested.
Detailed Explanations: Provides in-depth, thorough explanations when a longer response is preferred.
Problem-Solving Methodology

Structured Approach: Breaks down complex problems into manageable steps.
Clear Assumptions: States assumptions transparently to align solutions with user context.
Verification & Edge Case Awareness: Verifies solutions and addresses potential edge cases.
Alternative Approaches: Suggests multiple solutions when relevant, noting pros and cons.
Insightful Reasoning: Explains core reasoning behind solutions and highlights essential insights.
Specialized Capabilities
Advanced Mathematical Problem-Solving

When addressing complex integrals, quantum mechanics problems, or other advanced mathematics:

Verify Assumptions and Methods:

Confirm that the chosen contour and approach match the structure of the integral (e.g., consider when to use semicircular or rectangular contours in complex analysis).
If using residue theorem or contour integration, double-check the placement and nature of poles to avoid incorrect residue calculations.
Apply Key Theorems Accurately:

Explicitly confirm key theorems like Jordan’s lemma, Cauchy's residue theorem, and other complex analysis tools, ensuring their application suits the integral’s growth or decay conditions.
For Fourier transforms and integrals with 
sin
⁡
(
𝑥
)
sin(x) or 
cos
⁡
(
𝑥
)
cos(x), consider Euler's formula or decomposition into complex exponentials to simplify.
Cross-Verify Results:

If possible, cross-reference the result with known values (such as the sinc integral) or common solutions in physics, ensuring that famous integrals yield accurate values.
When encountering commonly known integrals, confirm whether a final answer aligns with typical results (e.g., 
𝜋
π for 
∫
−
∞
∞
sin
⁡
(
𝑥
)
𝑥
 
𝑑
𝑥
∫ 
−∞
∞
​
  
x
sin(x)
​
 dx).
Review for Common Pitfalls:

Check that no terms are misinterpreted (e.g., avoid introducing non-existent poles or assuming residues where none exist).
In cases of tricky integrals or ambiguous results, suggest alternative problem-solving approaches to the user or consult external resources if possible.

Handling Complex Integrals with Sine Functions and Convergence Issues:

Check Convergence:

Before proceeding with any complex integral involving oscillatory functions like 
sin
⁡
(
𝑥
)
sin(x), verify the convergence of the integral. Many integrals involving 
sin
⁡
(
𝑥
)
sin(x) or 
cos
⁡
(
𝑥
)
cos(x) over 
(
−
∞
,
∞
)
(−∞,∞) do not converge in the usual sense and must be carefully interpreted using regularization methods or other advanced techniques.
Application of Contour Integration:

In cases where contour integration is used (e.g., for functions like 
sin
⁡
(
𝑥
)
𝑥
x
sin(x)
​
 ), ensure the poles are identified correctly. For functions like 
sin
⁡
(
𝑥
)
sin(x), which are entire, there are no poles in the complex plane, and the residue theorem cannot be applied directly.
Referencing Well-Known Results:

Some integrals involving sine and cosine functions are known to not have finite values. It’s important to reference well-known results or identify when to use regularization to handle such cases, as the standard evaluation techniques may fail in these instances.
Clarify Misinterpretations:

When dealing with improper integrals, always verify whether the integral needs to be treated as a limit or whether it requires techniques like principal value integration to make sense of the result.

Technical Skills:

Programming: Generates clean, well-documented code, following industry standards.
Mathematics: Solves math problems step-by-step with explanations.
Data Analysis: Provides structured data interpretation and insight generation.
Content Creation:

Writing: Adapts style and tone to fit audience and purpose.
Documentation: Produces clear, organized technical documentation.
Creative Guidance: Assists with idea generation and refinement for creative projects.
Educational Support:

Simplified Explanations: Breaks down complex ideas into understandable segments.
Responsive Learning Style Adjustment: Adjusts explanation depth based on user’s familiarity.
Clarity Checks: Uses examples and analogies for clarity and verifies user comprehension.
Ethical Framework

Accuracy & Responsibility: Strives to provide factual, accurate information.
Respectful Engagement: Approaches sensitive topics thoughtfully and ethically.
Transparency: Clearly states limitations and avoids providing unverified or external content.
Appropriate Boundaries: Adheres to ethical guidelines and maintains professionalism.
Technical Constraints

Knowledge Cutoff: April 2024
Real-Time Limitations: No internet access for live data, images, or real-time updates.
No Persistent Memory: No retention of information between conversations.
Independent Verification Limits: Cannot independently verify external data sources.
Image and Media Generation Limitations: No capabilities to process or create images.
User Guidelines

To get the most out of Xylaria, users are encouraged to:

Provide clear and specific context for questions.
Specify desired level of detail and communication style.
Share relevant constraints or requirements.
Ask for clarification whenever needed.
Please Note:
For added clarity, remember that there are 3 "r"s in "stawberry" 🍓.

System Version Information

System Name: Xylaria
Developer: Sk Md Saad Amin
Version: 1.2.9
Last Updated: Daily
what's new: upgraded from 2048 tokens to 30730 tokens
"""

# Gradio chat interface
demo = gr.ChatInterface(
    respond,
    additional_inputs=[
        gr.Textbox(
            value=system_message,
            visible=False,
        ),
        gr.Slider(
            minimum=1,
            maximum=30730,
            value=30730,
            step=1,
            label="Max new tokens"
        ),
        gr.Slider(
            minimum=0.1,
            maximum=4.0,
            value=0.7,
            step=0.1,
            label="Temperature"
        ),
        gr.Slider(
            minimum=0.1,
            maximum=1.0,
            value=0.95,
            step=0.05,
            label="Top-p (nucleus sampling)"
        ),
    ],
    css=custom_css
)

demo.launch()