infoex-autowx.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 """
   5 InfoEx <-> NRCS/MesoWest Auto Wx implementation
   6 Alexander Vasarab
   7 Wylark Mountaineering LLC
   8
   9 This program fetches data from either an NRCS SNOTEL site or MesoWest
  10 weather station and pushes it to InfoEx using the new automated weather
  11 system implementation.
  12
  13 It is designed to be run hourly, and it asks for the last three hours
  14 of data of each desired type, and selects the most recent one. This
  15 lends some resiliency to the process and helps ensure that we have a
  16 value to send, but it can lead to somewhat inconsistent/untruthful
  17 data if e.g. the HS is from the last hour but the tempPres is from two
  18 hours ago because the instrumentation had a hiccup. It's worth
  19 considering if this is a bug or a feature.
  20
  21 For more information, see file: README
  22 For licensing, see file: LICENSE
  23 """
  24
  25 import configparser
  26 import csv
  27 import datetime
  28 import logging
  29 import os
  30 import sys
  31 import time
  32 import urllib3
  33 import importlib.util
  34
  35 from ftplib import FTP
  36 from argparse import ArgumentParser
  37
  38 import pytz
  39
  40 import requests
  41
  42 import zeep
  43 import zeep.cache
  44 import zeep.transports
  45
  46 __version__ = '3.2.3'
  47
  48 LOG = logging.getLogger(__name__)
  49 LOG.setLevel(logging.NOTSET)
  50
  51 urllib3.disable_warnings()
  52
  53 def get_parser():
  54     """Return OptionParser for this program"""
  55     parser = ArgumentParser()
  56
  57     parser.add_argument("--version",
  58                         action="version",
  59                         version=__version__)
  60
  61     parser.add_argument("--config",
  62                         dest="config",
  63                         metavar="FILE",
  64                         help="location of config file")
  65
  66     parser.add_argument("--log-level",
  67                         dest="log_level",
  68                         default=None,
  69                         help="set the log level (debug, info, warning)")
  70
  71     parser.add_argument("--dry-run",
  72                         action="store_true",
  73                         dest="dry_run",
  74                         default=False,
  75                         help="fetch data but don't upload to InfoEx")
  76
  77     return parser
  78
  79 def setup_config(config):
  80     """Setup config variable based on values specified in the ini file"""
  81     try:
  82         infoex = {
  83             'host': config['infoex']['host'],
  84             'uuid': config['infoex']['uuid'],
  85             'api_key': config['infoex']['api_key'],
  86             'csv_filename': config['infoex']['csv_filename'],
  87             'location_uuid': config['infoex']['location_uuid'],
  88             'wx_data': {}, # placeholder key, values to come later
  89         }
  90
  91         station = dict()
  92         station['provider'] = config['station']['type']
  93
  94         if station['provider'] not in ['nrcs', 'mesowest', 'python']:
  95             print("Please specify either nrcs or mesowest as the station type.")
  96             sys.exit(1)
  97
  98         if station['provider'] == 'nrcs':
  99             station['source'] = 'https://www.wcc.nrcs.usda.gov/awdbWebService/services?WSDL'
 100             station['station_id'] = config['station']['station_id']
 101             station['desired_data'] = config['station']['desired_data'].split(',')
 102             station['units'] = config['station']['units']
 103
 104         if station['provider'] == 'mesowest':
 105             station['source'] = 'https://api.synopticdata.com/v2/stations/timeseries'
 106             station['station_id'] = config['station']['station_id']
 107             station['units'] = config['station']['units']
 108             station['desired_data'] = config['station']['desired_data']
 109
 110             # construct full API URL (sans start/end time, added later)
 111             station['source'] = station['source'] + '?token=' + \
 112                                 config['station']['token'] + \
 113                                 '&within=60&units=' + station['units'] + \
 114                                 '&stid=' + station['station_id'] + \
 115                                 '&vars=' + station['desired_data']
 116
 117         if station['provider'] == 'python':
 118             station['path'] = config['station']['path']
 119
 120         tz = 'America/Los_Angeles'
 121
 122         if 'tz' in config['station']:
 123             tz = config['station']['tz']
 124
 125         try:
 126             station['tz'] = pytz.timezone(tz)
 127         except pytz.exceptions.UnknownTimeZoneError:
 128             LOG.critical("%s is not a valid timezone", tz)
 129             sys.exit(1)
 130
 131     except KeyError as err:
 132         LOG.critical("%s not defined in configuration file", err)
 133         sys.exit(1)
 134
 135     # all sections/values present in config file, final sanity check
 136     try:
 137         for key in config.sections():
 138             for subkey in config[key]:
 139                 if not config[key][subkey]:
 140                     raise ValueError
 141     except ValueError:
 142         LOG.critical("Config value '%s.%s' is empty", key, subkey)
 143         sys.exit(1)
 144
 145     return (infoex, station)
 146
 147 def setup_logging(log_level):
 148     """Setup our logging infrastructure"""
 149     try:
 150         from systemd.journal import JournalHandler
 151         LOG.addHandler(JournalHandler())
 152     except ImportError:
 153         ## fallback to syslog
 154         #import logging.handlers
 155         #LOG.addHandler(logging.handlers.SysLogHandler())
 156         # fallback to stdout
 157         handler = logging.StreamHandler(sys.stdout)
 158         formatter = logging.Formatter('%(asctime)s.%(msecs)03d '
 159                                       '%(levelname)s %(module)s - '
 160                                       '%(funcName)s: %(message)s',
 161                                       '%Y-%m-%d %H:%M:%S')
 162         handler.setFormatter(formatter)
 163         LOG.addHandler(handler)
 164
 165     # ugly, but passable
 166     if log_level in [None, 'debug', 'info', 'warning']:
 167         if log_level == 'debug':
 168             LOG.setLevel(logging.DEBUG)
 169         elif log_level == 'info':
 170             LOG.setLevel(logging.INFO)
 171         elif log_level == 'warning':
 172             LOG.setLevel(logging.WARNING)
 173         else:
 174             LOG.setLevel(logging.NOTSET)
 175     else:
 176         return False
 177
 178     return True
 179
 180 def main():
 181     """Main routine: sort through args, decide what to do, then do it"""
 182     parser = get_parser()
 183     options = parser.parse_args()
 184
 185     config = configparser.ConfigParser(allow_no_value=False)
 186
 187     if not options.config:
 188         parser.print_help()
 189         print("\nPlease specify a configuration file via --config.")
 190         sys.exit(1)
 191
 192     config.read(options.config)
 193
 194     if not setup_logging(options.log_level):
 195         parser.print_help()
 196         print("\nPlease select an appropriate log level or remove the switch (--log-level).")
 197         sys.exit(1)
 198
 199     (infoex, station) = setup_config(config)
 200
 201     LOG.debug('Config parsed, starting up')
 202
 203     # create mappings
 204     (fmap, final_data) = setup_infoex_fields_mapping(infoex['location_uuid'])
 205     iemap = setup_infoex_counterparts_mapping(station['provider'])
 206
 207     # override units if user selected metric
 208     if station['provider'] != 'python' and station['units'] == 'metric':
 209         final_data = switch_units_to_metric(final_data, fmap)
 210
 211     (begin_date, end_date) = setup_time_values(station)
 212
 213     if station['provider'] == 'python':
 214         LOG.debug("Getting custom data from external Python program")
 215     else:
 216         LOG.debug("Getting %s data from %s to %s (%s)",
 217                   str(station['desired_data']),
 218                   str(begin_date), str(end_date), end_date.tzinfo.zone)
 219
 220     time_all_elements = time.time()
 221
 222     # get the data
 223     if station['provider'] == 'nrcs':
 224         infoex['wx_data'] = get_nrcs_data(begin_date, end_date, station)
 225     elif station['provider'] == 'mesowest':
 226         infoex['wx_data'] = get_mesowest_data(begin_date, end_date,
 227                                               station)
 228     elif station['provider'] == 'python':
 229         try:
 230             spec = importlib.util.spec_from_file_location('custom_wx',
 231                                                           station['path'])
 232             mod = importlib.util.module_from_spec(spec)
 233             spec.loader.exec_module(mod)
 234             mod.LOG = LOG
 235
 236             try:
 237                 infoex['wx_data'] = mod.get_custom_data()
 238
 239                 if infoex['wx_data'] is None:
 240                     infoex['wx_data'] = []
 241             except Exception as exc:
 242                 LOG.error("Python program for custom Wx data failed in "
 243                           "execution: %s", str(exc))
 244                 sys.exit(1)
 245
 246             LOG.info("Successfully executed external Python program")
 247         except ImportError:
 248             LOG.error("Please upgrade to Python 3.3 or later")
 249             sys.exit(1)
 250         except FileNotFoundError:
 251             LOG.error("Specified Python program for custom Wx data "
 252                       "was not found")
 253             sys.exit(1)
 254         except Exception as exc:
 255             LOG.error("A problem was encountered when attempting to "
 256                       "load your custom Wx program: %s", str(exc))
 257             sys.exit(1)
 258
 259     LOG.info("Time taken to get all data : %.3f sec", time.time() -
 260              time_all_elements)
 261
 262     LOG.debug("infoex[wx_data]: %s", str(infoex['wx_data']))
 263
 264     # timezone massaging
 265     final_end_date = end_date.astimezone(station['tz'])
 266
 267     # Now we only need to add in what we want to change thanks to that
 268     # abomination of a variable declaration earlier
 269     final_data[fmap['Location UUID']] = infoex['location_uuid']
 270     final_data[fmap['obDate']] = final_end_date.strftime('%m/%d/%Y')
 271     final_data[fmap['obTime']] = final_end_date.strftime('%H:%M')
 272     final_data[fmap['timeZone']] = station['tz'].zone
 273
 274     for element_cd in infoex['wx_data']:
 275         if element_cd not in iemap:
 276             LOG.warning("BAD KEY wx_data['%s']", element_cd)
 277             continue
 278
 279         if infoex['wx_data'][element_cd] is None:
 280             continue
 281
 282         # do the conversion before the rounding
 283         if station['provider'] == 'nrcs' and station['units'] == 'metric':
 284             infoex['wx_data'][element_cd] = convert_nrcs_units_to_metric(element_cd, infoex['wx_data'][element_cd])
 285
 286         # Massage precision of certain values to fit InfoEx's
 287         # expectations
 288         #
 289         # 0 decimal places: relative humidity, wind speed, wind
 290         #                   direction, wind gust, snow depth
 291         # 1 decimal place:  air temp, baro
 292         # Avoid transforming None values
 293         if element_cd in ['wind_speed', 'WSPD', 'wind_direction',
 294                           'RHUM', 'relative_humidity', 'WDIR',
 295                           'wind_gust', 'SNWD', 'snow_depth']:
 296             infoex['wx_data'][element_cd] = round(infoex['wx_data'][element_cd])
 297         elif element_cd in ['TOBS', 'air_temp', 'PRES', 'pressure']:
 298             infoex['wx_data'][element_cd] = round(infoex['wx_data'][element_cd], 1)
 299         elif element_cd in ['PREC', 'precip_accum']:
 300             infoex['wx_data'][element_cd] = round(infoex['wx_data'][element_cd], 2)
 301
 302         # CONSIDER: Casting every value to Float() -- need to investigate if
 303         #           any possible elementCds we may want are any other data
 304         #           type than float.
 305         #
 306         #           Another possibility is to query the API with
 307         #           getStationElements and temporarily store the
 308         #           storedUnitCd. But that's pretty network-intensive and
 309         #           may not even be worth it if there's only e.g. one or two
 310         #           exceptions to any otherwise uniformly Float value set.
 311         final_data[fmap[iemap[element_cd]]] = infoex['wx_data'][element_cd]
 312
 313     LOG.debug("final_data: %s", str(final_data))
 314
 315     if infoex['wx_data']:
 316         if not write_local_csv(infoex['csv_filename'], final_data):
 317             LOG.warning('Could not write local CSV file: %s',
 318                         infoex['csv_filename'])
 319             return 1
 320
 321         if not options.dry_run:
 322             upload_csv(infoex['csv_filename'], infoex)
 323
 324     LOG.debug('DONE')
 325     return 0
 326
 327 # data structure operations
 328 def setup_infoex_fields_mapping(location_uuid):
 329     """
 330     Create a mapping of InfoEx fields to the local data's indexing scheme.
 331
 332     INFOEX FIELDS
 333
 334     This won't earn style points in Python, but here we establish a couple
 335     of helpful mappings variables. The reason this is helpful is that the
 336     end result is simply an ordered set, the CSV file. But we still may
 337     want to manipulate the values arbitrarily before writing that file.
 338
 339     Also note that the current Auto Wx InfoEx documentation shows these
 340     keys in a graphical table with the "index" beginning at 1, but here we
 341     sanely index beginning at 0.
 342     """
 343     # pylint: disable=too-many-statements,multiple-statements,bad-whitespace
 344     fmap = {}                           ; final_data     = [None] * 29
 345     fmap['Location UUID'] = 0           ; final_data[0]  = location_uuid
 346     fmap['obDate'] = 1                  ; final_data[1]  = None
 347     fmap['obTime'] = 2                  ; final_data[2]  = None
 348     fmap['timeZone'] = 3                ; final_data[3]  = 'Pacific'
 349     fmap['tempMaxHour'] = 4             ; final_data[4]  = None
 350     fmap['tempMaxHourUnit'] = 5         ; final_data[5]  = 'F'
 351     fmap['tempMinHour'] = 6             ; final_data[6]  = None
 352     fmap['tempMinHourUnit'] = 7         ; final_data[7]  = 'F'
 353     fmap['tempPres'] = 8                ; final_data[8]  = None
 354     fmap['tempPresUnit'] = 9            ; final_data[9]  = 'F'
 355     fmap['precipitationGauge'] = 10     ; final_data[10] = None
 356     fmap['precipitationGaugeUnit'] = 11 ; final_data[11] = 'in'
 357     fmap['windSpeedNum'] = 12           ; final_data[12] = None
 358     fmap['windSpeedUnit'] = 13          ; final_data[13] = 'mph'
 359     fmap['windDirectionNum'] = 14       ; final_data[14] = None
 360     fmap['hS'] = 15                     ; final_data[15] = None
 361     fmap['hsUnit'] = 16                 ; final_data[16] = 'in'
 362     fmap['baro'] = 17                   ; final_data[17] = None
 363     fmap['baroUnit'] = 18               ; final_data[18] = 'inHg'
 364     fmap['rH'] = 19                     ; final_data[19] = None
 365     fmap['windGustSpeedNum'] = 20       ; final_data[20] = None
 366     fmap['windGustSpeedNumUnit'] = 21   ; final_data[21] = 'mph'
 367     fmap['windGustDirNum'] = 22         ; final_data[22] = None
 368     fmap['dewPoint'] = 23               ; final_data[23] = None
 369     fmap['dewPointUnit'] = 24           ; final_data[24] = 'F'
 370     fmap['hn24Auto'] = 25               ; final_data[25] = None
 371     fmap['hn24AutoUnit'] = 26           ; final_data[26] = 'in'
 372     fmap['hstAuto'] = 27                ; final_data[27] = None
 373     fmap['hstAutoUnit'] = 28            ; final_data[28] = 'in'
 374
 375     return (fmap, final_data)
 376
 377 def setup_infoex_counterparts_mapping(provider):
 378     """
 379     Create a mapping of the NRCS/MesoWest fields that this program supports to
 380     their InfoEx counterparts
 381     """
 382     iemap = {}
 383
 384     if provider == 'nrcs':
 385         iemap['PREC'] = 'precipitationGauge'
 386         iemap['TOBS'] = 'tempPres'
 387         iemap['TMAX'] = 'tempMaxHour'
 388         iemap['TMIN'] = 'tempMinHour'
 389         iemap['SNWD'] = 'hS'
 390         iemap['PRES'] = 'baro'
 391         iemap['RHUM'] = 'rH'
 392         iemap['WSPD'] = 'windSpeedNum'
 393         iemap['WDIR'] = 'windDirectionNum'
 394         # unsupported by NRCS:
 395         # windGustSpeedNum
 396     elif provider == 'mesowest':
 397         iemap['precip_accum'] = 'precipitationGauge'
 398         iemap['air_temp'] = 'tempPres'
 399         iemap['air_temp_high_24_hour'] = 'tempMaxHour'
 400         iemap['air_temp_low_24_hour'] = 'tempMinHour'
 401         iemap['snow_depth'] = 'hS'
 402         iemap['pressure'] = 'baro'
 403         iemap['relative_humidity'] = 'rH'
 404         iemap['wind_speed'] = 'windSpeedNum'
 405         iemap['wind_direction'] = 'windDirectionNum'
 406         iemap['wind_gust'] = 'windGustSpeedNum'
 407     elif provider == 'python':
 408         # we expect Python programs to use the InfoEx data type names
 409         iemap['precipitationGauge'] = 'precipitationGauge'
 410         iemap['tempPres'] = 'tempPres'
 411         iemap['tempMaxHour'] = 'tempMaxHour'
 412         iemap['tempMinHour'] = 'tempMinHour'
 413         iemap['hS'] = 'hS'
 414         iemap['baro'] = 'baro'
 415         iemap['rH'] = 'rH'
 416         iemap['windSpeedNum'] = 'windSpeedNum'
 417         iemap['windDirectionNum'] = 'windDirectionNum'
 418         iemap['windGustSpeedNum'] = 'windGustSpeedNum'
 419
 420     return iemap
 421
 422 # provider-specific operations
 423 def get_nrcs_data(begin, end, station):
 424     """get the data we're after from the NRCS WSDL"""
 425     transport = zeep.transports.Transport(cache=zeep.cache.SqliteCache())
 426     transport.session.verify = False
 427     client = zeep.Client(wsdl=station['source'], transport=transport)
 428     remote_data = {}
 429
 430     # massage begin/end date format
 431     begin_date_str = begin.strftime('%Y-%m-%d %H:%M:00')
 432     end_date_str = end.strftime('%Y-%m-%d %H:%M:00')
 433
 434     for element_cd in station['desired_data']:
 435         time_element = time.time()
 436
 437         # get the last three hours of data for this elementCd/element_cd
 438         tmp = client.service.getHourlyData(
 439             stationTriplets=[station['station_id']],
 440             elementCd=element_cd,
 441             ordinal=1,
 442             beginDate=begin_date_str,
 443             endDate=end_date_str)
 444
 445         LOG.info("Time to get NRCS elementCd '%s': %.3f sec", element_cd,
 446                  time.time() - time_element)
 447
 448         values = tmp[0]['values']
 449
 450         # sort and isolate the most recent
 451         #
 452         # NOTE: we do this because sometimes there are gaps in hourly data
 453         #       in NRCS; yes, we may end up with slightly inaccurate data,
 454         #       so perhaps this decision will be re-evaluated in the future
 455         if values:
 456             ordered = sorted(values, key=lambda t: t['dateTime'], reverse=True)
 457             remote_data[element_cd] = ordered[0]['value']
 458         else:
 459             remote_data[element_cd] = None
 460
 461     return remote_data
 462
 463 def get_mesowest_data(begin, end, station):
 464     """get the data we're after from the MesoWest/Synoptic API"""
 465     remote_data = {}
 466
 467     # massage begin/end date format
 468     begin_date_str = begin.strftime('%Y%m%d%H%M')
 469     end_date_str = end.strftime('%Y%m%d%H%M')
 470
 471     # construct final, completed API URL
 472     api_req_url = station['source'] + '&start=' + begin_date_str + '&end=' + end_date_str
 473
 474     try:
 475         req = requests.get(api_req_url)
 476     except requests.exceptions.ConnectionError:
 477         LOG.error("Could not connect to '%s'", api_req_url)
 478         sys.exit(1)
 479
 480     try:
 481         json = req.json()
 482     except ValueError:
 483         LOG.error("Bad JSON in MesoWest response")
 484         sys.exit(1)
 485
 486     try:
 487         observations = json['STATION'][0]['OBSERVATIONS']
 488     except KeyError as exc:
 489         LOG.error("Unexpected JSON in MesoWest response: '%s'", exc)
 490         sys.exit(1)
 491     except IndexError as exc:
 492         LOG.error("Unexpected JSON in MesoWest response: '%s'", exc)
 493         try:
 494             LOG.error("Detailed MesoWest response: '%s'",
 495                       json['SUMMARY']['RESPONSE_MESSAGE'])
 496         except KeyError:
 497             pass
 498         sys.exit(1)
 499     except ValueError as exc:
 500         LOG.error("Bad JSON in MesoWest response: '%s'", exc)
 501         sys.exit(1)
 502
 503     pos = len(observations['date_time']) - 1
 504
 505     for element_cd in station['desired_data'].split(','):
 506         # sort and isolate the most recent, see note above in NRCS for how and
 507         # why this is done
 508         #
 509         # NOTE: Unlike in the NRCS case, the MesoWest API response contains all
 510         #       data (whereas with NRCS, we have to make a separate request for
 511         #       each element we want). This is nice for network efficiency but
 512         #       it means we have to handle this part differently for each.
 513         #
 514         # NOTE: Also unlike NRCS, MesoWest provides more granular data; NRCS
 515         #       provides hourly data, but MesoWest can often provide data every
 516         #       10 minutes -- though this provides more opportunity for
 517         #       irregularities
 518
 519         # we may not have the data at all
 520         key_name = element_cd + '_set_1'
 521
 522         if key_name in observations:
 523             if observations[key_name][pos]:
 524                 remote_data[element_cd] = observations[key_name][pos]
 525
 526                 # mesowest by default provides wind_speed in m/s, but
 527                 # we specify 'english' units in the request; either way,
 528                 # we want mph
 529                 if element_cd in ('wind_speed', 'wind_gust'):
 530                     remote_data[element_cd] = kn_to_mph(remote_data[element_cd])
 531             else:
 532                 remote_data[element_cd] = None
 533         else:
 534             remote_data[element_cd] = None
 535
 536     return remote_data
 537
 538 def switch_units_to_metric(data_map, mapping):
 539     """replace units with metric counterparts"""
 540
 541     # NOTE: to update this, use the fmap<->final_data mapping laid out
 542     #       in setup_infoex_fields_mapping ()
 543     data_map[mapping['tempMaxHourUnit']] = 'C'
 544     data_map[mapping['tempMinHourUnit']] = 'C'
 545     data_map[mapping['tempPresUnit']] = 'C'
 546     data_map[mapping['precipitationGaugeUnit']] = 'mm'
 547     data_map[mapping['hsUnit']] = 'cm'
 548     data_map[mapping['windSpeedUnit']] = 'm/s'
 549     data_map[mapping['windGustSpeedNumUnit']] = 'm/s'
 550     data_map[mapping['dewPointUnit']] = 'C'
 551     data_map[mapping['hn24AutoUnit']] = 'cm'
 552     data_map[mapping['hstAutoUnit']] = 'cm'
 553
 554     return data_map
 555
 556 def convert_nrcs_units_to_metric(element_cd, value):
 557     """convert NRCS values from English to metric"""
 558     if element_cd == 'TOBS':
 559         value = f_to_c(value)
 560     elif element_cd == 'SNWD':
 561         value = in_to_cm(value)
 562     elif element_cd == 'PREC':
 563         value = in_to_mm(value)
 564     return value
 565
 566 # CSV operations
 567 def write_local_csv(path_to_file, data):
 568     """Write the specified CSV file to disk"""
 569     with open(path_to_file, 'w') as file_object:
 570         # The requirement is that empty values are represented in the CSV
 571         # file as "", csv.QUOTE_NONNUMERIC achieves that
 572         LOG.debug("writing CSV file '%s'", path_to_file)
 573         writer = csv.writer(file_object, quoting=csv.QUOTE_NONNUMERIC)
 574         writer.writerow(data)
 575         file_object.close()
 576     return True
 577
 578 def upload_csv(path_to_file, infoex_data):
 579     """Upload the specified CSV file to InfoEx FTP and remove the file"""
 580     with open(path_to_file, 'rb') as file_object:
 581         LOG.debug("uploading FTP file '%s'", infoex_data['host'])
 582         ftp = FTP(infoex_data['host'], infoex_data['uuid'],
 583                   infoex_data['api_key'])
 584         ftp.storlines('STOR ' + path_to_file, file_object)
 585         ftp.close()
 586         file_object.close()
 587     os.remove(path_to_file)
 588
 589 # other miscellaneous routines
 590 def setup_time_values(station):
 591     """establish time bounds of data request(s)"""
 592
 593     # default timezone to UTC (for MesoWest)
 594     tz = pytz.utc
 595
 596     # but for NRCS, use the config-specified timezone
 597     if station['provider'] == 'nrcs':
 598         tz = station['tz']
 599
 600     # floor time to nearest hour
 601     date_time = datetime.datetime.now(tz=tz)
 602     end_date = date_time - datetime.timedelta(minutes=date_time.minute % 60,
 603                                               seconds=date_time.second,
 604                                               microseconds=date_time.microsecond)
 605     begin_date = end_date - datetime.timedelta(hours=3)
 606     return (begin_date, end_date)
 607
 608 def f_to_c(f):
 609     """convert Fahrenheit to Celsius"""
 610     return (float(f) - 32) * 5.0/9.0
 611
 612 def in_to_cm(inches):
 613     """convert inches to centimetrs"""
 614     return float(inches) * 2.54
 615
 616 def in_to_mm(inches):
 617     """convert inches to millimeters"""
 618     return (float(inches) * 2.54) * 10.0
 619
 620 def ms_to_mph(ms):
 621     """convert meters per second to miles per hour"""
 622     return ms * 2.236936
 623
 624 def kn_to_mph(kn):
 625     """convert knots to miles per hour"""
 626     return kn * 1.150779
 627
 628 if __name__ == "__main__":
 629     sys.exit(main())