Initial Commit

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

EatEasy_EveryThing_From_url.py

@@ -0,0 +1,565 @@
+# url = input("Enter Restro Url : ")
+from urllib.parse import urlparse
+import pymongo
+from config import settings
+
+def EatEasy_EveryThing_From_url(url):
+
+    client = pymongo.MongoClient(settings.MONGO_URL)
+
+    def restro_details(url,location_area,location_name):
+        
+    
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        parsed_url = urlparse(url)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_name = parsed_url.path.strip('/').split('/')[-1]
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name,
+            "location_area" : location_area ,
+            "location_name" : location_name
+          }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+
+    def main_excel_file(url_input):
+        import requests
+        import json
+        import pandas as pd
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+        import math
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+
+            for i, item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    type_ = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    type_ = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    value = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    value = None
+
+                if type_ not in category_name_list:
+                    category_name_list.append(type_)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": type_,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i, 
+                    "Image": image_url,
+                    "description": description,
+                    "price": price,
+                    "id": value,
+                }
+
+                menu_items_list.append(menu_item)  # Append menu item before the request
+                if value is not None:
+                    option_url = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{value}/1/"
+                    option_response = requests.post(option_url, headers=headers2, data=payload1)
+                    if option_response.status_code == 200:
+                        try:
+                            json_data = json.loads(option_response.text)
+                            extracted_data = []
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for choice in json_data['arrResult']['arrFoodChoice']:
+                                    extracted_data.append({
+                                        'Option_group_name': choice['choice_name'],
+                                        'Option_name': choice['name'],
+                                        'Extra_price': choice['price'],
+                                        'Min': choice.get('mandatory', 0),
+                                        'Max': choice.get('max_choice', 1)
+                                    })
+
+                            grouped_data = {}
+                            for choice in extracted_data:
+                                group_name = choice['Option_group_name']
+                                if group_name not in grouped_data:
+                                    grouped_data[group_name] = {
+                                        'Option_group_name': group_name,
+                                        'Min': choice['Min'],
+                                        'Max': max(choice['Max'], '1'),
+                                    }
+                                
+                                num_options = sum(key.startswith('Option ') for key in grouped_data[group_name])
+                                option_index = num_options + 1  # Index for the new option
+                                grouped_data[group_name][f"Option {option_index} Name"] = choice['Option_name']
+                                grouped_data[group_name][f"Option {option_index} Price"] = choice['Extra_price']
+                                
+                            for group_data in grouped_data.values():
+                                menu_items_list.append(group_data)
+
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {value}. Status code: {option_response.status_code}")
+
+            df = pd.DataFrame(menu_items_list)
+
+            # Ensure 'Max' column exists before renaming or shifting
+            if 'Max' in df.columns:
+                max_column_index = df.columns.get_loc('Max')
+                for i in range(max_column_index + 1, len(df.columns)):
+                    df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+                option_group_name_index = df.columns.get_loc('Option_group_name')
+                for i in range(option_group_name_index, len(df.columns)):
+                    df.iloc[:, i] = df.iloc[:, i].shift(-1)
+
+            excel_file = f"{restaurant_code}_menu.xlsx"
+            df.to_excel(excel_file, index=False)
+            print(f"Menu items saved to {excel_file}")
+
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+    
+
+    def main_json(url_input):
+        import requests
+        import json
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url_input, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+            location_area = soup.find('div', class_='location-area').text
+            location_name = soup.find('div', class_='location').text   
+
+            for i,item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    category = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    category = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    item_id = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    item_id = None
+                
+                if category not in category_name_list:
+                    category_name_list.append(category)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": category,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i,
+                    "Image": image_url,
+                    "Description": description,
+                    "Price": price,
+                    "ID": item_id,
+                    "Option_groups": []
+                
+                }
+
+                if item_id is not None:
+                    url1 = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{item_id}/1/"
+                    response = requests.request("POST", url1, headers=headers2, data=payload1, files=files)
+                    if response.status_code == 200:
+                        try:
+                            json_data = response.json()
+                            option_group_data = {}
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for option_group in json_data['arrResult']['arrFoodChoice']:
+                                    group_name = option_group['choice_name']
+                                    min_quantity = option_group['mandatory']
+                                    max_quantity = max((option_group['max_choice']), "1")
+
+                                    option_group_item = next((x for x in menu_item['Option_groups'] if x['Option_group_name'] == group_name), None)
+                                    if option_group_item:
+                                        option_group_item['Option_group_names'].append({
+                                            "Option_name": option_group['name'],
+                                            "Option_price": option_group['price']
+                                        })
+                                    else:
+                                        menu_item['Option_groups'].append({
+                                            "Option_group_name": group_name,
+                                            "Min": min_quantity,
+                                            "Max": max_quantity,
+                                            "Option_group_names": [{
+                                                "Option_name": option_group['name'],
+                                                "Option_price": option_group['price']
+                                            }]
+                                        })
+                            
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {item_id}. Status code: {response.status_code}")
+                if not menu_item['Option_groups']:  
+                    menu_item["Has_choice"] = False
+                
+                    
+                else:
+                    menu_item["Has_choice"] = True
+                menu_items_list.append(menu_item)
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+        # Convert the list of menu items into JSON
+        # with open(f'{restaurant_code}.json', 'w') as json_file:
+        #     json.dump(menu_items_list, json_file, indent=4)
+
+        print(f"Menu items saved to {restaurant_code}.json file.")
+
+        # main_excel_file(url_input)
+        return menu_items_list,location_area,location_name
+    
+
+    def extract_category(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+      
+
+        def item_extract_category(json,name):
+            items_list = []
+            for item in json:
+                if item['Category'] == name:
+                    item_info = {
+                            "id": item["ID"],
+                            "name": item["Item_name"]
+                        }
+                    items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+        existing_categories = set()
+        for item in json_data:
+            name = item['Category']
+            if name not in existing_categories:
+                # category_position = 1
+                # category_isActive = True
+                items = item_extract_category(json_data, name)
+
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_item(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['ID']
+            name = item['Item_name']
+            description = item['Description']
+            price = item['Price']
+            img_url= item['Image']
+            category_name = item['Category']
+            item_position = item['Item_position']
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('Option_groups', []):
+                    modifires.append(option_group['Option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                        restro_id = restro['_id']
+                            
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one(
+                  {
+                  'category_name': category_name,
+                  'restro_ref_id': restro_ref_id
+                  })
+            if category:
+                category_id = category['_id']
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            for option_group in item.get('Option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                    restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["Option_group_name"]
+                min_quantity = option_group["Min"]
+                max_quantity = option_group["Max"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("Option_group_names", []):
+                    option_name = option["Option_name"]
+                    option_price = option["Option_price"]
+                    option_names.append(option_name)
+                    option_names_trial = {
+                                'Option_name': option_name,
+                                'Option_price': option_price              
+                                }
+                    option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                    for option_group in item.get('Option_groups', []):
+                        option_group_name2 = option_group["Option_group_name"]
+                        option_group_names1 = option_group.get('Option_group_names',[])
+                        if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['Option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['Option_name']) ):
+                                item_id.append(item['ID'])
+                    
+                option_group_information = {
+                    "option_group_name" : option_group_name,
+                    "min_quantity" : min_quantity,
+                    "max_quantity" : max_quantity,
+                    "option_names"  : option_names,
+                    "item_id" : item_id,
+                    "restro_ref_id" : restro_ref_id
+                }
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+                
+                existing_categories.append(option_group_check)
+        result = collection.insert_many(option_group_info)
+        print("Inserted document IDs:", result.inserted_ids)
+ 
+    def extract_option_group_names(items):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        json_data = items
+        option_names = []
+        option_names_list = []
+        restro_collection = db['Restaurant_details']
+
+    
+        for item in json_data:
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                flag = 1
+                for option_group in item.get('Option_groups', []):
+                    option_group_name2 = option_group["Option_group_name"]
+                    for option in option_group.get("Option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                            restro_id = restro['_id']
+                            
+                        restro_ref_id = restro_id
+                        option_name = option["Option_name"]
+                        option_price = option["Option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+                        # restro = restro_collection.find_one({'url': url})
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,  
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                            }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                        if flag==1:
+                            option_names.append(option_group_name)
+                        option_names_list.append(option_name)
+
+        result = collection.insert_many(option_names)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    items,location_area,location_name = main_json(url)
+    restro_details(url,location_area,location_name)
+    extract_category(items)
+    extract_item(items)
+    extract_option_group(items)
+    extract_option_group_names(items)
+    return True
+
+
+# main(url)
+                
+                
+        
+    
+
+
+    
+    
+        
+        
+    
+  
+  
+
+
+    
+
+    
+                

EatEasy_Json_only.py

@@ -0,0 +1,138 @@
+def EatEasy_Json_extract(url_input):
+        import requests
+        import json
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url_input, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+            location_area = soup.find('div', class_='location-area').text
+            location_name = soup.find('div', class_='location').text   
+
+            for i,item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    category = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    category = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    item_id = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    item_id = None
+                
+                if category not in category_name_list:
+                    category_name_list.append(category)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": category,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i,
+                    "Image": image_url,
+                    "Description": description,
+                    "Price": price,
+                    "ID": item_id,
+                    "Option_groups": []
+                
+                }
+
+                if item_id is not None:
+                    url1 = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{item_id}/1/"
+                    response = requests.request("POST", url1, headers=headers2, data=payload1, files=files)
+                    if response.status_code == 200:
+                        try:
+                            json_data = response.json()
+                            option_group_data = {}
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for option_group in json_data['arrResult']['arrFoodChoice']:
+                                    group_name = option_group['choice_name']
+                                    min_quantity = option_group['mandatory']
+                                    max_quantity = max((option_group['max_choice']), "1")
+
+                                    option_group_item = next((x for x in menu_item['Option_groups'] if x['Option_group_name'] == group_name), None)
+                                    if option_group_item:
+                                        option_group_item['Option_group_names'].append({
+                                            "Option_name": option_group['name'],
+                                            "Option_price": option_group['price']
+                                        })
+                                    else:
+                                        menu_item['Option_groups'].append({
+                                            "Option_group_name": group_name,
+                                            "Min": min_quantity,
+                                            "Max": max_quantity,
+                                            "Option_group_names": [{
+                                                "Option_name": option_group['name'],
+                                                "Option_price": option_group['price']
+                                            }]
+                                        })
+                            
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {item_id}. Status code: {response.status_code}")
+                if not menu_item['Option_groups']:  
+                    menu_item["Has_choice"] = False
+                
+                    
+                else:
+                    menu_item["Has_choice"] = True
+                menu_items_list.append(menu_item)
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+        # Convert the list of menu items into JSON
+        # with open(f'{restaurant_code}.json', 'w') as json_file:
+        #     json.dump(menu_items_list, json_file, indent=4)
+
+        print(f"Menu items saved to {restaurant_code}.json file.")
+        return json.dumps(menu_items_list, indent=4) , restaurant_code

EatEasy_excel_only.py

@@ -0,0 +1,156 @@
+def EatEasy_excel_extract(url_input):
+
+    import requests
+    import json
+    import pandas as pd
+    from bs4 import BeautifulSoup
+    from urllib.parse import urlparse
+    import math
+    from io import BytesIO
+
+    payload1 = {'restId': '17902'}
+    files = []
+
+    headers2 = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+    }
+    headers = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+    }
+
+    # url_input = input("Enter the restaurant URL: ")
+
+    parsed_url = urlparse(url_input)
+    restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+    url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+    data = {
+        "restCode": restaurant_code
+    }
+
+    response = requests.post(url, data=data)
+
+    menu_items_list = []
+    category_name_list = []
+    j = 0
+
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, 'html.parser')
+        menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+
+        for i, item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+            img = item_box.find('img')  # Find the img tag within the div
+            if img:  # Check if img tag exists
+                image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+            else:
+                image_url = None  # If image URL is not found
+
+            menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+            if menu_item_details:
+                type_ = menu_item_details.find('p', class_='type').text.strip()
+                name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                description = menu_item_details.find('p', itemprop='description').text.strip()
+                price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+            else:
+                # If menu-item-details not found, set defaults
+                type_ = ""
+                name = ""
+                description = ""
+                price = ""
+
+            menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+            if menu_list_options:
+                value = menu_list_options.get('value')  # Get the value attribute
+            else:
+                value = None
+
+            if type_ not in category_name_list:
+                category_name_list.append(type_)
+                j = j+1
+                Category_position = j
+
+            else:
+                Category_position = j
+
+            menu_item = {
+                "Category": type_,
+                "Category_position": Category_position,
+                "Item_name": name,
+                "Item_position": i, 
+                "Image": image_url,
+                "description": description,
+                "price": price,
+                "id": value,
+            }
+
+            menu_items_list.append(menu_item)  # Append menu item before the request
+            if value is not None:
+                option_url = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{value}/1/"
+                option_response = requests.post(option_url, headers=headers2, data=payload1)
+                if option_response.status_code == 200:
+                    try:
+                        json_data = json.loads(option_response.text)
+                        extracted_data = []
+
+                        if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                            for choice in json_data['arrResult']['arrFoodChoice']:
+                                extracted_data.append({
+                                    'Option_group_name': choice['choice_name'],
+                                    'Option_name': choice['name'],
+                                    'Extra_price': choice['price'],
+                                    'Min': choice.get('mandatory', 0),
+                                    'Max': choice.get('max_choice', 1)
+                                })
+
+                        grouped_data = {}
+                        for choice in extracted_data:
+                            group_name = choice['Option_group_name']
+                            if group_name not in grouped_data:
+                                grouped_data[group_name] = {
+                                    'Option_group_name': group_name,
+                                    'Min': choice['Min'],
+                                    'Max': max(choice['Max'], '1'),
+                                }
+                            
+                            num_options = sum(key.startswith('Option ') for key in grouped_data[group_name])
+                            option_index = num_options + 1  # Index for the new option
+                            grouped_data[group_name][f"Option {option_index} Name"] = choice['Option_name']
+                            grouped_data[group_name][f"Option {option_index} Price"] = choice['Extra_price']
+                            
+                        for group_data in grouped_data.values():
+                            menu_items_list.append(group_data)
+
+                    except json.JSONDecodeError:
+                        print("JSON decoding error. Response content may not be in valid JSON format.")
+                else:
+                    print(f"Failed to get data for item with value {value}. Status code: {option_response.status_code}")
+
+        df = pd.DataFrame(menu_items_list)
+
+        # Ensure 'Max' column exists before renaming or shifting
+        if 'Max' in df.columns:
+            max_column_index = df.columns.get_loc('Max')
+            for i in range(max_column_index + 1, len(df.columns)):
+                df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+            option_group_name_index = df.columns.get_loc('Option_group_name')
+            for i in range(option_group_name_index, len(df.columns)):
+                df.iloc[:, i] = df.iloc[:, i].shift(-1)
+
+        df_cleaned = df.dropna(how='all')
+
+        output = BytesIO()
+        with pd.ExcelWriter(output, engine='openpyxl') as writer:
+            df_cleaned.to_excel(writer, index=False, sheet_name='Menu')
+        output.seek(0)
+
+        return output, f"{restaurant_code}_menu.xlsx"
+        # excel_file = f"{restaurant_code}_menu.xlsx"
+        # df.to_excel(excel_file, index=False)
+        # print(f"Menu items saved to {excel_file}")
+
+    else:
+        print(f"Failed to get menu items. Status code: {response.status_code}")
+        
+    return True

Eateasy_Multi_Urls.py

@@ -0,0 +1,5 @@
+def multi_urls(URLS):
+    from Mongo_Data_add import EatEasy_Mongo_Data_add
+
+    for URL in URLS:
+        EatEasy_Mongo_Data_add(URL)

Main_function_For_location.py

@@ -0,0 +1,565 @@
+# url = input("Enter Restro Url : ")
+from urllib.parse import urlparse
+import pymongo
+from config import settings
+
+def main(url,location,inside_location):
+
+    client = pymongo.MongoClient(settings.MONGO_URL)
+
+
+    def restro_details(url,location_area,location_name):
+        
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        parsed_url = urlparse(url)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_name = parsed_url.path.strip('/').split('/')[-1]
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name,
+            "location_area" : location_area ,
+            "location_name" : location_name
+          }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+
+    def main_excel_file(url_input):
+        import requests
+        import json
+        import pandas as pd
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+        import math
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+
+            for i, item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    type_ = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    type_ = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    value = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    value = None
+
+                if type_ not in category_name_list:
+                    category_name_list.append(type_)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": type_,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i, 
+                    "Image": image_url,
+                    "description": description,
+                    "price": price,
+                    "id": value,
+                }
+
+                menu_items_list.append(menu_item)  # Append menu item before the request
+                if value is not None:
+                    option_url = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{value}/1/"
+                    option_response = requests.post(option_url, headers=headers2, data=payload1)
+                    if option_response.status_code == 200:
+                        try:
+                            json_data = json.loads(option_response.text)
+                            extracted_data = []
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for choice in json_data['arrResult']['arrFoodChoice']:
+                                    extracted_data.append({
+                                        'Option_group_name': choice['choice_name'],
+                                        'Option_name': choice['name'],
+                                        'Extra_price': choice['price'],
+                                        'Min': choice.get('mandatory', 0),
+                                        'Max': choice.get('max_choice', 1)
+                                    })
+
+                            grouped_data = {}
+                            for choice in extracted_data:
+                                group_name = choice['Option_group_name']
+                                if group_name not in grouped_data:
+                                    grouped_data[group_name] = {
+                                        'Option_group_name': group_name,
+                                        'Min': choice['Min'],
+                                        'Max': max(choice['Max'], '1'),
+                                    }
+                                
+                                num_options = sum(key.startswith('Option ') for key in grouped_data[group_name])
+                                option_index = num_options + 1  # Index for the new option
+                                grouped_data[group_name][f"Option {option_index} Name"] = choice['Option_name']
+                                grouped_data[group_name][f"Option {option_index} Price"] = choice['Extra_price']
+                                
+                            for group_data in grouped_data.values():
+                                menu_items_list.append(group_data)
+
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {value}. Status code: {option_response.status_code}")
+
+            df = pd.DataFrame(menu_items_list)
+
+            # Ensure 'Max' column exists before renaming or shifting
+            if 'Max' in df.columns:
+                max_column_index = df.columns.get_loc('Max')
+                for i in range(max_column_index + 1, len(df.columns)):
+                    df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+                option_group_name_index = df.columns.get_loc('Option_group_name')
+                for i in range(option_group_name_index, len(df.columns)):
+                    df.iloc[:, i] = df.iloc[:, i].shift(-1)
+
+            excel_file = f"{restaurant_code}_menu.xlsx"
+            df.to_excel(excel_file, index=False)
+            print(f"Menu items saved to {excel_file}")
+
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+    
+
+    def main_json(url_input):
+        import requests
+        import json
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url_input, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+            location_area = soup.find('div', class_='location-area').text
+            location_name = soup.find('div', class_='location').text   
+
+            for i,item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    category = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    category = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    item_id = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    item_id = None
+                
+                if category not in category_name_list:
+                    category_name_list.append(category)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": category,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i,
+                    "Image": image_url,
+                    "Description": description,
+                    "Price": price,
+                    "ID": item_id,
+                    "Option_groups": []
+                
+                }
+
+                if item_id is not None:
+                    url1 = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{item_id}/1/"
+                    response = requests.request("POST", url1, headers=headers2, data=payload1, files=files)
+                    if response.status_code == 200:
+                        try:
+                            json_data = response.json()
+                            option_group_data = {}
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for option_group in json_data['arrResult']['arrFoodChoice']:
+                                    group_name = option_group['choice_name']
+                                    min_quantity = option_group['mandatory']
+                                    max_quantity = max((option_group['max_choice']), "1")
+
+                                    option_group_item = next((x for x in menu_item['Option_groups'] if x['Option_group_name'] == group_name), None)
+                                    if option_group_item:
+                                        option_group_item['Option_group_names'].append({
+                                            "Option_name": option_group['name'],
+                                            "Option_price": option_group['price']
+                                        })
+                                    else:
+                                        menu_item['Option_groups'].append({
+                                            "Option_group_name": group_name,
+                                            "Min": min_quantity,
+                                            "Max": max_quantity,
+                                            "Option_group_names": [{
+                                                "Option_name": option_group['name'],
+                                                "Option_price": option_group['price']
+                                            }]
+                                        })
+                            
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {item_id}. Status code: {response.status_code}")
+                if not menu_item['Option_groups']:  
+                    menu_item["Has_choice"] = False
+                
+                    
+                else:
+                    menu_item["Has_choice"] = True
+                menu_items_list.append(menu_item)
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+        # Convert the list of menu items into JSON
+        # with open(f'{restaurant_code}.json', 'w') as json_file:
+        #     json.dump(menu_items_list, json_file, indent=4)
+
+        print(f"Menu items saved to {restaurant_code}.json file.")
+
+        # main_excel_file(url_input)
+        return menu_items_list,location_area,location_name
+    
+
+    def extract_category(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+      
+
+        def item_extract_category(json,name):
+            items_list = []
+            for item in json:
+                if item['Category'] == name:
+                    item_info = {
+                            "id": item["ID"],
+                            "name": item["Item_name"]
+                        }
+                    items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+        existing_categories = set()
+        for item in json_data:
+            name = item['Category']
+            if name not in existing_categories:
+                # category_position = 1
+                # category_isActive = True
+                items = item_extract_category(json_data, name)
+
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_item(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['ID']
+            name = item['Item_name']
+            description = item['Description']
+            price = item['Price']
+            img_url= item['Image']
+            category_name = item['Category']
+            item_position = item['Item_position']
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('Option_groups', []):
+                    modifires.append(option_group['Option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                        restro_id = restro['_id']
+                            
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one(
+                  {
+                  'category_name': category_name,
+                  'restro_ref_id': restro_ref_id
+                  })
+            if category:
+                category_id = category['_id']
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            for option_group in item.get('Option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                    restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["Option_group_name"]
+                min_quantity = option_group["Min"]
+                max_quantity = option_group["Max"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("Option_group_names", []):
+                    option_name = option["Option_name"]
+                    option_price = option["Option_price"]
+                    option_names.append(option_name)
+                    option_names_trial = {
+                                'Option_name': option_name,
+                                'Option_price': option_price              
+                                }
+                    option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                    for option_group in item.get('Option_groups', []):
+                        option_group_name2 = option_group["Option_group_name"]
+                        option_group_names1 = option_group.get('Option_group_names',[])
+                        if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['Option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['Option_name']) ):
+                                item_id.append(item['ID'])
+                    
+                option_group_information = {
+                    "option_group_name" : option_group_name,
+                    "min_quantity" : min_quantity,
+                    "max_quantity" : max_quantity,
+                    "option_names"  : option_names,
+                    "item_id" : item_id,
+                    "restro_ref_id" : restro_ref_id
+                }
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+                
+                existing_categories.append(option_group_check)
+        result = collection.insert_many(option_group_info)
+        print("Inserted document IDs:", result.inserted_ids)
+ 
+    def extract_option_group_names(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        json_data = items
+        option_names = []
+        option_names_list = []
+        restro_collection = db['Restaurant_details']
+
+    
+        for item in json_data:
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                flag = 1
+                for option_group in item.get('Option_groups', []):
+                    option_group_name2 = option_group["Option_group_name"]
+                    for option in option_group.get("Option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                            restro_id = restro['_id']
+                            
+                        restro_ref_id = restro_id
+                        option_name = option["Option_name"]
+                        option_price = option["Option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+                        # restro = restro_collection.find_one({'url': url})
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,  
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                            }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                        if flag==1:
+                            option_names.append(option_group_name)
+                        option_names_list.append(option_name)
+
+        result = collection.insert_many(option_names)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    items,location_area,location_name = main_json(url)
+    restro_details(url,location,inside_location)
+    extract_category(items,url)
+    extract_item(items,url)
+    extract_option_group(items,url)
+    extract_option_group_names(items,url)
+    return True
+
+
+# main(url)
+                
+                
+        
+    
+
+
+    
+    
+        
+        
+    
+  
+  
+
+
+    
+
+    
+                

Mongo_Data_add.py

@@ -0,0 +1,398 @@
+from config import settings
+import pymongo
+from urllib.parse import urlparse
+def EatEasy_Mongo_Data_add(url):
+
+    client = pymongo.MongoClient(settings.MONGO_URL)
+
+    def restro_details(url,location_area,location_name):
+        
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        parsed_url = urlparse(url)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_name = parsed_url.path.strip('/').split('/')[-1]
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name.strip(),
+            "location_area" : location_area ,
+            "location_name" : location_name
+          }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+    
+
+    def main_json(url_input):
+        import requests
+        import json
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+
+        payload1 = {'restId': '17902'}
+        files = []
+
+        headers2 = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g'
+        }
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+
+        
+
+        parsed_url = urlparse(url_input)
+        restaurant_code = parsed_url.path.strip('/').split('/')[-1]
+
+        url = "https://www.eateasy.ae/dubai/food/getFilteredMenus"
+        data = {
+            "restCode": restaurant_code
+        }
+
+        response = requests.post(url_input, data=data)
+
+        menu_items_list = []
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            menu_item_boxes = soup.find_all('div', class_='menu-item-box')  # Find all divs with class 'menu-item-box'
+            location_area = soup.find('div', class_='location-area').text
+            input_element = soup.find('input', {'id': 'menuDeliveryLocationNewModalInput'})
+
+            # Get the value of the value attribute
+            location_name = input_element.get('value')
+            # location_name = soup.find('div', class_='location').text   
+
+            for i,item_box in enumerate(menu_item_boxes):  # Iterate over each menu item box
+                img = item_box.find('img')  # Find the img tag within the div
+                if img:  # Check if img tag exists
+                    image_url = img.get('data-image')  # Get the value of 'data-image' attribute
+                else:
+                    image_url = None  # If image URL is not found
+
+                menu_item_details = item_box.find('div', class_='menu-item-details')  # Find menu-item-details div
+                if menu_item_details:
+                    category = menu_item_details.find('p', class_='type').text.strip()
+                    name = menu_item_details.find('h5', class_='menu-food-title').text.strip()
+                    description = menu_item_details.find('p', itemprop='description').text.strip()
+                    price = menu_item_details.find('div', class_='menu-item-price').text.strip()
+                else:
+                    # If menu-item-details not found, set defaults
+                    category = ""
+                    name = ""
+                    description = ""
+                    price = ""
+
+                menu_list_options = item_box.find('a', class_='menu-list-options')  # Find the menu-list-options anchor tag
+                if menu_list_options:
+                    item_id = menu_list_options.get('value')  # Get the value attribute
+                else:
+                    item_id = None
+                
+                if category not in category_name_list:
+                    category_name_list.append(category)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+                menu_item = {
+                    "Category": category,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i,
+                    "Image": image_url,
+                    "Description": description,
+                    "Price": price,
+                    "ID": item_id,
+                    "Option_groups": []
+                
+                }
+
+                if item_id is not None:
+                    url1 = f"https://www.eateasy.ae/dubai/order/add_to_cart_v1/{item_id}/1/"
+                    response = requests.request("POST", url1, headers=headers2, data=payload1, files=files)
+                    if response.status_code == 200:
+                        try:
+                            json_data = response.json()
+                            option_group_data = {}
+
+                            if 'arrResult' in json_data and 'arrFoodChoice' in json_data['arrResult']:
+                                for option_group in json_data['arrResult']['arrFoodChoice']:
+                                    group_name = option_group['choice_name']
+                                    min_quantity = option_group['mandatory']
+                                    max_quantity = max((option_group['max_choice']), "1")
+
+                                    option_group_item = next((x for x in menu_item['Option_groups'] if x['Option_group_name'] == group_name), None)
+                                    if option_group_item:
+                                        option_group_item['Option_group_names'].append({
+                                            "Option_name": option_group['name'],
+                                            "Option_price": option_group['price']
+                                        })
+                                    else:
+                                        menu_item['Option_groups'].append({
+                                            "Option_group_name": group_name,
+                                            "Min": min_quantity,
+                                            "Max": max_quantity,
+                                            "Option_group_names": [{
+                                                "Option_name": option_group['name'],
+                                                "Option_price": option_group['price']
+                                            }]
+                                        })
+                            
+                        except json.JSONDecodeError:
+                            print("JSON decoding error. Response content may not be in valid JSON format.")
+                    else:
+                        print(f"Failed to get data for item with value {item_id}. Status code: {response.status_code}")
+                if not menu_item['Option_groups']:  
+                    menu_item["Has_choice"] = False
+                
+                    
+                else:
+                    menu_item["Has_choice"] = True
+                menu_items_list.append(menu_item)
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+        # Convert the list of menu items into JSON
+        # with open(f'{restaurant_code}.json', 'w') as json_file:
+        #     json.dump(menu_items_list, json_file, indent=4)
+
+        # print(f"Menu items saved to {restaurant_code}.json file.")
+
+        # main_excel_file(url_input)
+        return menu_items_list,location_area,location_name
+    
+
+    def extract_category(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+      
+
+        def item_extract_category(json,name):
+            items_list = []
+            for item in json:
+                if item['Category'] == name:
+                    item_info = {
+                            "id": item["ID"],
+                            "name": item["Item_name"]
+                        }
+                    items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+        existing_categories = set()
+        for item in json_data:
+            name = item['Category']
+            if name not in existing_categories:
+                # category_position = 1
+                # category_isActive = True
+                items = item_extract_category(json_data, name)
+
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted Category document IDs:", result.inserted_ids)
+
+    def extract_item(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['ID']
+            name = item['Item_name']
+            description = item['Description']
+            price = item['Price']
+            img_url= item['Image']
+            category_name = item['Category']
+            item_position = item['Item_position']
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('Option_groups', []):
+                    modifires.append(option_group['Option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                        restro_id = restro['_id']
+                            
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one(
+                  {
+                  'category_name': category_name,
+                  'restro_ref_id': restro_ref_id
+                  })
+            if category:
+                category_id = category['_id']
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted Items document IDs:", result.inserted_ids)
+
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            for option_group in item.get('Option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                    restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["Option_group_name"]
+                min_quantity = option_group["Min"]
+                max_quantity = option_group["Max"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("Option_group_names", []):
+                    option_name = option["Option_name"]
+                    option_price = option["Option_price"]
+                    option_names.append(option_name)
+                    option_names_trial = {
+                                'Option_name': option_name,
+                                'Option_price': option_price              
+                                }
+                    option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                    for option_group in item.get('Option_groups', []):
+                        option_group_name2 = option_group["Option_group_name"]
+                        option_group_names1 = option_group.get('Option_group_names',[])
+                        if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['Option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['Option_name']) ):
+                                item_id.append(item['ID'])
+                    
+                option_group_information = {
+                    "option_group_name" : option_group_name,
+                    "min_quantity" : min_quantity,
+                    "max_quantity" : max_quantity,
+                    "option_names"  : option_names,
+                    "item_id" : item_id,
+                    "restro_ref_id" : restro_ref_id
+                }
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+                
+                existing_categories.append(option_group_check)
+        result = collection.insert_many(option_group_info)
+        print("Inserted Option_Groups document IDs:", result.inserted_ids)
+ 
+    def extract_option_group_names(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        json_data = items
+        option_names = []
+        option_names_list = []
+        restro_collection = db['Restaurant_details']
+
+    
+        for item in json_data:
+            has_choices = item['Has_choice']
+            if has_choices == True:
+                flag = 1
+                for option_group in item.get('Option_groups', []):
+                    option_group_name2 = option_group["Option_group_name"]
+                    for option in option_group.get("Option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                            restro_id = restro['_id']
+                            
+                        restro_ref_id = restro_id
+                        option_name = option["Option_name"]
+                        option_price = option["Option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+                        # restro = restro_collection.find_one({'url': url})
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,  
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                            }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                        if flag==1:
+                            option_names.append(option_group_name)
+                        option_names_list.append(option_name)
+
+        result = collection.insert_many(option_names)
+        print("Inserted Options_name document IDs:", result.inserted_ids)
+
+    items,location_area,location_name = main_json(url)
+    restro_details(url,location_area,location_name)
+    extract_category(items,url)
+    extract_item(items,url)
+    extract_option_group(items,url)
+    extract_option_group_names(items,url)
+    return True

Talabat_files/Multi_urls.py

@@ -0,0 +1,6 @@
+def multi_url(URLS):
+    from Talabat_files.Talabat_Everything_From_url import Talabat_EveryThing_From_url
+    for URL in URLS:
+        Talabat_EveryThing_From_url(URL)
+
+

Talabat_files/Talabat_Everything_From_url.py

@@ -0,0 +1,523 @@
+# url = input("enter Restro url : ")
+
+import json
+import pymongo
+import requests
+import json
+from bs4 import BeautifulSoup
+import pandas as pd
+from urllib.parse import urlparse
+from config import settings
+
+def Talabat_EveryThing_From_url(url):
+
+    client = pymongo.MongoClient(settings.MONGO_URL)
+    def restro_details(url,location):
+        import requests
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+        import pymongo
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+
+        response = requests.get(url, headers=headers)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        parsed_url = urlparse(url,location)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_tag = soup.find('h1', {'data-testid': 'restaurant-title'})
+        restaurant_name = restaurant_tag.contents[0].strip()
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name,
+            "location" : location
+        }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+
+
+    def excel_extract(url):
+        import requests
+        import json
+        import pandas as pd
+        from bs4 import BeautifulSoup
+        from urllib.parse import urlparse
+
+        def extract_choices(item_id,restaurant_id):
+            choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+            response = requests.get(choice_url, headers=headers)
+            if response.status_code == 200:
+                choice_data = response.json()
+                return choice_data
+            else:
+                print("Failed to retrieve choices for item ID:", item_id)
+                return None
+            
+
+        url = url
+        parsed_url = urlparse(url)
+        path_segments = parsed_url.path.split('/')
+
+        restaurant_id = path_segments[-2]
+        restaurant_name = path_segments[-1]
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        response = requests.get(url, headers=headers)
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            script_tag = soup.find('script', id='__NEXT_DATA__')
+            
+            if script_tag:
+                json_content = json.loads(script_tag.string.strip())
+                
+                menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+                
+                menu_items_list = []
+                for i,item in enumerate(menu_data):
+                    item_id = item['id']
+                    name = item['name']
+                    description = item['description']
+                    price = item['price']
+                    original_image = item['originalImage']
+                    original_section = item['originalSection']
+                    has_choices = item['hasChoices']
+
+                    if original_section not in category_name_list:
+                        category_name_list.append(original_section)
+                        j = j+1
+                        Category_position = j
+
+                    else:
+                        Category_position = j
+                    
+                    menu_item = {
+                        "Category": original_section,
+                        "Category_positon": Category_position,
+                        "Item_name": name,
+                        "Item_position": i+1, 
+                        "Image": original_image,
+                        "description": description,
+                        "price": price,
+                        "id": item_id
+                    }
+                    
+                    menu_items_list.append(menu_item)
+                    
+                    if has_choices:
+                        choice_data = extract_choices(item_id,restaurant_id)
+                        if choice_data:
+                            choice_for_item = choice_data["result"].get('choiceForItem', [])[0]  # Accessing the first element of the list if exists
+                            choice_sections = choice_for_item.get('choiceSections', [])
+                            grouped_data = {}
+                            for option_group in choice_sections:
+                                option_group_name = option_group.get('nm', '')
+                                min_quantity = option_group.get('mnq', '')
+                                max_quantity = option_group.get('mxq', '')
+                                options = option_group.get('ich', [])
+                                for option_index, option in enumerate(options, start=1):
+                                    option_name = option.get('nm', '')
+                                    option_price = option.get('pr', '')
+                                    grouped_data.setdefault(option_group_name, {
+                                        "Option_group_name": option_group_name,
+                                        "Min_quantity": min_quantity,
+                                        "Max_quantity": max(max_quantity,1)
+                                    })
+                                    grouped_data[option_group_name][f"Option_{option_index}_Name"] = option_name
+                                    grouped_data[option_group_name][f"Option_{option_index}_Price"] = option_price
+                                    
+                            menu_items_list.extend(grouped_data.values())
+                
+                df = pd.DataFrame(menu_items_list)
+                if "Max_quantity" in df.columns:
+                    max_column_index = df.columns.get_loc('Max_quantity')
+                    for i in range(max_column_index + 1, len(df.columns)):
+                        df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+                    option_group_name_index = df.columns.get_loc('Option_group_name')
+                    for i in range(option_group_name_index, len(df.columns)):
+                        df.iloc[:, i] = df.iloc[:, i].shift(-1)
+                    
+                excel_file = f"{restaurant_name}_menu.xlsx"
+                df.to_excel(excel_file, index=False)
+                print(f"Menu items saved to {excel_file}")
+            else:
+                print("Script tag with id '__NEXT_DATA__' not found.")
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+
+
+    def main(url):
+        import json
+        import pymongo
+        import requests
+        import json
+        from bs4 import BeautifulSoup
+        import pandas as pd
+        from urllib.parse import urlparse
+
+
+        def extract_choices(item_id,restaurant_id):
+            choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+            response = requests.get(choice_url, headers=headers)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                choice_data = json.loads(soup.string.strip())
+                return choice_data
+            else:
+                print("Failed to retrieve choices for item ID:", item_id)
+                return None
+            
+
+        url = url
+        parsed_url = urlparse(url)
+        path_segments = parsed_url.path.split('/')
+
+        restaurant_id = path_segments[-2]
+        restaurant_name = path_segments[-1]
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            script_tag = soup.find('script', id='__NEXT_DATA__')
+            j = 0
+            category_name_list = []
+            
+            
+            if script_tag:
+                json_content = json.loads(script_tag.string.strip())
+                
+                menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+                location = json_content.get('props', {}).get('pageProps', {}).get('gtmEventData', {}).get('area', {}).get('name')
+                
+                items = []
+                for i,item in enumerate(menu_data):
+                    item_id = item['id']
+                    name = item['name']
+                    description = item['description']
+                    price = item['price']
+                    original_image = item['originalImage']
+                    original_section = item['originalSection']
+                    Category_id = item['sectionId']
+                    has_choices = item['hasChoices']
+
+                    if original_section not in category_name_list:
+                        category_name_list.append(original_section)
+                        j = j+1
+                        Category_position = j
+
+                    else:
+                        Category_position = j
+
+                    
+                    item_info = {
+                        'category': original_section,
+                        'category_postion': Category_position,
+                        'category_id': Category_id,
+                        'item_name': name,
+                        'item_position': i,
+                        'item_image': original_image,
+                        'description': description,
+                        'price': price,
+                        'item_id': item_id,
+                        'has_choices' : has_choices,
+                    }
+                    
+                    if has_choices:
+                        option_groups_info = []
+                        choice_data = extract_choices(item_id,restaurant_id)
+                        if choice_data:
+                            choice_for_item = choice_data["result"]['choiceForItem'][0]  # Accessing the first element of the list
+                            choice_sections = choice_for_item['choiceSections']
+                            for option_group in choice_sections:
+                                option_group_info = {
+                                    'option_group_name': option_group['nm'],
+                                    'min_quantity': option_group['mnq'],
+                                    'max_quantity': option_group['mxq'],
+                                    'option_group_names': []
+                                }
+                                if 'ich' in option_group:
+                                    option_group_names = option_group['ich']
+                                    for option_group_name in option_group_names:
+                                        option_group_name_info = {
+                                            'option_name': option_group_name['nm'],
+                                            'option_price': option_group_name['pr']
+                                        }
+                                        option_group_info['option_group_names'].append(option_group_name_info)
+                                option_groups_info.append(option_group_info)
+                            item_info['option_groups'] = option_groups_info
+                    items.append(item_info)
+                # with open(f"{restaurant_name}.json", "w") as json_file:
+                #     json.dump(items, json_file, indent=4)
+                print(f"josn named {restaurant_name}.json created succesfully")
+                
+                # excel_extract(url)
+                # print("excel Created succesfully")
+            else:
+                print("Script tag with id '__NEXT_DATA__' not found.")
+        else:
+            print("Failed to retrieve the webpage. Status code:", response.status_code)
+        return items,json_content,location
+
+    def extract_item(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['item_id']
+            name = item['item_name']
+            description = item['description']
+            price = item['price']
+            img_url= item['item_image']
+            category_name = item['category']
+            item_position = item['item_position']
+            has_choices = item['has_choices']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('option_groups', []):
+                    modifires.append(option_group['option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                    restro_id = restro['_id']
+                        
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one({
+                'category_name': category_name,
+                'restro_ref_id': restro_ref_id
+                
+            })
+            if category:
+                category_id = category['_id']
+            else:
+                 category_id = None
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'item_position':item_position,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_category(items,json_content,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+
+        def item_extract_category(json_content,name):
+            menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['categories']
+            items_list = []
+            for category in menu_data:
+                if category["name"] == name:
+                    for item in category["items"]:
+                        item_info = {
+                            "id": item["id"],
+                            "name": item["name"]
+                        }
+                        items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+
+        existing_categories = set()
+
+        for item in json_data:
+            name = item['category']
+            if name not in existing_categories:
+                category_positin = 1
+                category_isActive = True
+                items = item_extract_category(json_content, name)
+                
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'category_position': category_positin,
+                    'category_isActive': category_isActive,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            
+            for option_group in item.get('option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+
+                if restro:
+                    restro_id = restro['_id']                  
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["option_group_name"]
+                min_quantity = option_group["min_quantity"]
+                max_quantity = option_group["max_quantity"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("option_group_names", []):
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+                        option_names.append(option_name)
+                        option_names_trial = {
+                                'option_name': option_name,
+                                'option_price': option_price              
+                                }
+                        option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                        for option_group in item.get('option_groups', []):
+                            option_group_name2 = option_group["option_group_name"]
+                            option_group_names1 = option_group.get('option_group_names',[])
+                            if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['option_name']) ):
+                                item_id.append(item['item_id'])
+                            
+
+                option_group_information = {
+                        "option_group_name" : option_group_name,
+                        "min_quantity" : min_quantity,
+                        "max_quantity" : max_quantity,
+                        "option_names"  : option_names,
+                        "item_id" : item_id,
+                        "restro_ref_id" : restro_ref_id
+                    } 
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+
+                
+                existing_categories.append(option_group_check)
+        if option_group_info:       
+            result = collection.insert_many(option_group_info)
+            print("Inserted document IDs:", result.inserted_ids)
+
+    
+    def extract_option_group_names(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        restro_collection = db['Restaurant_details']
+        json_data = items
+        option_names = []
+        option_names_list = []
+
+        for item in json_data:
+            has_choices = item['has_choices']
+            if has_choices == True:
+                flag = 1
+                
+                for option_group in item.get('option_groups', []):
+                    option_group_name2 = option_group["option_group_name"]
+                    for option in option_group.get("option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                                restro_id = restro['_id']
+                                    
+                        restro_ref_id = restro_id
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # option_group_name_true = option_group_collection.find_one({'option_group_name': option_group_name2,
+                        #                                                            'restro_ref_id' : restro_id})
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                        }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                                 
+                        if flag==1:
+                            option_names.append(option_group_name)
+                           
+                        option_names_list.append(option_name)
+        if option_names:                
+            result = collection.insert_many(option_names)
+            print("Inserted document IDs:", result.inserted_ids)
+    
+
+
+    items,json_content,location = main(url)
+    restro_details(url,location)
+    extract_category(items,json_content,url)
+    extract_item(items,url)
+    extract_option_group(items,url)
+    extract_option_group_names(items,url)
+    return True
+
+# main_all_extract(url)

Talabat_files/Talabat_Mongo_Data_add.py

@@ -0,0 +1,402 @@
+from config import settings
+import pymongo
+import json
+import requests
+import json
+from bs4 import BeautifulSoup
+import pandas as pd
+from urllib.parse import urlparse
+
+def Talabat_mongo_data_add(url):
+
+    client = pymongo.MongoClient(settings.MONGO_URL)
+
+    def restro_details(url,location):
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+
+        response = requests.get(url, headers=headers)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        parsed_url = urlparse(url,location)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_tag = soup.find('h1', {'data-testid': 'restaurant-title'})
+        restaurant_name = restaurant_tag.contents[0].strip()
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name,
+            "location" : location
+        }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+
+
+
+    def main(url):
+       
+
+
+        def extract_choices(item_id,restaurant_id):
+            choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+            response = requests.get(choice_url, headers=headers)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                choice_data = json.loads(soup.string.strip())
+                return choice_data
+            else:
+                print("Failed to retrieve choices for item ID:", item_id)
+                return None
+            
+
+        url = url
+        parsed_url = urlparse(url)
+        path_segments = parsed_url.path.split('/')
+
+        restaurant_id = path_segments[-2]
+        restaurant_name = path_segments[-1]
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            script_tag = soup.find('script', id='__NEXT_DATA__')
+            j = 0
+            category_name_list = []
+            
+            
+            if script_tag:
+                json_content = json.loads(script_tag.string.strip())
+                
+                menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+                location = json_content.get('props', {}).get('pageProps', {}).get('gtmEventData', {}).get('area', {}).get('name')
+                
+                items = []
+                for i,item in enumerate(menu_data):
+                    item_id = item['id']
+                    name = item['name']
+                    description = item['description']
+                    price = item['price']
+                    original_image = item['originalImage']
+                    original_section = item['originalSection']
+                    Category_id = item['sectionId']
+                    has_choices = item['hasChoices']
+
+                    if original_section not in category_name_list:
+                        category_name_list.append(original_section)
+                        j = j+1
+                        Category_position = j
+
+                    else:
+                        Category_position = j
+
+                    
+                    item_info = {
+                        'category': original_section,
+                        'category_postion': Category_position,
+                        'category_id': Category_id,
+                        'item_name': name,
+                        'item_position': i,
+                        'item_image': original_image,
+                        'description': description,
+                        'price': price,
+                        'item_id': item_id,
+                        'has_choices' : has_choices,
+                    }
+                    
+                    if has_choices:
+                        option_groups_info = []
+                        choice_data = extract_choices(item_id,restaurant_id)
+                        if choice_data:
+                            choice_for_item = choice_data["result"]['choiceForItem'][0]  # Accessing the first element of the list
+                            choice_sections = choice_for_item['choiceSections']
+                            for option_group in choice_sections:
+                                option_group_info = {
+                                    'option_group_name': option_group['nm'],
+                                    'min_quantity': option_group['mnq'],
+                                    'max_quantity': option_group['mxq'],
+                                    'option_group_names': []
+                                }
+                                if 'ich' in option_group:
+                                    option_group_names = option_group['ich']
+                                    for option_group_name in option_group_names:
+                                        option_group_name_info = {
+                                            'option_name': option_group_name['nm'],
+                                            'option_price': option_group_name['pr']
+                                        }
+                                        option_group_info['option_group_names'].append(option_group_name_info)
+                                option_groups_info.append(option_group_info)
+                            item_info['option_groups'] = option_groups_info
+                    items.append(item_info)
+                # with open(f"{restaurant_name}.json", "w") as json_file:
+                #     json.dump(items, json_file, indent=4)
+                # print(f"josn named {restaurant_name}.json created succesfully")
+                
+                # excel_extract(url)
+                # print("excel Created succesfully")
+            else:
+                print("Script tag with id '__NEXT_DATA__' not found.")
+        else:
+            print("Failed to retrieve the webpage. Status code:", response.status_code)
+        return items,json_content,location
+
+    def extract_item(items,url):
+        
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['item_id']
+            name = item['item_name']
+            description = item['description']
+            price = item['price']
+            img_url= item['item_image']
+            category_name = item['category']
+            item_position = item['item_position']
+            has_choices = item['has_choices']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('option_groups', []):
+                    modifires.append(option_group['option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                    restro_id = restro['_id']
+                        
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one({
+                'category_name': category_name,
+                'restro_ref_id': restro_ref_id
+            })
+            if category:
+                category_id = category['_id']
+            else:
+                 category_id = None
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'item_position':item_position,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_category(items,json_content,url):
+
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+
+        def item_extract_category(json_content,name):
+            menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['categories']
+            items_list = []
+            for category in menu_data:
+                if category["name"] == name:
+                    for item in category["items"]:
+                        item_info = {
+                            "id": item["id"],
+                            "name": item["name"]
+                        }
+                        items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+
+        existing_categories = set()
+
+        for item in json_data:
+            name = item['category']
+            if name not in existing_categories:
+                category_positin = 1
+                category_isActive = True
+                items = item_extract_category(json_content, name)
+                
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'category_position': category_positin,
+                    'category_isActive': category_isActive,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            
+            for option_group in item.get('option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+
+                if restro:
+                    restro_id = restro['_id']                  
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["option_group_name"]
+                min_quantity = option_group["min_quantity"]
+                max_quantity = option_group["max_quantity"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("option_group_names", []):
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+                        option_names.append(option_name)
+                        option_names_trial = {
+                                'option_name': option_name,
+                                'option_price': option_price              
+                                }
+                        option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                        for option_group in item.get('option_groups', []):
+                            option_group_name2 = option_group["option_group_name"]
+                            option_group_names1 = option_group.get('option_group_names',[])
+                            if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['option_name']) ):
+                                item_id.append(item['item_id'])
+                    
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                            restro_id = restro['_id']
+                                
+                restro_ref_id = restro_id
+                            
+
+                option_group_information = {
+                        "option_group_name" : option_group_name,
+                        "min_quantity" : min_quantity,
+                        "max_quantity" : max_quantity,
+                        "option_names"  : option_names,
+                        "item_id" : item_id,
+                        "restro_ref_id" : restro_ref_id
+                    } 
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+
+                
+                existing_categories.append(option_group_check)
+        if option_group_info:
+            result = collection.insert_many(option_group_info)
+            print("Inserted document IDs:", result.inserted_ids)
+
+    
+    def extract_option_group_names(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        restro_collection = db['Restaurant_details']
+        json_data = items
+        option_names = []
+        option_names_list = []
+
+        for item in json_data:
+            has_choices = item['has_choices']
+            if has_choices == True:
+                flag = 1
+                
+                for option_group in item.get('option_groups', []):
+                    option_group_name2 = option_group["option_group_name"]
+                    for option in option_group.get("option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                                restro_id = restro['_id']
+                                    
+                        restro_ref_id = restro_id
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # option_group_name_true = option_group_collection.find_one({'option_group_name': option_group_name2,
+                        #                                                            'restro_ref_id' : restro_id})
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                        }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                                 
+                        if flag==1:
+                            option_names.append(option_group_name)
+                           
+                        option_names_list.append(option_name)
+        if option_names:                
+            result = collection.insert_many(option_names)
+            print("Inserted document IDs:", result.inserted_ids)
+    
+
+
+    items,json_content,location = main(url)
+    restro_details(url,location)
+    extract_category(items,json_content,url)
+    extract_item(items,url)
+    extract_option_group(items,url)
+    extract_option_group_names(items,url)
+    return True

Talabat_files/Talabat_excel_final.py

@@ -0,0 +1,123 @@
+def Talabat_excel_extract(url):
+    import requests
+    import json
+    import pandas as pd
+    from bs4 import BeautifulSoup
+    from urllib.parse import urlparse
+    from io import BytesIO
+
+    def extract_choices(item_id, restaurant_id):
+        choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+        response = requests.get(choice_url, headers=headers)
+        if response.status_code == 200:
+            choice_data = response.json()
+            return choice_data
+        else:
+            print("Failed to retrieve choices for item ID:", item_id)
+            return None
+
+    # url = input("Enter restaurant URL: ")
+    parsed_url = urlparse(url)
+    path_segments = parsed_url.path.split('/')
+
+    restaurant_id = path_segments[-2]
+    restaurant_name = path_segments[-1]
+
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+    }
+    response = requests.get(url, headers=headers)
+    j = 0
+    category_name_list = []
+
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, 'html.parser')
+        script_tag = soup.find('script', id='__NEXT_DATA__')
+
+        if script_tag:
+            json_content = json.loads(script_tag.string.strip())
+
+            menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+
+            menu_items_list = []
+
+            for i,item in enumerate(menu_data):
+                item_id = item['id']
+                name = item['name']
+                description = item['description']
+                price = item['price']
+                original_image = item['originalImage']
+                original_section = item['originalSection']
+                has_choices = item['hasChoices']
+
+
+                if original_section not in category_name_list:
+                    category_name_list.append(original_section)
+                    j = j+1
+                    Category_position = j
+
+                else:
+                    Category_position = j
+
+
+                menu_item = {
+                    "Category": original_section,
+                    "Category_position": Category_position,
+                    "Item_name": name,
+                    "Item_position": i+1,
+                    "Image": original_image,
+                    "description": description,
+                    "price": price,
+                    "id": item_id
+                }
+
+                menu_items_list.append(menu_item)
+
+                if has_choices:
+                    choice_data = extract_choices(item_id, restaurant_id)
+                    if choice_data:
+                        choice_for_item = choice_data["result"].get('choiceForItem', [])[0]  # Accessing the first element of the list if exists
+                        choice_sections = choice_for_item.get('choiceSections', [])
+                        grouped_data = {}
+                        for option_group in choice_sections:
+                            option_group_name = option_group.get('nm', '')
+                            min_quantity = option_group.get('mnq', '')
+                            max_quantity = option_group.get('mxq', '')
+                            options = option_group.get('ich', [])
+                            for option_index, option in enumerate(options, start=1):
+                                option_name = option.get('nm', '')
+                                option_price = option.get('pr', '')
+                                grouped_data.setdefault(option_group_name, {
+                                    "Option_group_name": option_group_name,
+                                    "Min_quantity": min_quantity,
+                                    "Max_quantity": max_quantity
+                                })
+                                grouped_data[option_group_name][f"Option_{option_index}_Name"] = option_name
+                                grouped_data[option_group_name][f"Option_{option_index}_Price"] = option_price
+
+                        menu_items_list.extend(grouped_data.values())
+
+            df = pd.DataFrame(menu_items_list)
+
+            if 'Max_quantity' in df.columns:
+                max_column_index = df.columns.get_loc('Max_quantity')
+                for i in range(max_column_index + 1, len(df.columns)):
+                    df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+                option_group_name_index = df.columns.get_loc('Option_group_name')
+                for i in range(option_group_name_index, len(df.columns)):
+                    df.iloc[:, i] = df.iloc[:, i].shift(-1)
+                    
+            df_cleaned = df.dropna(how='all')    
+            # excel_file = f"{restaurant_name}_menu.xlsx"
+            # df.to_excel(excel_file, index=False)
+            # print(f"Menu items saved to {excel_file}")
+            excel_file = BytesIO()
+            df_cleaned.to_excel(excel_file, index=False)
+            excel_file.seek(0)  # Move to the beginning of the BytesIO stream
+
+            return excel_file, f"{restaurant_name}_menu.xlsx"
+        else:
+            print("Script tag with id '__NEXT_DATA__' not found.")
+    else:
+        print(f"Failed to get menu items. Status code: {response.status_code}")

Talabat_files/Talabat_json_final.py

@@ -0,0 +1,107 @@
+def Talabat_Json_extract(url):
+    import json
+    import requests
+    import json
+    from bs4 import BeautifulSoup
+    import pandas as pd
+    from urllib.parse import urlparse
+    from io import BytesIO
+
+    def extract_choices(item_id):
+        choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+        response = requests.get(choice_url, headers=headers)
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            choice_data = json.loads(soup.string.strip())
+            return choice_data
+        else:
+            print("Failed to retrieve choices for item ID:", item_id)
+            return None
+        
+
+    # url = input("enter retro URL : ")
+    parsed_url = urlparse(url)
+    path_segments = parsed_url.path.split('/')
+
+    restaurant_id = path_segments[-2]
+    restaurant_name = path_segments[-1]
+
+
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+    }
+    response = requests.get(url, headers=headers)
+
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, 'html.parser')
+        script_tag = soup.find('script', id='__NEXT_DATA__')
+        
+        if script_tag:
+            json_content = json.loads(script_tag.string.strip())
+            
+            menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+            
+            items = []
+            for item in menu_data:
+                item_id = item['id']
+                name = item['name']
+                description = item['description']
+                price = item['price']
+                original_image = item['originalImage']
+                original_section = item['originalSection']
+                has_choices = item['hasChoices']
+                
+                item_info = {
+                    'category': original_section,
+                    'category_postion': 1,
+                    'item_name': name,
+                    'item_position': 1,
+                    'original_image': original_image,
+                    'description': description,
+                    'price': price,
+                    'item_id': item_id,
+                }
+                
+                if has_choices:
+                    option_groups_info = []
+                    choice_data = extract_choices(item_id,restaurant_id)
+                    if choice_data:
+                        choice_for_item = choice_data["result"]['choiceForItem'][0]  # Accessing the first element of the list
+                        choice_sections = choice_for_item['choiceSections']
+                        for option_group in choice_sections:
+                            option_group_info = {
+                                'option_group_name': option_group['nm'],
+                                'min_quantity': option_group['mnq'],
+                                'max_quantity': option_group['mxq'],
+                                'option_group_names': []
+                            }
+                            if 'ich' in option_group:
+                                option_group_names = option_group['ich']
+                                for option_group_name in option_group_names:
+                                    option_group_name_info = {
+                                        'option_name': option_group_name['nm'],
+                                        'option_price': option_group_name['pr']
+                                    }
+                                    option_group_info['option_group_names'].append(option_group_name_info)
+                            option_groups_info.append(option_group_info)
+                        item_info['option_groups'] = option_groups_info
+                items.append(item_info)
+            # with open(f"{restaurant_name}.json", "w") as json_file:
+            #     json.dump(items, json_file, indent=4)
+            json_content = json.dumps(items, indent=4)
+            
+            # Create BytesIO object to hold the JSON content
+            output = BytesIO()
+            output.write(json_content.encode('utf-8'))
+            output.seek(0) 
+
+            return  restaurant_name,output
+            
+        
+        
+            
+        else:
+            print("Script tag with id '__NEXT_DATA__' not found.")
+    else:
+        print("Failed to retrieve the webpage. Status code:", response.status_code)
+    return True

Talabat_files/Talabat_multy_location.py

@@ -0,0 +1,6 @@
+def Talabat_multy_LOCATION(locations):
+    from Talabat_files.location_link_fetch import Talabat_location_links
+    for loaction in locations:
+        Talabat_location_links(loaction)
+
+        

Talabat_files/location_fetch_function.py

@@ -0,0 +1,42 @@
+def location_all(location,inside_location):
+    import requests
+    from bs4 import BeautifulSoup
+    from Main_function_For_location import main
+
+    
+    location =location.replace(" ", "").lower()
+    inside_location = inside_location.replace(" ", "-").lower()
+
+    url = f"https://www.eateasy.ae/{location}/{inside_location}-restaurants"
+
+    payload = {}
+    files = {}
+    headers = {
+        'Cookie': 'eateasy-ae-website=lai3mvcb9hd99nnivbt0pn68ibfjsd6g',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36'
+    }
+
+    response = requests.post(url, headers=headers, data=payload, files=files)
+    hrefs = []
+    i = 1
+
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, 'html.parser')
+    
+        links = soup.find_all('a', class_='eateasy-restaurant-box-inner')
+        for link in links:
+            href = link.get('href')
+            if href:
+                hrefs.append(href)
+        print(f"Found {len(href)} Links")
+        if hrefs:
+            for href in hrefs:
+                print(href)
+                main(href,location,inside_location)
+                i = i+1
+                if i == 21:
+                    break
+        print(" DONE ") 
+
+    else:
+        print(f"Failed to retrieve the page. Status code: {response.status_code}")

Talabat_files/location_link_fetch.py

@@ -0,0 +1,64 @@
+def Talabat_location_links(location):
+    import requests
+    from bs4 import BeautifulSoup
+    import re
+    from Talabat_files.main_function import main_all_extract
+    # Function to convert text to kebab case
+    def to_kebab_case(text: str) -> str:
+        text = text.lower()  # Convert to lowercase
+        text = re.sub(r'\s+', '-', text)  # Replace spaces with dashes
+        text = re.sub(r'[^a-zA-Z0-9-]', '', text)  # Remove non-alphanumeric characters
+        return text
+
+    # Function to fetch location code
+    def location_code(name: str) -> int:
+        url = "https://www.talabat.com/nextApi/location/country-areas/4"
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36',
+            'Accept-Language': 'en-US',
+            'Cookie': '__cf_bm=_mZexeD7G1shqe.pO2VMyyTt.NCBm6Tt1saj4P.MQDk-1716294515-1.0.1.1-3nmOwncAyqyw5pak8.DFvLZjZYKQv4yW16.7jRG6groz0869YtR83cK8uy_VR70ebNG7mLMgRPRHxhTndBWJUGFQUlk; AWSALB=mS5qvg1IVA+fbSMlvbIt2qv6TrpVbPLMF2YveRn8OJQCwHyPfnEVsOhdmOOFINqeB93N6kx9xPbjNggoc9pBVTfQWCVeVayfSPMeOBQKSXFZ/ppIMGjDMTX3o+BP; AWSALBCORS=mS5qvg1IVA+fbSMlvbIt2qv6TrpVbPLMF2YveRn8OJQCwHyPfnEVsOhdmOOFINqeB93N6kx9xPbjNggoc9pBVTfQWCVeVayfSPMeOBQKSXFZ/ppIMGjDMTX3o+BP; dhhPerseusGuestId=1716186301782.797703851415064000.04xvpecztvkg; next-i18next=en; tlb_country=uae; tlb_lng=en'
+        }
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()  # Raise an error for bad status codes
+            jsondata = response.json()
+            
+            for data in jsondata.get('areas', []):
+                if name.lower() == data['cityName'].lower() or name.lower() == data['name'].lower():
+                    return data['id']
+            return None  
+        except requests.RequestException as e:
+            print(f"An error occurred: {e}")
+            return None
+
+
+    location_name_input = location.strip()
+    code = location_code(location_name_input)
+
+
+    if code is not None:
+        location_name = to_kebab_case(location_name_input)
+        url = f"https://www.talabat.com/uae/restaurants/{code}/{location_name}"
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36',
+            'Cookie': '__cf_bm=pUdFBMFwQSdL5rRym8o1cr4lAKqQLqpz661jnZp9q_M-1716188106-1.0.1.1-P989rK8kUjlPuclwf7GVdcxuX9SXwyF8r4eelpQtsA7M1yCX82n4b74tSDaNTPdILiY7SHC8qXP61WKIFX1RcsV4cdtVsKmEq9Adzzo1Mxs; AWSALB=HWer/ht79Hy5nHr3VOFEqnaCc0UyDHrkYx/xyAYcq3bIe8SybCBoqXaT9B4yG/08Xhy2KaCjgh75x3No44IhEJbg8cy/n+opvCEW2lfo4TOW2MBorkBSyQ1GQ6HY; AWSALBCORS=HWer/ht79Hy5nHr3VOFEqnaCc0UyDHrkYx/xyAYcq3bIe8SybCBoqXaT9B4yG/08Xhy2KaCjgh75x3No44IhEJbg8cy/n+opvCEW2lfo4TOW2MBorkBSyQ1GQ6HY; dhhPerseusGuestId=1716186301782.797703851415064000.04xvpecztvkg; next-i18next=en; tlb_country=uae; tlb_lng=en'
+        }
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()  # Raise an error for bad status codes
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            restaurant_list_div = soup.find('div', class_='restaurant-list')
+            if restaurant_list_div:
+                links = restaurant_list_div.find_all('a', {'data-testid': 'restaurant-a'}) 
+                hrefs = ['https://www.talabat.com' + link.get('href') for link in links]
+                print(f"Found {len(hrefs)} Links")
+                for href in hrefs:
+                    print(href)
+                    main_all_extract(href)
+            else:
+                print("No restaurant list found.")
+        except requests.RequestException as e:
+            print(f"An error occurred while fetching the restaurant data: {e}")
+    else:
+        print(f"Location '{location_name_input}' not found.")

Talabat_files/main_function.py

@@ -0,0 +1,517 @@
+# url = input("enter Restro url : ")
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse
+from config import settings
+import pymongo
+import json
+import pandas as pd
+        
+
+def main_all_extract(url):
+    
+    client = pymongo.MongoClient(settings.MONGO_URL)
+    
+    def restro_details(url,location):
+        
+        
+        db = client.Restaurants_in_dubai
+        collection = db.Restaurant_details
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+
+        response = requests.get(url, headers=headers)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        parsed_url = urlparse(url,location)
+        platform_name = parsed_url.netloc.split('.')[1].capitalize()
+        restaurant_tag = soup.find('h1', {'data-testid': 'restaurant-title'})
+        restaurant_name = restaurant_tag.contents[0].strip()
+        restaurant_details = {
+            'url' : url,
+            'platform_name' : platform_name,
+            "restaurant_name" : restaurant_name,
+            "location" : location
+        }
+        result = collection.insert_one(restaurant_details)
+        print("Inserted document IDs:", result.inserted_id)
+
+
+    def excel_extract(url):
+        
+
+        def extract_choices(item_id,restaurant_id):
+            choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+            response = requests.get(choice_url, headers=headers)
+            if response.status_code == 200:
+                choice_data = response.json()
+                return choice_data
+            else:
+                print("Failed to retrieve choices for item ID:", item_id)
+                return None
+            
+
+        url = url
+        parsed_url = urlparse(url)
+        path_segments = parsed_url.path.split('/')
+
+        restaurant_id = path_segments[-2]
+        restaurant_name = path_segments[-1]
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        response = requests.get(url, headers=headers)
+        category_name_list = []
+        j = 0
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            script_tag = soup.find('script', id='__NEXT_DATA__')
+            
+            if script_tag:
+                json_content = json.loads(script_tag.string.strip())
+                
+                menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+                
+                menu_items_list = []
+                for i,item in enumerate(menu_data):
+                    item_id = item['id']
+                    name = item['name']
+                    description = item['description']
+                    price = item['price']
+                    original_image = item['originalImage']
+                    original_section = item['originalSection']  
+                    has_choices = item['hasChoices']
+
+                    if original_section not in category_name_list:
+                        category_name_list.append(original_section)
+                        j = j+1
+                        Category_position = j
+
+                    else:
+                        Category_position = j
+                    
+                    menu_item = {
+                        "Category": original_section,
+                        "Category_positon": Category_position,
+                        "Item_name": name,
+                        "Item_position": i, 
+                        "Image": original_image,
+                        "description": description,
+                        "price": price,
+                        "id": item_id
+                    }
+                    
+                    menu_items_list.append(menu_item)
+                    
+                    if has_choices:
+                        choice_data = extract_choices(item_id,restaurant_id)
+                        if choice_data:
+                            choice_for_item = choice_data["result"].get('choiceForItem', [])[0]  # Accessing the first element of the list if exists
+                            choice_sections = choice_for_item.get('choiceSections', [])
+                            grouped_data = {}
+                            for option_group in choice_sections:
+                                option_group_name = option_group.get('nm', '')
+                                min_quantity = option_group.get('mnq', '')
+                                max_quantity = option_group.get('mxq', '')
+                                options = option_group.get('ich', [])
+                                for option_index, option in enumerate(options, start=1):
+                                    option_name = option.get('nm', '')
+                                    option_price = option.get('pr', '')
+                                    grouped_data.setdefault(option_group_name, {
+                                        "Option_group_name": option_group_name,
+                                        "Min_quantity": min_quantity,
+                                        "Max_quantity": max(max_quantity,1)
+                                    })
+                                    grouped_data[option_group_name][f"Option_{option_index}_Name"] = option_name
+                                    grouped_data[option_group_name][f"Option_{option_index}_Price"] = option_price
+                                    
+                            menu_items_list.extend(grouped_data.values())
+                
+                df = pd.DataFrame(menu_items_list)
+                if "Max_quantity" in df.columns:
+                    max_column_index = df.columns.get_loc('Max_quantity')
+                    for i in range(max_column_index + 1, len(df.columns)):
+                        df.rename(columns={df.columns[i]: ''}, inplace=True)
+
+                    option_group_name_index = df.columns.get_loc('Option_group_name')
+                    for i in range(option_group_name_index, len(df.columns)):
+                        df.iloc[:, i] = df.iloc[:, i].shift(-1)
+                    
+                excel_file = f"{restaurant_name}_menu.xlsx"
+                df.to_excel(excel_file, index=False)
+                print(f"Menu items saved to {excel_file}")
+            else:
+                print("Script tag with id '__NEXT_DATA__' not found.")
+        else:
+            print(f"Failed to get menu items. Status code: {response.status_code}")
+
+
+
+    def main(url):
+
+
+        def extract_choices(item_id,restaurant_id):
+            choice_url = f"https://www.talabat.com/nextMenuApi/v2/branches/{restaurant_id}/menu/{item_id}/choices"
+            response = requests.get(choice_url, headers=headers)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                choice_data = json.loads(soup.string.strip())
+                return choice_data
+            else:
+                print("Failed to retrieve choices for item ID:", item_id)
+                return None
+            
+
+        url = url
+        parsed_url = urlparse(url)
+        path_segments = parsed_url.path.split('/')
+
+        restaurant_id = path_segments[-2]
+        restaurant_name = path_segments[-1]
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            script_tag = soup.find('script', id='__NEXT_DATA__')
+            j = 0
+            category_name_list = []
+            
+            
+            if script_tag:
+                json_content = json.loads(script_tag.string.strip())
+                
+                menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['items']
+                location = json_content.get('props', {}).get('pageProps', {}).get('gtmEventData', {}).get('area', {}).get('name')
+                
+                items = []
+                for i,item in enumerate(menu_data):
+                    item_id = item['id']
+                    name = item['name']
+                    description = item['description']
+                    price = item['price']
+                    original_image = item['originalImage']
+                    original_section = item['originalSection']
+                    Category_id = item['sectionId']
+                    has_choices = item['hasChoices']
+
+                    if original_section not in category_name_list:
+                        category_name_list.append(original_section)
+                        j = j+1
+                        Category_position = j
+
+                    else:
+                        Category_position = j
+
+                    
+                    item_info = {
+                        'category': original_section,
+                        'category_postion': Category_position,
+                        'category_id': Category_id,
+                        'item_name': name,
+                        'item_position': i,
+                        'item_image': original_image,
+                        'description': description,
+                        'price': price,
+                        'item_id': item_id,
+                        'has_choices' : has_choices,
+                    }
+                    
+                    if has_choices:
+                        option_groups_info = []
+                        choice_data = extract_choices(item_id,restaurant_id)
+                        if choice_data:
+                            choice_for_item = choice_data["result"]['choiceForItem'][0]  # Accessing the first element of the list
+                            choice_sections = choice_for_item['choiceSections']
+                            for option_group in choice_sections:
+                                option_group_info = {
+                                    'option_group_name': option_group['nm'],
+                                    'min_quantity': option_group['mnq'],
+                                    'max_quantity': option_group['mxq'],
+                                    'option_group_names': []
+                                }
+                                if 'ich' in option_group:
+                                    option_group_names = option_group['ich']
+                                    for option_group_name in option_group_names:
+                                        option_group_name_info = {
+                                            'option_name': option_group_name['nm'],
+                                            'option_price': option_group_name['pr']
+                                        }
+                                        option_group_info['option_group_names'].append(option_group_name_info)
+                                option_groups_info.append(option_group_info)
+                            item_info['option_groups'] = option_groups_info
+                    items.append(item_info)
+                # with open(f"{restaurant_name}.json", "w") as json_file:
+                #     json.dump(items, json_file, indent=4)
+                print(f"josn named {restaurant_name}.json created succesfully")
+                
+                
+                # excel_extract(url)
+                # print("excel Created succesfully")
+            else:
+                print("Script tag with id '__NEXT_DATA__' not found.")
+        else:
+            print("Failed to retrieve the webpage. Status code:", response.status_code)
+        return items,json_content,location
+
+    def extract_item(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Items
+        json_data = items
+        category_collection = db['Category']
+        restro_collection = db['Restaurant_details']
+
+
+        items_info = []
+        
+        for item in json_data:
+            id = item['item_id']
+            name = item['item_name']
+            description = item['description']
+            price = item['price']
+            img_url= item['item_image']
+            category_name = item['category']
+            item_position = item['item_position']
+            has_choices = item['has_choices']
+            if has_choices == True:
+                modifires = []
+                for option_group in item.get('option_groups', []):
+                    modifires.append(option_group['option_group_name'])
+            else:
+                modifires = "None"
+            
+            restro = restro_collection.find_one({'url': url})
+            if restro:
+                    restro_id = restro['_id']
+                        
+            restro_ref_id = restro_id
+
+            category = category_collection.find_one({
+                'category_name': category_name,
+                'restro_ref_id': restro_ref_id
+            })
+            if category:
+                category_id = category['_id']
+            else:
+                 category_id = None
+            
+            ref_id = category_id
+
+
+            item_info = {
+                'item_id': id,
+                'name': name,
+                'description': description,
+                'amount': price,
+                'image': img_url,
+                'category_name':category_name,
+                'item_position':item_position,
+                'modifires':modifires,
+                'ref_id_category' : ref_id,
+                'restro_ref_id' : restro_ref_id
+                
+            }
+            items_info.append(item_info)
+        result = collection.insert_many(items_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_category(items,json_content,url):
+        db = client.Restaurants_in_dubai
+        collection = db.Category
+        json_data = items
+        restro_collection = db['Restaurant_details']
+
+        def item_extract_category(json_content,name):
+            menu_data = json_content['props']['pageProps']['initialMenuState']['menuData']['categories']
+            items_list = []
+            for category in menu_data:
+                if category["name"] == name:
+                    for item in category["items"]:
+                        item_info = {
+                            "id": item["id"],
+                            "name": item["name"]
+                        }
+                        items_list.append(item_info)
+
+            return items_list
+            
+            
+        categories_info = []
+
+        existing_categories = set()
+
+        for item in json_data:
+            name = item['category']
+            if name not in existing_categories:
+                category_positin = 1
+                category_isActive = True
+                items = item_extract_category(json_content, name)
+                
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                        restro_id = restro['_id']
+                            
+                restro_ref_id = restro_id
+
+                category_info = {
+                    'category_name': name,
+                    'category_position': category_positin,
+                    'category_isActive': category_isActive,
+                    'items': items,
+                    'restro_ref_id' : restro_ref_id
+                }
+                categories_info.append(category_info)
+                existing_categories.add(name)
+        result = collection.insert_many(categories_info)
+        print("Inserted document IDs:", result.inserted_ids)
+
+    def extract_option_group(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionGroup
+        option_group_info = []
+        existing_categories = []
+        option_group_names_list = []
+        restro_collection = db['Restaurant_details']
+        
+        for item in items:
+            
+            for option_group in item.get('option_groups', []):
+                flag = 1
+                restro = restro_collection.find_one({'url': url})
+
+                if restro:
+                    restro_id = restro['_id']                  
+                restro_ref_id = restro_id
+
+                
+                option_group_name = option_group["option_group_name"]
+                min_quantity = option_group["min_quantity"]
+                max_quantity = option_group["max_quantity"]
+                option_names = []
+                option_names_trial_all = []
+
+                for option in option_group.get("option_group_names", []):
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+                        option_names.append(option_name)
+                        option_names_trial = {
+                                'option_name': option_name,
+                                'option_price': option_price              
+                                }
+                        option_names_trial_all.append(option_names_trial)
+                item_id = []
+                for item in items:
+                        for option_group in item.get('option_groups', []):
+                            option_group_name2 = option_group["option_group_name"]
+                            option_group_names1 = option_group.get('option_group_names',[])
+                            if(option_group_name2 == option_group_name and (sorted(option_group_names1, key=lambda x: x['option_name'])) ==  sorted(option_names_trial_all, key=lambda x: x['option_name']) ):
+                                item_id.append(item['item_id'])
+                    
+                restro = restro_collection.find_one({'url': url})
+                if restro:
+                            restro_id = restro['_id']
+                                
+                restro_ref_id = restro_id
+                            
+
+                option_group_information = {
+                        "option_group_name" : option_group_name,
+                        "min_quantity" : min_quantity,
+                        "max_quantity" : max_quantity,
+                        "option_names"  : option_names,
+                        "item_id" : item_id,
+                        "restro_ref_id" : restro_ref_id
+                    } 
+                option_group_check ={
+                    "option_group_name" : option_group_name,
+                     "option_names"  : option_names
+                    }
+                for category in existing_categories:
+                    if (category['option_group_name'] == option_group_check['option_group_name'] and
+                        sorted(category['option_names']) == sorted(option_group_check['option_names'])):
+                        flag = 0
+                if flag==1:
+                    option_group_info.append(option_group_information)
+
+                
+                existing_categories.append(option_group_check)
+        if option_group_info:       
+            result = collection.insert_many(option_group_info)
+            print("Inserted document IDs:", result.inserted_ids)
+
+    
+    def extract_option_group_names(items,url):
+        db = client.Restaurants_in_dubai
+        collection = db.OptionName
+        option_group_collection = db['OptionGroup']
+        restro_collection = db['Restaurant_details']
+        json_data = items
+        option_names = []
+        option_names_list = []
+
+        for item in json_data:
+            has_choices = item['has_choices']
+            if has_choices == True:
+                flag = 1
+                
+                for option_group in item.get('option_groups', []):
+                    option_group_name2 = option_group["option_group_name"]
+                    for option in option_group.get("option_group_names", []):
+                        restro = restro_collection.find_one({'url': url})
+                        if restro:
+                                restro_id = restro['_id']
+                                    
+                        restro_ref_id = restro_id
+                        option_name = option["option_name"]
+                        option_price = option["option_price"]
+
+                        query = {
+                           
+                            'restro_ref_id': restro_id,
+                            'option_names': option_name  
+                        }
+
+                        
+                        matching_documents = option_group_collection.find(query)
+                        matching_ids = [doc['_id'] for doc in matching_documents]
+                        # option_group_name_true = option_group_collection.find_one({'option_group_name': option_group_name2,
+                        #                                                            'restro_ref_id' : restro_id})
+                        # if option_group_name_true:
+                        #         option_group_id = option_group_name_true['_id']
+
+                        option_group_name = {
+                                "option_name" : option_name,
+                                "option_price" : option_price,
+                                "ref_option_group_id" : matching_ids,
+                                "restro_ref_id" : restro_ref_id
+                        }
+                        if (option_name in option_names_list ):
+                                flag = 0
+                                 
+                        if flag==1:
+                            option_names.append(option_group_name)
+                           
+                        option_names_list.append(option_name)
+                        
+        if option_names:                
+            result = collection.insert_many(option_names)
+            print("Inserted document IDs:", result.inserted_ids)
+    
+
+
+    items,json_content,location = main(url)
+    restro_details(url,location)
+    extract_category(items,json_content,url)
+    extract_item(items,url)
+    extract_option_group(items,url)
+    extract_option_group_names(items,url)
+    return True
+
+# main_all_extract(url) 

app.py

@@ -0,0 +1,222 @@
+from fastapi import FastAPI, HTTPException,Response
+from io import BytesIO
+from pydantic import BaseModel
+from EatEasy_EveryThing_From_url import EatEasy_EveryThing_From_url
+from EatEasy_excel_only import EatEasy_excel_extract
+from EatEasy_Json_only import EatEasy_Json_extract
+from location_fetch_function import location_all
+from Mongo_Data_add import EatEasy_Mongo_Data_add
+from Talabat_files.Talabat_Everything_From_url import Talabat_EveryThing_From_url
+from Talabat_files.Talabat_excel_final import Talabat_excel_extract
+from Talabat_files.Talabat_json_final import Talabat_Json_extract
+from Talabat_files.location_link_fetch import Talabat_location_links
+from Talabat_files.Talabat_Mongo_Data_add import Talabat_mongo_data_add
+from Talabat_files.Multi_urls import multi_url
+from Talabat_files.Talabat_multy_location import Talabat_multy_LOCATION
+from  Eateasy_Multi_Urls import multi_urls
+from starlette.responses import RedirectResponse
+
+app = FastAPI()
+
+
+class EatEasyUrlInput0(BaseModel):
+    url: list
+
+class EatEasyUrlInput(BaseModel):
+    url: str
+
+class EatEasyUrlInput1(BaseModel):
+    url: str
+
+class EatEasyUrlInput2(BaseModel):
+    url: str
+
+class Location_input(BaseModel):
+    location: str
+    inside_location: str
+
+class EatEasyUrlInput3(BaseModel):
+    url: str
+
+class UrlInputTalabat1(BaseModel):
+    url: str
+class UrlInputTalabat2(BaseModel):
+    url: str
+class UrlInputTalabat3(BaseModel):
+    url: str
+class UrlInputTalabat4(BaseModel):
+    location: list
+class UrlInputTalabat5(BaseModel):
+    url: str
+
+class UrlInputTalabat6(BaseModel):
+    url: list
+
+@app.get("/")
+def Docsmain():
+    return RedirectResponse(url="/docs")
+
+
+# @app.post("/EatEasy_Excel_Json_MongoData_From_URL",tags=["EatEasy"])
+# def extract_eat_easy_data(url_input: EatEasyUrlInput):
+#     try:
+#         data = EatEasy_EveryThing_From_url(url_input.url)
+#         return {"message": "Extraction process completed successfully", "data": data}
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.post("/EatEasy_Mongo_from_Multi_urls",tags=["EatEasy"])
+def EatEasy_Mongo_from_Multi_Urls(url_input: EatEasyUrlInput0):
+    try:
+        data = multi_urls(url_input.url)
+        return {"message": "Extraction process completed successfully", "data": data}
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.post("/EatEasy_Extract_Excel_only",tags=["EatEasy"])
+def extract_EatEasy_Excel_only(url_input: EatEasyUrlInput1):
+    try:
+        output, filename = EatEasy_excel_extract(url_input.url)
+        headers = {
+            'Content-Disposition': f'attachment; filename="{filename}"'
+        }
+        return Response(content=output.getvalue(), media_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', headers=headers)
+    except HTTPException as e:
+        raise e
+    except Exception as e:  
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+# @app.post("/EatEasy_Extract_Json_only",tags=["EatEasy"])
+# def extract_EatEasy_Json_only(url_input: EatEasyUrlInput2):
+#     try:
+#         json_data, restaurant_code = EatEasy_Json_extract(url_input.url)
+        
+#         # Create an in-memory binary stream
+#         json_file = BytesIO()
+#         json_file.write(json_data.encode('utf-8'))
+#         json_file.seek(0)
+
+#         file_name = f"{restaurant_code}.json"
+
+#         headers = {
+#             'Content-Disposition': f'attachment; filename="{file_name}"'
+#         }
+
+#         return Response(content=json_file.getvalue(), media_type='application/json', headers=headers)
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))    
+    
+
+
+
+@app.post("/EatEasy_Excel_Json_MongoData_From_Location",tags=["EatEasy"])
+def extract_data(url_input: Location_input):
+    try:
+        data = location_all(url_input.location , url_input.inside_location)
+        return {"message": "Extraction process completed successfully", "data": data}
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# @app.post("/EatEasy_Mongo_Data_Add_from_url",tags=["EatEasy"])
+# def EatEasy_Mongo_Data_add_fun(url_input: EatEasyUrlInput3):
+#     try:
+#         data = EatEasy_Mongo_Data_add(url_input.url)
+#         return {"message": "Extraction process completed successfully", "data": data}
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+    
+
+
+# @app.post("/Talabat_MongoData_From_URL", tags=["Talabat"])
+# def extract_Talabat_data_all(url_input: UrlInputTalabat1):
+#     try:
+#         data = Talabat_EveryThing_From_url(url_input.url)
+#         return {"message": "Extraction process completed successfully", "data": data}
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.post("/Talabat_Extract_excel_only", tags=["Talabat"])
+def extract_Talabat_Excel_only(url_input: UrlInputTalabat2):
+    try:
+        excel_file, filename = Talabat_excel_extract(url_input.url)
+
+        response = Response(content=excel_file.getvalue())
+        response.headers["Content-Disposition"] = f"attachment; filename={filename}"
+        response.headers["Content-Type"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+
+        return response
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+# @app.post("/Talabat_Extract_Json_only",tags=["Talabat"])
+# def extract_Talabat_Json_only(url_input: UrlInputTalabat3):
+#     try:
+#         restaurant_name, output = Talabat_Json_extract(url_input.url)
+        
+#         # Prepare response to return the JSON file as downloadable content
+#         response = Response(content=output.getvalue())
+#         response.headers["Content-Disposition"] = f"attachment; filename={restaurant_name}.json"
+#         response.headers["Content-Type"] = "application/json"
+
+#         return response
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.post("/Talabat_MongoData_From_Location",tags=["Talabat"])
+def extract_data_Talabat(url_input: UrlInputTalabat4):
+    try:
+        data = Talabat_multy_LOCATION(url_input.location)
+        return {"message": "Extraction process completed successfully", "data": data}
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# @app.post("/Talabat_Mongo_Data_Add_from_url",tags=["Talabat"])
+# def Talabat_Mongo_Data_add_fun(url_input: UrlInputTalabat5):
+#     try:
+#         data = Talabat_mongo_data_add(url_input.url)
+#         return {"message": "Extraction process completed successfully", "data": data}
+#     except HTTPException as e:
+#         raise e
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+    
+@app.post("/Talabat_MongoData_From_Multy_URLs", tags=["Talabat"])
+def Talabat_MongoData_From_URLs(url_input: UrlInputTalabat6):
+    try:
+        data = multi_url(url_input.url)
+        return {"message": "Extraction process completed successfully", "data": data}
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

config.py

@@ -0,0 +1,9 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+import os
+
+class Settings(BaseSettings):
+    MONGO_URL: str = os.environ.get("MONGO_URL", "FAKE")
+
+    model_config = SettingsConfigDict(env_file=".env")
+
+settings = Settings()

mongo.py

@@ -0,0 +1 @@
+MONGO_URL = "C:\Users\dipen\OneDrive\Desktop\Git_repo_hugging_face\talabat_eateasy\.env"

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+pydantic
+pymongo
+requests
+beautifulsoup4
+pandas
+starlette
+openpyxl
+pydantic_settings