Initial commit

app.py

@@ -1,64 +1,409 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    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})
-
-    response = ""
-
-    for message in 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
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, 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)",
-        ),
-    ],
+from flask import Flask, request, jsonify, render_template
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # Disable GPU for PyTorch
+import torch
+import speech_recognition as sr
+import pyttsx3
+import wikipediaapi
+from googlesearch import search
+import requests
+from newsapi import NewsApiClient
+import pyjokes
+import yfinance as yf
+from diffusers import StableDiffusionPipeline
+from deep_translator import GoogleTranslator
+import sympy as sp
+from forex_python.converter import CurrencyRates
+import re
+from download_models import download_models_from_s3
+from accelerate import init_empty_weights, load_checkpoint_and_dispatch
+
+app = Flask(__name__)
+
+engine = pyttsx3.init()
+
+wiki_wiki = wikipediaapi.Wikipedia(
+    language="en",
+    user_agent="AIChatbot/1.0 (sonu.singh@poczta.fm)"  # Change email to yours
 )
 
+OPENWEATHER_API_KEY = "59ba015cbd69ea483e8390970ffff366"
+
+NEWSAPI_KEY = "46cae6ce089f4b55b748afdaf8fb5ecc"  # Replace with your actual NewsAPI key
+newsapi = NewsApiClient(api_key=NEWSAPI_KEY)
+
+# Supported Language Mappings (ISO Codes)
+LANGUAGE_CODES = {
+    "afrikaans": "af", "albanian": "sq", "amharic": "am", "arabic": "ar", "armenian": "hy", 
+    "azerbaijani": "az", "basque": "eu", "belarusian": "be", "bengali": "bn", "bosnian": "bs", 
+    "bulgarian": "bg", "catalan": "ca", "chinese": "zh-CN", "croatian": "hr", "czech": "cs", 
+    "danish": "da", "dutch": "nl", "english": "en", "estonian": "et", "finnish": "fi", 
+    "french": "fr", "german": "de", "greek": "el", "hindi": "hi", "hungarian": "hu", 
+    "indonesian": "id", "italian": "it", "japanese": "ja", "korean": "ko", "latin": "la", 
+    "latvian": "lv", "lithuanian": "lt", "malay": "ms", "marathi": "mr", "nepali": "ne", 
+    "norwegian": "no", "persian": "fa", "polish": "pl", "portuguese": "pt", "romanian": "ro", 
+    "russian": "ru", "serbian": "sr", "slovak": "sk", "slovenian": "sl", "spanish": "es", 
+    "swedish": "sv", "tamil": "ta", "telugu": "te", "thai": "th", "turkish": "tr", 
+    "ukrainian": "uk", "urdu": "ur", "vietnamese": "vi", "welsh": "cy", "xhosa": "xh", "zulu": "zu"
+}
+
+currency_rates = CurrencyRates()
+
+# Load Sentiment Analysis Model
+sentiment_model = pipeline("sentiment-analysis")
+
+def speak(text):
+    engine.say(text)
+    engine.runAndWait()
+
+def listen():
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        print("🎤 Listening...")
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+    try:
+        print("🟡 Recognizing...")
+        return recognizer.recognize_google(audio)
+    except:
+        return "❌ Could not understand audio"
+
+def search_wikipedia(query):
+    page = wiki_wiki.page(query)
+    if page.exists():
+        return page.summary[:500]  # Limit to 500 characters
+    return "⚠️ No Wikipedia article found for that topic."
+
+
+def google_search(query):
+    try:
+        print(f"🔎 Searching Google for: {query}")  # Debugging
+        results = list(search(query, num_results=3, advanced=True))
+        if not results:
+            return "⚠️ No search results found."
+
+        # Convert SearchResult objects to plain text links
+        links = [result.url for result in results]
+        return "\n".join(links)
+    except Exception as e:
+        print(f"❌ Google Search Error: {e}")
+        return "⚠️ Error fetching search results."
+
+def get_weather(city):
+    try:
+        city = city.strip().title()  # Format city name properly
+        url = f"http://api.openweathermap.org/data/2.5/weather?q={city},US&appid={OPENWEATHER_API_KEY}&units=metric"
+        response = requests.get(url).json()
+
+        print(f"⛅ Weather API Response: {response}")  # Debugging
+
+        if response.get("cod") != 200:
+            return f"⚠️ Couldn't fetch weather data for {city}. Try another city."
+
+        weather_desc = response["weather"][0]["description"]
+        temp = response["main"]["temp"]
+        return f"The weather in {city} is {weather_desc} with a temperature of {temp}°C."
+    except Exception as e:
+        print(f"❌ Weather API Error: {e}")
+        return "⚠️ Error fetching weather data."
+
+def get_news():
+    try:
+        articles = newsapi.get_top_headlines(language='en', country='us')
+        headlines = [article['title'] for article in articles['articles'][:3]]  # Get top 3 headlines
+        return "\n".join(headlines) if headlines else "⚠️ No news found."
+    except Exception as e:
+        print(f"❌ News API Error: {e}")
+        return "⚠️ Error fetching news."
+
+def get_joke():
+    return pyjokes.get_joke()
+
+def get_stock_price(stock_symbol):
+    try:
+        stock_symbol = stock_symbol.upper().strip()
+        if not stock_symbol:
+            return "⚠️ Please enter a valid stock symbol (e.g., AAPL, TSLA, MSFT)."
+
+        stock = yf.Ticker(stock_symbol)
+        stock_data = stock.history(period="1d")
+
+        if stock_data.empty:  # Check if the stock data is empty
+            return f"⚠️ No stock data found for {stock_symbol}. It may be delisted or incorrect."
+
+        price = stock_data["Close"].iloc[-1]  # Get the latest closing price
+        return f"📈 The current price of {stock_symbol} is **${price:.2f}**."
+    
+    except Exception as e:
+        print(f"❌ Stock API Error: {e}")
+        return "⚠️ Error fetching stock price. Please try again later."
+
+def translate_text(user_input):
+    try:
+        # Extract text & target language using regex (improved)
+        match = re.match(r"(?:translate\s+)?(.+?)\s+to\s+(\w+)", user_input, re.IGNORECASE)
+
+        if not match:
+            return "⚠️ Please use format: 'Hello to French' or 'Translate Hello to Spanish'."
+
+        text_to_translate, target_language = match.groups()
+        target_lang_code = LANGUAGE_CODES.get(target_language.lower())
+
+        if not target_lang_code:
+            return "⚠️ Unsupported language. Try using a valid language like 'French', 'Spanish', or 'German'."
+
+        print(f"🔄 Translating '{text_to_translate}' to {target_language} ({target_lang_code})...")
+        translator = GoogleTranslator(target=target_lang_code)
+        translated_text = translator.translate(text_to_translate.strip())
+
+        return f"🌍 Translated to {target_language.capitalize()}: {translated_text}"
+
+    except Exception as e:
+        print(f"❌ Translation Error: {e}")  # Logs error for debugging
+        return f"⚠️ Error translating text: {e}"
+
+def generate_code(prompt):
+    try:
+        print(f"🟡 Generating code for: {prompt}")
+
+        response = phi_pipeline(
+            f"Write Python code for {prompt}:",
+            max_length=75,  # Reduced length
+            truncation=True,
+        ) # Removed device argument
+
+        generated_code = response[0]["generated_text"]
+
+        try:
+            generated_code = generated_code.split("```python")[-1].split("```")[0].strip()
+        except IndexError:
+            print("❌ Code extraction failed. Model output format is unexpected.")
+            return "⚠️ Error generating code. Model output format is unexpected."
+
+        return f"```python\n{generated_code}\n```"
+
+    except Exception as e:
+        print(f"❌ Code Generation Error: {type(e).__name__}: {e}")
+        import traceback
+        traceback.print_exc()  # Print the full traceback
+        return "⚠️ Error generating code. Check the server logs for details."
+
+def solve_math(user_input):
+    try:
+        print(f"🟡 Solving: {user_input}")  # Debugging
+
+        # Extract only the math expression (remove words like "solve")
+        expression = re.sub(r"[^0-9+\-*/().]", "", user_input)
+
+        if not expression:
+            return "⚠️ No valid math expression found. Try: '5 + 3 * 2' or 'Solve 10 / 2'."
+
+        # Evaluate the expression
+        result = sp.N(sp.sympify(expression), 2)  # Limit to 2 decimal places
+
+        return f"🧮 Answer: {result:.2f}"  # Format as two decimal places
+
+    except Exception as e:
+        print(f"❌ Math Solver Error: {e}")
+        return "⚠️ Invalid math expression. Please check the equation."
+
+def convert_currency(amount, from_currency, to_currency):
+    try:
+        # Convert currency using real-time exchange rates
+        converted_amount = currency_rates.convert(from_currency.upper(), to_currency.upper(), float(amount))
+        return f"💱 {amount} {from_currency.upper()} = {converted_amount:.2f} {to_currency.upper()}"
+    except Exception as e:
+        print(f"❌ Currency Conversion Error: {e}")
+        return "⚠️ Invalid currency code or conversion failed."
+
+def analyze_sentiment(text):
+    try:
+        result = sentiment_model(text)[0]
+        label = result["label"]  # "POSITIVE" or "NEGATIVE" or "NEUTRAL"
+        score = round(result["score"] * 100, 2)  # Confidence Score in %
+
+        return f"📊 Sentiment: {label} ({score}% confidence)"
+    except Exception as e:
+        print(f"❌ Sentiment Analysis Error: {e}")
+        return "⚠️ Unable to analyze sentiment."
+
+# Load Phi-1.5 model
+MODEL_PATH = "./models/phi-1.5"
+
+# List of expected model files
+MODEL_FILES = [
+    "model-00001-of-00002.safetensors",
+    "model-00002-of-00002.safetensors",
+    "config.json",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "special_tokens_map.json",
+    "added_tokens.json",
+    "generation_config.json",
+    "merges.txt",
+    "model.safetensors.index.json",
+    "vocab.json"
+]
+
+# Check if all model files exist
+if all(os.path.exists(os.path.join(MODEL_PATH, f)) for f in MODEL_FILES):
+    print("✅ Models found locally. Skipping download.")
+else:
+    print("❌ Model files missing! Please run `download_hf_model.py` to fetch the model.")
+    exit(1)
+
+try:
+    print("🟡 Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, local_files_only=True)
+    print("✅ Tokenizer loaded!")
+
+    print("🟡 Loading model...")
+    model = AutoModelForCausalLM.from_pretrained(
+    	MODEL_PATH,
+    	torch_dtype=torch.float32,  
+    	device_map={"": "cpu"}  # Explicitly set to CPU
+    )
+    model.to("cuda" if torch.cuda.is_available() else "cpu")  # Move to GPU if available
+    print("✅ Model loaded successfully!")
+
+    print("🟡 Creating pipeline...")
+    phi_pipeline = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    print("✅ Pipeline created!")
+
+except Exception as e:
+    print(f"❌ Error loading model: {type(e).__name__}: {e}")
+    import traceback
+    traceback.print_exc()
+    exit(1)
+
+# Use Stability AI's Stable Diffusion Model
+MODEL_NAME = "runwayml/stable-diffusion-v1-5"
+
+def generate_image(prompt):
+    try:
+        print("🟡 Loading Stable Diffusion pipeline...")
+
+        # Enforce CPU usage
+        device = "cpu"
+        torch_dtype = torch.float32  # Use float32 for CPU
+
+        # Load Stable Diffusion model
+        pipe = StableDiffusionPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5",
+            torch_dtype=torch_dtype
+        ).to(device)
+
+        print(f"✅ Model loaded on {device.upper()}")
+
+        # Generate image with lower resolution (reduce RAM usage)
+        image = pipe(prompt, height=512, width=512).images[0]
+
+        # Save the image
+        image_path = "static/generated_image.png"
+        image.save(image_path)
+
+        print("✅ Image generated successfully!")
+        return f"🌆 Image generated successfully! View at: {image_path}"
+
+    except Exception as e:
+        print(f"❌ Image Generation Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return "⚠️ Error generating image. Try again later."
+
+
+@app.route("/")
+def home():
+    return render_template("index.html")
+
+@app.route('/voice', methods=['POST'])
+def voice_chat():
+    try:
+        user_input = listen()
+        print(f"📥 Voice Input: {user_input}")
+
+        response = phi_pipeline(user_input, max_length=100, truncation=True)
+        generated_text = response[0]["generated_text"]
+        print(f"📤 AI Response: {generated_text}")
+
+        speak(generated_text)  # AI reads response aloud
+        return jsonify({"response": generated_text})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/chat', methods=['POST'])
+def chat_with_phi1_5():
+    try:
+        data = request.get_json()
+        user_input = data["message"].strip()
+        print(f"📥 Received input: {user_input}")
+
+        # News Updates
+        if "news" in user_input.lower():
+            response_text = get_news()
+        # Wikipedia Search
+        elif "Wikipedia" in user_input:
+            response_text = search_wikipedia(user_input.replace("Wikipedia", "").strip())
+        # Google Search
+        elif "Google" in user_input:
+            response_text = google_search(user_input.replace("Google", "").strip())
+        # Weather Update
+        elif "weather" in user_input.lower():
+            response_text = get_weather(user_input.replace("weather", "").strip())
+        # Jokes
+        elif "joke" in user_input.lower():
+            response_text = get_joke()
+        # Stock Prices
+        elif "stock" in user_input.lower():
+            stock_symbol = user_input.replace("stock", "").strip().upper()
+            response_text = get_stock_price(stock_symbol)
+        # AI Image Generation
+        elif "generate image" in user_input.lower():
+            prompt = user_input.replace("generate image", "").strip()
+            response_text = generate_image(prompt)
+        # AI Language Translation
+        elif "translate" in user_input.lower():
+            response_text = translate_text(user_input)  # Correct call to translate_text
+        # AI Code Generation
+        elif "generate code" in user_input.lower():
+            response_text = generate_code(user_input.replace("generate code", "").strip()) # Call the improved function
+        # AI Bug Fixing
+        elif "fix code" in user_input.lower():
+            response = phi_ai("Fix this code: " + user_input.replace("fix code", "").strip(), max_length=150, truncation=True)
+            response_text = f"🔹 Fixed Code:\n```python\n{response[0]['generated_text']}\n```"
+        # AI Math Solver
+        elif "solve" in user_input.lower() or "=" in user_input:
+            response_text = solve_math(user_input)
+        # Currency Conversion
+        elif "convert" in user_input and "to" in user_input:
+            try:
+                parts = user_input.replace("convert", "").strip().split(" to ")
+                amount_currency = parts[0].split()
+                amount = amount_currency[0]
+                from_currency = amount_currency[1]
+                to_currency = parts[1]
+                response_text = convert_currency(amount, from_currency, to_currency)
+            except:
+                response_text = "⚠️ Please use format: 'Convert 100 USD to EUR'."
+        # Sentiment Analysis
+        elif "analyze sentiment" in user_input.lower():
+            response_text = analyze_sentiment(user_input.replace("analyze sentiment", "").strip())
+        # Default AI Response
+        else:
+            response = phi_pipeline(user_input, max_length=100, truncation=True)
+            response_text = response[0]["generated_text"]
+
+        print(f"📤 AI Response: {response_text}")
+        return jsonify({"response": response_text})
+
+    except Exception as e:
+        print(f"❌ Chat Error: {type(e).__name__}: {e}") # Improved error handling
+        import traceback
+        traceback.print_exc() # Print traceback
+        return jsonify({"error": str(e)}), 500
+
 
-if __name__ == "__main__":
-    demo.launch()
+if __name__ == '__main__':
+    print("🌍 Running Flask on http://0.0.0.0:5000")
+    app.run(host="0.0.0.0", port=5000, debug=True)