Create app.py

app.py

@@ -0,0 +1,289 @@
+import gradio as gr
+import pandas as pd
+import re
+import numpy as np
+from typing import List, Dict, Any
+
+# Load and clean the dataset
+df = pd.read_csv("indian_car_info.csv")
+
+# Clean brand and model columns
+df["brand"] = df["brand"].str.strip().str.lower()
+df["model"] = df["model"].str.strip()
+df["features"] = df["features"].astype(str).str.lower()
+
+# Control long responses
+MAX_TOTAL_CHARACTERS = 3000
+
+def extract_numbers(text: str) -> List[float]:
+    """Extract all numbers from text"""
+    return [float(x) for x in re.findall(r'\d+\.?\d*', text)]
+
+def find_brand_mentions(query: str) -> List[str]:
+    """Find all brand mentions in query"""
+    unique_brands = df["brand"].unique()
+    return [brand for brand in unique_brands if brand in query.lower()]
+
+def find_model_mentions(query: str) -> List[str]:
+    """Find all model mentions in query"""
+    unique_models = df["model"].str.lower().unique()
+    return [model for model in unique_models if model.lower() in query.lower()]
+
+def extract_price_range(query: str) -> tuple:
+    """Extract price range from query"""
+    min_price, max_price = None, None
+    
+    # Pattern for "under X", "below X", "less than X"
+    under_match = re.search(r'(?:under|below|less than|up to)\s*₹?(\d+)', query.lower())
+    if under_match:
+        max_price = float(under_match.group(1))
+    
+    # Pattern for "above X", "more than X", "at least X"
+    above_match = re.search(r'(?:above|more than|at least|over)\s*₹?(\d+)', query.lower())
+    if above_match:
+        min_price = float(above_match.group(1))
+    
+    # Pattern for "between X and Y"
+    between_match = re.search(r'between\s*₹?(\d+)\s*(?:and|to)\s*₹?(\d+)', query.lower())
+    if between_match:
+        min_price = float(between_match.group(1))
+        max_price = float(between_match.group(2))
+    
+    # Pattern for "around X", "approximately X"
+    around_match = re.search(r'(?:around|approximately|about)\s*₹?(\d+)', query.lower())
+    if around_match:
+        target = float(around_match.group(1))
+        min_price = target - 2
+        max_price = target + 2
+    
+    return min_price, max_price
+
+def extract_mileage_range(query: str) -> tuple:
+    """Extract mileage requirements from query"""
+    min_mileage, max_mileage = None, None
+    
+    # Look for mileage-related keywords
+    mileage_keywords = ['mileage', 'fuel efficiency', 'kmpl', 'fuel economy']
+    has_mileage_context = any(keyword in query.lower() for keyword in mileage_keywords)
+    
+    if has_mileage_context:
+        # Pattern for "above X kmpl", "more than X kmpl"
+        above_match = re.search(r'(?:above|more than|at least|over)\s*(\d+)', query.lower())
+        if above_match:
+            min_mileage = float(above_match.group(1))
+        
+        # Pattern for "below X kmpl", "under X kmpl"
+        below_match = re.search(r'(?:below|under|less than)\s*(\d+)', query.lower())
+        if below_match:
+            max_mileage = float(below_match.group(1))
+    
+    return min_mileage, max_mileage
+
+def extract_features(query: str) -> List[str]:
+    """Extract feature requirements from query"""
+    feature_keywords = [
+        "sunroof", "automatic", "manual", "cruise control", "abs", "airbags", 
+        "android auto", "touchscreen", "rear camera", "parking sensor", 
+        "bluetooth", "usb", "keyless", "push button", "climate control",
+        "leather seats", "alloy wheels", "fog lights", "power steering",
+        "power windows", "central locking", "music system", "navigation"
+    ]
+    
+    return [feat for feat in feature_keywords if feat in query.lower()]
+
+def get_comparison_cars(query: str) -> List[Dict]:
+    """Handle comparison queries"""
+    # Look for comparison keywords
+    comparison_words = ['vs', 'versus', 'compare', 'comparison', 'better', 'best']
+    if not any(word in query.lower() for word in comparison_words):
+        return []
+    
+    brands = find_brand_mentions(query)
+    models = find_model_mentions(query)
+    
+    if len(brands) >= 2 or len(models) >= 2:
+        # Return cars for comparison
+        if models:
+            return df[df["model"].str.lower().isin(models)].to_dict('records')
+        else:
+            return df[df["brand"].isin(brands)].to_dict('records')
+    
+    return []
+
+def handle_specific_questions(query: str) -> str:
+    """Handle specific question types"""
+    query_lower = query.lower()
+    
+    # Price questions
+    if any(word in query_lower for word in ['cheapest', 'lowest price', 'most affordable']):
+        cheapest = df.loc[df['price_lakh'].idxmin()]
+        return f"💰 Cheapest car: {cheapest['brand'].title()} {cheapest['model']} at ₹{cheapest['price_lakh']} Lakh"
+    
+    if any(word in query_lower for word in ['most expensive', 'highest price', 'premium']):
+        expensive = df.loc[df['price_lakh'].idxmax()]
+        return f"💎 Most expensive car: {expensive['brand'].title()} {expensive['model']} at ₹{expensive['price_lakh']} Lakh"
+    
+    # Mileage questions
+    if any(word in query_lower for word in ['best mileage', 'highest mileage', 'most fuel efficient']):
+        best_mileage = df.loc[df['mileage_kmpl'].idxmax()]
+        return f"⛽ Best mileage car: {best_mileage['brand'].title()} {best_mileage['model']} with {best_mileage['mileage_kmpl']} kmpl"
+    
+    if any(word in query_lower for word in ['worst mileage', 'lowest mileage', 'least fuel efficient']):
+        worst_mileage = df.loc[df['mileage_kmpl'].idxmin()]
+        return f"⛽ Lowest mileage car: {worst_mileage['brand'].title()} {worst_mileage['model']} with {worst_mileage['mileage_kmpl']} kmpl"
+    
+    # Count questions
+    if any(word in query_lower for word in ['how many', 'count', 'number of']):
+        if any(brand in query_lower for brand in df['brand'].unique()):
+            brand = next(brand for brand in df['brand'].unique() if brand in query_lower)
+            count = len(df[df['brand'] == brand])
+            return f"📊 {brand.title()} has {count} cars in our database"
+        else:
+            return f"📊 Total cars in database: {len(df)}"
+    
+    # Average questions
+    if 'average' in query_lower:
+        if 'price' in query_lower:
+            avg_price = df['price_lakh'].mean()
+            return f"📊 Average car price: ₹{avg_price:.2f} Lakh"
+        elif 'mileage' in query_lower:
+            avg_mileage = df['mileage_kmpl'].mean()
+            return f"📊 Average mileage: {avg_mileage:.2f} kmpl"
+    
+    # Brand-specific questions
+    brands = find_brand_mentions(query)
+    if brands and any(word in query_lower for word in ['models', 'variants', 'options']):
+        brand = brands[0]
+        brand_cars = df[df['brand'] == brand]
+        models = brand_cars['model'].unique()
+        return f"🚗 {brand.title()} models: {', '.join(models)}"
+    
+    return ""
+
+def format_car_details(car: Dict, show_features: bool = True) -> str:
+    """Format car details for display"""
+    features_text = ""
+    if show_features and 'features' in car:
+        features = car['features'][:200] + "..." if len(car['features']) > 200 else car['features']
+        features_text = f"- Features: {features.title()}\n"
+    
+    return f"""🚗 {car['brand'].title()} {car['model']}
+- Engine: {car['engine']}
+- Mileage: {car['mileage_kmpl']} kmpl
+- Price: ₹{car['price_lakh']} Lakh
+{features_text}"""
+
+def answer_question(query: str) -> str:
+    if not query.strip():
+        return "❓ Please ask me something about Indian cars!"
+    
+    query = query.strip()
+    
+    # Handle specific questions first
+    specific_answer = handle_specific_questions(query)
+    if specific_answer:
+        return specific_answer
+    
+    # Handle comparisons
+    comparison_cars = get_comparison_cars(query)
+    if comparison_cars:
+        response = "📊 Car Comparison:\n\n"
+        for car in comparison_cars[:3]:  # Limit to 3 cars
+            response += format_car_details(car, show_features=False) + "\n"
+        return response.strip()
+    
+    # Check for specific car mention (brand + model)
+    for _, row in df.iterrows():
+        car_name = f"{row['brand']} {row['model']}".lower()
+        if car_name in query.lower():
+            return f"📌 {row['brand'].title()} {row['model']} Details:\n" + format_car_details(row.to_dict())
+    
+    # Start filtering
+    filtered_df = df.copy()
+    
+    # Filter by brand
+    brands = find_brand_mentions(query)
+    if brands:
+        filtered_df = filtered_df[filtered_df["brand"].isin(brands)]
+    
+    # Filter by model
+    models = find_model_mentions(query)
+    if models:
+        filtered_df = filtered_df[filtered_df["model"].str.lower().isin(models)]
+    
+    # Filter by price
+    min_price, max_price = extract_price_range(query)
+    if min_price is not None:
+        filtered_df = filtered_df[filtered_df["price_lakh"] >= min_price]
+    if max_price is not None:
+        filtered_df = filtered_df[filtered_df["price_lakh"] <= max_price]
+    
+    # Filter by mileage
+    min_mileage, max_mileage = extract_mileage_range(query)
+    if min_mileage is not None:
+        filtered_df = filtered_df[filtered_df["mileage_kmpl"] >= min_mileage]
+    if max_mileage is not None:
+        filtered_df = filtered_df[filtered_df["mileage_kmpl"] <= max_mileage]
+    
+    # Filter by features
+    features = extract_features(query)
+    for feature in features:
+        filtered_df = filtered_df[filtered_df["features"].str.contains(feature, na=False)]
+    
+    # Sort results based on query intent
+    if any(word in query.lower() for word in ['cheap', 'affordable', 'budget']):
+        filtered_df = filtered_df.sort_values('price_lakh')
+    elif any(word in query.lower() for word in ['expensive', 'premium', 'luxury']):
+        filtered_df = filtered_df.sort_values('price_lakh', ascending=False)
+    elif any(word in query.lower() for word in ['mileage', 'fuel efficient', 'economy']):
+        filtered_df = filtered_df.sort_values('mileage_kmpl', ascending=False)
+    
+    # Generate response
+    if filtered_df.empty:
+        return "❌ No matching cars found for your query. Try adjusting your requirements!"
+    
+    response = ""
+    if len(filtered_df) > 1:
+        response += f"Found {len(filtered_df)} matching cars:\n\n"
+    
+    for _, row in filtered_df.head(5).iterrows():  # Show top 5 results
+        entry = format_car_details(row.to_dict()) + "\n"
+        if len(response + entry) > MAX_TOTAL_CHARACTERS:
+            break
+        response += entry
+    
+    if len(filtered_df) > 5:
+        response += f"\n... and {len(filtered_df) - 5} more cars match your criteria."
+    
+    return response.strip()
+
+# Enhanced Gradio interface
+examples = [
+    "Show me Maruti cars under 8 lakhs with sunroof",
+    "What's the mileage of Tata Nexon?",
+    "Compare Hyundai Creta vs Tata Harrier",
+    "Cheapest automatic car",
+    "Best mileage car under 10 lakhs",
+    "Mahindra cars with price and mileage",
+    "Cars between 5 and 15 lakhs",
+    "Which car has the best features?",
+    "Show me all Honda models",
+    "Average price of cars in database"
+]
+
+gr.Interface(
+    fn=answer_question,
+    inputs=gr.Textbox(
+        lines=2,
+        placeholder="Ask me anything about Indian cars! E.g., 'Best mileage car under 10L', 'Compare Creta vs Harrier'",
+        label="Your Question"
+    ),
+    outputs=gr.Textbox(
+        lines=15,
+        label="Car Information"
+    ),
+    title="🚘 Enhanced Indian Car AI Assistant",
+    description="Ask me anything about Indian cars! I can help with comparisons, recommendations, specifications, and more.",
+    examples=examples,
+    theme="soft"
+).launch()