Merge branch 'master' of http://gitlab.sliit.lk/2022-020/2022-020 into IT19179568

TravelTimePredictionNN.py

+# %%
+import pandas as pd
+
+# %%
+data = pd.read_csv('BusTravelData.csv')
+
+
+# %%
+data['Day'].unique()
+
+# %%
+data['Day'].map({'Sunday':0,'Monday':1,'Tuesday':2})
+
+# %%
+data['Day'] = data['Day'].map({'Sunday':0,'Monday':1,'Tuesday':2})
+
+# %%
+data.head()
+
+# %%
+data['Special'] = data['Special'].map({'No':0,'Yes':1})
+
+# %%
+data.tail()
+
+# %%
+data['Weather'].unique()
+
+# %%
+data.columns
+
+# %%
+X = data.drop(['Date','Travel Time'],axis=1)
+
+
+# %%
+y = data['Travel Time']
+
+
+# %% [markdown]
+# Train/test split
+# 
+# 1. split data into two parts 
+# 
+#     training data set
+#     testing data set
+# 
+# 2. Train the models on training set
+# 
+# 3. Test the models on testing data set
+
+# %%
+from sklearn.model_selection import train_test_split
+
+# %%
+X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=42)
+
+# %%
+y_train
+
+# %%
+from sklearn.linear_model import LinearRegression
+from sklearn.svm import SVR
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.neural_network import MLPClassifier
+
+
+# %%
+lr = LinearRegression()
+NN = MLPClassifier()
+lr.fit(X_train,y_train)
+NN.fit(X_train,y_train)
+
+# %%
+y_pred1 = lr.predict(X_test)
+
+# %%
+df1 = pd.DataFrame({'Actual':y_test, 'Lr Results':y_pred1})
+
+# %%
+df1
+
+# %%
+y_pred2 = NN.predict(X_test)
+df2 = pd.DataFrame({'Actual':y_test, 'NN Results':y_pred2, 'LR Results':y_pred1})
+df2
+
+# %%
+import matplotlib.pyplot as plt
+
+# %%
+plt.subplot(221)
+plt.plot(df1['Actual'].iloc[0:11],label='Actual')
+plt.plot(df1['Lr Results'].iloc[0:11],label='Lr Results')
+plt.legend()
+
+# %% [markdown]
+# 	Time	Day	Rush	Special	Congestion	Drving Speed	Stops	Weather	Distance	Travel Time
+
+# %%
+plt.subplot(221)
+plt.plot(df1['Actual'].iloc[0:11],label='Actual')
+plt.plot(df2['NN Results'].iloc[0:11],label='NN Results')
+plt.legend()
+
+# %% [markdown]
+# Prediction with Current parameters (Predict Time with trained Model)
+
+# %%
+data = {'Time':6,
+        'Day':1,
+        'Special':0,
+        'Congestion':8,
+        'Drving Speed':40,
+        'Stops':14,
+        'Weather':23,
+        'Distance':14.7
+        }
+df = pd.DataFrame(data,index=[0])
+df
+
+
+# %%
+new_pred = lr.predict(df)
+NN_pred = NN.predict(df)
+
+
+# %%
+data = {'Time':17,
+        'Day':1,
+        'Special':0,
+        'Congestion':5,
+        'Drving Speed':40,
+        'Stops':20,
+        'Weather':24,
+        'Distance':14.7
+        }
+ddf = pd.DataFrame(data,index=[0])
+ddf
+
+# %%
+resultsNN = NN.predict(ddf)
+resultsNN
+
+# %%
+def GetPrediction(time,date,special,congestion,dspeed,stops,weather,distance):
+    data = {'Time':time,
+        'Day':date,
+        'Special':special,
+        'Congestion':congestion,
+        'Drving Speed':dspeed,
+        'Stops':stops,
+        'Weather':weather,
+        'Distance':distance
+        }
+    ddf = pd.DataFrame(data,index=[0])
+    resultsNN = NN.predict(ddf)
+    resultsNN
+    print('Travel Time Prediction :-',*resultsNN,'Min')
+
+# %%
+def GetDateCode(date):
+    if('Sunday' == date ):
+        return 0
+    elif('Monday' == date):
+        return 1
+    elif('Tuesday' == date):
+        return 2
+    elif('Wednesday' == date):
+        return 3
+    elif('Thursday' == date):
+        return 4
+    elif('Friday' == date):
+        return 5
+    elif('Saturday' == date):
+        return 6
+    else:
+        return 9
+    
+import testingWeather
+
+city = "malabe"
+city = city+" weather"
+ 
+time= 6  #this time come from semins data/member of route planning
+day ='Friday'  #date come from UI 
+date = GetDateCode(day)
+special = 0 # Special Day or Not 1/0
+Congestion= 8 # This is depend on the depature time---- heavy traffic =9 / No Traffic = 0 
+drivingspeedAVG = 40 #this is come from GPS data
+stops =14 #total Bus stops/holts between the travel --- data come from the Seminas data/member of route planning 
+weather =testingWeather.weather(city)  #Get weather in travel area
+Distance =14.7 #Distance data come from seminas ----- data come from the Seminas data/member of route planning
+
+
+GetPrediction(time,date,special,Congestion,drivingspeedAVG,stops,weather,Distance)
+
+
+
+
+

gps.ino

+#include <WiFi.h>
+#include <FirebaseESP32.h>
+#include <TinyGPS++.h>
+
+#define FIREBASE_HOST "gps-b123c-default-rtdb.firebaseio.com"
+#define FIREBASE_AUTH "gEjXkGOWaMEzkZKpKIYqwFH7dQMetih25gsmligT"
+#define WIFI_SSID "LAZI 5G"
+#define WIFI_PASSWORD "fmrp1530"
+FirebaseData firebaseData;
+
+#define RXD2 5
+#define TXD2 21
+HardwareSerial neogps(1);
+String ESP32_API_KEY = "Ad5F10jkBM0";
+TinyGPSPlus gps;
+void setup(){
+  
+  Initialization();
+  WiFiConnection();
+  neogps.begin(9600, SERIAL_8N1, RXD2, TXD2);
+  
+ }
+
+float counter2 = 0.5;
+
+void Initialization(){
+  
+  Serial.begin(115200); 
+ }
+
+void WiFiConnection(){
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+  Serial.print("Connecting to Wi-Fi");
+  while (WiFi.status() != WL_CONNECTED)
+  {
+    Serial.print(".");
+    delay(300);
+  }
+  Serial.println();
+  Serial.print("Connected with IP: ");
+  Serial.println(WiFi.localIP());
+  Serial.println();
+
+  Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
+  Firebase.reconnectWiFi(true);
+}
+
+void loop(){
+  boolean newData = false;
+  for (unsigned long start = millis(); millis() - start < 2000;){
+    while(neogps.available()){
+      if(gps.encode(neogps.read())){
+        if(gps.location.isValid() == 1){
+          newData = true;
+          break;
+        }
+      }
+    }
+  }
+  //NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+  
+  //MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
+  //If newData is true
+  if(true){
+    newData = false;
+  
+    //NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+    String latitude, longitude;
+    //float altitude;
+    //unsigned long date, time, speed, satellites;
+    
+    latitude = String(gps.location.lat(), 6); // Latitude in degrees (double)
+    longitude = String(gps.location.lng(), 6); // Longitude in degrees (double)
+    
+    //altitude = gps.altitude.meters(); // Altitude in meters (double)
+    //date = gps.date.value(); // Raw date in DDMMYY format (u32)
+    //time = gps.time.value(); // Raw time in HHMMSSCC format (u32)
+    //speed = gps.speed.kmph();
+    
+    //Serial.print("Latitude= "); 
+    //Serial.print(latitude);
+    //Serial.print(" Longitude= "); 
+    //Serial.println(longitude);
+    String gps_data;
+    gps_data = "api_key="+ESP32_API_KEY;
+    gps_data += "&lat="+latitude;
+    gps_data += "&lng="+longitude;
+
+    Serial.print("gps_data: ");
+    Serial.println(gps_data);
+    
+    String x = gps_data;
+    
+  if(Firebase.setString(firebaseData, "location", x)){
+    }
+    if(Firebase.getString(firebaseData, "location")){
+    if(firebaseData.dataType() == "string"){
+      Serial.print("data = ");
+      Serial.println(firebaseData.stringData());
+    }
+  }
+}
+}
\ No newline at end of file

routeplanner/AL.py

+from helpers import load_map_test, load_map_bus, load_map_train,route_177
+import math
+
+val = 0
+
+class PathPlanner():
+    
+    def __init__(self, M, start=None, goal=None, type=None):
+        
+        self.map = M
+        self.start= start
+        self.goal = goal
+        self.type = type
+        self.dis = 0
+
+        self.closedSet = self.create_closedSet() if goal != None and start != None else None
+        self.openSet = self.create_openSet() if goal != None and start != None else None
+        self.cameFrom = self.create_cameFrom() if goal != None and start != None else None
+        self.gScore = self.create_gScore() if goal != None and start != None else None
+        self.fScore = self.create_fScore() if goal != None and start != None else None
+        self.path = self.run_search() if self.map and self.start != None and self.goal != None else None
+    
+    def reconstruct_path(self, current):
+        total_path = [current]
+        while current in self.cameFrom.keys():
+            current = self.cameFrom[current]
+            total_path.append(current)
+        return total_path
+    
+    def _reset(self):
+        self.closedSet = None
+        self.openSet = None
+        self.cameFrom = None
+        self.gScore = None
+        self.fScore = None
+        self.path = self.run_search() if self.map and self.start and self.goal else None
+
+    def run_search(self):
+        """ """
+        if self.map == None:
+            raise(ValueError, "Must create map before running search")
+        if self.goal == None:
+            raise(ValueError, "Must create goal node before running search")
+        if self.start == None:
+            raise(ValueError, "Must create start node before running search")
+
+        self.closedSet = self.closedSet if self.closedSet != None else self.create_closedSet()
+        self.openSet = self.openSet if self.openSet != None else  self.create_openSet()
+        self.cameFrom = self.cameFrom if self.cameFrom != None else  self.create_cameFrom()
+        self.gScore = self.gScore if self.gScore != None else  self.create_gScore()
+        self.fScore = self.fScore if self.fScore != None else  self.create_fScore()
+
+        while not self.is_open_empty():
+            current = self.get_current_node()
+
+            if current == self.goal:
+                self.path = [x for x in reversed(self.reconstruct_path(current))]
+                return self.path
+            else:
+                self.openSet.remove(current)
+                self.closedSet.add(current)
+
+            for neighbor in self.get_neighbors(current):
+                if neighbor in self.closedSet:
+                    continue    # Ignore the neighbor which is already evaluated.
+
+                if not neighbor in self.openSet:    # Discover a new node
+                    self.openSet.add(neighbor)
+                
+                # The distance from start to a neighbor
+                if self.getTempGScore(current, neighbor) >= self.get_gScore(neighbor):
+                    continue 
+
+
+                # This path is the best until now. Record it!
+                global val  #
+                val = val + self.dis
+                self.record_best_path_to(current, neighbor)
+        print("No Path Found")
+        self.path = None
+        return False
+
+    def create_closedSet(self):
+        return set()
+
+    def create_openSet(self):
+
+        openSet = set()
+        openSet.add(self.start)
+        return openSet
+        
+    def create_cameFrom(self):
+        cameFrom = {}
+        return cameFrom
+
+    def create_gScore(self):
+        gScore = {}
+        for node in self.map.intersections.keys():
+            if node == self.start:
+                gScore[node] = 0
+            else: gScore[node] = float('inf')
+        return gScore
+
+    def create_fScore(self):
+        if self.start != None:
+            fScore = {}
+            for node in self.map.intersections.keys():
+                if node == self.start:
+                    fScore[node] = self.heuristic_cost_estimate(self.start)
+                else: fScore[node] = float('inf')
+            return fScore
+        raise(ValueError, "Must create start node before creating fScore.")
+
+    def set_map(self, M):
+        "set map attribute "
+        self._reset(self)
+        self.start = None
+        self.goal = None 
+        self.map = M
+
+    def set_start(self, start):
+        " set start attribute "
+        self._reset(self)
+        self.start = start
+        self.goal = None
+        
+    def set_goal(self, goal):
+        "set goal attribute "
+        self._reset(self)
+        self.goal = goal
+
+    #-------------------------------- get information --------------------------------#
+
+    def is_open_empty(self):
+        "returns True if the open set is empty"
+        return not bool(self.openSet)
+    def get_current_node(self):
+        " Returns the node in the open set with the lowest value of f(node)"
+        
+        current = None
+        minim = float('inf')
+        for node in self.openSet:
+            if self.fScore[node] < minim:
+                minim = self.fScore[node]
+                current = node
+        return current        
+
+    def get_neighbors(self, node):
+        """Returns the neighbors of a node"""
+        return set(self.map.roads[node]) 
+
+    def get_traveled_distance(self):
+        #traveled_distance 
+        return self.dis
+
+    #-------------------------------- Calculations --------------------------------#
+
+    def get_gScore(self, node):
+        return self.gScore[node]
+
+    def getTempGScore(self, current, neighbor):
+        # distance from the current node to it's neighbors
+        
+        g_score_current = self.get_gScore(current)
+        dist_current_neighbor = self.distance(current,neighbor)
+        return g_score_current+dist_current_neighbor
+
+    def heuristic_cost_estimate(self, node):
+
+        if self.goal != None:
+            heuristic_estimate = self.distance(node,self.goal)
+            return heuristic_estimate
+        raise(ValueError, "Must create goal node before calculating huristic ")
+
+    def calculate_fscore(self, node):
+        #  F = G + H
+        
+        f_score = self.get_gScore(node) + self.heuristic_cost_estimate(node)
+        return f_score
+
+
+    # best path
+    def record_best_path_to(self, current, neighbor):
+        
+        self.cameFrom[neighbor] = current
+        self.gScore[neighbor] = self.getTempGScore(current,neighbor)
+        self.fScore[neighbor] = self.gScore[neighbor] + self.heuristic_cost_estimate(neighbor)
+
+    def distance(self, node_1, node_2):
+        from math import radians, cos, sin, asin, sqrt
+
+        #The math module contains a function named
+        #radians which converts from degrees to radians.
+
+        lon1 = radians(self.map.intersections [node_1][0])
+        lon2 = radians(self.map.intersections [node_2][0])
+        lat1 = radians(self.map.intersections [node_1][1])
+        lat2 = radians(self.map.intersections [node_2][1])
+        
+        # Haversine formula
+        dlon = lon2 - lon1
+        dlat = lat2 - lat1
+        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
+    
+        c = 2 * asin(sqrt(a))
+        
+        # Radius of earth in kilometers. Use 3956 for miles
+        r = 6371
+        
+        # calculate the result
+        dist = (c * r)
+        #print (dist)
+        self.dis = dist
+        return dist
+
+
+# Get route  
+def main( a, node1, node2):
+    if a == 3:
+        map = load_map_train()
+    elif a == 2:
+        map = load_map_bus()
+    else:
+        map = load_map_test()
+    
+    planner = PathPlanner(map,node1,node2)
+    print(map.roads)
+
+    path = planner.path
+    print('distance =' ,val)
+    if path == [5, 16, 37, 12, 34]:
+        print("code works for test path!!!")
+        print(path)
+    else:
+        print("Genarated path")
+        
+        print(path)
+        
+        # for x in path:
+        #     if routeNo
+        #     print (x)
+        
+        #for each in path:
+            
+
+
+main( 1, 2, 14)   
\ No newline at end of file

routeplanner/helpers.py

+
+import networkx as nx
+import pickle
+from chart_studio import plotly as py
+import random
+from plotly.graph_objs import *
+from plotly.offline import init_notebook_mode, plot, iplot
+#init_notebook_mode(connected=True)
+
+
+route_177 = { 
+	1: 34, 
+	2: 42, 
+	3: 54, 
+	4: 67, 
+	5: 80, 
+	6: 92, 
+	7: 105, 
+	8: 109, 
+	9: 117,
+	10: 126,
+	11: 134,
+	12: 140,
+	13: 149,
+	14: 157,
+	15: 163,
+}
+
+map_test = {
+	0: {'pos': (6.911034627182109, 79.84918916006576), 'connections': [1], 'name' : 'Kollupitiya','type': 0,'routeNo': 177, 'hValue': 1}, 
+	1: {'pos': (6.911751932322411, 79.86194701315071), 'connections': [0,2], 'name' : 'Viharamahadevi Park', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	2: {'pos': (6.911385550864001, 79.87682791026592), 'connections': [1,3], 'name' : 'House Of Fashion', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	3: {'pos': (6.911031363415147, 79.88498429384545), 'connections': [2,4], 'name' : 'Castle Street', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	4: {'pos': (6.908462881966912, 79.89338919261249), 'connections': [3,5], 'name' : 'Rajagiriya', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	5: {'pos': (6.906663916178293, 79.90205413217801), 'connections': [4,6], 'name' : 'Hsbc Rajagiriya', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	6: {'pos': (6.90333333857459, 79.90747047529919), 'connections': [5,7], 'name' : 'Ethulkotte New', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	7: {'pos': (6.903185701293392, 79.91168232658337), 'connections': [6,8], 'name' : 'Parliament Junction', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	8: {'pos': (6.902102452411621, 79.91741047710077), 'connections': [7,9], 'name' : 'Battaramulla Junction', 'type': 0, 'routeNo': 177, 'hValue': 1}, 
+	9: {'pos': (6.90431022366131, 79.92400480782847), 'connections': [8,10], 'name' : 'Ganahena', 'type': 0, 'routeNo': 177, 'hValue': 1},
+	10: {'pos': (6.906173952520986, 79.92862087153598), 'connections': [9,11], 'name' : 'Koswatta', 'type': 0, 'routeNo': 177, 'hValue': 1},
+	11: {'pos': (6.9084657304543455, 79.9383708894408), 'connections': [10,12], 'name' : 'Kotte-Bope', 'type': 0, 'routeNo': 177, 'hValue': 1},
+	12: {'pos': (6.9085023402918155, 79.94425286198016), 'connections': [11,13], 'name' : 'Thalahena Junction', 'type': 0, 'routeNo': 177, 'hValue': 1},
+	13: {'pos': (6.903962700873259, 79.95430199947661), 'connections': [12,14], 'name' : 'Malabe', 'type': 0, 'routeNo': 177, 'hValue': 1},
+	14: {'pos': (6.933539686667202, 79.85005389798111), 'connections': [15], 'name' : 'Fort', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+	15: {'pos': (6.923619774894732, 79.84965509086771), 'connections': [14,16], 'name' : 'Kompannavidiya', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+	16: {'pos': (6.911282166657041, 79.84821747831087), 'connections': [15,1,17], 'name' : 'Kollupitiya', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+	17: {'pos': (6.893710110662125, 79.85300590028642), 'connections': [16,18], 'name' : 'Bambalapitiya', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+	18: {'pos': (6.875030063532378, 79.85744793142631), 'connections': [17,19], 'name' : 'Wellawatte', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+	19: {'pos': (6.850915755796403, 79.8620969312958), 'connections': [18], 'name' : 'Dehiwala ', 'type': 1, 'routeNo': 8717, 'hValue': 1},
+}
+
+
+class Map:
+	def __init__(self, G):
+		self._graph = G
+		self.intersections = nx.get_node_attributes(G, "pos")
+		self.routeNo = nx.get_node_attributes(G, "routeNo")
+		self.type = nx.get_node_attributes(G, "type")
+		self.roads = [list(G[node]) for node in G.nodes()]
+		
+		
+
+	def save(self, filename):
+		with open(filename, 'wb') as f:
+			pickle.dump(self._graph, f)
+
+def load_map_graph(map_dict):
+	G = nx.Graph()
+	for node in map_dict.keys():
+		G.add_node(node, pos=map_dict[node]['pos'], type=map_dict[node]['type'],routeNo=map_dict[node]['routeNo'])
+	for node in map_dict.keys():
+		for con_node in map_dict[node]['connections']:
+			G.add_edge(node, con_node)
+	
+	return G
+	
+
+def load_map_b(map_dict):
+	# G = nx.Graph()
+	# for node in map_dict.keys():
+	# 	#nodeValue = 
+	# 	if map_dict[node]['type'] != 1:
+	# 		continue
+	# 	else:
+	# 		G.add_node(node, pos=map_dict[node]['pos'], type=map_dict[node]['type'],routeNo=map_dict[node]['routeNo'])
+	G = nx.Graph()
+	for node in map_dict.keys():
+		G.add_node(node, pos=map_dict[node]['pos'], type=map_dict[node]['type'],routeNo=map_dict[node]['routeNo'])	
+	# for node in map_dict.keys():
+	# 	for con_node in map_dict[node]['connections']:
+	# 		if map_dict[con_node]['type'] != 1:
+	# 			continue
+	# 		else:
+	# 			G.add_edge(node, con_node)
+	for node in map_dict.keys():
+		for con_node in map_dict[node]['connections']:
+			if map_dict[node]['type'] != 1:
+				continue
+			elif map_dict[con_node]['type'] != 1:
+				continue
+			else:
+				G.add_edge(node, con_node)
+	return G
+
+#map for train
+def load_map_t(map_dict):
+	G = nx.Graph()
+	for node in map_dict.keys():
+		G.add_node(node, pos=map_dict[node]['pos'], type=map_dict[node]['type'],routeNo=map_dict[node]['routeNo'])	
+	
+	for node in map_dict.keys():
+		for con_node in map_dict[node]['connections']:
+			if map_dict[node]['type'] == 1:
+				continue
+			elif map_dict[con_node]['type'] == 1:
+				continue
+			else:
+				G.add_edge(node, con_node)
+	return G
+
+def load_map_test():
+	G = load_map_graph(map_test)
+	return Map(G)
+
+def load_map_bus():
+	G = load_map_b(map_test)
+	return Map(G)
+
+def load_map_train():
+	G = load_map_t(map_test)
+	return Map(G)
+

routeplanner/test.py

+from helpers import load_map_40
+
+MAP_40_ANSWERS = [
+    (5, 34, [5, 16, 37, 12, 34]),
+    (5, 5,  [5]),
+    (8, 24, [8, 14, 16, 37, 12, 17, 10, 24])
+]
+
+def test(shortest_path_function):
+    map_40 = load_map_40()
+    correct = 0
+    for start, goal, answer_path in MAP_40_ANSWERS:
+        path = shortest_path_function(map_40, start, goal).path
+        if path == answer_path:
+            correct += 1
+            print("For start:", start, 
+                  "Goal:     ", goal,
+                  "Your path:", path,
+                  "Correct:  ", answer_path)
+        else:
+             print("Error Testing faild !!!" )
+    if correct == len(MAP_40_ANSWERS):
+        print("All tests pass ")
+    else:
+        print("Only passed", correct, "/", len(MAP_40_ANSWERS), "test cases")
+    
\ No newline at end of file

testingWeather.py

+from bs4 import BeautifulSoup
+import requests
+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'}
+ 
+ 
+def weather(city):
+    city = city.replace(" ", "+")
+    res = requests.get(
+        f'https://www.google.com/search?q={city}&oq={city}&aqs=chrome.0.35i39l2j0l4j46j69i60.6128j1j7&sourceid=chrome&ie=UTF-8', headers=headers)
+    
+    soup = BeautifulSoup(res.text, 'html.parser')
+    location = soup.select('#wob_loc')[0].getText().strip()
+    time = soup.select('#wob_dts')[0].getText().strip()
+    info = soup.select('#wob_dc')[0].getText().strip()
+    weather = soup.select('#wob_tm')[0].getText().strip()
+    return weather
+ 
+