ActiveState Code

#! /usr/local/bin/python
# ========================================================================
# (c) Copyright belongs to Ken Washington
# All rights reserved
# ========================================================================

# imports
import os
import re
import sys
import time
import sched
import string
import urllib
import httplib
from HTMLParser import HTMLParser

# ========================================================================
# you MUST change these parameters to the values for your flight
# the DEBUG_SCH should be 0 to run delayed scheduling automatically
# set to 1 to skip the scheduler if we are not within 24 hours
#          immediate calls to the Internet will be made within 24 hrs
# set to 2 to simulate Internet calls. Locally saved .htm files
#          must be present with specific names for this to work
# The names are listed here - they must be EXACTLY as shown
# 1) Southwest Airlines - Retrieve Itinerary.htm
# 2) Southwest Airlines - Schedule.htm
# 3) Southwest Airlines - Check In and Print Boarding Pass.htm
# 4) Southwest Airlines - Print Boarding Pass.htm
# 5) Southwest Airlines - Retrieve-Print Boarding Pass.htm
# ========================================================================
confirmation = 'ABCDEF'
firstname = 'Firstname'
lastname = 'Lastname'
DEBUG_SCH = 2
# ========================================================================
# fill in these parameters if you want the script to email you
# to disable make the emailaddr = None
emailaddr = None
# emailaddr = "myemail@myemail.com"
smtpserver = "smtpserver.com"
smtpauth = False
smtpport = 80
smtpuser = "username"
smtppass = "password"

# ========================================================================
# fixed page locations and parameters - updated to bypass Ajax front page
# DO NOT change these parameters
main_url = 'www.southwest.com'
checkin_url = '/content/travel_center/retrieveCheckinDoc.html'
retrieve_url = '/travel_center/retrieveItinerary.html'
defaultboxes = ["recordLocator", "firstName", "lastName"]
months = "JanFebMarAprMayJunJulAugSepOctNovDec"
# ========================================================================


# =========== function definitions =======================================

# this is a parser for the Southwest pages
class HTMLSouthwestParser(HTMLParser):

    def __init__(self, swdata):
        self._reset()
        HTMLParser.__init__(self)

        # if a web page string is passed, feed it
        if swdata != None and len(swdata)>0:
            self.feed(swdata)
            self.close()

    def _reset(self):
        self.searchtags = {}
        self.hiddentags = {}
        self.searchaction = ""
        self.formaction = ""
        self.is_search = False
        self.textnames = []
        
    # override the feed function to reset our parameters
    # and then call the original feed function
    def feed(self, formdata):
        self._reset()
        HTMLParser.feed(self, formdata)

    # handle tags in web pages
    # this is where the real magic is done
    def handle_starttag(self, tag, attrs):
        if tag=="input":
            ishidden = False
            ischeckbox = False
            istext = False
            issubmit = False
            thevalue = ""
            thename = None
            for attr in attrs:
                if attr[0]=="type":
                    if attr[1]=="hidden":
                        ishidden= True
                    elif attr[1]=="checkbox" or attr[1]=="radio":
                        ischeckbox = True
                    elif attr[1]=="text":
                        istext = True
                    elif attr[1]=="submit":
                        issubmit = True
                elif attr[0]=="name":
                    thename= attr[1]
                    istext = True
                elif attr[0]=="value":
                    thevalue= attr[1]

            # store the tag for search forms separately
            # from the tags for non-search forms
            if ishidden or ischeckbox:
                if self.is_search:
                    self.searchtags[thename] = thevalue
                else:
                    self.hiddentags[thename] = thevalue

            # otherwise, append the name of the text fields
            elif istext and self.is_search==False and issubmit==False:
                self.textnames.append(thename)

        elif tag=="form":
            for attr in attrs:
                if attr[0]=="action":
                    theaction = attr[1]
                    
                    # check to see if this is a search form
                    if theaction.find("search") > 0:
                        self.searchaction = theaction
                        self.is_search = True
                    else:
                        self.formaction = theaction
                        self.is_search = False


# function to send an simple text email message
def sendEmail(wdata, emailaddr, smtpserver, smtpport= 25, \
              smtpauth=False, smtpuser="", smtppass=""):
    import smtplib
    from email.MIMEText import MIMEText

    # Create a text/plain message
    msg = MIMEText(wdata)

    # me == the sender's email address
    # you == the recipient's email address
    msg['Subject'] = 'Results of Southwest checkin script'
    msg['From'] = emailaddr
    msg['To'] = emailaddr
    s = smtplib.SMTP()

    # connect on the designated port - will be 25 or 80
    try:
        s.connect(smtpserver, 80)
    except Exception, connerror:
        print connerror.__class__, connerror
        return False

    if smtpauth:
        try:
            s.login(smtpuser, smtppass)
        except Exception, connerror:
            print connerror.__class__, connerror
            return False
    try:
        s.sendmail(emailaddr, emailaddr, msg.as_string())
    except Exception, connerror:
        print connerror.__class__, connerror
        return False
    
    s.close()
    return True

# this function reads a URL and returns the text of the page
def ReadUrl(host, req):
    wdata = ""

    try:
        conn = httplib.HTTPConnection(host)
        conn.request("GET", req)
        resp = conn.getresponse()
    except:
        print "Error: Cannot connect in GET mode to ", host+req
        sys.exit(1)

    if resp.status == 200:
        wdata = resp.read()
    else:
        print "Error: Cannot read data from ", host+req
        print "Response: ", resp.status, resp.reason
        sys.exit(1)

    return wdata

# this function sends a post just like you clicked on a submit button
def PostUrl(host, req, dparams):
    wdata = ""
    params = urllib.urlencode(dparams)
    headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}

    try:
        conn = httplib.HTTPConnection(host)
        conn.request("POST", req, params, headers)
        resp = conn.getresponse()
    except:
        print "Error: Cannot connect in POST mode to ", host+req
        print "Params = ", dparams
        sys.exit(1)
        
    if resp.status == 200:
        wdata = resp.read()
    else:
        print "Error: Cannot post data to ", host+req
        print "Params = ", dparams
        print "Response: ",resp.status, resp.reason
        sys.exit(1)

    return wdata

def setInputBoxes(textnames, conf_number, first_name, last_name):
    if len(textnames) == 3:
        boxes = textnames
    else:
        boxes = default_boxes

    params = {}
    params[boxes[0]] = conf_number
    params[boxes[1]] = first_name
    params[boxes[2]] = last_name
    
    return params

def airportCodeTZ(code):
    airportzone = {}
    airportzone["ALB"] = "US/Eastern"
    airportzone["ABQ"] = "US/Mountain"
    airportzone["AMA"] = "US/Central"
    airportzone["AUS"] = "US/Central"
    airportzone["BWI"] = "US/Eastern"
    airportzone["BHM"] = "US/Central"
    airportzone["BOI"] = "US/Mountain"
    airportzone["BUF"] = "US/Eastern"
    airportzone["BUR"] = "US/Pacific"
    airportzone["MDW"] = "US/Central"
    airportzone["CLE"] = "US/Eastern"
    airportzone["CMH"] = "US/Eastern"
    airportzone["CRP"] = "US/Central"
    airportzone["DAL"] = "US/Central"
    airportzone["DEN"] = "US/Mountain"
    airportzone["DTW"] = "US/Eastern"
    airportzone["ELP"] = "US/Mountain"
    airportzone["FLL"] = "US/Eastern"
    airportzone["RSW"] = "US/Eastern"
    airportzone["HRL"] = "US/Central"
    airportzone["BDL"] = "US/Eastern"
    airportzone["HOU"] = "US/Central"
    airportzone["IND"] = "US/Eastern"
    airportzone["JAN"] = "US/Central"
    airportzone["JAX"] = "US/Eastern"
    airportzone["MCI"] = "US/Central"
    airportzone["LAS"] = "US/Pacific"
    airportzone["LIT"] = "US/Central"
    airportzone["ISP"] = "US/Eastern"
    airportzone["LAX"] = "US/Pacific"
    airportzone["SDF"] = "US/Eastern"
    airportzone["LBB"] = "US/Central"
    airportzone["MHT"] = "US/Eastern"
    airportzone["MAF"] = "US/Central"
    airportzone["BNA"] = "US/Central"
    airportzone["MSY"] = "US/Central"
    airportzone["ORF"] = "US/Eastern"
    airportzone["OAK"] = "US/Pacific"
    airportzone["OKC"] = "US/Central"
    airportzone["OMA"] = "US/Central"
    airportzone["ONT"] = "US/Pacific"
    airportzone["SNA"] = "US/Pacific"
    airportzone["MCO"] = "US/Eastern"
    airportzone["PHL"] = "US/Eastern"
    airportzone["PHX"] = "US/Arizona"
    airportzone["PIT"] = "US/Eastern"
    airportzone["PDX"] = "US/Pacific"
    airportzone["PVD"] = "US/Eastern"
    airportzone["RDU"] = "US/Eastern"
    airportzone["RNO"] = "US/Pacific"
    airportzone["SMF"] = "US/Pacific"
    airportzone["SLC"] = "US/Mountain"
    airportzone["SAT"] = "US/Central"
    airportzone["SAN"] = "US/Pacific"
    airportzone["SJC"] = "US/Pacific"
    airportzone["SFO"] = "US/Pacific"
    airportzone["SEA"] = "US/Pacific"
    airportzone["GEG"] = "US/Pacific"
    airportzone["STL"] = "US/Central"
    airportzone["TPA"] = "US/Eastern"
    airportzone["TUS"] = "US/Arizona"
    airportzone["TUL"] = "US/Central"
    airportzone["IAD"] = "US/Eastern"
    airportzone["PBI"] = "US/Eastern"

    # use pacific as default if not found
    try:
        TZcode = airportzone[code]
    except:
        TZcode = "US/Pacific"

    return TZcode

def getTimeZones(timeline):
    # Use a regular expression to find the returning Airport
    reap = re.compile("\((...)\)")
    ts = reap.findall(timeline)

    # these values are number of seconds offsets from UTC
    fr_tz = airportCodeTZ(ts[0])
    fr_dest_tz = airportCodeTZ(ts[1])
    return (fr_tz, fr_dest_tz);

# this routine extracts the departure date and time
def getFlightTimes(the_url, conf_number, first_name, last_name):

    now = time.time()
    current_time = time.localtime(now)
    thisyear = current_time[0];
    thismonth = time.strftime("%b",current_time)

    if DEBUG_SCH > 1:
        fd = open("dbg-retrieveItinerary.html","r")
        swdata = fd.read(-1)
        fd.close()
    else:
        swdata = ReadUrl(main_url, the_url)

    if swdata==None or len(swdata)==0:
        print "Error: no data returned from ", main_url+the_url
        sys.exit(1)

    gh = HTMLSouthwestParser(swdata)

    # get the post action name from the parser
    post_url = gh.formaction
    if post_url==None or post_url=="":
        print "Error: no POST action found in ", main_url+the_url
        sys.exit(1)

    # load the parameters into the text boxes
    params = setInputBoxes(gh.textnames, conf_number, first_name, last_name)

    # submit the request to pull up the reservations on this confirmation number
    if DEBUG_SCH > 1:
        fd = open("dbg-viewPnr.htm","r")
        reservations = fd.read(-1)
        fd.close()
    else:
        reservations = PostUrl(main_url, post_url, params)

    if reservations==None or len(reservations)==0:
        print "Error: no data returned from ", main_url+post_url
        print "Params = ", dparams
        sys.exit(1)

    # parse the returned file to grab the dates and times
    # the last word in the table above the first date is "Routing Details"
    # this is currently a unique word in the html returned by the above
    dateloc_0 = reservations.find("Details")
    dateloc_1 = reservations.find("bookingFormText", dateloc_0)
    i1 = reservations.find(">", dateloc_1)
    i2 = reservations.find("<", i1)
    to_date = reservations[i1+1:i2]

    # narrow down the search to the line with the word depart
    timeloc = reservations.find("Depart", dateloc_1)
    timeline = reservations[timeloc:timeloc+80]

    # use a regular expression to find the two times
    tm = re.compile("\d{1,2}\:\d{1,2}[apAP][mM]")
    ts = tm.findall(timeline)
    to_depart_time = ts[0]
    to_arrive_time = ts[1]

    # get the to time zones
    tzones = getTimeZones(timeline);
    to_tz = tzones[0]
    to_dest_tz = tzones[1]

    # beginning of the return location
    postloc = reservations.find("<form",0)
    airloc = reservations.find("airBackground", timeloc)

    # added logic to address connecting flights
    # only picks up the last connection for the destination arrival
    while True:
        timeloc = reservations.find("Depart", timeloc+80)
        if (timeloc < 0): break

        # ran out of destination legs
        if ( (airloc < postloc) and (timeloc > airloc) ):
            timeloc = airloc
            break;

        timeline = reservations[timeloc:timeloc+80]
        ts = tm.findall(timeline)
        to_arrive_time = ts[1]

        # get the return time zones
        tzones = getTimeZones(timeline)
        to_dest_tz = tzones[1]

    # no return flight if this happens
    if ( (airloc < 0) or (airloc > postloc) ):
        print "Warning: No return flight, this script has not been tested for this case"
        print "         but it might work, so use at your own risk..."
        to_year = thisyear
        to_month = to_date[:3]
        # print to_month, " ", thismonth
        if (months.find(to_month) > months.find(thismonth)):
            to_year = to_year - 1
        to_date = to_date + ", "+str(to_year)
        departure = (to_date, to_depart_time, to_arrive_time, to_tz, to_dest_tz, \
                     to_date, to_depart_time, to_arrive_time, to_tz, to_dest_tz )
        return departure
                
    # now find the return flight date and time information
    dateloc_2 = reservations.find("Details", timeloc)
    dateloc_3 = reservations.find("bookingFormText", dateloc_2)
    i1 = reservations.find(">", dateloc_3)
    i2 = reservations.find("<", i1)
    fr_date = reservations[i1+1:i2]

    # return flight times
    timeloc = reservations.find("Depart", dateloc_3)
    timeline = reservations[timeloc:timeloc+80]
    ts = tm.findall(timeline)
    fr_depart_time = ts[0]
    fr_arrive_time = ts[1]

    # get the return time zones
    tzones = getTimeZones(timeline);
    fr_tz = tzones[0]
    fr_dest_tz = tzones[1]

    # added logic to address connecting flights
    # only picks up the last connection for the destination arrival
    while True:
        timeloc = reservations.find("Depart", timeloc+80)
        if (timeloc < 0): break
        timeline = reservations[timeloc:timeloc+80]
        ts = tm.findall(timeline)
        fr_arrive_time = ts[1]

        # get the return time zones
        tzones = getTimeZones(timeline)
        fr_dest_tz = tzones[1]

    # some logic to create the year - we assume if return month
    # is earlier than departure month that it is in a new year
    to_year = thisyear
    fr_year = thisyear
    to_month = to_date[:3]
    fr_month = fr_date[:3]
    if ( (to_month==thismonth) and (months.find(fr_month) < months.find(to_month)) ):
        fr_year = thisyear+1
    if ( (fr_month==thismonth) and (months.find(fr_month) < months.find(to_month)) ):
        to_year = thisyear-1

    # now lets add on the years
    to_date = to_date + ", "+str(to_year)
    fr_date = fr_date + ", "+str(fr_year)  

    # if DEBUG_SCH>1:
    #    print to_month," ",fr_month," ",thismonth," ",to_year," ",fr_year," ",thisyear, " ", to_date, " ", fr_date

    # now we include the time zones so we can create a UTC time conversion later
    departure = (to_date, to_depart_time, to_arrive_time, to_tz, to_dest_tz, \
                 fr_date, fr_depart_time, fr_arrive_time, fr_tz, fr_dest_tz )
    
    return departure

def getBoardingPass(the_url, conf_number, first_name, last_name):

    # read the southwest checkin web site
    if DEBUG_SCH > 1:
        fd = open("dbg-retrieveCheckinDoc.html","r")
        swdata = fd.read(-1)
        fd.close()
    else:
        swdata = ReadUrl(main_url, the_url)

    if swdata==None or len(swdata)==0:
        print "Error: no data returned from ", main_url+the_url
        sys.exit(1)

    # parse the data
    gh = HTMLSouthwestParser(swdata)

    # get the post action name from the parser
    post_url = gh.formaction
    if post_url==None or post_url=="":
        print "Error: no POST action found in ", main_url+the_url
        sys.exit(1)

    # load the parameters into the text boxes by name
    # where the names are obtained from the parser
    params = setInputBoxes(gh.textnames, conf_number, first_name, last_name)

    # submit the request to pull up the reservations
    if DEBUG_SCH > 1:
        fd = open("dbg-selectBoardingPass.htm","r")
        reservations = fd.read(-1)
        fd.close()
    else:
        reservations = PostUrl(main_url, post_url, params)

    if reservations==None or len(reservations)==0:
        print "Error: no data returned from ", main_url+post_url
        print "Params = ", params
        sys.exit(1)

    # parse the returned reservations page
    rh = HTMLSouthwestParser(reservations)

    # Extract the name of the post function to check into the flight
    final_url = rh.formaction

    # the returned web page contains three unique security-related hidden fields
    # plus a dynamically generated value for the checkbox or radio button
    # these must be sent to the next submit post to work properly
    # they are obtained from the parser object
    params = rh.hiddentags
    if len(params) < 4:
        print "Error: Fewer than the expect 4 special fields returned from ", main_url+post_url
        print "Params = ", params
        sys.exit(1)

    # finally, lets check in the flight and make our success file
    if DEBUG_SCH > 1:
        fd = open("dbg-viewBoardingPass.htm","r")
        checkinresult = fd.read(-1)
        fd.close()
    else:
        checkinresult = PostUrl(main_url, final_url, params)

    # write the returned page to a file for later inspection
    if checkinresult==None or len(checkinresult)==0:
        print "Error: no data returned from ", main_url+final_url
        print "Params = ", params
        sys.exit(1)

    # always save the returned file for later viewing
    fd = open("boardingpass.htm","w")
    fd.write(checkinresult)
    fd.close()

    # look for what boarding letter and number we got in the file
    # now we use re for both letter and number
    myre = re.compile("boarding[ABC]\.gif")
    bgroup = myre.findall(checkinresult)
    if (len(bgroup) >0):
        bletter = bgroup[0][8]
    else:
        bletter = "Unknown"

# logic below allows a valid letter and an unknown number
    myre2 = re.compile("boarding(\d).gif")
    bnumarr = myre2.findall(checkinresult)
    if(len(bnumarr) > 0):
        bnumber = bnumarr[0]
    else:
        bnumber = "Unknown"
        
    if (len(bnumarr) > 1):
        bnumber = bnumber + bnumarr[1]

    if len(bgroup)>0:
        msg = "Boarding group = " + bletter + "   Boarding number = " + bnumber
    else:
        msg = "Boarding group and number are unknown"

    # email this information to self if requested
    if DEBUG_SCH==0 and emailaddr:
        try:
            sendEmail(msg, emailaddr, smtpserver, smtpport, smtpauth, smtpuser, smtppass)
        except:
            print "Unable to email result to %s %s" % (first_name, last_name)

    return msg

# determine the time when we can submit checkin successfully
def getDelay(leave_time, now):

    # start with 24 hours before departure and pad it by 2 minutes just to be sure
    sched_time = leave_time - 24.0*3600.0
    sched_time = sched_time + 120.0

    # now = time.time()
    min_left = int(sched_time - now) / 60
    absmin = abs(min_left)
    days = absmin / 60 / 24
    hours = (absmin - days*24*60) / 60
    minutes = absmin - days*24*60 - hours*60
    # print "Departure time: ", time.strftime("%A %B %d, %Y  at  %I:%M %p",leave_time)

    # print a different message if the time to check in ahead of time is in the past
    if ( min_left <= 0 ):
        msg = "You were ready to check in %d days, %d hours, and %d minutes ago." % \
              (days, hours, minutes)
    else:
        msg = "You have %d days, %d hours, and %d minutes remaining to check in." % \
              (days, hours, minutes)

    # print msg
    return sched_time, msg

# print some information to the terminal for confirmation purposes
def displayFlightInfo(to_time, pr_to_time, to_arrive, fr_time, pr_fr_time, fr_arrive, current, current_UTC):
    print "Confirmation number: ", confirmation
    print "Passenger name:      ", firstname, lastname
    print "Current time:        ", current
    print "Current UTC time:    ", current_UTC
    print " "
    print "==========================================================================="
    print "Destination Flight"
    print "==========================================================================="
    print "Departing: ", to_time
    print "Arriving:  ", to_arrive
    print " "
    print "==========================================================================="
    print "Return Flight"
    print "==========================================================================="

    if ( (to_time==fr_time) and (to_arrive==fr_arrive) ):
        print "There is no return flight"
    else:
        print "Departing: ", fr_time
        print "Arriving:  ", fr_arrive
        print " "

    print "==========================================================================="
    print "UTC Flight departure times (used to determine checkin times)"
    print "==========================================================================="
    print "Departing: ", pr_to_time
    if ( (to_time==fr_time) and (to_arrive==fr_arrive) ):
        print "No returning time"
    else:
        print "Returning: ", pr_fr_time
    print "==========================================================================="

# modified paul's routine to use the year from earlier logic
# and replace the Unix specific time zone trick with a generic one
def makedate(monthdayyear, daytime, TZ):

    # the following code doesn't work on Windows
    # os.environ['TZ'] = TZ
    # time.tzset()
    # need to enter number of seconds for each TZ instead

    # set the time zone delta based on the name
    tzdelta = 8
    if ( TZ == "US/Eastern" ):
        tzdelta = 5
    if ( TZ == "US/Central" ):
        tzdelta = 6
    if ( TZ == "US/Mountain" ):
        tzdelta = 7
    if ( TZ == "US/Arizona" ):
        tzdelta = 7
    if ( TZ == "US/Pacific" ):
        tzdelta = 8

    to_time = "%s %s" % (monthdayyear, daytime)
    time_struct = time.strptime(to_time, "%b %d, %Y %I:%M%p")
    timesarray = (time_struct, time.mktime(time_struct)+tzdelta*3600.0)

    # print timesarray[0], " ", timesarray[1], " ", tzdelta, " ", TZ
    return timesarray

# main program
def main():

    # get the departure times in a tuple
    departure = getFlightTimes(retrieve_url, confirmation, firstname, lastname)

    # get the current time
    now = time.time()
    local_time = time.localtime(now)
    local_zone = time.tzname[0]

    current_time = time.gmtime(now)
    now_UTC = time.mktime(current_time)

    # Convert times to UTC times
    times = makedate(departure[0], departure[1], departure[3])
    to_time = time.strftime("%b %d, %Y %I:%M%p ", times[0]) + departure[3]
    leave_time_1 = times[1]
    pr_to_time = time.strftime("%b %d, %Y %I:%M%p UTC", time.localtime(leave_time_1))

    times = makedate(departure[0], departure[2], departure[4])
    to_arrive = time.strftime("%b %d, %Y %I:%M%p ", times[0]) + departure[4]

    times = makedate(departure[5], departure[6], departure[8])
    fr_time = time.strftime("%b %d, %Y %I:%M%p ", times[0]) + departure[8]
    leave_time_2 = times[1]
    pr_fr_time = time.strftime("%b %d, %Y %I:%M%p UTC", time.localtime(leave_time_2))

    times = makedate(departure[5], departure[7], departure[9])
    fr_arrive = time.strftime("%b %d, %Y %I:%M%p ", times[0]) + departure[9]

    current = time.strftime("%b %d, %Y %I:%M%p ", local_time) + local_zone
    pr_current = time.strftime("%b %d, %Y %I:%M%p UTC", current_time)

    # print some information to the terminal for confirmation purposes
    displayFlightInfo(to_time, pr_to_time, to_arrive, fr_time, pr_fr_time, fr_arrive, current, pr_current)

    # find the time when we can check in within the 24 hour time window
    sched_1, msg_depart = getDelay(leave_time_1, now_UTC)

    # get a scheduler object
    sch = sched.scheduler(time.time, time.sleep)

    # schedule the checkin of the flights if it is in the future
    # also we check to see if we have at least an hour before departure
    # if not then we skip to the return flight - if that fails we do nothing
    msg1 = "Please wait for the scheduler to check in the departing flight..."
    msg2 = "Departing flight has been checked in - see boardingpass.htm for details"
    msg3 = ""
    
    # first branch is before first departing flight
    if sched_1 > now_UTC:
        print msg_depart
        ev1 = sch.enterabs(sched_1, 1, getBoardingPass, (checkin_url, confirmation, firstname, lastname))

    # second branch is when we are ready to do departing flight
    elif ( leave_time_1 - 3660.0 ) > now_UTC:
        print msg_depart
        print "Obtaining departing flight boarding pass right now..."
        msg3 = getBoardingPass(checkin_url, confirmation, firstname, lastname)

    # otherwise handle return flight
    elif (leave_time_1 == leave_time_2):
        msg2 = "Departing flight has been checked in - see boardingpass.htm for details"
        msg3 = "There is no return flight"
        
    else:
        # schedule the second pass or call it now if we are within an hour
        msg1 = "Please wait for the scheduler to check in the returning flight..."
        msg2 = "Returning flight has been checked in - see boardingpass.htm for details"
        sched_2, msg_depart = getDelay(leave_time_2, now_UTC)
        print msg_depart
        if sched_2 > now_UTC:
            ev2 = sch.enterabs(sched_2, 1, getBoardingPass, (checkin_url, confirmation, firstname, lastname))
        elif (leave_time_2-3660.0) > now_UTC:
            print "Obtaining returning flight boarding pass right now..."
            msg3 = getBoardingPass(checkin_url, confirmation, firstname, lastname)
        else:
            msg2 = "It is too late to check in the returning flight"

    # run the scheduled events
    # nothing will be printed during this long pause, so run in the background
    if not sch.empty():
        print msg1
        if DEBUG_SCH==0: sch.run()

    print msg2
    print msg3

if __name__=='__main__':
    main()