Update app.py

app.py

@@ -1,169 +1,59 @@
 import gradio as gr
-import requests
-from bs4 import BeautifulSoup
-import json
-import time
-from typing import Dict, List
-import concurrent.futures
-import re
-from datetime import datetime
+from transformers import pipeline
+import urllib.parse
 
-class ProductDatabase:
-    """Simple in-memory product database with caching"""
-    def __init__(self):
-        self.products = self._load_initial_products()
-        self.price_cache = {}
-        self.cache_timeout = 3600  # 1 hour cache timeout
+def extract_keywords(text: str, nlp_pipeline) -> list:
+    """Extract relevant keywords from the input text"""
+    prompt = f"Extract 3-4 most relevant gift-related keywords from: {text}\nKeywords:"
+    response = nlp_pipeline(prompt, max_new_tokens=30, num_return_sequences=1)
+    keywords = response[0]['generated_text'].split('Keywords:')[-1].strip()
+    return [k.strip() for k in keywords.split(',') if k.strip()]
 
-    def _load_initial_products(self) -> Dict:
-        """Load initial product database"""
-        return {
-            "gaming": [
-                {
-                    "id": "g1",
-                    "name": "Razer DeathAdder Essential Gaming Mouse",
-                    "base_price": 1999,
-                    "category": ["gaming", "accessories"],
-                    "keywords": ["fps", "gaming", "mouse"],
-                    "urls": {
-                        "amazon": "B07F2GC4S9",
-                        "flipkart": "ACCEYJY6GZGFDW8T"
-                    }
-                },
-                # Add more gaming products...
-            ],
-            "puzzles": [
-                {
-                    "id": "p1",
-                    "name": "Rubik's Speed Cube Pro Set",
-                    "base_price": 1499,
-                    "category": ["puzzles", "brain teasers"],
-                    "keywords": ["puzzle", "cube", "brain teaser"],
-                    "urls": {
-                        "amazon": "B07X1Z3YPV",
-                        "flipkart": "PUZRUBSPEED123"
-                    }
-                },
-                # Add more puzzle products...
-            ]
-        }
-
-class PriceFetcher:
-    """Handles real-time price fetching from e-commerce sites"""
-    def __init__(self):
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        }
-        
-    async def fetch_amazon_price(self, product_id: str) -> float:
-        """Fetch price from Amazon (simplified example)"""
-        try:
-            url = f"https://www.amazon.in/dp/{product_id}"
-            response = requests.get(url, headers=self.headers)
-            if response.status_code == 200:
-                soup = BeautifulSoup(response.text, 'html.parser')
-                price_elem = soup.find('span', class_='a-price-whole')
-                if price_elem:
-                    return float(re.sub(r'[^\d.]', '', price_elem.text))
-            return None
-        except Exception as e:
-            print(f"Error fetching Amazon price: {str(e)}")
-            return None
-
-    async def fetch_flipkart_price(self, product_id: str) -> float:
-        """Fetch price from Flipkart (simplified example)"""
-        try:
-            url = f"https://www.flipkart.com/product/{product_id}"
-            response = requests.get(url, headers=self.headers)
-            if response.status_code == 200:
-                soup = BeautifulSoup(response.text, 'html.parser')
-                price_elem = soup.find('div', class_='_30jeq3')
-                if price_elem:
-                    return float(re.sub(r'[^\d.]', '', price_elem.text))
-            return None
-        except Exception as e:
-            print(f"Error fetching Flipkart price: {str(e)}")
-            return None
-
-class RecommendationEngine:
-    """Handles product recommendations based on user input"""
-    def __init__(self, product_db: ProductDatabase, price_fetcher: PriceFetcher):
-        self.product_db = product_db
-        self.price_fetcher = price_fetcher
-        
-    def extract_keywords(self, text: str) -> List[str]:
-        """Extract relevant keywords from user input"""
-        # Convert to lowercase and split into words
-        words = text.lower().split()
-        
-        # Define common categories and their related terms
-        categories = {
-            "gaming": ["game", "gaming", "fps", "shooter", "console"],
-            "puzzles": ["puzzle", "brain teaser", "rubik", "cube"],
-            # Add more categories...
-        }
-        
-        # Extract matching keywords
-        keywords = []
-        for word in words:
-            for category, terms in categories.items():
-                if word in terms:
-                    keywords.append(category)
-        
-        return list(set(keywords))
+def generate_search_urls(keywords: list) -> dict:
+    """Generate search URLs for various e-commerce platforms"""
+    # Join keywords with appropriate separators for each platform
+    amazon_query = '+'.join(keywords)
+    flipkart_query = ' '.join(keywords)
+    igp_query = '+'.join(keywords)
+    indiamart_query = ' '.join(keywords)
+    
+    # Properly encode the queries
+    amazon_query = urllib.parse.quote(amazon_query)
+    flipkart_query = urllib.parse.quote(flipkart_query)
+    igp_query = urllib.parse.quote(igp_query)
+    indiamart_query = urllib.parse.quote(indiamart_query)
+    
+    return {
+        "Amazon India": f"https://www.amazon.in/s?k={amazon_query}",
+        "Flipkart": f"https://www.flipkart.com/search?q={flipkart_query}",
+        "IGP Gifts": f"https://www.igp.com/search?q={igp_query}",
+        "IndiaMart": f"https://www.indiamart.com/find?q={indiamart_query}"
+    }
 
-    async def get_recommendations(self, text: str) -> Dict:
-        """Get personalized recommendations based on user input"""
-        keywords = self.extract_keywords(text)
-        recommendations = []
+def recommend_gifts(text: str):
+    """Main function to generate gift recommendations"""
+    if not text:
+        return {"error": "Please provide a description."}
+    
+    try:
+        # Initialize the language model
+        nlp = pipeline(
+            "text-generation",
+            model="gpt2",
+            device_map="auto"
+        )
         
-        # Get relevant products based on keywords
-        for keyword in keywords:
-            if keyword in self.product_db.products:
-                products = self.product_db.products[keyword][:2]  # Get top 2 products per category
-                recommendations.extend(products)
+        # Extract relevant keywords
+        keywords = extract_keywords(text, nlp)
         
-        # Fetch real-time prices and format recommendations
-        formatted_recommendations = []
-        for product in recommendations:
-            # Fetch prices concurrently
-            amazon_price = await self.price_fetcher.fetch_amazon_price(product['urls'].get('amazon'))
-            flipkart_price = await self.price_fetcher.fetch_flipkart_price(product['urls'].get('flipkart'))
-            
-            # Use the lowest available price or fall back to base price
-            current_price = min(
-                filter(None, [amazon_price, flipkart_price, product['base_price']])
-            )
-            
-            formatted_recommendations.append({
-                "name": product['name'],
-                "price": f"₹{current_price:,.2f}",
-                "links": {
-                    "Amazon": f"https://www.amazon.in/dp/{product['urls'].get('amazon')}",
-                    "Flipkart": f"https://www.flipkart.com/product/{product['urls'].get('flipkart')}"
-                }
-            })
+        # Generate search URLs
+        search_links = generate_search_urls(keywords)
         
         return {
-            "recommendations": formatted_recommendations,
-            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            "keywords": keywords,
+            "search_links": search_links
         }
-
-# Initialize components
-product_db = ProductDatabase()
-price_fetcher = PriceFetcher()
-recommendation_engine = RecommendationEngine(product_db, price_fetcher)
-
-def recommend_gifts(text: str) -> Dict:
-    """Gradio interface function"""
-    if not text:
-        return {"error": "Please provide a description."}
-    
-    try:
-        # Get recommendations (using asyncio in a simplified way)
-        import asyncio
-        recommendations = asyncio.run(recommendation_engine.get_recommendations(text))
-        return recommendations
+        
     except Exception as e:
         return {"error": f"An error occurred: {str(e)}"}
 
@@ -172,14 +62,15 @@ demo = gr.Interface(
     fn=recommend_gifts,
     inputs=gr.Textbox(
         lines=3,
-        placeholder="Describe the person you're buying a gift for (their interests, hobbies, age, occasion, etc.)"
+        placeholder="Describe who you're buying a gift for (age, interests, occasion, etc.)"
     ),
     outputs=gr.JSON(),
     title="🎁 Smart Gift Recommender",
-    description="Get personalized gift recommendations with real-time prices!",
+    description="Get personalized gift suggestions with direct shopping links!",
     examples=[
+        ["a small kid of age 3 want him to have something like toy that teaches him alphabets"],
         ["age is 25 and he loves puzzle and online FPS games"],
-        ["Looking for a gift for my mom who enjoys gardening and cooking"],
+        ["Looking for a gift for my mom who enjoys gardening and cooking"]
     ]
 )