Update app.py

app.py

@@ -4,71 +4,71 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import linear_kernel
 import gradio as gr
 
-# Function to fetch sustainable products from Open Food Facts API
-def fetch_sustainable_products():
-    url = "https://world.openfoodfacts.org/cgi/search.pl"
+# Function to fetch medicine data from Open Drug Facts (or another source if available)
+def fetch_medicine_data():
+    url = "https://api.opendrugfacts.org/cgi/search.pl"  # Replace with actual URL if available
     params = {
-        'search_terms': 'sustainable',
-        'page_size': 100,  # Fetch up to 100 products
+        'search_terms': 'drug',  # General search term for medications
+        'page_size': 100,        # Fetch up to 100 drugs
         'json': True
     }
     
     response = requests.get(url, params=params)
     if response.status_code == 200:
         data = response.json()
-        products = data.get('products', [])
+        medicines = data.get('products', [])
         
-        # Create a DataFrame from the product data
-        product_data = []
-        for product in products:
-            product_info = {
-                'product_id': product.get('id'),
-                'product_name': product.get('product_name'),
-                'category': product.get('categories', ['Unknown'])[0],  # Get first category or 'Unknown'
-                'description': product.get('ingredients_text', 'No description available'),
-                'eco_rating': product.get('ecoscore_score', 0)  # Eco score (if available)
+        # Create a DataFrame from the medicine data
+        medicine_data = []
+        for med in medicines:
+            med_info = {
+                'drug_id': med.get('id'),
+                'drug_name': med.get('product_name'),
+                'composition': med.get('ingredients_text', 'No composition available'),
+                'category': med.get('categories', ['Unknown'])[0],
+                'description': med.get('generic_name', 'No description available')
             }
-            product_data.append(product_info)
+            medicine_data.append(med_info)
         
-        return pd.DataFrame(product_data)
+        return pd.DataFrame(medicine_data)
     else:
         print("Failed to fetch data:", response.status_code)
         return pd.DataFrame()
 
-# Fetch the sustainable products
-products_df = fetch_sustainable_products()
+# Fetch the medicine data
+medicines_df = fetch_medicine_data()
 
-# Creating the TF-IDF matrix
+# Create the TF-IDF matrix for finding similar medicines
 tfidf = TfidfVectorizer(stop_words='english')
-tfidf_matrix = tfidf.fit_transform(products_df['description'].fillna(''))
+tfidf_matrix = tfidf.fit_transform(medicines_df['composition'].fillna(''))
 
 # Compute the cosine similarity matrix
 cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)
 
-# Function to get recommendations based on product name
-def get_recommendations(product_name, cosine_sim=cosine_sim):
-    if product_name not in products_df['product_name'].values:
-        return pd.DataFrame(columns=['product_name', 'description'])  # Return empty DataFrame if not found
-    idx = products_df.index[products_df['product_name'] == product_name][0]
+# Function to get recommendations based on drug name or composition
+def get_alternatives(drug_name, cosine_sim=cosine_sim):
+    if drug_name not in medicines_df['drug_name'].values:
+        return pd.DataFrame(columns=['drug_name', 'composition'])  # Return empty DataFrame if not found
+    idx = medicines_df.index[medicines_df['drug_name'] == drug_name][0]
     sim_scores = list(enumerate(cosine_sim[idx]))
     sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
-    sim_scores = sim_scores[1:4]  # Get top 3 recommendations
-    product_indices = [i[0] for i in sim_scores]
-    return products_df.iloc[product_indices][['product_name', 'description']]
+    sim_scores = sim_scores[1:4]  # Get top 3 alternatives
+    alternative_indices = [i[0] for i in sim_scores]
+    return medicines_df.iloc[alternative_indices][['drug_name', 'composition']]
 
-# Define the recommend_product function for Gradio
-def recommend_product(selected_product):
-    recommendations = get_recommendations(selected_product)
-    return recommendations
+# Define the recommend_alternative function for Gradio
+def recommend_alternative(selected_drug):
+    alternatives = get_alternatives(selected_drug)
+    return alternatives
 
 # Create the Gradio interface
-product_names = products_df['product_name'].dropna().tolist()  # List of product names
+drug_names = medicines_df['drug_name'].dropna().tolist()  # List of drug names
 interface = gr.Interface(
-    fn=recommend_product,
-    inputs=gr.Dropdown(choices=product_names, label="Select a Product"),
+    fn=recommend_alternative,
+    inputs=gr.Dropdown(choices=drug_names, label="Select a Drug"),
     outputs="dataframe",
-    title="Sustainable Product Recommendation System",
-    description="Select a product to see similar sustainable product recommendations."
+    title="Medicine Alternative Recommendation System",
+    description="Select a medicine to see alternative drugs with similar compositions."
 )
 
 # Launch the interface