# Install required libraries
pip install chatterbot==1.0.4
pip install chatterbot-corpus
pip install nltk
pip install spacy
pip install flask
python -m spacy download en_core_web_sm

# My First Python Chatbot
import random

class SimpleChatBot:
    def __init__(self):
        # Store responses for different inputs
        self.responses = {
            'hello': ['Hi there!', 'Hello!', 'Hey! How can I help?'],
            'how are you': ['I am good!', 'Doing great!', 'Fine, thanks!'],
            'bye': ['Goodbye!', 'See you later!', 'Bye bye!'],
            'name': ['I am ChatBot', 'My name is Bot', 'Call me Helper']
        }
    
    def get_response(self, user_input):
        # Make input lowercase for easier matching
        user_input = user_input.lower()
        
        # Check each response category
        for keyword in self.responses:
            if keyword in user_input:
                # Pick a random response from the list
                return random.choice(self.responses[keyword])
        
        # Default response if no match found
        return "I don't understand. Can you say that differently?"

# Create our chatbot
my_bot = SimpleChatBot()

# Test the chatbot
print("ChatBot: Hi! I'm your first chatbot.")
print("ChatBot:", my_bot.get_response("hello"))
print("ChatBot:", my_bot.get_response("how are you"))
print("ChatBot:", my_bot.get_response("what is your name"))

# Advanced ChatterBot Example
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer, ListTrainer

# Create a new chatbot
my_chatbot = ChatBot(
    'MyBot',
    # Store conversations in database
    storage_adapter='chatterbot.storage.SQLStorageAdapter',
    database_uri='sqlite:///database.sqlite3',
    # Configure logic adapters
    logic_adapters=[
        'chatterbot.logic.BestMatch',
        'chatterbot.logic.TimeLogicAdapter',
        'chatterbot.logic.MathematicalEvaluation'
    ]
)

# Train with English conversation data
print("Training chatbot with English conversations...")
trainer = ChatterBotCorpusTrainer(my_chatbot)
trainer.train("chatterbot.corpus.english")

# Train with custom conversations
print("Adding custom training data...")
custom_trainer = ListTrainer(my_chatbot)
custom_trainer.train([
    "What is Python?",
    "Python is a programming language used for many things including chatbots.",
    "How do chatbots work?",
    "Chatbots use pattern matching and machine learning to understand and respond to users.",
    "What can I build with Python?",
    "You can build websites, games, chatbots, data analysis tools, and much more!"
])

print("Training complete! Chatbot is ready to talk.")

# Function to chat with the bot
def chat_conversation():
    print("ChatBot: Hello! I'm trained and ready to chat. Type 'quit' to exit.")
    
    while True:
        user_message = input("You: ")
        
        if user_message.lower() == 'quit':
            print("ChatBot: Goodbye! It was nice talking with you.")
            break
        
        # Get response from chatbot
        bot_response = my_chatbot.get_response(user_message)
        print(f"ChatBot: {bot_response}")

# Start the conversation
# chat_conversation()

# NLTK-Powered Chatbot
import nltk
from nltk.chat.util import Chat, reflections
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
import string
import random

# Download required NLTK data (run once)
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')

class NLTKChatBot:
    def __init__(self):
        # Initialize NLTK tools
        self.lemmatizer = WordNetLemmatizer()
        self.stop_words = set(stopwords.words('english'))
        
        # Conversation patterns with more complex matching
        self.patterns = [
            # Greetings
            [r'my name is (.*)', ['Hello %1! Nice to meet you.', 'Hi %1! How can I help you today?']],
            [r'hi|hello|hey|greetings', ['Hello there!', 'Hi! How are you?', 'Hey! What can I do for you?']],
            
            # Questions about the bot
            [r'what is your name|who are you', ['I am an NLTK-powered chatbot', 'You can call me NLTK Bot']],
            [r'how are you|how do you feel', ['I am doing well, thank you!', 'Great! Ready to help you.']],
            
            # Learning questions
            [r'what is (.*)', ['%1 is an interesting topic. Let me think about that.', 'I would need more context about %1.']],
            [r'how do I (.*)', ['To %1, you might want to start by researching the basics.', 'Learning to %1 takes practice!']],
            
            # Weather and time
            [r'.*weather.*', ['I cannot check the weather, but you can use a weather app!', 'Weather varies by location. Where are you?']],
            [r'.*time.*', ['I do not have access to current time, sorry!']],
            
            # Goodbye
            [r'bye|goodbye|see you|exit|quit', ['Goodbye! It was nice talking with you.', 'See you later!', 'Take care!']]
        ]
        
        # Create the chatbot
        self.chatbot = Chat(self.patterns, reflections)
    
    def preprocess_text(self, text):
        """Clean and prepare text for better understanding"""
        # Convert to lowercase
        text = text.lower()
        
        # Remove punctuation
        text = text.translate(str.maketrans('', '', string.punctuation))
        
        # Tokenize (split into words)
        tokens = word_tokenize(text)
        
        # Remove stop words and lemmatize
        processed_tokens = []
        for token in tokens:
            if token not in self.stop_words:
                lemmatized = self.lemmatizer.lemmatize(token)
                processed_tokens.append(lemmatized)
        
        return ' '.join(processed_tokens)
    
    def get_response(self, user_input):
        """Get chatbot response with preprocessing"""
        # First try with original input
        response = self.chatbot.respond(user_input)
        
        # If no response found, try with preprocessed input
        if not response or response == "I don't understand that.":
            processed_input = self.preprocess_text(user_input)
            response = self.chatbot.respond(processed_input)
        
        # If still no response, give default
        if not response:
            defaults = [
                "That's interesting! Can you tell me more?",
                "I'm still learning. Can you rephrase that?",
                "Hmm, I'm not sure about that. What else would you like to know?"
            ]
            response = random.choice(defaults)
        
        return response

# Create and test the NLTK chatbot
nltk_bot = NLTKChatBot()

# Test examples
print("NLTK ChatBot: Hello! I use natural language processing.")
print("NLTK ChatBot:", nltk_bot.get_response("Hello, my name is Sarah"))
print("NLTK ChatBot:", nltk_bot.get_response("What is machine learning?"))
print("NLTK ChatBot:", nltk_bot.get_response("How do I learn Python programming?"))

# Advanced spaCy Chatbot with Entity Recognition
import spacy
import random
from collections import defaultdict

class SpaCySmartChatBot:
    def __init__(self):
        # Load spaCy language model
        print("Loading spaCy language model...")
        self.nlp = spacy.load("en_core_web_sm")
        
        # Intent-based responses
        self.intent_responses = {
            "greeting": [
                "Hello! I'm powered by spaCy for advanced language understanding.",
                "Hi there! I can understand context and entities in your messages.",
                "Hey! What would you like to know about?"
            ],
            "question": [
                "That's a great question! Let me analyze what you're asking.",
                "I can help you with that. Let me process your question.",
                "Interesting question! I'll do my best to help."
            ],
            "person_question": [
                "I see you're asking about a person. Can you provide more context?",
                "That person sounds interesting! Tell me more about them."
            ],
            "location_question": [
                "I notice you mentioned a location. Are you planning to visit there?",
                "That place sounds interesting! What would you like to know about it?"
            ],
            "compliment": [
                "Thank you! I appreciate your kind words.",
                "That's very nice of you to say!",
                "I'm glad I could help!"
            ],
            "goodbye": [
                "Goodbye! Thanks for chatting with my spaCy-powered brain!",
                "See you later! I enjoyed our conversation.",
                "Take care! Come back anytime for more AI-powered chats."
            ]
        }
        
        # Keywords for intent detection
        self.greeting_words = ["hello", "hi", "hey", "greetings", "good morning", "good afternoon"]
        self.question_words = ["what", "how", "why", "when", "where", "who", "can", "could", "would", "should"]
        self.compliment_words = ["great", "awesome", "amazing", "wonderful", "excellent", "good", "fantastic"]
        self.goodbye_words = ["bye", "goodbye", "see you", "farewell", "exit", "quit", "later"]
    
    def analyze_entities(self, text):
        """Extract and analyze named entities"""
        doc = self.nlp(text)
        entities = []
        
        for ent in doc.ents:
            entities.append({
                "text": ent.text,
                "label": ent.label_,
                "description": spacy.explain(ent.label_),
                "start": ent.start_char,
                "end": ent.end_char
            })
        
        return entities
    
    def get_intent(self, text):
        """Determine user intent using spaCy analysis"""
        doc = self.nlp(text.lower())
        
        # Extract tokens (words) and their properties
        tokens = [token for token in doc if not token.is_stop and not token.is_punct]
        
        # Check for greeting intent
        for token in tokens:
            if token.lemma_ in self.greeting_words:
                return "greeting"
        
        # Check for goodbye intent
        for token in tokens:
            if token.lemma_ in self.goodbye_words:
                return "goodbye"
        
        # Check for compliment intent
        for token in tokens:
            if token.lemma_ in self.compliment_words:
                return "compliment"
        
        # Check for question intent
        for token in tokens:
            if token.lemma_ in self.question_words:
                # Check if question is about a person or location
                entities = self.analyze_entities(text)
                for entity in entities:
                    if entity["label"] == "PERSON":
                        return "person_question"
                    elif entity["label"] in ["GPE", "LOC"]:  # GPE = countries, cities, states
                        return "location_question"
                return "question"
        
        return "unknown"
    
    def analyze_sentiment(self, text):
        """Basic sentiment analysis using spaCy"""
        doc = self.nlp(text)
        
        # Simple sentiment based on positive/negative words
        positive_words = ["good", "great", "excellent", "amazing", "wonderful", "fantastic", "love", "like"]
        negative_words = ["bad", "terrible", "awful", "hate", "dislike", "horrible", "worst"]
        
        pos_count = 0
        neg_count = 0
        
        for token in doc:
            if token.lemma_ in positive_words:
                pos_count += 1
            elif token.lemma_ in negative_words:
                neg_count += 1
        
        if pos_count > neg_count:
            return "positive"
        elif neg_count > pos_count:
            return "negative"
        else:
            return "neutral"
    
    def get_response(self, user_input):
        """Generate intelligent response using spaCy analysis"""
        # Analyze entities in user input
        entities = self.analyze_entities(user_input)
        
        # Get user intent
        intent = self.get_intent(user_input)
        
        # Analyze sentiment
        sentiment = self.analyze_sentiment(user_input)
        
        # Generate base response
        if intent in self.intent_responses:
            response = random.choice(self.intent_responses[intent])
        else:
            response = "I'm processing what you said with my spaCy language model. Can you elaborate?"
        
        # Add entity information if found
        if entities:
            entity_info = []
            for entity in entities:
                entity_info.append(f"{entity['text']} (which is a {entity['description']})")
            
            if len(entity_info) == 1:
                response += f" I noticed you mentioned {entity_info[0]}."
            else:
                response += f" I found these entities: {', '.join(entity_info)}."
        
        # Add sentiment information
        if sentiment == "positive":
            response += " I sense positive feelings in your message!"
        elif sentiment == "negative":
            response += " I detect some negative sentiment. How can I help improve your mood?"
        
        return response

# Create and test the spaCy chatbot
print("Initializing spaCy chatbot...")
spacy_bot = SpaCySmartChatBot()

# Test examples
print("\nTesting spaCy chatbot:")
print("Bot:", spacy_bot.get_response("Hello, I'm John from New York and I love machine learning!"))
print("Bot:", spacy_bot.get_response("What do you think about artificial intelligence?"))
print("Bot:", spacy_bot.get_response("Can you tell me about Paris, France?"))
print("Bot:", spacy_bot.get_response("This chatbot is amazing and wonderful!"))

# AI Chatbot with Memory and Context
import json
import datetime
from typing import List, Dict
import random

class MemoryAIChatBot:
    def __init__(self):
        # Conversation memory
        self.conversation_history = []
        self.user_profile = {
            "name": None,
            "interests": [],
            "preferences": {},
            "conversation_count": 0
        }
        
        # Knowledge base for intelligent responses
        self.knowledge_base = {
            "python": {
                "description": "Python is a programming language that's easy to learn and powerful to use.",
                "uses": ["web development", "data science", "artificial intelligence", "automation"],
                "learning_resources": ["Python.org tutorials", "online courses", "coding bootcamps"]
            },
            "machine_learning": {
                "description": "Machine learning helps computers learn patterns from data without explicit programming.",
                "types": ["supervised learning", "unsupervised learning", "reinforcement learning"],
                "applications": ["image recognition", "natural language processing", "recommendation systems"]
            },
            "chatbots": {
                "description": "Chatbots are programs that simulate conversation with humans.",
                "types": ["rule-based", "AI-powered", "hybrid systems"],
                "benefits": ["24/7 availability", "consistent responses", "cost-effective customer service"]
            }
        }
        
        # Response templates for different contexts
        self.response_templates = {
            "first_time": [
                "Welcome! I'm an AI chatbot with memory. What's your name?",
                "Hello! I'm excited to meet you. I can remember our conversation as we chat.",
                "Hi there! I'm a smart chatbot that learns about you. What should I call you?"
            ],
            "returning_user": [
                "Welcome back, {name}! I remember our last conversation about {topic}.",
                "Hi {name}! Good to see you again. Last time we discussed {topic}.",
                "Hello {name}! I've been thinking about our chat on {topic}."
            ],
            "learning_response": [
                "Interesting! I'll remember that you're interested in {topic}.",
                "Thanks for sharing! I've noted your interest in {topic}.",
                "Good to know you like {topic}. I'll keep that in mind for future conversations."
            ]
        }
    
    def add_to_memory(self, user_input: str, bot_response: str):
        """Add conversation to memory"""
        conversation_entry = {
            "timestamp": datetime.datetime.now().isoformat(),
            "user_input": user_input,
            "bot_response": bot_response,
            "conversation_id": len(self.conversation_history) + 1
        }
        self.conversation_history.append(conversation_entry)
        
        # Update conversation count
        self.user_profile["conversation_count"] += 1
    
    def extract_user_info(self, user_input: str):
        """Extract and store user information"""
        user_input_lower = user_input.lower()
        
        # Extract name if user introduces themselves
        if "my name is" in user_input_lower or "i'm" in user_input_lower or "i am" in user_input_lower:
            words = user_input.split()
            for i, word in enumerate(words):
                if word.lower() in ["is", "am"] and i + 1 < len(words):
                    potential_name = words[i + 1].strip(".,!?")
                    if potential_name.isalpha() and len(potential_name) > 1:
                        self.user_profile["name"] = potential_name
                        return f"Nice to meet you, {potential_name}!"
        
        # Extract interests
        interest_keywords = ["like", "love", "enjoy", "interested in", "passionate about", "hobby"]
        for keyword in interest_keywords:
            if keyword in user_input_lower:
                # Simple interest extraction (this could be more sophisticated)
                words_after_keyword = user_input_lower.split(keyword)[1].split()[:3]
                interest = " ".join(words_after_keyword).strip(".,!?")
                if interest and interest not in self.user_profile["interests"]:
                    self.user_profile["interests"].append(interest)
                    return random.choice(self.response_templates["learning_response"]).format(topic=interest)
        
        return None
    
    def get_knowledge_response(self, user_input: str):
        """Check if user is asking about topics in our knowledge base"""
        user_input_lower = user_input.lower()
        
        for topic, info in self.knowledge_base.items():
            if topic in user_input_lower or any(keyword in user_input_lower for keyword in topic.split("_")):
                response = f"Great question about {topic.replace('_', ' ')}! "
                response += info["description"] + " "
                
                if "how" in user_input_lower or "learn" in user_input_lower:
                    if "learning_resources" in info:
                        response += f"To learn more, I recommend: {', '.join(info['learning_resources'])}."
                elif "what" in user_input_lower and "use" in user_input_lower:
                    if "uses" in info:
                        response += f"It's commonly used for: {', '.join(info['uses'])}."
                elif "type" in user_input_lower:
                    if "types" in info:
                        response += f"The main types include: {', '.join(info['types'])}."
                
                return response
        
        return None
    
    def get_contextual_response(self, user_input: str):
        """Generate response based on conversation context"""
        # Check if this is the first conversation
        if self.user_profile["conversation_count"] == 0:
            return random.choice(self.response_templates["first_time"])
        
        # Check for user information extraction
        user_info_response = self.extract_user_info(user_input)
        if user_info_response:
            return user_info_response
        
        # Check for knowledge-based questions
        knowledge_response = self.get_knowledge_response(user_input)
        if knowledge_response:
            return knowledge_response
        
        # Generate contextual response based on conversation history
        if len(self.conversation_history) > 0:
            last_conversation = self.conversation_history[-1]
            
            # Reference previous conversation
            if "remember" in user_input.lower() or "earlier" in user_input.lower():
                return f"Yes, I remember! Earlier you said: '{last_conversation['user_input']}'"
            
            # Build on previous topic
            if len(self.conversation_history) >= 2:
                recent_topics = []
                for conv in self.conversation_history[-3:]:
                    if any(topic in conv['user_input'].lower() for topic in self.knowledge_base.keys()):
                        for topic in self.knowledge_base.keys():
                            if topic in conv['user_input'].lower():
                                recent_topics.append(topic.replace('_', ' '))
                
                if recent_topics and self.user_profile["name"]:
                    return f"Building on our discussion about {recent_topics[-1]}, what specific aspect interests you most, {self.user_profile['name']}?"
        
        # Default intelligent responses
        default_responses = [
            "That's fascinating! Can you tell me more about that?",
            "I find that very interesting. What made you think about this topic?",
            "Thanks for sharing that with me. I'm always learning from our conversations.",
            "I appreciate you taking the time to explain that. What else would you like to discuss?"
        ]
        
        if self.user_profile["name"]:
            return f"{random.choice(default_responses).replace('you', self.user_profile['name'])}"
        else:
            return random.choice(default_responses)
    
    def get_response(self, user_input: str):
        """Main method to get chatbot response"""
        response = self.get_contextual_response(user_input)
        
        # Add to memory
        self.add_to_memory(user_input, response)
        
        return response
    
    def get_conversation_summary(self):
        """Get a summary of the conversation"""
        if not self.conversation_history:
            return "No conversation history yet."
        
        summary = f"Conversation Summary:\n"
        summary += f"Total messages: {len(self.conversation_history)}\n"
        if self.user_profile["name"]:
            summary += f"User name: {self.user_profile['name']}\n"
        if self.user_profile["interests"]:
            summary += f"User interests: {', '.join(self.user_profile['interests'])}\n"
        
        return summary

# Create and test the memory AI chatbot
memory_bot = MemoryAIChatBot()

# Simulate a conversation
print("Memory AI ChatBot: Starting conversation with memory enabled!")
print("Bot:", memory_bot.get_response("Hello there!"))
print("Bot:", memory_bot.get_response("My name is Alex and I love programming"))
print("Bot:", memory_bot.get_response("What is machine learning?"))
print("Bot:", memory_bot.get_response("Do you remember what I told you earlier?"))
print("\n" + memory_bot.get_conversation_summary())

# Flask Web Chatbot Application
from flask import Flask, render_template, request, jsonify
import json
import datetime
import random

app = Flask(__name__)

class WebChatBot:
    def __init__(self):
        self.conversation_sessions = {}
        
        # Web-specific responses
        self.web_responses = {
            'greeting': [
                "Hello! Welcome to our web chatbot. How can I help you today?",
                "Hi there! I'm your web assistant. What would you like to know?",
                "Welcome! I'm here to help you navigate our website and answer questions."
            ],
            'website_help': [
                "I can help you find information on our website. What are you looking for?",
                "Need help navigating? Just ask me about any topic!",
                "I'm here to make your website experience better. How can I assist?"
            ],
            'services': [
                "We offer Python development, AI consulting, and custom chatbot creation.",
                "Our services include web development, machine learning solutions, and technical training.",
                "We specialize in Python programming, artificial intelligence, and automation solutions."
            ],
            'contact': [
                "You can reach us at contact@emitechlogic.com for any inquiries.",
                "Feel free to contact our team for personalized assistance!",
                "We'd love to hear from you! Send us a message anytime."
            ]
        }
    
    def get_session_id(self, request):
        """Create or get session ID for user"""
        session_id = request.remote_addr + str(datetime.datetime.now().date())
        if session_id not in self.conversation_sessions:
            self.conversation_sessions[session_id] = {
                'history': [],
                'user_info': {},
                'session_start': datetime.datetime.now().isoformat()
            }
        return session_id
    
    def analyze_intent(self, user_input):
        """Determine what the user wants"""
        user_input_lower = user_input.lower()
        
        # Greeting detection
        if any(word in user_input_lower for word in ['hello', 'hi', 'hey', 'greetings']):
            return 'greeting'
        
        # Website help
        if any(word in user_input_lower for word in ['help', 'navigate', 'find', 'where']):
            return 'website_help'
        
        # Services inquiry
        if any(word in user_input_lower for word in ['service', 'offer', 'do', 'provide', 'develop']):
            return 'services'
        
        # Contact information
        if any(word in user_input_lower for word in ['contact', 'email', 'reach', 'phone', 'address']):
            return 'contact'
        
        # Programming questions
        if any(word in user_input_lower for word in ['python', 'programming', 'code', 'developer']):
            return 'programming'
        
        # AI/ML questions
        if any(word in user_input_lower for word in ['ai', 'artificial intelligence', 'machine learning', 'chatbot']):
            return 'ai_ml'
        
        return 'general'
    
    def get_response(self, user_input, session_id):
        """Generate appropriate response"""
        intent = self.analyze_intent(user_input)
        session = self.conversation_sessions[session_id]
        
        # Add user message to history
        session['history'].append({
            'type': 'user',
            'message': user_input,
            'timestamp': datetime.datetime.now().isoformat()
        })
        
        # Generate response based on intent
        if intent in self.web_responses:
            response = random.choice(self.web_responses[intent])
        elif intent == 'programming':
            response = "Python is perfect for web development, data science, and AI! Check out our programming tutorials and services."
        elif intent == 'ai_ml':
            response = "Artificial Intelligence and Machine Learning are exciting fields! We offer AI consulting and custom chatbot development."
        else:
            response = "Thanks for your message! I'm here to help with information about our services and website."
        
        # Add bot response to history
        session['history'].append({
            'type': 'bot',
            'message': response,
            'timestamp': datetime.datetime.now().isoformat()
        })
        
        return response

# Initialize chatbot
web_bot = WebChatBot()

@app.route('/')
def home():
    """Main chatbot page"""
    return '''
    
    
    
        
        
        
        
    
    
        
Python Web Chatbot Demo
        

            
Hello! I'm your web chatbot assistant. Ask me about our services, Python programming, or AI development!
        
        

            
            Send
        
        
        
    
    
    '''

@app.route('/chat', methods=['POST'])
def chat():
    """Handle chat messages"""
    try:
        data = request.get_json()
        user_message = data.get('message', '')
        
        if not user_message:
            return jsonify({'error': 'No message provided'}), 400
        
        # Get session and response
        session_id = web_bot.get_session_id(request)
        bot_response = web_bot.get_response(user_message, session_id)
        
        return jsonify({
            'response': bot_response,
            'timestamp': datetime.datetime.now().isoformat()
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/history')
def conversation_history():
    """Get conversation history for debugging"""
    session_id = web_bot.get_session_id(request)
    session = web_bot.conversation_sessions.get(session_id, {})
    return jsonify(session)

if __name__ == '__main__':
    print("Starting Flask Web Chatbot...")
    print("Visit http://localhost:5000 to chat with the bot!")
    app.run(debug=True, host='0.0.0.0', port=5000)

# Chatbot with Weather API Integration
import requests
import json

class WeatherChatBot:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "http://api.openweathermap.org/data/2.5/weather"
    
    def get_weather(self, city_name):
        """Get weather information for a city"""
        try:
            # Build API request URL
            complete_url = f"{self.base_url}?q={city_name}&appid={self.api_key}&units=metric"
            
            # Make API request
            response = requests.get(complete_url)
            weather_data = response.json()
            
            if weather_data["cod"] != "404":
                # Extract weather information
                main_data = weather_data["main"]
                weather_desc = weather_data["weather"][0]["description"]
                temperature = main_data["temp"]
                feels_like = main_data["feels_like"]
                humidity = main_data["humidity"]
                
                weather_report = f"""
Weather in {city_name}:
Temperature: {temperature}°C (feels like {feels_like}°C)
Condition: {weather_desc.title()}
Humidity: {humidity}%
                """
                return weather_report.strip()
            else:
                return f"Sorry, I couldn't find weather information for {city_name}."
                
        except Exception as e:
            return "Sorry, I'm having trouble getting weather information right now."
    
    def respond(self, user_input):
        """Main chatbot response method"""
        user_input_lower = user_input.lower()
        
        # Check if user is asking about weather
        if "weather" in user_input_lower:
            # Try to extract city name
            words = user_input.split()
            city_keywords = ["in", "for", "at", "weather"]
            
            city_name = None
            for i, word in enumerate(words):
                if word.lower() in city_keywords and i + 1 < len(words):
                    # Get the next word as potential city name
                    potential_city = words[i + 1].strip(".,!?")
                    if potential_city.isalpha():
                        city_name = potential_city
                        break
            
            if city_name:
                return self.get_weather(city_name)
            else:
                return "To get weather information, please ask like: 'What's the weather in London?'"
        
        # Regular chatbot responses
        elif "hello" in user_input_lower or "hi" in user_input_lower:
            return "Hello! I can help you with weather information. Just ask about the weather in any city!"
        
        elif "help" in user_input_lower:
            return "I can provide weather information for cities around the world. Try asking: 'What's the weather in [city name]?'"
        
        else:
            return "I specialize in weather information. Ask me about the weather in any city!"

# Note: You need to get a free API key from OpenWeatherMap.org
# weather_bot = WeatherChatBot("your_api_key_here")
# print(weather_bot.respond("What's the weather in London?"))

# Voice-Enabled Chatbot
# Install: pip install SpeechRecognition pyttsx3 pyaudio

import speech_recognition as sr
import pyttsx3
import threading

class VoiceChatBot:
    def __init__(self):
        # Initialize speech recognition
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
        
        # Initialize text-to-speech
        self.tts_engine = pyttsx3.init()
        self.setup_voice()
        
        # Adjust for ambient noise
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
    
    def setup_voice(self):
        """Configure text-to-speech settings"""
        voices = self.tts_engine.getProperty('voices')
        
        # Try to use a female voice if available
        for voice in voices:
            if "female" in voice.name.lower() or "zira" in voice.name.lower():
                self.tts_engine.setProperty('voice', voice.id)
                break
        
        # Set speech rate and volume
        self.tts_engine.setProperty('rate', 150)  # Words per minute
        self.tts_engine.setProperty('volume', 0.8)  # Volume level (0.0 to 1.0)
    
    def speak(self, text):
        """Convert text to speech"""
        print(f"Bot: {text}")
        self.tts_engine.say(text)
        self.tts_engine.runAndWait()
    
    def listen(self):
        """Listen for user speech and convert to text"""
        try:
            print("Listening...")
            with self.microphone as source:
                # Listen for audio with timeout
                audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=10)
            
            print("Processing speech...")
            # Convert speech to text
            text = self.recognizer.recognize_google(audio)
            print(f"You said: {text}")
            return text
            
        except sr.WaitTimeoutError:
            return "timeout"
        except sr.UnknownValueError:
            return "could_not_understand"
        except sr.RequestError as e:
            print(f"Speech recognition error: {e}")
            return "error"
    
    def get_text_response(self, user_input):
        """Generate chatbot response (same as text chatbot)"""
        user_input_lower = user_input.lower()
        
        if "hello" in user_input_lower or "hi" in user_input_lower:
            return "Hello! I'm your voice-enabled chatbot. I can hear you and speak back!"
        
        elif "how are you" in user_input_lower:
            return "I'm doing great! Thanks for asking. How are you today?"
        
        elif "weather" in user_input_lower:
            return "I'd need to connect to a weather service to get current weather information."
        
        elif "what can you do" in user_input_lower or "help" in user_input_lower:
            return "I can listen to your speech, understand what you're saying, and respond with voice. Try asking me questions!"
        
        elif "goodbye" in user_input_lower or "bye" in user_input_lower:
            return "Goodbye! It was great talking with you. Have a wonderful day!"
        
        else:
            return "That's interesting! I'm still learning to understand different topics. What else would you like to talk about?"
    
    def start_conversation(self):
        """Main conversation loop"""
        self.speak("Hello! I'm your voice chatbot. Start talking to me!")
        
        while True:
            # Listen for user input
            user_speech = self.listen()
            
            if user_speech == "timeout":
                self.speak("I didn't hear anything. Are you still there?")
                continue
            elif user_speech == "could_not_understand":
                self.speak("Sorry, I couldn't understand what you said. Could you repeat that?")
                continue
            elif user_speech == "error":
                self.speak("I'm having trouble with speech recognition. Let's try again.")
                continue
            
            # Check for exit commands
            if any(word in user_speech.lower() for word in ["goodbye", "bye", "exit", "quit"]):
                self.speak("Goodbye! Thanks for chatting with me.")
                break
            
            # Generate and speak response
            response = self.get_text_response(user_speech)
            self.speak(response)

# Create and start voice chatbot
# voice_bot = VoiceChatBot()
# voice_bot.start_conversation()

# Chatbot with Sentiment Analysis
from textblob import TextBlob
import random

class SentimentAwareChatBot:
    def __init__(self):
        self.positive_responses = [
            "I'm glad you're feeling positive! How can I help you today?",
            "Your positive energy is wonderful! What would you like to discuss?",
            "It's great to chat with someone in a good mood! What's on your mind?"
        ]
        
        self.negative_responses = [
            "I sense you might be feeling down. I'm here to help if you need it.",
            "It sounds like you're having a tough time. Would you like to talk about it?",
            "I'm sorry you're not feeling great. How can I make your day better?"
        ]
        
        self.neutral_responses = [
            "Thanks for sharing that with me. What else would you like to know?",
            "I understand. How can I assist you today?",
            "Got it. What other questions do you have?"
        ]
    
    def analyze_sentiment(self, text):
        """Analyze the emotional tone of user input"""
        blob = TextBlob(text)
        polarity = blob.sentiment.polarity
        
        # Polarity ranges from -1 (negative) to 1 (positive)
        if polarity > 0.1:
            return "positive"
        elif polarity < -0.1:
            return "negative"
        else:
            return "neutral"
    
    def get_emotion_keywords(self, text):
        """Detect emotion-related keywords"""
        text_lower = text.lower()
        
        positive_keywords = ["happy", "great", "awesome", "wonderful", "excited", "love", "amazing", "fantastic"]
        negative_keywords = ["sad", "angry", "frustrated", "upset", "terrible", "awful", "hate", "annoyed"]
        
        positive_count = sum(1 for word in positive_keywords if word in text_lower)
        negative_count = sum(1 for word in negative_keywords if word in text_lower)
        
        if positive_count > negative_count:
            return "positive"
        elif negative_count > positive_count:
            return "negative"
        else:
            return "neutral"
    
    def respond(self, user_input):
        """Generate response based on sentiment analysis"""
        # Analyze sentiment using both methods
        textblob_sentiment = self.analyze_sentiment(user_input)
        keyword_sentiment = self.get_emotion_keywords(user_input)
        
        # Combine both analyses
        if textblob_sentiment == "positive" or keyword_sentiment == "positive":
            final_sentiment = "positive"
        elif textblob_sentiment == "negative" or keyword_sentiment == "negative":
            final_sentiment = "negative"
        else:
            final_sentiment = "neutral"
        
        # Choose appropriate response based on sentiment
        if final_sentiment == "positive":
            base_response = random.choice(self.positive_responses)
        elif final_sentiment == "negative":
            base_response = random.choice(self.negative_responses)
        else:
            base_response = random.choice(self.neutral_responses)
        
        # Add content-specific response
        user_input_lower = user_input.lower()
        
        if "help" in user_input_lower:
            base_response += " I'm here to help with any questions you have."
        elif "learn" in user_input_lower or "teach" in user_input_lower:
            base_response += " I love helping people learn new things!"
        elif "problem" in user_input_lower or "issue" in user_input_lower:
            base_response += " Let's work together to solve this problem."
        
        return base_response

# Test the sentiment-aware chatbot
sentiment_bot = SentimentAwareChatBot()

print("Sentiment-Aware ChatBot: Hello! I can understand your emotions.")
print("Bot:", sentiment_bot.respond("I'm having a fantastic day!"))
print("Bot:", sentiment_bot.respond("I'm really frustrated with this problem."))
print("Bot:", sentiment_bot.respond("Can you help me learn Python programming?"))