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 main():
nm = NotificationManager()
bs = BackendService()
ids = bs.expired_ids()
email_to = bs.get_active_users()
subject = 'kończące się umowy'
body = nm.generate_body('notification', ids, context={'subject': subject})
# send mail to users
nm.notify(subject, body, email_to)
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)
def __init__(self, release_name):
self.release = release_name
self.config = SncConfig()
self.git_url = self.config.getstring('git_repo', 'git_url')
self.base_dir = self.config.getstring('git_repo', 'base_dir')
self.path_to_workspace = self.base_dir + os.sep + release_name
self.abort_on_error = self.config.getboolean('envbuilder',
'abort_on_error')
self.parallel_run = self.config.getboolean('envbuilder',
'parallel_run')
self.print_cmd_output = self.config.getboolean('envbuilder',
'print_cmd_output')
self.print_cmd = self.config.getboolean('envbuilder', 'print_cmd')
self.repo_status = {}
self.notif_mgr = NotificationManager(None, None, None)
if os.path.exists("errors.txt"):
os.remove("errors.txt")
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(args):
"""
メイン関数
"""
em = NotificationManager()
for url in setting.check_sites_url:
start = time.time()
request = req.Request(url)
try:
response = req.urlopen(request)
elapsed_time = time.time() - start
time_str = "読み込み時間{0}".format(elapsed_time) + "[sec]"
text = "*完了*\n%s" % (time_str)
except err.URLError as e:
elapsed_time = time.time() - start
time_str = "読み込み時間{0}".format(elapsed_time) + "[sec]"
text = "*「%s」からレスポンスがありません*\n%s\n--------------\n%s" % (url, e.reason, time_str)
print(text)
em.send_error_message_to_slack(text)
def search_flights(self):
date_now = dt.datetime.now()
search_url = f"{TEQUILA_URL}/v2/search"
search_headers = {
"apikey": TEQUILA_API_KEY,
"accept": "application/json"
}
search_params = {
"fly_from":
"LON",
"fly_to":
self.city_obj['iataCode'],
"date_from":
date_now.strftime("%d/%m/%Y"),
"date_to":
(date_now + dt.timedelta(days=(6 * 30))).strftime("%d/%m/%Y"),
"nights_in_dst_from":
7,
"nights_in_dst_to":
28,
"curr":
"GBP",
"flight_type":
"round",
"one_for_city":
1
}
search_res = requests.get(url=search_url,
headers=search_headers,
params=search_params)
search_data = search_res.json()
if len(search_data['data']) > 0:
flight_data_result = FlightData(search_data)
else:
flight_data_result = None
if flight_data_result:
if flight_data_result.price < self.city_obj['lowestPrice']:
text_message = NotificationManager(
flight_data_result.flight_dict)
text_message.send_text()
else:
print("No Deal")
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 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 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)
#!/usr/bin/env python
from amazon_price_checker import AmazonPriceChecker
from notification_manager import NotificationManager
from item_info import ItemInfo
notification = NotificationManager()
apc = AmazonPriceChecker()
apc.add_item(
ItemInfo(
item_id="B078MGXLVS",
threshold_price=70.00, # normal price = 69.99
description="Blue Radius III Custom Shockmount",
))
apc.add_item(
ItemInfo(
item_id="B078MLBGRM",
threshold_price=140.00, # normal price = 139.00
description="Blue Compass Premium Tube-Style Broadcast Boom Arm",
))
apc.get_all_item_price()
cheap_items = apc.get_cheap_items()
for item in cheap_items:
message = (f"{item.description} is priced at ${item.actual_price:.2f}, "
f"which is below our threshold of ${item.threshold_price:.2f}\n"
f"URL: {item.url}")
notification.send_email(message=message)
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"],
departure_date=date_from,
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"]:
notification.check_prices()
x += 1
import requests
from flight_search import FlightSearch
from notification_manager import NotificationManager
from datetime import datetime
from data_manager import DataManager
from flight_data import FlightData
#This file will need to use the DataManager,FlightSearch, FlightData, NotificationManager classes to achieve the program requirements.
SHEET_API_KEY = "3d0f05f887e0580677d4c0878ad2d460"
data_manager = DataManager(SHEET_API_KEY)
sheet_data = data_manager.get_data()['prices']
flight_data = FlightData()
# print(flight_data.api_call("PAR"))
notification = NotificationManager()
for data in sheet_data:
price = flight_data.api_call(data['iataCode'])
for lowest in price:
if data['lowestPrice'] > lowest['price']:
notification.send_message(
f"Low price alert! Only ${lowest['price']} to fly from "
f"{lowest['cityFrom']}-{lowest['flyFrom']}"
f" to {lowest['cityTo']}-{lowest['flyTo']}"
f" from {datetime.now().date()} to "
f"{lowest['utc_departure'].split('T')[0]}")
break
# for data in sheet_data:
# if data['iataCode'] == "":
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 datetime import datetime, timedelta
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
from view import View
from email_manager import EmailManager
data_manager = DataManager()
sheet_data = data_manager.get_destination_data()
flight_search = FlightSearch()
notification_manager = NotificationManager()
ui = View()
email = EmailManager()
user_data = data_manager.get_users()
if user_data[0] != "":
for row in user_data:
email.send_email(row["email"])
ORIGIN_CITY_IATA = "LON"
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))
for destination in sheet_data:
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_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_data import FlightData
from notification_manager import NotificationManager
import os
account_sid = os.environ['account_sid']
auth_token = os.environ['auth_token']
tequila_key = os.environ['tequila_key']
auth = os.environ['Authorization']
my_phone = os.environ['my_phone']
twilio_phone = os.environ['twilio_phone']
dm = DataManager()
prices = dm.get_prices()
users = dm.get_users()
# Updates the dictionary element for the appropriate IATA Code corresponding to the city column
for elem in prices:
if elem['iataCode'] == '':
dm.update_iata_code(elem)
for elem in prices:
fd = FlightData()
data = fd.get_prices(elem['iataCode'])
if data[0] < int(elem['lowestPrice']):
nm = NotificationManager()
# nm.notify(data)
for j in users:
nm.send_emails(data, j['email'])
from pprint import pprint
from data_manager import DataManager
from flight_search import FlightSearch
from flight_data import FlightData
from notification_manager import NotificationManager
data = DataManager()
search = FlightSearch()
flight = FlightData()
notification = NotificationManager()
sheet_data = data.get_data()
# for i in sheet_data:
# i['iataCode'] = (search.iata_check(i)) #print(sheet_data[0]['city'])
#
# for i in sheet_data:
# data.put(i)
# for i in sheet_data:
# i['iataCode'] = search.iata_check(i)
#
# pprint(sheet_data)
#
# for i in sheet_data:
# data.put(i)
for i in sheet_data:
flight_data = flight.flight_get(i)
flight_price = flight_data['data'][0]['price']
from data_manager import DataManager
from flight_search import FlightSearch
from datetime import datetime, timedelta
from notification_manager import NotificationManager
flight_search = FlightSearch()
data_manager = DataManager()
notification_manager = NotificationManager()
ORIGIN_CITY_IATA = "LON"
sheet_data = data_manager.get_destination_data()
# print(sheet_data)
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 = datetime.now() + timedelta(days=180)
for destination in sheet_data:
flight = flight_search.check_flights(
ORIGIN_CITY_IATA,
destination["iataCode"],
from_time=tomorrow,
to_time=six_month
#This file will need to use the DataManager,FlightSearch, FlightData, NotificationManager classes to achieve the program requirements.
from notification_manager import NotificationManager
from flight_search import FlightSearch
from flight_data import FlightData
from data_manager import DataManager
notification_manager = NotificationManager()
flight_search = FlightSearch()
flight_data = FlightData()
data_manger = DataManager()
destination_list = data_manger.get_data()
for city in destination_list:
city_id = city['id']
lowest_price = city['lowestPrice']
fly_to = city['iataCode']
price_data = flight_search.get_data(fly_to)
is_cheap_deal = flight_data.compare(price_data, lowest_price)
if is_cheap_deal:
flight_details = flight_data.get_data()
data_manger.update_data(city_id, flight_data.min_price)
notification_manager.send_alert(flight_details)
from datetime import datetime, timedelta
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
data_manager = DataManager()
sheet_data = data_manager.get_destination_data()
print(sheet_data)
flight_search = FlightSearch()
notification_manager = NotificationManager()
ORIGIN_CITY_IATA = "OAK"
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))
for destination in sheet_data:
flight = flight_search.check_flights(ORIGIN_CITY_IATA,
destination["iataCode"],
from_time=tomorrow,
to_time=six_month_from_today)
try:
if int(flight.price) < int(destination["lowestPrice"]):
print(int(flight.price) < int(destination["lowestPrice"]))
id = destination["id"]
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 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_CODE = "LON"
data_manager = DataManager()
flight_search = FlightSearch()
notification_manager = NotificationManager()
sheet_data = data_manager.get_destination_data()
for data in sheet_data:
if data["iataCode"] == "":
city_names = [row["city"] for row in sheet_data]
print(city_names)
codes = flight_search.get_destination_code(city_names)
data_manager.update_destination_codes(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)
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]
return_flight = routes[1]['local_arrival'].split("T")[0]
message = f"Low price alert! Only £{price} to fly from {data['cityFrom']}-{data['flyFrom']} to" \
f" {data['cityTo']}-{data['flyTo']}, departing {depart} and returning {return_flight}"
stop_overs = data['stop_overs']
if stop_overs > 0:
via_city = data['route'][0]["cityTo"]
message += f"\n Flight has {stop_overs} stop over, via {via_city}"
email_messs = f"https://www.google.co.uk/flights?hl=en#flt={data['flyFrom']}.{data['flyTo']}.{depart}*{data['flyTo']}.{data['flyFrom']}.{return_flight}"
notification = NotificationManager()
# notification.send_message(message)
notification.send_emails(message, email_messs)
from datetime import datetime, timedelta
from data_manager import DataManager
from flight_search import FlightSearch
from notification_manager import NotificationManager
GOOGLE_FLIGHT_ENDPOINT = 'https://www.google.ca/flights'
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()
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_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)
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',
'iataCode': 'PAR',
'lowestPrice': 0,
