def main():
data_manager = DataManager()
sheet_data = data_manager.read_data()
flight_search = FlightSearch()
notification_manager = NotificationManager()
if len(sheet_data) > 0:
for row in sheet_data:
if row['iataCode'] == '':
row['iataCode'] = flight_search.search_iata(row['city'])
data_manager.destination_data = sheet_data
data_manager.update_data()
tomorrow = datetime.now() + timedelta(days=1)
six_months_from_today = datetime.now() + timedelta(days=180)
for destination in sheet_data:
flight = flight_search.search_flights(ORIGIN_CITY_IATA,
destination['iataCode'],
from_time=tomorrow,
to_time=six_months_from_today)
if flight.price < destination['lowestPrice']:
notification_manager.send_sms(
msg=
f'Low price alert! Only £{flight.price} to fly from {flight.origin_city}-{flight.origin_airport} '
f'to {flight.destination_city}-{flight.destination_airport}, from {flight.out_date} '
f'to {flight.return_date}.')
def update_iata_code(self, dict):
fs = FlightSearch()
iata_code = fs.get_code(dict['city'])
body = {'price': {'iataCode': iata_code}}
response = requests.put(f'{SHEETY_ENDPOINT_PRICES}/{dict["id"]}',
json=body,
headers=header)
print(response.text)
def __init__(self):
self.ui = UI()
self.flight_data_manager = FlightDataManager()
self.spreadsheet_data_manager = SpreadsheetDataManager(
self.flight_data_manager)
self.notification_manager = NotificationManager()
self.flight_search = FlightSearch(self.spreadsheet_data_manager,
self.flight_data_manager,
self.notification_manager)
def main():
data_manager = DataManager()
flight_search = FlightSearch()
list_of_cities = data_manager.get_cities_from_google_sheet().json(
)["prices"]
for city in list_of_cities:
# print(city["city"])
iata = flight_search.get_iata_for_cities(
city["city"]).json()["locations"][0]["code"]
# print(iata)
data_manager.add_iata_to_google_sheet(city["id"], iata)
def find_cheapest(self):
for city in self.iata_prices:
search = FlightSearch(LONDON_IATA, city)
result = search.find_flights()
cheapest_flight = result[0]
for flight in result:
if flight["price"] > cheapest_flight["price"]:
cheapest_flight = flight
if self.iata_prices[city] > cheapest_flight["price"]:
text = f"Low Price alert! Only {cheapest_flight['price']}, to fly from London-{cheapest_flight['flyFrom']} to {cheapest_flight['cityTo']}-{cheapest_flight['flyTo']}."
print(text)
def main():
data_manager = DataManager()
sheet_data = data_manager.read_data()
flight_search = FlightSearch()
notification_manager = NotificationManager()
if len(sheet_data) > 0:
for row in sheet_data:
if row['iataCode'] == '':
row['iataCode'] = flight_search.search_iata(row['city'])
data_manager.destination_data = sheet_data
data_manager.update_data()
sheet_data = data_manager.read_data()
destinations = {
data["iataCode"]: {
"id": data["id"],
"city": data["city"],
"price": data["lowestPrice"]
}
for data in sheet_data
}
tomorrow = datetime.now() + timedelta(days=1)
six_months_from_today = datetime.now() + timedelta(days=180)
for destination in destinations:
flight = flight_search.search_flights(ORIGIN_CITY_IATA,
destination['iataCode'],
from_time=tomorrow,
to_time=six_months_from_today)
if flight is None:
continue
if flight.price < sheet_data[destination]['price']:
users = data_manager.get_customer_emails()
emails = [row['email'] for row in users]
names = [row['firstName'] for row in users]
msg = f'Low price alert! Only £{flight.price} to fly from {flight.origin_city}-{flight.origin_airport} '
f'to {flight.destination_city}-{flight.destination_airport}, from {flight.out_date} '
f'to {flight.return_date}.'
if flight['stop_overs'] > 0:
msg += f'\nFlight has {flight["stop_overs"]} stop over, via {flight["via_city"]}'
link = f'https://www.google.co.uk/flights?hl=en#flt={flight.origin_airport}.{flight.destination_airport}' \
f'.{flight.out_date}*{flight.destination_airport}.{flight.origin_airport}.{flight.return_date}'
notification_manager.send_emails(emails, msg, link)
class App:
def __init__(self):
self.ui = UI()
self.flight_data_manager = FlightDataManager()
self.spreadsheet_data_manager = SpreadsheetDataManager(
self.flight_data_manager)
self.notification_manager = NotificationManager()
self.flight_search = FlightSearch(self.spreadsheet_data_manager,
self.flight_data_manager,
self.notification_manager)
# PUBLIC METHODS
def start(self):
self.flight_search.check_flights()
def main():
load_dotenv('.env')
notification_manager = NotificationManager()
data_manager = DataManager()
# TODO: Uncomment after this month because of rate limit on sheety
# data = data_manager.get_data()
data = {
"prices": [{
"id": 1,
"city": "Paris",
"iataCode": "",
"lowestPrice": 100
}, {
"id": 2,
"city": "Berlin",
"iataCode": "",
"lowestPrice": 100
}]
}
flight_search = FlightSearch()
for destination in data['prices']:
code = ""
try:
if destination['iataCode'] == '':
code = flight_search.get_iata(city_name=destination['city'])
else:
code = destination['iataCode']
except KeyError:
code = flight_search.get_iata(city_name=destination['city'])
finally:
cheapest_flight = flight_search.get_price(origin=MY_LOCATION,
destination=code)
price = cheapest_flight['price']
body = {
"price": {
"id": destination['id'],
"city": destination['city'],
"iataCode": code,
"lowestPrice": price
},
}
if price < destination['lowestPrice']:
message = f"Low Price Alert: Only €{price} to fly from {MY_CITY} " \
f"to {destination['city']}-{cheapest_flight['flyTo']}! between " \
f"{cheapest_flight['utc_departure'].split('T')[0]} and " \
f"{cheapest_flight['utc_arrival'].split('T')[0]} "
# TODO: Uncomment after this month because of rate limit on sheety
print(message)
def __init__(self):
self.service = self.authentic_sheets()
self.prices = self.get_prices_list(self.service)
self.city_list = self.get_city_list(self.service)
self.IATA_list = FlightSearch.iataassign(self.city_list)
self.value_range_body_city_list_IATA = {
"majorDimension": "COLUMNS",
"values": [self.IATA_list]
}
def main():
flight_search = FlightSearch()
data_manager = DataManager()
notification_manager = NotificationManager()
data = data_manager.get_data()["prices"]
# Get IATA Codes for cities in spreadsheet.
if data[0]["iataCode"] == "":
city_ids = [(elem["id"], elem["city"]) for elem in data]
for elem in city_ids:
iata = flight_search.get_iata_code_by_city(elem[1])
body = {
"price": {
"iataCode": iata,
}
}
data_manager.put_data(body, elem[0])
# Get Cheap flights from LON (London) to destinations in spread sheet.
for destination in data:
flight = flight_search.search_a_flight(destination["iataCode"])
if flight is None:
continue
# Notify if cheap flight is found.
if destination["lowestPrice"] > flight.price:
message = "Low price alert!\n" \
f"Only {flight.price} to fly from {flight.origin_city}-{flight.origin_airport}" \
f" to {flight.destination_city}-{flight.destination_airport}" \
f" from {flight.out_date}" \
f" to {flight.return_date}."
if flight.stop_overs > 0:
message += f"\nFlight has {flight.stop_overs} stop over, via {flight.via_city}."
# Notify me on phone
notification_manager.send_message(message)
#notify customers via mail
customers = data_manager.get_users()["users"]
notification_manager.send_emails(customers[0]["email"], flight)
def main():
print(f"Departure: {POINT_OF_DEPARTURE}")
print(f"Date from: {DATE_FROM}")
print(f"Date to: {DATE_TO}")
# Here we load our preferred destinations from the provided google sheet.
data_manager = DataManager(
sheety_sheet_endpoint=SHEETY_SHEET_ENDPOINT
)
flight_data = data_manager.flight_data
# Here we update our preferred destinations with IATA code if code is missing.
updated_records = []
for record in flight_data:
if record.iata_code == "":
iata_code = FlightSearch.fetch_iata_code(record.city)
record.iata_code = iata_code
updated_records.append(record)
# print(updated_records)
# Here we update our Google Sheets with the IATA Codes.
data_manager.update_flight_data_with_iata_code(
updated_records=updated_records
)
# Here we search for cheap flight.
flight_searcher = FlightSearch(
point_of_departure=POINT_OF_DEPARTURE,
date_from=DATE_FROM,
date_to=DATE_TO,
min_nights_in_destination=MIN_NIGHTS_IN_DESTINATION,
max_nights_in_destination=MAX_NIGHTS_IN_DESTINATION,
)
# Here we fetch the cheapest flights and send an SMS.
for record in flight_data:
record.cheapest_flight = flight_searcher.fetch_cheap_flights(record)
if record.cheapest_flight is not None:
NotificationManager.send_message(flight_data=record.cheapest_flight, message_to=MY_PHONE_NUMBER)
def __init__(self, city):
search = FlightSearch(city)
flights = [
flight for flight in search.response
if flight["availability"]["seats"]
]
self.data = {
"city_dpt": CITY,
"city_to": city,
"air_dpt": flights[0]["flyFrom"] if flights else "",
"air_to": flights[0]["flyTo"] if flights else "",
"price": flights[0]["price"] if flights else "",
"date": flights[0]["local_departure"] if flights else "",
}
def peres(self):
self.alldata = []
dm = DataManager()
for city in dm.Codes_Prices:
if len(self.alldata) == 0:
fs = FlightSearch(city, dm.time_do, dm.time_posle,
dm.Codes_Prices[city])
fs.peresadki(city, dm.time_do, dm.time_posle,
dm.Codes_Prices[city])
data = {
i['cityTo']: [
i['flyFrom'], i['price'],
i['local_departure'].split('T')[0], i['routes']
]
for i in fs.peresadka if i['cityTo'] not in data.keys()
}
self.alldata.append(data)
for i in self.alldata:
if i == {}:
self.alldata.remove(i)
print(self.alldata)
return self.alldata
def fill_iata_column(self):
if self.iata_codes[0] == "":
for flight in self.flights:
fs = FlightSearch(flight)
index = self.cities.index(flight['city']) + 2
iata_data = {"flight": {"iataCode": f"{fs.iata_code}"}}
if ENVIRONMENT == "Production":
iata_res = requests.put(
url=f"{SHEETY_URL}/flights/{index}", json=iata_data)
print(iata_res.text)
else:
pass
if ENVIRONMENT != "Production":
print(f"Env: {ENVIRONMENT}")
self.update_data()
def __init__(self):
self.alldata = []
dm = DataManager()
for city in dm.Codes_Prices:
fs = FlightSearch(city, dm.time_do, dm.time_posle,
dm.Codes_Prices[city])
data = {
i['cityTo']:
[i['flyFrom'], i['price'], i['local_departure'].split('T')[0]]
for i in fs.onewway
}
self.alldata.append(data)
for i in self.alldata:
if i == {}:
self.alldata.remove(i)
print(self.alldata)
def create_flights(cls, IATA_list, prices):
# kiwi response is a dit: dict_keys(['id', 'nightsInDest', 'duration', 'flyFrom', 'cityFrom', 'cityCodeFrom',
# 'countryFrom', 'flyTo', 'cityTo', 'cityCodeTo', 'countryTo', 'distance', 'routes', 'airlines', 'pnr_count',
# 'has_airport_change', 'technical_stops', 'price', 'bags_price', 'baglimit', 'availability',
# 'facilitated_booking_available', 'conversion', 'quality', 'booking_token', 'deep_link', 'tracking_pixel',
# 'transfers', 'type_flights', 'virtual_interlining', 'route', 'local_arrival', 'utc_arrival', 'local_departure',
# 'utc_departure'])
flights = []
for city, price in zip(IATA_list, prices):
FoundFlight = FlightSearch.kiwi_search(city, price)
if not FoundFlight:
flights.append(None)
print(f"No flights to {city} at the set price")
else:
flights.append(
cls(FoundFlight[0]['price'], FoundFlight[0]['cityTo'],
FoundFlight[0]['route'][0]['local_departure'],
FoundFlight[0]['route'][1]['local_departure'],
FoundFlight[0]['deep_link']))
return flights
class FlightData:
def __init__(self):
self.flightsearch = FlightSearch()
self.datamanager = DataManager()
self.sheety_data = self.datamanager.get_data()
def data(self, city_codes):
data = {}
min_prices = []
out_date = []
return_date = []
for city in city_codes:
self.flight_info = self.flightsearch.search_flights(city)
price = self.flight_info["price"]
min_prices.append(price)
out = self.flight_info["route"][0]["local_departure"].split("T")[0]
out_date.append(out)
back = self.flight_info["route"][1]["local_departure"].split(
"T")[0]
return_date.append(back)
data["prices"] = min_prices
data["out date"] = out_date
data["return date"] = return_date
return data
def list_cities(self):
cities = [flight["city"] for flight in self.sheety_data["prices"]]
return cities
def orig_prices(self):
orig_prices = [
flight["lowestPrice"] for flight in self.sheety_data["prices"]
]
return orig_prices
from flight_data import FlightData
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
flight_search = FlightSearch()
data_manager = DataManager()
sheet_data = data_manager.get_destination_data()
if sheet_data[0]["iataCode"] == "":
for row in sheet_data:
row["iataCode"] = flight_search.get_destination_code(row["city"])
print(sheet_data)
data_manager.destination_data = sheet_data
data_manager.update_destination_codes()
print(sheet_data)
cities = [value["iataCode"] for value in sheet_data]
for i in cities:
x = 0
price = flight_search.get_prices(i)
notification = NotificationManager(price.price, price.origin_city,
price.origin_airport,
price.destination_city,
price.return_date, price.out_date,
price.destination_airport, price.noinfo)
if price.noinfo and price.price < sheet_data[x]["lowestPrice"]:
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
from flight_data import FlightData
data = DataManager()
flight = FlightSearch()
notif = NotificationManager(data)
print("Welcome to Sidi Flight Club.")
print("We find the best flight deals and email you.")
first_name = input("What is your first name?"\n)
last_name = input("What is your last name?\n")
email = input("What is your email?\n")
if email != input("Type your email again.\n"):
print("bad email")
else:
print("You're in the club!")
data.add_user(first_name, last_name, email)
flight_data = FlightData(data_manager=data, flight_search=flight, notif_manager=notif)
from data_manager import DataManager
from flight_search import FlightSearch
from flight_data import FlightData
from notification_manager import NotificationManager
data_manager = DataManager()
sheet_data = data_manager.get_data()
if sheet_data[0]['iataCode'] == "":
flight_search = FlightSearch()
for city in sheet_data:
city["iataCode"] = flight_search.get_city_code(city["city"])
print(f"sheet_data:\n {sheet_data}")
data_manager.destination_data = sheet_data
data_manager.input_data()
flight_data = FlightData()
for city in sheet_data:
data = flight_data.flight_info(city["iataCode"])
if data == "unavailable":
print(f"{city['city']}: not available, even with stopover")
continue
else:
price = data["price"]
print(f"{city['city']}: £{price}")
if price is not None:
if int(price) < city["lowestPrice"]:
routes = data['route']
depart = routes[0]['local_arrival'].split("T")[0]
# This file will need to use the DataManager,FlightSearch, FlightData, NotificationManager classes to achieve the program requirements.
from data_manager import DataManager
from pprint import pprint
data_manager = DataManager()
sheet_data = data_manager.get_destination_data()
pprint(sheet_data)
for data in sheet_data:
if data['iataCode'] == "":
from flight_search import FlightSearch
flight_search = FlightSearch()
data['iataCode'] = flight_search.get_destination_code(data['city'])
pprint(sheet_data)
data_manager.destination_data = sheet_data
data_manager.update_destination_code()
from datetime import datetime, timedelta
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
from pprint import pprint
data_manager = DataManager()
sheet_data = data_manager.get_destination_data()
flight_search = FlightSearch()
notification_manager = NotificationManager()
ORIGIN_CITY_IATA = "YYZ"
if sheet_data[0]["iataCode"] == "":
for row in sheet_data:
row["iataCode"] = flight_search.get_destination_code(row["city"])
data_manager.destination_data = sheet_data
data_manager.update_destination_codes()
tomorrow = datetime.now() + timedelta(days=1)
six_month_from_today = datetime.now() + timedelta(days=(6 * 30))
pprint(sheet_data)
for destination in sheet_data:
flight = flight_search.check_flights(
ORIGIN_CITY_IATA,
destination["iataCode"],
from_time=tomorrow,
to_time=six_month_from_today
)
if flight:
if int(flight.price)< int(destination['lowestPrice']):
from data_manager import DataManager
from flight_search import FlightSearch
from datetime import datetime, timedelta
from notification_manager import NotificationManager
ORIGIN_CITY_CODE = "NYC"
# Step 3
data_manager = DataManager()
sheet_data = data_manager.get_data_destination()
customer_data = data_manager.get_customer_emails()
flight_search = FlightSearch()
notificator = NotificationManager()
# If the city in the spreadsheet doesn't have a IATA Code this part will get it and update the spreadsheet
for row in range(len(sheet_data)):
if sheet_data[row]['IATA Code'] == '':
sheet_data[row]['IATA Code'] = flight_search.get_city_code(
sheet_data[row]['City'])
data_manager.data_destination = sheet_data
data_manager.update_destination_code()
# Obtain dates
tomorrow = datetime.now() + timedelta(days=1)
six_months_from_now = tomorrow + timedelta(days=(6 * 30))
found_flights = True
for destination in sheet_data:
flight = flight_search.search_for_flight(
ORIGIN_CITY_CODE,
destination['IATA Code'],
from_date=tomorrow,
from datetime import datetime, timedelta
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
ORIGIN_CITY_IATA = "LON"
data_manager = DataManager()
flight_search = FlightSearch()
notification_manager = NotificationManager()
sheet_data = data_manager.get_destination_data()
if sheet_data[0]["iataCode"] == "":
city_names = [row["city"] for row in sheet_data]
data_manager.city_codes = flight_search.get_destination_code(city_names)
data_manager.update_destination_codes()
sheet_data = data_manager.get_destination_data()
destinations = {
data["iataCode"]: {
"id": data["id"],
"city": data["city"],
"price": data["lowestPrice"]
}
for data in sheet_data
}
tomorrow = datetime.now() + timedelta(days=1)
six_month_from_today = datetime.now() + timedelta(days=6 * 30)
from data_manager import DataManager
from flight_data import FlightData
from notification_manager import NotificationManager
from flight_search import FlightSearch
data_manager = DataManager()
flight_data = FlightData()
flight_search = FlightSearch()
sheet_data = data_manager.get_codes()
user_data = data_manager.get_users()
notification_manager = NotificationManager()
ORIGIN_CITY = "MEL"
if sheet_data[len(sheet_data) - 1]["iataCode"] == '':
for row in sheet_data:
row['iataCode'] = flight_search.get_flight_code(row['destination'])
data_manager.destination_data = sheet_data
data_manager.update_sheet("flightList")
if user_data[len(user_data) - 1]["iataCode"] == '':
for row in user_data:
row['iataCode'] = flight_search.get_flight_code(row['airport'])
row['country'] = flight_search.get_flight_country_code(row['airport'])
row['cityName'] = flight_search.get_flight_city_name(row['airport'])
data_manager.user_data = user_data
data_manager.update_sheet("user")
# GET DEALS BASED ON SHEET
from data_manager import DataManager
from flight_search import FlightSearch
from flight_data import FlightData
from notification_manager import NotificationManager
data_manager = DataManager()
flight_search = FlightSearch()
flight_data = FlightData()
notification_manager = NotificationManager()
sheet_data = data_manager.prices
SHEETY_PUT_ENDPOINT = "https://api.sheety.co/47fa3e5c564ccef88d4272e69984a527/flightDealsFinder/prices"
for row in sheet_data:
city = row["city"]
current_price = row["lowestPrice (inRupees)"]
iataCode = row["iataCode"]
row_id = row["id"]
# Fill the IATA codes column
if iataCode == "":
iataCode = flight_search.iata_search(city)
data_manager.update_sheet(row_id=row_id,
params={"price": {
"iataCode": iataCode
}})
# Search for the latest price
search_results = flight_search.search(
flight_data.fly_from, flight_data.date_from, flight_data.date_to,
from data_manager import DataManager
from flight_search import FlightSearch
SHEETY_PRICES_ENDPOINT = decouple.config("SHEETY_PRICES_ENDPOINT")
SHEETY_USERS_ENDPOINT = decouple.config("SHEETY_USERS_ENDPOINT")
SHEETY_BEARER_TOKEN = decouple.config("SHEETY_BEARER_TOKEN")
prices_sheet = DataManager(endpoint=SHEETY_PRICES_ENDPOINT,
token=SHEETY_BEARER_TOKEN)
prices_sheet_data = prices_sheet.get_rows()["lowestPrice"]
users_sheet = DataManager(endpoint=SHEETY_USERS_ENDPOINT,
token=SHEETY_BEARER_TOKEN)
users_sheet_data = users_sheet.get_rows()["users"]
searcher = FlightSearch()
def get_IATACodes():
for row in prices_sheet_data:
if not row.get("iataCode"):
row["iataCode"] = searcher.search_location(row["city"])
payload = {"price": row}
status = prices_sheet.edit_row(obj=payload, row_n=row["id"])
print(status)
def get_flights():
cheap_flights = {"cheap flights": []}
for row in prices_sheet_data:
city = {row["city"]: []}
from datetime import datetime, timedelta
from dotenv import load_dotenv
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
load_dotenv()
CURRENCY = "GBP"
home_city_iata = os.getenv("HOME_CITY_IATA")
# This file will need to use the DataManager,FlightSearch, FlightData,
# NotificationManager classes to achieve the program requirements.
data_manager = DataManager()
flight_search = FlightSearch()
notification = NotificationManager()
data_manager.read_sheet()
date_from = (datetime.now() + timedelta(days=1)).strftime("%d/%m/%Y")
date_to = (datetime.now() + timedelta(days=(6 * 30))).strftime("%d/%m/%Y")
for row in data_manager.sheet_data:
if not row["iataCode"]:
row["iataCode"] = flight_search.get_city_code(row["city"])
data_manager.update_iata(row["id"], row["iataCode"])
flight = flight_search.get_flights(
departure_iata=home_city_iata,
destination_iata=row["iataCode"],
# Search for Flights for all "City" entries in sheety spreadsheet.
for i in sheet_data:
flight = flight_searcher.find_flights(HOME_CITY_IATA_CODE,
i['iataCode'], tomorrow_date,
to_date, i['city'])
try:
if flight.price < i['lowestPrice']:
dest_city = str(flight.dest_city).split("'")[1]
notification_manager.send_notification(dest_city, flight.price)
except AttributeError:
continue
# Initialize objects.
data_manager = DataManager(SHEETY_ENDPOINT, SHEETY_TOKEN)
flight_searcher = FlightSearch(KIWI_API_KEY, KIWI_ENDPOINT)
notification_manager = NotificationManager(SMS_ACCOUNT_SID, SMS_AUTH_TOKEN,
SOURCE_PHONE_NUMBER,
DEST_PHONE_NUMBER)
#sheet_data = (data_manager.get_iata_data())
# Uncomment to test without having to make calls to sheety - free account only gets 200 API calls a month.
sheet_data = [
{
'city': 'Seoul',
'iataCode': 'ICN',
'lowestPrice': 0,
'id': 2
},
{
'city': 'Paris',
from data_manager import DataManager
from flight_search import FlightSearch
from flight_data import FlightData
data_manager = DataManager()
flight = FlightSearch()
sheet_data = data_manager.get_destination_data()
flight_data = FlightData(sheet_data)
if sheet_data[0]["iataCode"] == "":
for row in sheet_data:
row["iataCode"] = flight.get_flight_search(row["city"])
#print(sheet_data)
data_manager.destination_data = sheet_data
data_manager.update_destination_codes()
