Module 1: AI Automation Fundamentals – Part 1

# Example: Different types of data inputs in Python
import json
import requests
from datetime import datetime

# Text Input Example
def process_text_input(user_message):
    """Process text input from user"""
    cleaned_text = user_message.strip().lower()
    word_count = len(cleaned_text.split())
    
    return {
        'original': user_message,
        'processed': cleaned_text,
        'word_count': word_count,
        'timestamp': datetime.now().isoformat()
    }

# API Data Input Example
def fetch_api_data(endpoint_url):
    """Fetch data from an external API"""
    try:
        response = requests.get(endpoint_url)
        if response.status_code == 200:
            return response.json()
        else:
            return {'error': f'API returned status code {response.status_code}'}
    except Exception as e:
        return {'error': str(e)}

# File Input Example
def read_csv_data(file_path):
    """Read data from a CSV file"""
    import csv
    data = []
    try:
        with open(file_path, 'r') as file:
            csv_reader = csv.DictReader(file)
            for row in csv_reader:
                data.append(row)
        return data
    except FileNotFoundError:
        return {'error': 'File not found'}

# Example usage
if __name__ == "__main__":
    # Process text input
    user_input = "Hello, I need help with my order #12345"
    text_result = process_text_input(user_input)
    print(f"Text Processing Result: {json.dumps(text_result, indent=2)}")
    
    # Fetch from API (example with a public API)
    api_url = "https://api.github.com/users/github"
    api_result = fetch_api_data(api_url)
    print(f"nAPI Data Sample: {json.dumps(api_result, indent=2)[:200]}...")
    
    # Note: CSV reading would require an actual file
    print("nData input successfully processed!")

# Example: Simple AI Processing with Sentiment Analysis
# This example demonstrates how AI processes text to understand sentiment

class SimpleAIProcessor:
    def __init__(self):
        # Simple keyword-based sentiment analysis for demonstration
        self.positive_words = ['good', 'great', 'excellent', 'happy', 'love', 
                              'wonderful', 'amazing', 'fantastic', 'perfect', 'best']
        self.negative_words = ['bad', 'terrible', 'awful', 'hate', 'worst', 
                              'horrible', 'disappointing', 'poor', 'useless', 'broken']
        
    def analyze_sentiment(self, text):
        """Analyze the sentiment of given text"""
        text_lower = text.lower()
        words = text_lower.split()
        
        positive_score = sum(1 for word in words if word in self.positive_words)
        negative_score = sum(1 for word in words if word in self.negative_words)
        
        # Determine overall sentiment
        if positive_score > negative_score:
            sentiment = 'positive'
            confidence = (positive_score / len(words)) * 100
        elif negative_score > positive_score:
            sentiment = 'negative'
            confidence = (negative_score / len(words)) * 100
        else:
            sentiment = 'neutral'
            confidence = 50
            
        return {
            'text': text,
            'sentiment': sentiment,
            'positive_score': positive_score,
            'negative_score': negative_score,
            'confidence': round(confidence, 2),
            'word_count': len(words)
        }
    
    def categorize_intent(self, text):
        """Categorize the intent of the message"""
        text_lower = text.lower()
        
        # Simple intent detection based on keywords
        if any(word in text_lower for word in ['help', 'support', 'problem', 'issue']):
            return 'support_request'
        elif any(word in text_lower for word in ['buy', 'purchase', 'order', 'price']):
            return 'sales_inquiry'
        elif any(word in text_lower for word in ['cancel', 'refund', 'return']):
            return 'cancellation_request'
        elif any(word in text_lower for word in ['thank', 'thanks', 'appreciate']):
            return 'appreciation'
        else:
            return 'general_inquiry'
    
    def generate_response(self, sentiment, intent):
        """Generate an appropriate response based on sentiment and intent"""
        responses = {
            'positive': {
                'support_request': "I'm glad to help you! Let me assist you with your concern.",
                'sales_inquiry': "Wonderful! I'd be happy to help you with your purchase.",
                'appreciation': "Thank you so much! We're delighted to serve you.",
                'general_inquiry': "Thanks for reaching out! How can I assist you today?"
            },
            'negative': {
                'support_request': "I understand your frustration. Let me help resolve this immediately.",
                'sales_inquiry': "I apologize for any inconvenience. Let me help you find the right solution.",
                'cancellation_request': "I'm sorry to hear that. Let me process your request right away.",
                'general_inquiry': "I apologize for any issues. How can I make this right?"
            },
            'neutral': {
                'support_request': "I'll be happy to help you with your request.",
                'sales_inquiry': "I can help you with product information and pricing.",
                'general_inquiry': "Thank you for contacting us. How may I assist you?"
            }
        }
        
        return responses.get(sentiment, {}).get(intent, "Thank you for your message. How can I help you?")

# Example usage
processor = SimpleAIProcessor()

# Test messages
test_messages = [
    "This product is absolutely amazing! Best purchase ever!",
    "I'm having a terrible problem with my order. Very disappointing.",
    "Can you help me with the pricing for your premium plan?",
    "I want to cancel my subscription immediately.",
    "Thanks for the great customer service!"
]

print("AI Processing Engine Demon" + "="*50)
for message in test_messages:
    # Analyze sentiment
    sentiment_result = processor.analyze_sentiment(message)
    
    # Detect intent
    intent = processor.categorize_intent(message)
    
    # Generate response
    response = processor.generate_response(sentiment_result['sentiment'], intent)
    
    print(f"nInput: {message}")
    print(f"Sentiment: {sentiment_result['sentiment']} (Confidence: {sentiment_result['confidence']}%)")
    print(f"Intent: {intent}")
    print(f"AI Response: {response}")
    print("-" * 50)

Recommended Browser Extensions:

1. JSON Viewer (Chrome/Firefox)
   - Purpose: Makes API responses readable
   - Install from your browser's extension store
   
2. Postman or Insomnia
   - Purpose: Testing API calls
   - Download from: postman.com or insomnia.rest
   
3. Web Developer Tools
   - Purpose: Inspect web elements
   - Built into Chrome/Firefox (Press F12)
   
4. Grammarly (Optional)
   - Purpose: Helps with content generation tasks
   - Install from grammarly.com
   
5. LastPass or Bitwarden
   - Purpose: Password management
   - Essential for managing multiple service accounts