~m-buck/+junk/gtk-desktop-info

#  Author: Kaivalagi

# Created: 23/11/2008

from datetime import datetime, timedelta

from optparse import OptionParser

from xml.dom import minidom

import gettext

import locale

import re

import shutil

import traceback

import uuid

 

try:

        "20": u"0", #Fog

        "21": u"9", #Haze

        "22": u"4", #Smoke

        "24": u"6", #Windy

        "25": u"-", #N/A

        "26": u"f", #Cloudy

        "na": u"-", #N/A

        "-": u"-" #N/A

    }

    conditions_moon_icon = {

        "0": u"24",

        "1": u"01",

 

    # New translatable strings

    # foppeh >> These arrays are here so they get translated even if they

    # first all about moon phases

    "New": _(u"New"),

    "First Quarter": _(u"First Quarter"),

    "Full": _(u"Full"),

    "Waxing Crescent": _(u"Waxing Crescent"),

    "Waxing Gibbous": _(u"Waxing Gibbous")

    }

    # foppeh >> Something is going on with these string. I don't know if they are valid.

    #           The weird thing is they are in lower case and the XML seems to spit

    #           text with too many Uppercase. So I don't know if strings presented here

    #           will ever be a valid output from weather.com. Yet I stored them here for

    #           future reference (and because of the French translation).

    # all about weather conditions

    # 'blowing dust'                 => 'tempￃﾪte de sable',

    # 'blowing snow'                 => 'tempￃﾪte de neige',

    # 'widespread dust'              => 'vents de poussiￃﾨre',

    # 'wintry mix'                   => 'conditions hivernales variables',

 

    # some general things...

    general = {

     "n/a": _(u"n/a"),

    'day': _(u"day"),

    'night': _(u"night")

    }

    # UV index ...

    UV_index = {

    "Extreme": _(u"Extreme"),

    "Moderate": (u"Moderate"),

    "Low": _(u"Low")

    }

    # tendencies used for barometric pressure

    bar_pressure = {

    "Very Low": _(u"Very Low"),

    "West Northwest": _(u"West Northwest"),

    "West Southwest": _(u"West Southwest")

    }

    wind_directions_short = {

    "E": _(u"E"),

    "ENE": _(u"ENE"),

        self.sunrise = sunrise

        self.sunset = sunset

        self.moon_phase = moon_phase

        self.bar_read = bar_read

        self.bar_desc = bar_desc

        self.uv_index = uv_index

 

class ForecastLocation:

    timestamp = None

    def __init__(self, current, day, night, timestamp):

        self.current = current

        self.day = day

        self.night = night

        self.timestamp = timestamp #datetime.today()

    def outdated(self, mins):

        if datetime.today() > self.timestamp + timedelta(minutes=mins):

            return True

            return False

 

class Output:

    # design time variables

    options = None

    config = None

    loaded_locations = []

    error = ""

    errorfound = False

    # design time settings

    #CONFIG_FILENAME = ".plugin_forecast.config"

    CACHE_FILENAME_TEMPLATE = ".plugin_forecast-LOCATION.cache"

    template_options = """

        --location : location code for weather data [default: %default],Use the following url to determine your location code by city name: http://xoap.weather.com/search/search?where=Norwich")

        --datatype : The data type options are: DW (Day of Week), WF (Weather Font output), LT (Forecast:Low Temp,Current:Feels Like Temp), HT (Forecast:High Temp,Current:Current Temp), CC (Current Conditions), CT (Conditions Text), PC (Precipitation Chance), HM (Humidity), VI (Visibility), WD (Wind Direction), WA (Wind Angle - in degrees), WS (Wind Speed), WG (Wind Gusts), BF (Bearing Font), BS (Bearing font with Speed), CN (City Name), CO (Country), OB (Observatory), SR (SunRise), SS (SunSet), DL (DayLight), MP (Moon Phase), MF (Moon Font), BR (Barometer Reading), BD (Barometer Description), UI (UV Index), UT (UV Text), DP (Dew Point), LU (Last Update at weather.com), LF (Last Fetch from weather.com), WM (weather map). Not applicable at command line when using templates.")

        --hidedegreesymbol : Hide the degree symbol used with temperature output, this is only valid if used in conjunction with --hideunits.")

        --minuteshide : Works only with LU and LF. If present, hides the date part of the LU or LF timestamp if the day of the timestamp is today. The time part is also hidden, if the timestamp is older than minutes specified in this argument. If set to 0, the time part is always shown. If set to -1, the value EXPIRY_MINUTES from the config file is used.")

        """

    def __init__(self, options):

        self.options = options

        self.logger = logging.getLogger(app_name+"."+module_name)

        self.loadConfigData()

        self.loadTranslation()

        # setup timeout for connections

        # TODO: seems like this doesn't work in all cases..

        socket.setdefaulttimeout(self.config.CONNECTION_TIMEOUT)

    def loadTranslation(self):

            # set the locale

            if self.config.LOCALE == None:

                self.config.LOCALE = locale.getdefaultlocale()[0][0:2]

            self.logger.info("Locale set to " + self.config.LOCALE)

            if self.config.LOCALE != "en":

                self.logger.info("Looking for translation file for '%s' under %s" % (self.config.LOCALE, localedirectory))

                if gettext.find(domain, localedirectory, languages=[self.config.LOCALE]) != None:

                    self.logger.info("Translation file found for '%s'" % self.config.LOCALE)

                    try:

                        trans = gettext.translation(domain, localedirectory, languages=[self.config.LOCALE])

                        trans.install(unicode=True)

                        self.logger.info("Translation installed for '%s'" % self.config.LOCALE)

                    except Exception, e:

                        self.logger.error("Unable to load translation for '%s' %s" % (self.config.LOCALE, e.__str__()))

                else:

                    self.logger.info("Translation file not found for '%s', defaulting to 'en'" % self.config.LOCALE)

                    self.config.LOCALE = "en"

        except Exception, e:

            self.logger.error(e.__str__()+"\n"+traceback.format_exc())

    def loadConfigData(self):

        try:

            self.config = ForecastConfig()

            if self.options.config != None:

                # load the config based on options passed in from the main app

                configfilepath = self.options.config

            else:

                # load plugin config from home directory of the user

                configfilepath = os.path.join(os.path.expanduser('~'), ".config/"+app_name+"/"+module_name+".config")

            if os.path.exists(configfilepath):

                self.logger.info("Loading config settings from \"%s\""%configfilepath)

                for line in fileinput.input(os.path.expanduser(configfilepath)):

                    line = line.strip()

                    if len(line) > 0 and line[0:1] != "#": # ignore commented lines or empty ones

                        name = line.split("=")[0].strip().upper() # config setting name on the left of =

                        value = line.split("=")[1].split("#")[0].strip() # config value on the right of = (minus any trailing comments)

                        if len(value) > 0:

                            if name == "HEADERTEMPLATE":

                            elif name == "TEMPLATE":

                            elif name == "LOCATION":

                            elif name == "CACHE_FOLDERPATH":

                            elif name == "CONNECTION_TIMEOUT":

                            elif name == "EXPIRY_MINUTES":

                            elif name == "TIMEFORMAT":

                            elif name == "DATEFORMAT":

                            elif name == "LOCALE":

                            elif name == "XOAP_PARTNER_ID":

                            elif name == "XOAP_LICENCE_KEY":

                            elif name == "MAXIMUM_DAYS_FORECAST":

                            elif name == "IMAGESIZE":

                            elif name == "REFETCH":

                            else:

                                self.logger.error("Unknown option in config file: " + name)

            else:

                self.logger.info("Config data file %s not found, using defaults and setting up config file for next time" % configfilepath)

                userconfigpath = os.path.join(os.path.expanduser('~'), ".config/"+app_name+"/")

                configsource = os.path.join(app_path, "config/"+module_name+".config")

                if os.path.exists(userconfigpath) == False:

                    os.makedirs(userconfigpath)

 

                shutil.copy(configsource, configfilepath)

        except Exception, e:

            self.logger.error(e.__str__()+"\n"+traceback.format_exc())

 

    def checkAndLoad(self, location):

 

        # define CACHE_FILEPATH based on cache folder and location code

        cachefilepath = os.path.join(self.config.CACHE_FOLDERPATH, self.CACHE_FILENAME_TEMPLATE.replace("LOCATION", location))

        # if the location was not loaded before (or attempted to load)

        if not location in self.loaded_locations:

            # add it to the list so it doesn't get loaded again (or attempted to load)

                        self.logger.info("Loading cache file " + cachefilepath)

                        file = open(cachefilepath, 'rb')

                    except Exception, e:

                    else:

                        self.forecast_data[location] = pickle.load(file)

                    finally:

        if self.forecast_data.has_key(location):

            return True

        else:

            return False

 

    def checkAndUpdate(self, location):

            try:

                #url = "http://xoap.weather.com/weather/local/" + location + "?cc=*&dayf=10&link=xoap&prod=xoap&par=" + str(self.config.XOAP_PARTNER_ID) + "&key=" + self.config.XOAP_LICENCE_KEY + "&unit=m"

                url = "http://xoap.weather.com/weather/local/" + location + "?cc=*&dayf=10&par=" + str(self.config.XOAP_PARTNER_ID) + "&key=" + self.config.XOAP_LICENCE_KEY + "&unit=m"

                self.logger.info("Fetching weather data from " + url)

 

                usock = urllib2.urlopen(url)

                xml = usock.read()

                usock.close()

            except Exception, e:

                self.logger.error("Server connection error: " + e.__str__()+"\n"+traceback.format_exc())

            else:

                # interrogate weather data

                try:

                    # parse the XML

                    self.weatherxmldoc = minidom.parseString(xml)

                    weather_n = self.weatherxmldoc.documentElement

                    # check for an error and raise an exception

                    if len(weather_n.getElementsByTagName('err')) > 0:

                        raise Exception, self.getText(weather_n, 'err')

                    #head_n = self.getChild(weather_n, 'head')

                    #visibility_unit = self.getText(head_n, 'ud')

                    location_n = self.getChild(weather_n, 'loc')

                    city, country = self.getText(location_n, 'dnam').split(',')

                    country = country.strip()

                    # current conditions data

                    day_of_week = _(u"Today")

                    precip = _(u"N/A")

                    current_code = self.getText(current_condition_n, 'icon')

                    current_temp = self.getText(current_condition_n, 'tmp')

                    current_temp_feels = self.getText(current_condition_n, 'flik')

                    bar_n = self.getChild(current_condition_n, 'bar')

                    bar_read = self.getText(bar_n, 'r')

                    bar_desc = self.getText(bar_n, 'd')

                    wind_n = self.getChild(current_condition_n, 'wind')

                    wind_speed = self.getText(wind_n, 's')

                    wind_gusts = self.getText(wind_n, 'gust')

                    wind_direction_numeric = self.getText(wind_n, 'd')

                    wind_direction = self.getText(wind_n, 't')

                    humidity = self.getText(current_condition_n, 'hmid')

                    visibility = self.getText(current_condition_n, 'vis')

                    #    visibility = visibility + visibility_unit

                    uv_n = self.getChild(current_condition_n, 'uv')

                    uv_index = self.getText(uv_n, 'i')

                    uv_text = self.getText(uv_n, 't')

                    dew_point = self.getText(current_condition_n, 'dewp')

                    moon_n = self.getChild(current_condition_n, 'moon')

                    moon_icon = self.getText(moon_n, 'icon')

                    moon_phase = self.getText(moon_n, 't')

                    weathermap = self.getImageSrcForWeatherMap(location)

                    current_forecast_data = ForecastDataset(last_update, day_of_week, current_temp_feels, current_temp, current_code, current_desc, precip, humidity, wind_direction, wind_direction_numeric, wind_speed, wind_gusts, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc, uv_index, uv_text, dew_point, observatory, visibility, city, country, weathermap)

                    # collect forecast data

                    observatory = _(u"N/A")

                    bar_read = _(u"N/A")

                    dew_point = _(u"N/A")

                    moon_phase = _(u"N/A")

                    moon_icon = _(u"N/A")

                    forecast_n = self.getChild(weather_n, 'dayf')

                    last_update = self.getText(forecast_n, 'lsup')

                    day_nodes = forecast_n.getElementsByTagName('day')

                    day_forecast_data_list = []

                    night_forecast_data_list = []

                    for day in day_nodes:

                        day_of_week = day.getAttribute('t')

 

                        low_temp = self.getText(day, 'low')

                        sunrise = self.getText(day, 'sunr')

                        sunset = self.getText(day, 'suns')

                        # day forecast specific data

                        daytime_n = self.getChild(day, 'part')

                        condition_code = self.getText(daytime_n, 'icon')

                        wind_gusts = self.getText(wind_n, 'gust')

                        wind_direction_numeric = self.getText(wind_n, 'd')

                        wind_direction = self.getText(wind_n, 't')

                        precip = self.getText(daytime_n, 'ppcp')

                        humidity = self.getText(daytime_n, 'hmid')

                        day_forecast_data = ForecastDataset(last_update, day_of_week, low_temp, high_temp, condition_code, condition, precip, humidity, wind_direction, wind_direction_numeric, wind_speed, wind_gusts, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc, uv_index, uv_text, dew_point, observatory, visibility, city, country, weathermap)

                        day_forecast_data_list.append(day_forecast_data)

                        # night forecast specific data

                        daytime_n = self.getChild(day, 'part', 1)

                        condition_code = self.getText(daytime_n, 'icon')

                        wind_gusts = self.getText(wind_n, 'gust')

                        wind_direction_numeric = self.getText(wind_n, 'd')

                        wind_direction = self.getText(wind_n, 't')

                        precip = self.getText(daytime_n, 'ppcp')

                        humidity = self.getText(daytime_n, 'hmid')

                        night_forecast_data = ForecastDataset(last_update, day_of_week, low_temp, high_temp, condition_code, condition, precip, humidity, wind_direction, wind_direction_numeric, wind_speed, wind_gusts, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc, uv_index, uv_text, dew_point, observatory, visibility, city, country, weathermap)

                        night_forecast_data_list.append(night_forecast_data)

                    self.forecast_data[location] = ForecastLocation(current_forecast_data, day_forecast_data_list, night_forecast_data_list, datetime.today())

                    return True

                except Exception, e:

                    self.logger.error("Error reading weather data: " + e.__str__()+"\n"+traceback.format_exc())

 

        # minuteshide:

        # None = disabled

        # -1 = hide days and use config.EXPIRY_MINUTES

        # 0 = hide days and always show hours

        output = u""

        today = datetime.today()

        days = today.day - timestamp.day

        if days or minuteshide == None:

            output += timestamp.strftime(self.config.DATEFORMAT)

        if minuteshide == -1:

            minuteshide = self.config.EXPIRY_MINUTES

        delta = today - timestamp

        if days or minuteshide == None or minuteshide == 0 or delta.seconds > minuteshide * 60:

            if (len(output) > 0):

                output += " "

            output += timestamp.strftime(self.config.TIMEFORMAT)

        return output

 

 

                        except:

                            self.logger.error("Failed to extract update datetime from data using python 2.4 compliant code" + traceback.format_exc())

                            output = ""

                    if timezone != None and timezone != "Local Time" and len(output) > 0:

                        output = output + " " + timezone

 

                if len(output) == 0:

                    self.logger.error("Unable to extract the Last update date from the dataset, using raw text without formatting")

                    output = set.last_update.strip()

            elif datatype == "LF":

                output = self.getTimestampOutput(self.forecast_data[location].timestamp, minuteshide)

            elif datatype == "DW":

                #output = ForecastText.conditions_weather_font[set.condition_code]

                output = self.getImageSrcForConditionCode(set.condition_code)

            elif datatype == "LT":

                    if imperial == True:

                        string = self.convertCelsiusToFahrenheit(set.low)

                    else:

                    string = _(set.low)

                output = string

            elif datatype == "HT":

                    if imperial == True:

                        string = self.convertCelsiusToFahrenheit(set.high)

                    else:

                #output = _(set.condition_text)

                output = _(ForecastText.conditions_text[set.condition_code])

            elif datatype == "PC":

                    string = set.precip + u"%"

                else:

                    string = _(set.precip)

                output = string

            elif datatype == "HM":

                    string = set.humidity + u"%"

                else:

                    string = _(set.humidity)

            elif datatype == "BS":

                if set.wind_speed == "calm":

                    output = self.getImageSrcForBearing(ForecastText.bearing_icon["calm"])

                    if (set.wind_dir == "VAR"):

                        #TODO: need speed factored in once we have bearing icons with speed and direction...

                        #output = self.getImageSrcForBearing(ForecastText.bearing_icon[set.wind_dir])

                        output = self.getImageSrcForBearing(int(ForecastText.bearing_icon[set.wind_dir]) + self.getWindLevel(set.wind_speed))

                        try:

                            #TODO: need speed factored in once we have bearing icons with speed and direction...

                            #output = self.getImageSrcForBearing(ForecastText.bearing_icon[set.wind_dir])

            elif datatype == "WA":

                output = _(set.wind_dir_numeric)

            elif datatype == "WS":

                    if beaufort == True:

                        string = self.convertKPHtoBeaufort(set.wind_speed)

                    elif imperial == True:

                    string = _(set.wind_speed)

                output = string

            elif datatype == "WG":

                    if beaufort == True:

                        string = self.convertKPHtoBeaufort(set.wind_gusts)

                    elif imperial == True:

                    string = _(set.wind_gusts) # need to define translations

                output = string

            elif datatype == "SR":

                try:

                    srtime = datetime.strptime(set.sunrise, "%I:%M %p")

                    output = srtime.strftime(self.config.TIMEFORMAT)

                    except:

                        self.logger.error("Failed to extract sunrise datetime from data using python 2.4 compliant code" + traceback.format_exc())

                        output = set.sunrise

            elif datatype == "SS":

                try:

                    sstime = datetime.strptime(set.sunset, "%I:%M %p")

                    except:

                        self.logger.error("Failed to extract sunset datetime from data using python 2.4 compliant code" + traceback.format_exc())

                        output = set.sunset

            elif datatype == "DL":

                srtime = None

                sstime = None

                try:

                    srtime = datetime.strptime(set.sunrise, "%I:%M %p")

                except:

                    self.logger.error("Failed to extract sunrise/sunset from data using standard code" + traceback.format_exc())

                    try:

                        self.logger.error("Failed to extract sunrise/sunset from data using python 2.4 compliant code" + traceback.format_exc())

 

                if srtime != None and sstime != None:

                else:

                    output = "??:??"

            elif datatype == "MP":

                output = _(set.moon_phase) # need to define translations

            elif datatype == "MF":

                output = self.getImageSrcForMoonCode(ForecastText.conditions_moon_icon[set.moon_icon])

            elif datatype == "BR":

                    if imperial == True:

                        string = self.convertMillibarsToInches(set.bar_read,2)

                    else:

            elif datatype == "UT":

                output = _(set.uv_text)

            elif datatype == "DP":

                    if imperial == True:

                        string = self.convertCelsiusToFahrenheit(set.dew_point)

                    else:

            elif datatype == "OB":

                output = set.observatory

            elif datatype == "VI":

                    if imperial == True:

                        string = self.convertKilometresToMiles(set.visibility,1)

                    else:

                    string = string + distanceunit

                else:

                    string = _(set.visibility)

            elif datatype == "CN":

                output = set.city

            elif datatype == "CO":

                self.logger.error("Unknown datatype requested: " + datatype)

 

        except KeyError, e:

        return output

 

    def getDatasetOutput(self, location, datatype, startday, endday, night, shortweekday, imperial, beaufort, hideunits, hidedegreesymbol, spaces, minuteshide):

        if not self.checkAndLoad(location):

            self.logger.error("Failed to load the location cache")

            return u""

        # define current units for output

        if hideunits == False:

            if imperial == False:

                speedunit = u"mph"

                distanceunit = u"m"

                pressureunit = u"in"

            # override speed units if beaufort selected

            if beaufort == True:

                speedunit = u""

                tempunit = u"°"

            else:

                tempunit = u""

            speedunit = u""

            distanceunit = u""

            pressureunit = u""

        else: # forecast data

 

            # ensure startday and enday are within the forecast limit

            if startday < 0:

                startday = 0

                self.logger.error("--startday set beyond forecast limit, reset to minimum of 0")

            elif startday > self.config.MAXIMUM_DAYS_FORECAST:

                startday = self.config.MAXIMUM_DAYS_FORECAST

                self.logger.error("--startday set beyond forecast limit, reset to maximum of " + str(self.config.MAXIMUM_DAYS_FORECAST))

            if endday == None: # if no endday was set use startday

                endday = startday

            elif endday < 0:

            elif endday > self.config.MAXIMUM_DAYS_FORECAST:

                endday = self.config.MAXIMUM_DAYS_FORECAST

                self.logger.error("--endday set beyond forecast limit, reset to maximum of " + str(self.config.MAXIMUM_DAYS_FORECAST))

            for daynumber in range(startday, endday + 1):

                if night == True:

                    output += self.getDatatypeFromSet(location, datatype, self.forecast_data[location].night[daynumber], shortweekday, imperial, beaufort, tempunit, speedunit, distanceunit, pressureunit, minuteshide)

                else:

                    output += self.getDatatypeFromSet(location, datatype, self.forecast_data[location].day[daynumber], shortweekday, imperial, beaufort, tempunit, speedunit, distanceunit, pressureunit, minuteshide)

                if daynumber != endday:

 

        return output

 

    def getTemplateItemOutput(self, template_text):

        # keys to template data

        LOCATION_KEY = "location"

        DATATYPE_KEY = "datatype"

        HIDEDEGREESYMBOL_KEY = "hidedegreesymbol"

        SPACES_KEY = "spaces"

        MINUTESHIDE_KEY = "minuteshide"

        location = self.config.LOCATION

        datatype = None

        startday = None

        hidedegreesymbol = False

        spaces = None

        minuteshide = None

        for option in template_text.split('--'):

            if len(option) == 0 or option.isspace():

                continue

            # not using split here...it can't assign both key and value in one call, this should be faster

            x = option.find('=')

            if (x != -1):

            else:

                key = option.strip()

                value = None

            try:

                if key == LOCATION_KEY:

                elif key == DATATYPE_KEY:

                elif key == STARTDAY_KEY:

                elif key == ENDDAY_KEY:

                elif key == NIGHT_KEY:

                    night = True

                elif key == SHORTWEEKDAY_KEY:

                elif key == HIDEDEGREESYMBOL_KEY:

                    hidedegreesymbol = True

                elif key == SPACES_KEY:

                elif key == MINUTESHIDE_KEY:

                    if value != None:

                    else:

                        minuteshide = -1

                else:

            except (TypeError, ValueError):

                self.logger.error("Cannot convert option argument to number: " + option)

                return u""

        if datatype != None:

            output = self.getDatasetOutput(location, datatype, startday, endday, night, shortweekday, imperial, beaufort, hideunits, hidedegreesymbol, spaces, minuteshide)

            return output

        output = u""

        end = False

        a = 0

        # a and b are indexes in the template string

        # moving from left to right the string is processed

        # b is index of the opening bracket and a of the closing bracket

        # everything between b and a is a template that needs to be parsed

        while not end:

            b = template.find('[', a)

            if b == -1:

                b = len(template)

                end = True

            # if there is something between a and b, append it straight to output

            if b > a:

                output += template[a : b]

                    # skip the bracket in the input string and continue from the beginning

                    a = b + 1

                    continue

            if end:

                break

            a = template.find(']', b)

            if a == -1:

                self.logger.error("Missing terminal bracket (]) for a template item")

                return u""

            # if there is some template text...

            if a > b + 1:

                output += self.getTemplateItemOutput(template[b + 1 : a])

            a = a + 1

 

        return output

 

    def getOutput(self):

        if self.options.noheader == True:

            headertemplatefilepath = app_path+"/templates/nullheader.template"

            self.logger.info("Using custom header template file '%s'"%headertemplatefilepath)

            headertemplate = inputfile.read()

        finally:

            inputfile.close()

        if self.options.template != None:

            templatefilepath = self.options.template

            self.logger.info("Using custom template file '%s'"%templatefilepath)

        else:

            templatefilepath = app_path+"/templates/forecast.template"

            self.logger.info("Using default template")

        # load the file

        try:

            inputfile = codecs.open(os.path.expanduser(templatefilepath), encoding='utf-8')

 

        output = headertemplate

        output = output + self.getOutputFromTemplate(template)

        return output.encode("utf-8")

    def getText(self, parentNode, name):

        try:

            node = parentNode.getElementsByTagName(name)[0]

            if child.nodeType == child.TEXT_NODE:

                rc = rc + child.data

        return rc

    def getChild(self, parentNode, name, index = 0):

        try:

            return parentNode.getElementsByTagName(name)[index]

        except IndexError:

            raise Exception, "Data element <%s> is not present under <%s> (index %i)" % (name, parentNode.tagName, index)

 

    def convertCelsiusToFahrenheit(self, temp, dp=0):

        value = ((float(temp) * 9.0) / 5.0) + 32

        if dp == 0:

            return str(int(round(value,dp))) # lose the dp

        else:

            return str(round(value,dp))

    def convertMillibarsToInches(self,mb,dp=0):

        value = float(mb)/33.8582

        if dp == 0:

            return str(int(round(value,dp))) # lose the dp

        else:

            return str(round(value,dp))

    def getWindLevel(self, speed):

        beaufort = int(self.convertKPHtoBeaufort(speed))

        if beaufort < 4:

        else:

            return 3

 

    def getImageSrcForConditionCode(self, conditioncode):

            conditioncode = "25" # N/A image

        imagesrc = "file://%s/images/weathericons/%s.png"%(app_path, str(conditioncode).rjust(2,"0"))

        return imagesrc

    def getImageSrcForMoonCode(self, mooncode):

        imagesrc = "file://%s/images/moonicons/%s.png"%(app_path, str(mooncode).rjust(2,"0"))

        return imagesrc

 

    def getImageSrcForBearing(self, bearingcode):

        if int(bearingcode) > 0 and int(bearingcode) <= 4:

        else:

            fileext = "png"

        imagesrc = "file://%s/images/bearingicons/%s.%s"%(app_path, str(bearingcode).rjust(2,"0"),fileext)

        imagetag = ""

        try:

            url = "http://www.weather.com/outlook/travel/businesstraveler/map/" + location

            self.logger.info("Fetching satellite image page from " + url)

            usock = urllib2.urlopen(url)

        except Exception, e:

            self.logger.error("Error downloading the satellite image page: " + e.__str__()+"\n"+traceback.format_exc())

        else:

            regex = """<IMG NAME="mapImg" SRC="([^\"]+)" WIDTH=([0-9]+) HEIGHT=([0-9]+) BORDER"""

            result = re.findall(regex, html)

            if result and len(result) == 1:

        finally:

            usock.close()

        try:

            self.logger.info("Fetching satellite image from " + imagesrc)

            usock = urllib2.urlopen(imagesrc)

            img = usock.read()

        except Exception, e:

            imgfile.close()

 

        return imgfilepath

 

def getHTML(options):

    output = Output(options)

    html = output.getOutput()

 

# to enable testing in isolation

if __name__ == "__main__":

    parser = OptionParser()

    parser.add_option("--headertemplate", dest="headertemplate", type="string", metavar="FILE", help=u"Override the header template for the plugin, default or config based template ignored.")

    parser.add_option("--template", dest="template", type="string", metavar="FILE", help=u"Override the template for the plugin, default or config based template ignored.")

    parser.add_option("--verbose", dest="verbose", default=False, action="store_true", help=u"Outputs verbose info to the terminal")

    parser.add_option("--version", dest="version", default=False, action="store_true", help=u"Displays the version of the script.")

    (options, args) = parser.parse_args()

    output = Output(options)

    html = output.getOutput()

    del output

    print html