PageRenderTime 61ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/metar/Metar.py

http://github.com/timetric/python-metar
Python | 1186 lines | 1153 code | 4 blank | 29 comment | 3 complexity | 582503c3faa116f937356fd0a788024f MD5 | raw file
    

  1. #!/usr/bin/env python
    2. 

  2. #
    3. 

  3. #  A python package for interpreting METAR and SPECI weather reports.
    4. 

  4. #  
    5. 

  5. #  US conventions for METAR/SPECI reports are described in chapter 12 of
    6. 

  6. #  the Federal Meteorological Handbook No.1. (FMH-1 1995), issued by NOAA. 
    7. 

  7. #  See <http://metar.noaa.gov/>
    8. 

  8. # 
    9. 

  9. #  International conventions for the METAR and SPECI codes are specified in 
    10. 

  10. #  the WMO Manual on Codes, vol I.1, Part A (WMO-306 I.i.A).  
    11. 

  11. #
    12. 

  12. #  This module handles a reports that follow the US conventions, as well
    13. 

  13. #  the more general encodings in the WMO spec.  Other regional conventions
    14. 

  14. #  are not supported at present.
    15. 

  15. #
    16. 

  16. #  The current METAR report for a given station is available at the URL
    17. 

  17. #  http://weather.noaa.gov/pub/data/observations/metar/stations/<station>.TXT
    18. 

  18. #  where <station> is the four-letter ICAO station code.  
    19. 

  19. #
    20. 

  20. #  The METAR reports for all reporting stations for any "cycle" (i.e., hour) 
    21. 

  21. #  in the last 24 hours is available in a single file at the URL
    22. 

  22. #  http://weather.noaa.gov/pub/data/observations/metar/cycles/<cycle>Z.TXT
    23. 

  23. #  where <cycle> is a 2-digit cycle number (e.g., "00", "05" or "23").  
    24. 

  24. # 
    25. 

  25. #  Copyright 2004  Tom Pollard
    26. 

  26. # 
    27. 

  27. """
    28. 

  28. This module defines the Metar class.  A Metar object represents the weather report encoded by a single METAR code.
    29. 

  29. """
    30. 

    31. 

  31. __author__ = "Tom Pollard"
    32. 

  32. 

  33. __email__ = "pollard@alum.mit.edu"
    34. 

  34. 

  35. __version__ = "1.2"
    36. 

  36. 

  37. __LICENSE__ = """
    38. 

  38. Copyright (c) 2004, %s
    39. 

  39. All rights reserved.
    40. 

  40. 

  41. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
    42. 

  42. 

  43. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    44. 

  44. 

  45. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
    46. 

  46. 

  47. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    48. 

  48. """ % __author__
    49. 

    50. 

  50. import re
    51. 

  51. import datetime
    52. 

  52. import string
    53. 

  53. from Datatypes import *
    54. 

  54. 

  55. ## Exceptions
    56. 

  56. 

  57. class ParserError(Exception):
    58. 

  58.   """Exception raised when an unparseable group is found in body of the report."""
    59. 

  59.   pass
    60. 

  60. 

  61. ## regular expressions to decode various groups of the METAR code
    62. 

  62. 

  63. MISSING_RE = re.compile(r"^[M/]+$")
    64. 

  64. 

  65. TYPE_RE =     re.compile(r"^(?P<type>METAR|SPECI)\s+")
    66. 

  66. STATION_RE =  re.compile(r"^(?P<station>[A-Z][A-Z0-9]{3})\s+")
    67. 

  67. TIME_RE = re.compile(r"""^(?P<day>\d\d)
    68. 

  68.                           (?P<hour>\d\d)
    69. 

  69.                           (?P<min>\d\d)Z?\s+""",
    70. 

  70.                           re.VERBOSE)
    71. 

  71. MODIFIER_RE = re.compile(r"^(?P<mod>AUTO|FINO|NIL|TEST|CORR?|RTD|CC[A-G])\s+")
    72. 

  72. WIND_RE = re.compile(r"""^(?P<dir>[\dO]{3}|[0O]|///|MMM|VRB)
    73. 

  73.                           (?P<speed>P?[\dO]{2,3}|[0O]+|[/M]{2,3})
    74. 

  74.                         (G(?P<gust>P?(\d{1,3}|[/M]{1,3})))?
    75. 

  75.                           (?P<units>KTS?|LT|K|T|KMH|MPS)?
    76. 

  76.                       (\s+(?P<varfrom>\d\d\d)V
    77. 

  77.                           (?P<varto>\d\d\d))?\s+""",
    78. 

  78.                           re.VERBOSE)
    79. 

  79. # VISIBILITY_RE =   re.compile(r"""^(?P<vis>(?P<dist>M?(\d\s+)?\d/\d\d?|M?\d+)
    80. 

  80. #                                     ( \s*(?P<units>SM|KM|M|U) | NDV |
    81. 

  81. #                                          (?P<dir>[NSEW][EW]?) )? |
    82. 

  82. #                                    CAVOK )\s+""",
    83. 

  83. #                                    re.VERBOSE)
    84. 

  84. # start patch
    85. 

  85. VISIBILITY_RE = re.compile(r"""^(?P<vis>(?P<dist>(M|P)?\d\d\d\d|////)
    86. 

  86.                                             (?P<dir>[NSEW][EW]? | NDV)? |
    87. 

  87.                                         (?P<distu>(M|P)?(\d+|\d\d?/\d\d?|\d+\s+\d/\d))
    88. 

  88.                                            (?P<units>SM|KM|M|U) | 
    89. 

  89.                                         CAVOK )\s+""",
    90. 

  90.                                  re.VERBOSE)
    91. 

  91. # end patch
    92. 

  92. RUNWAY_RE = re.compile(r"""^(RVRNO | 
    93. 

  93.                              R(?P<name>\d\d(RR?|LL?|C)?)/
    94. 

  94.                               (?P<low>(M|P)?\d\d\d\d)
    95. 

  95.                             (V(?P<high>(M|P)?\d\d\d\d))?
    96. 

  96.                               (?P<unit>FT)?[/NDU]*)\s+""",
    97. 

  97.                               re.VERBOSE)
    98. 

  98. WEATHER_RE = re.compile(r"""^(?P<int>(-|\+|VC)*)
    99. 

  99.                              (?P<desc>(MI|PR|BC|DR|BL|SH|TS|FZ)+)?
    100. 

  100.                              (?P<prec>(DZ|RA|SN|SG|IC|PL|GR|GS|UP|/)*)
    101. 

  101.                              (?P<obsc>BR|FG|FU|VA|DU|SA|HZ|PY)?
    102. 

  102.                              (?P<other>PO|SQ|FC|SS|DS|NSW|/+)?
    103. 

  103.                              (?P<int2>[-+])?\s+""",
    104. 

  104.                              re.VERBOSE)
    105. 

  105. SKY_RE= re.compile(r"""^(?P<cover>VV|CLR|SKC|SCK|NSC|NCD|BKN|SCT|FEW|[O0]VC|///)
    106. 

  106.                         (?P<height>[\dO]{2,4}|///)?
    107. 

  107.                         (?P<cloud>([A-Z][A-Z]+|///))?\s+""",
    108. 

  108.                         re.VERBOSE)
    109. 

  109. TEMP_RE = re.compile(r"""^(?P<temp>(M|-)?\d+|//|XX|MM)/
    110. 

  110.                           (?P<dewpt>(M|-)?\d+|//|XX|MM)?\s+""",
    111. 

  111.                           re.VERBOSE)
    112. 

  112. PRESS_RE = re.compile(r"""^(?P<unit>A|Q|QNH|SLP)?
    113. 

  113.                            (?P<press>[\dO]{3,4}|////)
    114. 

  114.                            (?P<unit2>INS)?\s+""",
    115. 

  115.                            re.VERBOSE)
    116. 

  116. RECENT_RE = re.compile(r"""^RE(?P<desc>MI|PR|BC|DR|BL|SH|TS|FZ)?
    117. 

  117.                               (?P<prec>(DZ|RA|SN|SG|IC|PL|GR|GS|UP)*)?
    118. 

  118.                               (?P<obsc>BR|FG|FU|VA|DU|SA|HZ|PY)?
    119. 

  119.                               (?P<other>PO|SQ|FC|SS|DS)?\s+""",
    120. 

  120.                               re.VERBOSE)
    121. 

  121. WINDSHEAR_RE = re.compile(r"^(WS\s+)?(ALL\s+RWY|RWY(?P<name>\d\d(RR?|L?|C)?))\s+")
    122. 

  122. COLOR_RE = re.compile(r"""^(BLACK)?(BLU|GRN|WHT|RED)\+?
    123. 

  123.                         (/?(BLACK)?(BLU|GRN|WHT|RED)\+?)*\s*""",
    124. 

  124.                         re.VERBOSE)
    125. 

  125. RUNWAYSTATE_RE = re.compile(r"""((?P<name>\d\d) | R(?P<namenew>\d\d)(RR?|LL?|C)?/?)
    126. 

  126.                                 ((?P<special> SNOCLO|CLRD(\d\d|//)) |
    127. 

  127.                                  (?P<deposit>(\d|/))
    128. 

  128.                                  (?P<extent>(\d|/))
    129. 

  129.                                  (?P<depth>(\d\d|//))
    130. 

  130.                                  (?P<friction>(\d\d|//)))\s+""",
    131. 

  131.                              re.VERBOSE)
    132. 

  132. TREND_RE = re.compile(r"^(?P<trend>TEMPO|BECMG|FCST|NOSIG)\s+")
    133. 

  133. 

  134. TRENDTIME_RE = re.compile(r"(?P<when>(FM|TL|AT))(?P<hour>\d\d)(?P<min>\d\d)\s+")
    135. 

  135. 

  136. REMARK_RE = re.compile(r"^(RMKS?|NOSPECI|NOSIG)\s+")
    137. 

  137. 

  138. ## regular expressions for remark groups
    139. 

  139. 

  140. AUTO_RE = re.compile(r"^AO(?P<type>\d)\s+")
    141. 

  141. SEALVL_PRESS_RE = re.compile(r"^SLP(?P<press>\d\d\d)\s+")
    142. 

  142. PEAK_WIND_RE = re.compile(r"""^P[A-Z]\s+WND\s+
    143. 

  143.                                (?P<dir>\d\d\d)
    144. 

  144.                                (?P<speed>P?\d\d\d?)/
    145. 

  145.                                (?P<hour>\d\d)?
    146. 

  146.                                (?P<min>\d\d)\s+""",
    147. 

  147.                                re.VERBOSE)
    148. 

  148. WIND_SHIFT_RE = re.compile(r"""^WSHFT\s+
    149. 

  149.                                 (?P<hour>\d\d)?
    150. 

  150.                                 (?P<min>\d\d)
    151. 

  151.                                 (\s+(?P<front>FROPA))?\s+""",
    152. 

  152.                                 re.VERBOSE)
    153. 

  153. PRECIP_1HR_RE = re.compile(r"^P(?P<precip>\d\d\d\d)\s+")
    154. 

  154. PRECIP_24HR_RE = re.compile(r"""^(?P<type>6|7)
    155. 

  155.                                  (?P<precip>\d\d\d\d)\s+""",
    156. 

  156.                                  re.VERBOSE)
    157. 

  157. PRESS_3HR_RE = re.compile(r"""^5(?P<tend>[0-8])
    158. 

  158.                                 (?P<press>\d\d\d)\s+""",
    159. 

  159.                                 re.VERBOSE)
    160. 

  160. TEMP_1HR_RE = re.compile(r"""^T(?P<tsign>0|1)
    161. 

  161.                                (?P<temp>\d\d\d)
    162. 

  162.                                ((?P<dsign>0|1)
    163. 

  163.                                (?P<dewpt>\d\d\d))?\s+""",
    164. 

  164.                                re.VERBOSE)
    165. 

  165. TEMP_6HR_RE = re.compile(r"""^(?P<type>1|2)
    166. 

  166.                               (?P<sign>0|1)
    167. 

  167.                               (?P<temp>\d\d\d)\s+""",
    168. 

  168.                               re.VERBOSE)
    169. 

  169. TEMP_24HR_RE = re.compile(r"""^4(?P<smaxt>0|1)
    170. 

  170.                                 (?P<maxt>\d\d\d)
    171. 

  171.                                 (?P<smint>0|1)
    172. 

  172.                                 (?P<mint>\d\d\d)\s+""",
    173. 

  173.                                 re.VERBOSE)
    174. 

  174. UNPARSED_RE = re.compile(r"(?P<group>\S+)\s+")
    175. 

  175. 

  176. LIGHTNING_RE = re.compile(r"""^((?P<freq>OCNL|FRQ|CONS)\s+)?
    177. 

  177.                              LTG(?P<type>(IC|CC|CG|CA)*)
    178. 

  178.                                 ( \s+(?P<loc>( OHD | VC | DSNT\s+ | \s+AND\s+ | 
    179. 

  179.                                  [NSEW][EW]? (-[NSEW][EW]?)* )+) )?\s+""",
    180. 

  180.                                 re.VERBOSE)
    181. 

  181.                                                   
    182. 

  182. TS_LOC_RE = re.compile(r"""TS(\s+(?P<loc>( OHD | VC | DSNT\s+ | \s+AND\s+ | 
    183. 

  183.                                            [NSEW][EW]? (-[NSEW][EW]?)* )+))?
    184. 

  184.                                           ( \s+MOV\s+(?P<dir>[NSEW][EW]?) )?\s+""",
    185. 

  185.                            re.VERBOSE)
    186. 

  186. 

  187. ## translation of weather location codes
    188. 

  188. 

  189. loc_terms = [ ("OHD", "overhead"), 
    190. 

  190.               ("DSNT", "distant"),
    191. 

  191.               ("AND", "and"),
    192. 

  192.               ("VC", "nearby") ]
    193. 

  193.                           
    194. 

  194. def xlate_loc( loc ):
    195. 

  195.   """Substitute English terms for the location codes in the given string."""
    196. 

  196.   for code, english in loc_terms:
    197. 

  197.       loc = loc.replace(code,english)
    198. 

  198.   return loc
    199. 

  199.   
    200. 

  200. ## translation of the sky-condition codes into english
    201. 

  201. 

  202. SKY_COVER = { "SKC":"clear",
    203. 

  203.               "CLR":"clear",
    204. 

  204.               "NSC":"clear",
    205. 

  205.               "NCD":"clear",
    206. 

  206.               "FEW":"a few ",
    207. 

  207.               "SCT":"scattered ",
    208. 

  208.               "BKN":"broken ",
    209. 

  209.               "OVC":"overcast",
    210. 

  210.               "///":"",
    211. 

  211.               "VV":"indefinite ceiling" }
    212. 

  212.                           
    213. 

  213. CLOUD_TYPE = { "TCU":"towering cumulus",
    214. 

  214.                "CU":"cumulus",
    215. 

  215.                "CB":"cumulonimbus",
    216. 

  216.                "SC":"stratocumulus",
    217. 

  217.                "CBMAM":"cumulonimbus mammatus",
    218. 

  218.                "ACC":"altocumulus castellanus",
    219. 

  219.                "SCSL":"standing lenticular stratocumulus",
    220. 

  220.                "CCSL":"standing lenticular cirrocumulus",
    221. 

  221.                "ACSL":"standing lenticular altocumulus" }
    222. 

  222.                               
    223. 

  223. ## translation of the present-weather codes into english
    224. 

  224. 

  225. WEATHER_INT = { "-":"light", 
    226. 

  226.                 "+":"heavy", 
    227. 

  227.                 "-VC":"nearby light", 
    228. 

  228.                 "+VC":"nearby heavy", 
    229. 

  229.                 "VC":"nearby" }
    230. 

  230. WEATHER_DESC = { "MI":"shallow",
    231. 

  231.                  "PR":"partial",
    232. 

  232.                  "BC":"patches of", 
    233. 

  233.                  "DR":"low drifting", 
    234. 

  234.                  "BL":"blowing",
    235. 

  235.                  "SH":"showers",
    236. 

  236.                  "TS":"thunderstorm",
    237. 

  237.                  "FZ":"freezing" }
    238. 

  238. WEATHER_PREC = { "DZ":"drizzle",
    239. 

  239.                  "RA":"rain",
    240. 

  240.                  "SN":"snow",
    241. 

  241.                  "SG":"snow grains",
    242. 

  242.                  "IC":"ice crystals",
    243. 

  243.                  "PL":"ice pellets",
    244. 

  244.                  "GR":"hail",
    245. 

  245.                  "GS":"snow pellets",
    246. 

  246.                  "UP":"unknown precipitation",
    247. 

  247.                  "//":"" }
    248. 

  248. WEATHER_OBSC = { "BR":"mist",
    249. 

  249.                  "FG":"fog",
    250. 

  250.                  "FU":"smoke",
    251. 

  251.                  "VA":"volcanic ash",
    252. 

  252.                  "DU":"dust",
    253. 

  253.                  "SA":"sand",
    254. 

  254.                  "HZ":"haze",
    255. 

  255.                  "PY":"spray" }
    256. 

  256. WEATHER_OTHER = { "PO":"sand whirls",
    257. 

  257.                   "SQ":"squalls",
    258. 

  258.                   "FC":"funnel cloud",
    259. 

  259.                   "SS":"sandstorm",
    260. 

  260.                   "DS":"dust storm" }
    261. 

  261. 

  262. WEATHER_SPECIAL = { "+FC":"tornado" }
    263. 

  263. 

  264. COLOR = { "BLU":"blue",
    265. 

  265.           "GRN":"green",
    266. 

  266.           "WHT":"white" }
    267. 

  267.                   
    268. 

  268. ## translation of various remark codes into English
    269. 

  269.               
    270. 

  270. PRESSURE_TENDENCY = { "0":"increasing, then decreasing",
    271. 

  271.                       "1":"increasing more slowly",
    272. 

  272.                       "2":"increasing",        
    273. 

  273.                       "3":"increasing more quickly",
    274. 

  274.                       "4":"steady",
    275. 

  275.                       "5":"decreasing, then increasing",
    276. 

  276.                       "6":"decreasing more slowly",
    277. 

  277.                       "7":"decreasing",
    278. 

  278.                       "8":"decreasing more quickly" }
    279. 

  279. 

  280. LIGHTNING_FREQUENCY = { "OCNL":"occasional",
    281. 

  281.                         "FRQ":"frequent",
    282. 

  282.                         "CONS":"constant" }
    283. 

  283. LIGHTNING_TYPE = { "IC":"intracloud",
    284. 

  284.                    "CC":"cloud-to-cloud",
    285. 

  285.                    "CG":"cloud-to-ground",
    286. 

  286.                    "CA":"cloud-to-air" }
    287. 

  287. 

  288. REPORT_TYPE = { "METAR":"routine report",
    289. 

  289.                 "SPECI":"special report",
    290. 

  290.                 "AUTO":"automatic report",
    291. 

  291.                 "COR":"manually corrected report" }
    292. 

  292. 

  293. ## Helper functions
    294. 

  294. 

  295. def _report_match(handler,match):
    296. 

  296.   """Report success or failure of the given handler function. (DEBUG)"""
    297. 

  297.   if match:
    298. 

  298.       print handler.__name__," matched '"+match+"'"
    299. 

  299.   else:
    300. 

  300.       print handler.__name__," didn't match..."
    301. 

  301.       
    302. 

  302. def _unparsedGroup( self, d ):
    303. 

  303.     """
    304. 

  304.     Handle otherwise unparseable main-body groups.
    305. 

  305.     """
    306. 

  306.     self._unparsed_groups.append(d['group'])
    307. 

  307.       
    308. 

  308. ## METAR report objects
    309. 

  309. 

  310. debug = False
    311. 

  311. 

  312. class Metar(object):
    313. 

  313.   """METAR (aviation meteorology report)"""
    314. 

  314.   
    315. 

  315.   def __init__( self, metarcode, month=None, year=None, utcdelta=None):
    316. 

  316.       """Parse raw METAR code."""
    317. 

  317.       self.code = metarcode              # original METAR code
    318. 

  318.       self.type = 'METAR'                # METAR (routine) or SPECI (special)
    319. 

  319.       self.mod = "AUTO"                  # AUTO (automatic) or COR (corrected)
    320. 

  320.       self.station_id = None             # 4-character ICAO station code
    321. 

  321.       self.time = None                   # observation time [datetime]
    322. 

  322.       self.cycle = None                  # observation cycle (0-23) [int]
    323. 

  323.       self.wind_dir = None               # wind direction [direction]
    324. 

  324.       self.wind_speed = None             # wind speed [speed]
    325. 

  325.       self.wind_gust = None              # wind gust speed [speed]
    326. 

  326.       self.wind_dir_from = None          # beginning of range for win dir [direction]
    327. 

  327.       self.wind_dir_to = None            # end of range for wind dir [direction]
    328. 

  328.       self.vis = None                    # visibility [distance]
    329. 

  329.       self.vis_dir = None                # visibility direction [direction]
    330. 

  330.       self.max_vis = None                # visibility [distance]
    331. 

  331.       self.max_vis_dir = None            # visibility direction [direction]
    332. 

  332.       self.temp = None                   # temperature (C) [temperature]
    333. 

  333.       self.dewpt = None                  # dew point (C) [temperature]
    334. 

  334.       self.press = None                  # barometric pressure [pressure]
    335. 

  335.       self.runway = []                   # runway visibility (list of tuples)
    336. 

  336.       self.weather = []                  # present weather (list of tuples)
    337. 

  337.       self.recent = []                   # recent weather (list of tuples)
    338. 

  338.       self.sky = []                      # sky conditions (list of tuples)
    339. 

  339.       self.windshear = []                # runways w/ wind shear (list of strings)
    340. 

  340.       self.wind_speed_peak = None        # peak wind speed in last hour
    341. 

  341.       self.wind_dir_peak = None          # direction of peak wind speed in last hour
    342. 

  342.       self.peak_wind_time = None         # time of peak wind observation [datetime]
    343. 

  343.       self.wind_shift_time = None        # time of wind shift [datetime]
    344. 

  344.       self.max_temp_6hr = None           # max temp in last 6 hours
    345. 

  345.       self.min_temp_6hr = None           # min temp in last 6 hours
    346. 

  346.       self.max_temp_24hr = None          # max temp in last 24 hours
    347. 

  347.       self.min_temp_24hr = None          # min temp in last 24 hours
    348. 

  348.       self.press_sea_level = None        # sea-level pressure
    349. 

  349.       self.precip_1hr = None             # precipitation over the last hour
    350. 

  350.       self.precip_3hr = None             # precipitation over the last 3 hours
    351. 

  351.       self.precip_6hr = None             # precipitation over the last 6 hours
    352. 

  352.       self.precip_24hr = None            # precipitation over the last 24 hours
    353. 

  353.       self._trend = False                # trend groups present (bool)
    354. 

  354.       self._trend_groups = []            # trend forecast groups
    355. 

  355.       self._remarks = []                 # remarks (list of strings)
    356. 

  356.       self._unparsed_groups = []
    357. 

  357.       self._unparsed_remarks = []
    358. 

  358.       
    359. 

  359.       self._now = datetime.datetime.utcnow()
    360. 

  360.       if utcdelta:
    361. 

  361.           self._utcdelta = utcdelta
    362. 

  362.       else:
    363. 

  363.           self._utcdelta = datetime.datetime.now() - self._now
    364. 

  364. 

  365.       self._month = month
    366. 

  366.       self._year = year
    367. 

  367.       
    368. 

  368.       code = self.code+" "    # (the regexps all expect trailing spaces...)
    369. 

  369.       try:
    370. 

  370.           ngroup = len(Metar.handlers)
    371. 

  371.           igroup = 0
    372. 

  372.           ifailed = -1
    373. 

  373.           while igroup < ngroup and code: 
    374. 

  374.               pattern, handler, repeatable = Metar.handlers[igroup]
    375. 

  375.               if debug: print handler.__name__,":",code
    376. 

  376.               m = pattern.match(code)
    377. 

  377.               while m:
    378. 

  378.                   ifailed = -1
    379. 

  379.                   if debug: _report_match(handler,m.group())
    380. 

  380.                   handler(self,m.groupdict())
    381. 

  381.                   code = code[m.end():]
    382. 

  382.                   if self._trend:
    383. 

  383.                       code = self._do_trend_handlers(code)
    384. 

  384.                   if not repeatable: break
    385. 

  385.                   
    386. 

  386.                   if debug: print handler.__name__,":",code
    387. 

  387.                   m = pattern.match(code)
    388. 

  388.               if not m and ifailed < 0:
    389. 

  389.                   ifailed = igroup
    390. 

  390.               igroup += 1
    391. 

  391.               if igroup == ngroup and not m:
    392. 

  392.                   # print "** it's not a main-body group **"
    393. 

  393.                   pattern, handler = (UNPARSED_RE, _unparsedGroup)
    394. 

  394.                   if debug: print handler.__name__,":",code
    395. 

  395.                   m = pattern.match(code)
    396. 

  396.                   if debug: _report_match(handler,m.group())
    397. 

  397.                   handler(self,m.groupdict())
    398. 

  398.                   code = code[m.end():]
    399. 

  399.                   igroup = ifailed
    400. 

  400.                   ifailed = -2  # if it's still -2 when we run out of main-body
    401. 

  401.                                 #  groups, we'll try parsing this group as a remark
    402. 

  402.           if pattern == REMARK_RE or self.press:
    403. 

  403.               while code:
    404. 

  404.                   for pattern, handler in Metar.remark_handlers:
    405. 

  405.                       if debug: print handler.__name__,":",code
    406. 

  406.                       m = pattern.match(code)
    407. 

  407.                       if m:
    408. 

  408.                           if debug: _report_match(handler,m.group())
    409. 

  409.                           handler(self,m.groupdict())
    410. 

  410.                           code = pattern.sub("",code,1)
    411. 

  411.                           break
    412. 

  412. 

  413.       except Exception, err:
    414. 

  414.           raise ParserError(handler.__name__+" failed while processing '"+code+"'\n"+string.join(err.args))
    415. 

  415.           raise err
    416. 

  416.       if self._unparsed_groups:
    417. 

  417.           code = ' '.join(self._unparsed_groups)
    418. 

  418.           raise ParserError("Unparsed groups in body: "+code)
    419. 

  419. 

  420.   def _do_trend_handlers(self, code):
    421. 

  421.       for pattern, handler, repeatable in Metar.trend_handlers:
    422. 

  422.           if debug: print handler.__name__,":",code
    423. 

  423.           m = pattern.match(code)
    424. 

  424.           while m:
    425. 

  425.               if debug: _report_match(handler, m.group())
    426. 

  426.               self._trend_groups.append(string.strip(m.group()))
    427. 

  427.               handler(self,m.groupdict())
    428. 

  428.               code = code[m.end():]
    429. 

  429.               if not repeatable: break
    430. 

  430.               m = pattern.match(code)
    431. 

  431.       return code
    432. 

  432.                   
    433. 

  433.   def __str__(self):
    434. 

  434.       return self.string()
    435. 

  435. 

  436.   def _handleType( self, d ):
    437. 

  437.       """
    438. 

  438.       Parse the code-type group.
    439. 

  439.       
    440. 

  440.       The following attributes are set:
    441. 

  441.           type   [string]
    442. 

  442.       """
    443. 

  443.       self.type = d['type'] 
    444. 

  444.           
    445. 

  445.   def _handleStation( self, d ):
    446. 

  446.       """
    447. 

  447.       Parse the station id group.
    448. 

  448.       
    449. 

  449.       The following attributes are set:
    450. 

  450.           station_id   [string]
    451. 

  451.       """
    452. 

  452.       self.station_id = d['station'] 
    453. 

  453.           
    454. 

  454.   def _handleModifier( self, d ):
    455. 

  455.       """
    456. 

  456.       Parse the report-modifier group.
    457. 

  457.       
    458. 

  458.       The following attributes are set:
    459. 

  459.           mod   [string]
    460. 

  460.       """
    461. 

  461.       mod = d['mod'] 
    462. 

  462.       if mod == 'CORR': mod = 'COR'
    463. 

  463.       if mod == 'NIL' or mod == 'FINO': mod = 'NO DATA'
    464. 

  464.       self.mod = mod
    465. 

  465.                           
    466. 

  466.   def _handleTime( self, d ):
    467. 

  467.       """
    468. 

  468.       Parse the observation-time group.
    469. 

  469.       
    470. 

  470.       The following attributes are set:
    471. 

  471.           time   [datetime]
    472. 

  472.           cycle  [int]
    473. 

  473.           _day   [int]
    474. 

  474.           _hour  [int]
    475. 

  475.           _min   [int]
    476. 

  476.       """
    477. 

  477.       self._day = int(d['day'])
    478. 

  478.       if not self._month: 
    479. 

  479.           self._month = self._now.month
    480. 

  480.           if self._day > self._now.day: 
    481. 

  481.               if self._month == 1:
    482. 

  482.                   self._month = 12
    483. 

  483.               else:
    484. 

  484.                   self._month = self._month - 1
    485. 

  485.       if not self._year:
    486. 

  486.           self._year = self._now.year
    487. 

  487.           if self._month > self._now.month:
    488. 

  488.               self._year = self._year - 1
    489. 

  489.           elif self._month == self._now.month and self._day > self._now.day:
    490. 

  490.               self._year = self._year - 1
    491. 

  491.       self._hour = int(d['hour'])
    492. 

  492.       self._min = int(d['min'])
    493. 

  493.       self.time = datetime.datetime(self._year, self._month, self._day,
    494. 

  494.                                                                   self._hour, self._min)
    495. 

  495.       if self._min < 45:
    496. 

  496.           self.cycle = self._hour
    497. 

  497.       else:
    498. 

  498.           self.cycle = self._hour+1
    499. 

  499.                           
    500. 

  500.   def _handleWind( self, d ):
    501. 

  501.       """
    502. 

  502.       Parse the wind and variable-wind groups.
    503. 

  503.       
    504. 

  504.       The following attributes are set:
    505. 

  505.           wind_dir           [direction]
    506. 

  506.           wind_speed         [speed]
    507. 

  507.           wind_gust          [speed]
    508. 

  508.           wind_dir_from      [int]
    509. 

  509.           wind_dir_to        [int]
    510. 

  510.       """
    511. 

  511.       wind_dir = d['dir'].replace('O','0')
    512. 

  512.       if wind_dir != "VRB" and wind_dir != "///" and wind_dir != "MMM":
    513. 

  513.           self.wind_dir = direction(wind_dir)    
    514. 

  514.       wind_speed = d['speed'].replace('O','0')
    515. 

  515.       units = d['units']
    516. 

  516.       if units == 'KTS' or units == 'K' or units == 'T' or units == 'LT': 
    517. 

  517.           units = 'KT'
    518. 

  518.       if wind_speed.startswith("P"):
    519. 

  519.           self.wind_speed = speed(wind_speed[1:], units, ">")
    520. 

  520.       elif not MISSING_RE.match(wind_speed):
    521. 

  521.           self.wind_speed = speed(wind_speed, units)
    522. 

  522.       if d['gust']:
    523. 

  523.           wind_gust = d['gust']
    524. 

  524.           if wind_gust.startswith("P"):
    525. 

  525.               self.wind_gust = speed(wind_gust[1:], units, ">")
    526. 

  526.           elif not MISSING_RE.match(wind_gust):
    527. 

  527.               self.wind_gust = speed(wind_gust, units)
    528. 

  528.       if d['varfrom']:
    529. 

  529.           self.wind_dir_from = direction(d['varfrom'])
    530. 

  530.           self.wind_dir_to = direction(d['varto'])      
    531. 

  531.       
    532. 

  532.   def _handleVisibility( self, d ):
    533. 

  533.       """
    534. 

  534.       Parse the minimum and maximum visibility groups.
    535. 

  535.        
    536. 

  536.       The following attributes are set:
    537. 

  537.           vis          [distance]
    538. 

  538.           vis_dir      [direction]
    539. 

  539.           max_vis      [distance]
    540. 

  540.           max_vis_dir  [direction]
    541. 

  541.       """
    542. 

  542.       vis = d['vis']
    543. 

  543.       vis_less = None
    544. 

  544.       vis_dir = None
    545. 

  545.       vis_units = "M"
    546. 

  546.       vis_dist = "10000"
    547. 

  547.       if d['dist'] and d['dist'] != '////':
    548. 

  548.           vis_dist = d['dist']
    549. 

  549.           if d['dir'] and d['dir'] != 'NDV':
    550. 

  550.               vis_dir = d['dir']    
    551. 

  551.       elif d['distu']:
    552. 

  552.           vis_dist = d['distu']
    553. 

  553.           if d['units'] and d['units'] != "U":
    554. 

  554.                   vis_units = d['units']
    555. 

  555.       if vis_dist == "9999":
    556. 

  556.           vis_dist = "10000"
    557. 

  557.           vis_less = ">"
    558. 

  558.       if self.vis:
    559. 

  559.           if vis_dir:
    560. 

  560.               self.max_vis_dir = direction(vis_dir)
    561. 

  561.           self.max_vis = distance(vis_dist, vis_units, vis_less)
    562. 

  562.       else:
    563. 

  563.           if vis_dir:
    564. 

  564.               self.vis_dir = direction(vis_dir)
    565. 

  565.           self.vis = distance(vis_dist, vis_units, vis_less)
    566. 

  566.                           
    567. 

  567.   def _handleRunway( self, d ):
    568. 

  568.       """
    569. 

  569.       Parse a runway visual range group.
    570. 

  570.       
    571. 

  571.       The following attributes are set:
    572. 

  572.           range   [list of tuples]
    573. 

  573.           . name  [string]
    574. 

  574.           . low   [distance]
    575. 

  575.           . high  [distance]
    576. 

  576.       """
    577. 

  577.       if d['name']:
    578. 

  578.           name = d['name']
    579. 

  579.           low = distance(d['low'])
    580. 

  580.           if d['high']:
    581. 

  581.               high = distance(d['high'])
    582. 

  582.           else:
    583. 

  583.               high = low
    584. 

  584.           self.runway.append((name,low,high))
    585. 

  585.                           
    586. 

  586.   def _handleWeather( self, d ):
    587. 

  587.       """
    588. 

  588.       Parse a present-weather group.
    589. 

  589.       
    590. 

  590.       The following attributes are set:
    591. 

  591.           weather    [list of tuples]
    592. 

  592.           .  intensity     [string]
    593. 

  593.           .  description   [string]
    594. 

  594.           .  precipitation [string]
    595. 

  595.           .  obscuration   [string]
    596. 

  596.           .  other         [string]
    597. 

  597.       """
    598. 

  598.       inteni = d['int']
    599. 

  599.       if not inteni and d['int2']:
    600. 

  600.           inteni = d['int2']
    601. 

  601.       desci = d['desc']
    602. 

  602.       preci = d['prec']
    603. 

  603.       obsci = d['obsc']
    604. 

  604.       otheri = d['other']
    605. 

  605.       self.weather.append((inteni,desci,preci,obsci,otheri))
    606. 

  606.                           
    607. 

  607.   def _handleSky( self, d ):
    608. 

  608.       """
    609. 

  609.       Parse a sky-conditions group.
    610. 

  610.       
    611. 

  611.       The following attributes are set:
    612. 

  612.           sky        [list of tuples]
    613. 

  613.           .  cover   [string]
    614. 

  614.           .  height  [distance]
    615. 

  615.           .  cloud   [string]
    616. 

  616.       """
    617. 

  617.       height = d['height']
    618. 

  618.       if not height or height == "///":
    619. 

  619.           height = None
    620. 

  620.       else:
    621. 

  621.           height = height.replace('O','0')
    622. 

  622.           height = distance(int(height)*100,"FT")
    623. 

  623.       cover = d['cover']
    624. 

  624.       if cover == 'SCK' or cover == 'SKC' or cover == 'CL': cover = 'CLR'
    625. 

  625.       if cover == '0VC': cover = 'OVC'
    626. 

  626.       cloud = d['cloud']
    627. 

  627.       if cloud == '///': cloud = ""
    628. 

  628.       self.sky.append((cover,height,cloud))
    629. 

  629.                           
    630. 

  630.   def _handleTemp( self, d ):
    631. 

  631.       """
    632. 

  632.       Parse a temperature-dewpoint group.
    633. 

  633.       
    634. 

  634.       The following attributes are set:
    635. 

  635.           temp    temperature (Celsius) [float]
    636. 

  636.           dewpt   dew point (Celsius) [float]
    637. 

  637.       """
    638. 

  638.       temp = d['temp']
    639. 

  639.       dewpt = d['dewpt']
    640. 

  640.       if  temp and temp != "//" and temp != "XX" and temp != "MM" :
    641. 

  641.           self.temp = temperature(temp)
    642. 

  642.       if dewpt and dewpt != "//" and dewpt != "XX" and dewpt != "MM" :
    643. 

  643.           self.dewpt = temperature(dewpt)
    644. 

  644.       
    645. 

  645.   def _handlePressure( self, d ):
    646. 

  646.       """
    647. 

  647.       Parse an altimeter-pressure group.
    648. 

  648.       
    649. 

  649.       The following attributes are set:
    650. 

  650.           press    [int]
    651. 

  651.       """
    652. 

  652.       press = d['press']
    653. 

  653.       if press != '////':
    654. 

  654.           press = float(press.replace('O','0'))
    655. 

  655.           if d['unit']:
    656. 

  656.               if d['unit'] == 'A' or (d['unit2'] and d['unit2'] == 'INS'):
    657. 

  657.                   self.press = pressure(press/100,'IN')
    658. 

  658.               elif d['unit'] == 'SLP':
    659. 

  659.                   if press < 500:
    660. 

  660.                       press = press/10 + 1000
    661. 

  661.                   else:
    662. 

  662.                       press = press/10 + 900
    663. 

  663.                   self.press = pressure(press,'MB')
    664. 

  664.                   self._remarks.append("sea-level pressure %.1fhPa" % press)
    665. 

  665.               else:
    666. 

  666.                   self.press = pressure(press,'MB')
    667. 

  667.           elif press > 2500:
    668. 

  668.               self.press = pressure(press/100,'IN')
    669. 

  669.           else:
    670. 

  670.               self.press = pressure(press,'MB')
    671. 

  671.                           
    672. 

  672.   def _handleRecent( self, d ):
    673. 

  673.       """
    674. 

  674.       Parse a recent-weather group.
    675. 

  675.       
    676. 

  676.       The following attributes are set:
    677. 

  677.           weather    [list of tuples]
    678. 

  678.           .  intensity     [string]
    679. 

  679.           .  description   [string]
    680. 

  680.           .  precipitation [string]
    681. 

  681.           .  obscuration   [string]
    682. 

  682.           .  other         [string]
    683. 

  683.       """
    684. 

  684.       desci = d['desc']
    685. 

  685.       preci = d['prec']
    686. 

  686.       obsci = d['obsc']
    687. 

  687.       otheri = d['other']
    688. 

  688.       self.recent.append(("",desci,preci,obsci,otheri))
    689. 

  689.       
    690. 

  690.   def _handleWindShear( self, d ):
    691. 

  691.       """
    692. 

  692.       Parse wind-shear groups.
    693. 

  693.       
    694. 

  694.       The following attributes are set:
    695. 

  695.           windshear    [list of strings]
    696. 

  696.       """
    697. 

  697.       if d['name']:
    698. 

  698.           self.windshear.append(d['name'])
    699. 

  699.       else:
    700. 

  700.           self.windshear.append("ALL")
    701. 

  701.       
    702. 

  702.   def _handleColor( self, d ):
    703. 

  703.       """
    704. 

  704.       Parse (and ignore) the color groups.
    705. 

  705.       
    706. 

  706.       The following attributes are set:
    707. 

  707.           trend    [list of strings]
    708. 

  708.       """
    709. 

  709.       pass
    710. 

  710.  
    711. 

  711.   def _handleRunwayState( self, d ):
    712. 

  712.       """
    713. 

  713.       Parse (and ignore) the runway state.
    714. 

  714. 

  715.       The following attributes are set:
    716. 

  716.       """
    717. 

  717.       pass
    718. 

  718. 

  719.   def _handleTrend( self, d ):
    720. 

  720.       """
    721. 

  721.       Parse (and ignore) the trend groups.
    722. 

  722.       """
    723. 

  723.       if d.has_key('trend'):
    724. 

  724.           self._trend_groups.append(d['trend'])
    725. 

  725.       self._trend = True
    726. 

  726.       
    727. 

  727.   def _startRemarks( self, d ):
    728. 

  728.       """
    729. 

  729.       Found the start of the remarks section.
    730. 

  730.       """
    731. 

  731.       self._remarks = []
    732. 

  732.       
    733. 

  733.   def _handleSealvlPressRemark( self, d ):
    734. 

  734.       """
    735. 

  735.       Parse the sea-level pressure remark group.
    736. 

  736.       """
    737. 

  737.       value = float(d['press'])/10.0
    738. 

  738.       if value < 50: 
    739. 

  739.           value += 1000
    740. 

  740.       else: 
    741. 

  741.           value += 900
    742. 

  742.       if not self.press:
    743. 

  743.           self.press = pressure(value,"MB")
    744. 

  744.       self.press_sea_level = pressure(value,"MB")
    745. 

  745.               
    746. 

  746.   def _handlePrecip24hrRemark( self, d ):
    747. 

  747.       """
    748. 

  748.       Parse a 3-, 6- or 24-hour cumulative preciptation remark group.
    749. 

  749.       """
    750. 

  750.       value = float(d['precip'])/100.0
    751. 

  751.       if d['type'] == "6":
    752. 

  752.           if self.cycle == 3 or self.cycle == 9 or self.cycle == 15 or self.cycle == 21:
    753. 

  753.               self.precip_3hr = precipitation(value,"IN")
    754. 

  754.           else:
    755. 

  755.               self.precip_6hr = precipitation(value,"IN")
    756. 

  756.       else:
    757. 

  757.           self.precip_24hr = precipitation(value,"IN")
    758. 

  758.               
    759. 

  759.   def _handlePrecip1hrRemark( self, d ):
    760. 

  760.       """Parse an hourly precipitation remark group."""
    761. 

  761.       value = float(d['precip'])/100.0
    762. 

  762.       self.precip_1hr = precipitation(value,"IN")
    763. 

  763.                               
    764. 

  764.   def _handleTemp1hrRemark( self, d ):
    765. 

  765.       """
    766. 

  766.       Parse a temperature & dewpoint remark group.
    767. 

  767.       
    768. 

  768.       These values replace the temp and dewpt from the body of the report.
    769. 

  769.       """
    770. 

  770.       value = float(d['temp'])/10.0
    771. 

  771.       if d['tsign'] == "1": value = -value
    772. 

  772.       self.temp = temperature(value)
    773. 

  773.       if d['dewpt']:
    774. 

  774.           value2 = float(d['dewpt'])/10.0
    775. 

  775.           if d['dsign'] == "1": value2 = -value2
    776. 

  776.           self.dewpt = temperature(value2)
    777. 

  777.                               
    778. 

  778.   def _handleTemp6hrRemark( self, d ):
    779. 

  779.       """
    780. 

  780.       Parse a 6-hour maximum or minimum temperature remark group.
    781. 

  781.       """
    782. 

  782.       value = float(d['temp'])/10.0
    783. 

  783.       if d['sign'] == "1": value = -value
    784. 

  784.       if d['type'] == "1":
    785. 

  785.           self.max_temp_6hr = temperature(value,"C")
    786. 

  786.       else:
    787. 

  787.           self.min_temp_6hr = temperature(value,"C")
    788. 

  788.       
    789. 

  789.   def _handleTemp24hrRemark( self, d ):
    790. 

  790.       """
    791. 

  791.       Parse a 24-hour maximum/minimum temperature remark group.
    792. 

  792.       """
    793. 

  793.       value = float(d['maxt'])/10.0
    794. 

  794.       if d['smaxt'] == "1": value = -value
    795. 

  795.       value2 = float(d['mint'])/10.0
    796. 

  796.       if d['smint'] == "1": value2 = -value2
    797. 

  797.       self.max_temp_24hr = temperature(value,"C")
    798. 

  798.       self.min_temp_24hr = temperature(value2,"C")
    799. 

  799.                       
    800. 

  800.   def _handlePress3hrRemark( self, d ):
    801. 

  801.       """
    802. 

  802.       Parse a pressure-tendency remark group.
    803. 

  803.       """
    804. 

  804.       value = float(d['press'])/10.0
    805. 

  805.       descrip = PRESSURE_TENDENCY[d['tend']]
    806. 

  806.       self._remarks.append("3-hr pressure change %.1fhPa, %s" % (value,descrip))
    807. 

  807.           
    808. 

  808.   def _handlePeakWindRemark( self, d ):
    809. 

  809.       """
    810. 

  810.       Parse a peak wind remark group.
    811. 

  811.       """
    812. 

  812.       peak_dir = int(d['dir'])
    813. 

  813.       peak_speed = int(d['speed'])
    814. 

  814.       self.wind_speed_peak = speed(peak_speed, "KT")
    815. 

  815.       self.wind_dir_peak = direction(peak_dir)
    816. 

  816.       peak_min = int(d['min'])
    817. 

  817.       if d['hour']:
    818. 

  818.           peak_hour = int(d['hour'])
    819. 

  819.       else:
    820. 

  820.           peak_hour = self._hour
    821. 

  821.       self.peak_wind_time = datetime.datetime(self._year, self._month, self._day,
    822. 

  822.                                                                   peak_hour, peak_min)
    823. 

  823.       if self.peak_wind_time > self.time:
    824. 

  824.           if peak_hour > self._hour:
    825. 

  825.               self.peak_wind_time -= datetime.timedelta(hours=24)
    826. 

  826.           else:
    827. 

  827.               self.peak_wind_time -= datetime.timedelta(hours=1)
    828. 

  828.       self._remarks.append("peak wind %dkt from %d degrees at %d:%02d" % \
    829. 

  829.                                               (peak_speed, peak_dir, peak_hour, peak_min))
    830. 

  830.           
    831. 

  831.   def _handleWindShiftRemark( self, d ):
    832. 

  832.       """
    833. 

  833.       Parse a wind shift remark group.
    834. 

  834.       """
    835. 

  835.       if d['hour']:
    836. 

  836.           wshft_hour = int(d['hour'])
    837. 

  837.       else:
    838. 

  838.           wshft_hour = self._hour
    839. 

  839.       wshft_min = int(d['min'])
    840. 

  840.       self.wind_shift_time = datetime.datetime(self._year, self._month, self._day,
    841. 

  841.                                                                   wshft_hour, wshft_min)
    842. 

  842.       if self.wind_shift_time > self.time:
    843. 

  843.           if wshft_hour > self._hour:
    844. 

  844.               self.wind_shift_time -= datetime.timedelta(hours=24)
    845. 

  845.           else:
    846. 

  846.               self.wind_shift_time -= datetime.timedelta(hours=1)
    847. 

  847.       text = "wind shift at %d:%02d" %  (wshft_hour, wshft_min)
    848. 

  848.       if d['front']:
    849. 

  849.           text += " (front)"
    850. 

  850.       self._remarks.append(text)
    851. 

  851.           
    852. 

  852.   def _handleLightningRemark( self, d ):
    853. 

  853.       """
    854. 

  854.       Parse a lightning observation remark group.
    855. 

  855.       """
    856. 

  856.       parts = []
    857. 

  857.       if d['freq']:
    858. 

  858.           parts.append(LIGHTNING_FREQUENCY[d['freq']])
    859. 

  859.       parts.append("lightning")        
    860. 

  860.       if d['type']:
    861. 

  861.           ltg_types = []
    862. 

  862.           group = d['type']
    863. 

  863.           while group:
    864. 

  864.               ltg_types.append(LIGHTNING_TYPE[group[:2]])
    865. 

  865.               group = group[2:]
    866. 

  866.           parts.append("("+string.join(ltg_types,",")+")")
    867. 

  867.       if d['loc']:
    868. 

  868.           parts.append(xlate_loc(d['loc']))
    869. 

  869.       self._remarks.append(string.join(parts," "))
    870. 

  870.           
    871. 

  871.   def _handleTSLocRemark( self, d ):
    872. 

  872.       """
    873. 

  873.       Parse a thunderstorm location remark group.
    874. 

  874.       """
    875. 

  875.       text = "thunderstorm"
    876. 

  876.       if d['loc']:
    877. 

  877.           text += " "+xlate_loc(d['loc'])
    878. 

  878.       if d['dir']:
    879. 

  879.           text += " moving %s" % d['dir']
    880. 

  880.       self._remarks.append(text)
    881. 

  881.       
    882. 

  882.   def _handleAutoRemark( self, d ):
    883. 

  883.       """
    884. 

  884.       Parse an automatic station remark group.
    885. 

  885.       """
    886. 

  886.       if d['type'] == "1":
    887. 

  887.           self._remarks.append("Automated station")
    888. 

  888.       elif d['type'] == "2":
    889. 

  889.           self._remarks.append("Automated station (type 2)")
    890. 

  890.       
    891. 

  891.   def _unparsedRemark( self, d ):
    892. 

  892.       """
    893. 

  893.       Handle otherwise unparseable remark groups.
    894. 

  894.       """
    895. 

  895.       self._unparsed_remarks.append(d['group'])
    896. 

  896.       
    897. 

  897.   ## the list of handler functions to use (in order) to process a METAR report
    898. 

  898. 

  899.   handlers = [ (TYPE_RE, _handleType, False),
    900. 

  900.                (STATION_RE, _handleStation, False), 
    901. 

  901.                (TIME_RE, _handleTime, False), 
    902. 

  902.                (MODIFIER_RE, _handleModifier, False), 
    903. 

  903.                (WIND_RE, _handleWind, False), 
    904. 

  904.                (VISIBILITY_RE, _handleVisibility, True), 
    905. 

  905.                (RUNWAY_RE, _handleRunway, True), 
    906. 

  906.                (WEATHER_RE, _handleWeather, True), 
    907. 

  907.                (SKY_RE, _handleSky, True), 
    908. 

  908.                (TEMP_RE, _handleTemp, False), 
    909. 

  909.                (PRESS_RE, _handlePressure, True), 
    910. 

  910.                (RECENT_RE,_handleRecent, True), 
    911. 

  911.                (WINDSHEAR_RE, _handleWindShear, True), 
    912. 

  912.                (COLOR_RE, _handleColor, True), 
    913. 

  913.                (RUNWAYSTATE_RE, _handleRunwayState, True),
    914. 

  914.                (TREND_RE, _handleTrend, False),
    915. 

  915.                (REMARK_RE, _startRemarks, False) ]
    916. 

  916. 

  917.   trend_handlers = [ (TRENDTIME_RE, _handleTrend, True),
    918. 

  918.                      (WIND_RE, _handleTrend, True),
    919. 

  919.                      (VISIBILITY_RE, _handleTrend, True),
    920. 

  920.                      (WEATHER_RE, _handleTrend, True),
    921. 

  921.                      (SKY_RE, _handleTrend, True),
    922. 

  922.                      (COLOR_RE, _handleTrend, True)]
    923. 

  923. 

  924.   ## the list of patterns for the various remark groups, 
    925. 

  925.   ## paired with the handler functions to use to record the decoded remark.
    926. 

  926. 

  927.   remark_handlers = [ (AUTO_RE,         _handleAutoRemark),
    928. 

  928.                       (SEALVL_PRESS_RE, _handleSealvlPressRemark),
    929. 

  929.                       (PEAK_WIND_RE,    _handlePeakWindRemark),
    930. 

  930.                       (WIND_SHIFT_RE,   _handleWindShiftRemark),
    931. 

  931.                       (LIGHTNING_RE,    _handleLightningRemark),
    932. 

  932.                       (TS_LOC_RE,       _handleTSLocRemark),
    933. 

  933.                       (TEMP_1HR_RE,     _handleTemp1hrRemark),
    934. 

  934.                       (PRECIP_1HR_RE,   _handlePrecip1hrRemark),
    935. 

  935.                       (PRECIP_24HR_RE,  _handlePrecip24hrRemark),
    936. 

  936.                       (PRESS_3HR_RE,    _handlePress3hrRemark),
    937. 

  937.                       (TEMP_6HR_RE,     _handleTemp6hrRemark),
    938. 

  938.                       (TEMP_24HR_RE,    _handleTemp24hrRemark),
    939. 

  939.                       (UNPARSED_RE,     _unparsedRemark) ]
    940. 

  940.   
    941. 

  941.   ## functions that return text representations of conditions for output
    942. 

  942. 

  943.   def string( self ):
    944. 

  944.       """
    945. 

  945.       Return a human-readable version of the decoded report.
    946. 

  946.       """
    947. 

  947.       lines = []
    948. 

  948.       lines.append("station: %s" % self.station_id)
    949. 

  949.       if self.type:
    950. 

  950.           lines.append("type: %s" % self.report_type())
    951. 

  951.       if self.time:
    952. 

  952.           lines.append("time: %s" % self.time.ctime())
    953. 

  953.       if self.temp:
    954. 

  954.           lines.append("temperature: %s" % self.temp.string("C"))
    955. 

  955.       if self.dewpt:
    956. 

  956.           lines.append("dew point: %s" % self.dewpt.string("C"))
    957. 

  957.       if self.wind_speed:
    958. 

  958.           lines.append("wind: %s" % self.wind())
    959. 

  959.       if self.wind_speed_peak:
    960. 

  960.           lines.append("peak wind: %s" % self.peak_wind())
    961. 

  961.       if self.wind_shift_time:
    962. 

  962.           lines.append("wind shift: %s" % self.wind_shift())
    963. 

  963.       if self.vis:
    964. 

  964.           lines.append("visibility: %s" % self.visibility())
    965. 

  965.       if self.runway:
    966. 

  966.           lines.append("visual range: %s" % self.runway_visual_range())
    967. 

  967.       if self.press:
    968. 

  968.           lines.append("pressure: %s" % self.press.string("mb"))
    969. 

  969.       if self.weather:
    970. 

  970.           lines.append("weather: %s" % self.present_weather())
    971. 

  971.       if self.sky:
    972. 

  972.           lines.append("sky: %s" % self.sky_conditions("\n     "))
    973. 

  973.       if self.press_sea_level:
    974. 

  974.           lines.append("sea-level pressure: %s" % self.press_sea_level.string("mb"))
    975. 

  975.       if self.max_temp_6hr:
    976. 

  976.           lines.append("6-hour max temp: %s" % str(self.max_temp_6hr))
    977. 

  977.       if self.max_temp_6hr:
    978. 

  978.           lines.append("6-hour min temp: %s" % str(self.min_temp_6hr))
    979. 

  979.       if self.max_temp_24hr:
    980. 

  980.           lines.append("24-hour max temp: %s" % str(self.max_temp_24hr))
    981. 

  981.       if self.max_temp_24hr:
    982. 

  982.           lines.append("24-hour min temp: %s" % str(self.min_temp_24hr))
    983. 

  983.       if self.precip_1hr:
    984. 

  984.           lines.append("1-hour precipitation: %s" % str(self.precip_1hr))
    985. 

  985.       if self.precip_3hr:
    986. 

  986.           lines.append("3-hour precipitation: %s" % str(self.precip_3hr))
    987. 

  987.       if self.precip_6hr:
    988. 

  988.           lines.append("6-hour precipitation: %s" % str(self.precip_6hr))
    989. 

  989.       if self.precip_24hr:
    990. 

  990.           lines.append("24-hour precipitation: %s" % str(self.precip_24hr))
    991. 

  991.       if self._remarks:
    992. 

  992.           lines.append("remarks:")
    993. 

  993.           lines.append("- "+self.remarks("\n- "))
    994. 

  994.       if self._unparsed_remarks:
    995. 

  995.           lines.append("- "+' '.join(self._unparsed_remarks))
    996. 

  996.       lines.append("METAR: "+self.code)
    997. 

  997.       return string.join(lines,"\n")
    998. 

  998. 

  999.   def report_type( self ):
    1000. 

  1000.       """
    1001. 

  1001.       Return a textual description of the report type.
    1002. 

  1002.       """
    1003. 

  1003.       if self.type == None:
    1004. 

  1004.           text = "unknown report type"
    1005. 

  1005.       elif REPORT_TYPE.has_key(self.type):
    1006. 

  1006.           text  = REPORT_TYPE[self.type]
    1007. 

  1007.       else:
    1008. 

  1008.           text = self.type+" report"
    1009. 

  1009.       if self.cycle:
    1010. 

  1010.           text += ", cycle %d" % self.cycle
    1011. 

  1011.       if self.mod:
    1012. 

  1012.           if REPORT_TYPE.has_key(self.mod):
    1013. 

  1013.               text += " (%s)" % REPORT_TYPE[self.mod]
    1014. 

  1014.           else:
    1015. 

  1015.               text += " (%s)" % self.mod
    1016. 

  1016.       return text
    1017. 

  1017. 

  1018.   def wind( self, units="KT" ):
    1019. 

  1019.       """
    1020. 

  1020.       Return a textual description of the wind conditions.
    1021. 

  1021.       
    1022. 

  1022.       Units may be specified as "MPS", "KT", "KMH", or "MPH".
    1023. 

  1023.       """
    1024. 

  1024.       if self.wind_speed == None:
    1025. 

  1025.           return "missing"
    1026. 

  1026.       elif self.wind_speed.value() == 0.0:
    1027. 

  1027.           text = "calm"
    1028. 

  1028.       else:
    1029. 

  1029.           wind_speed = self.wind_speed.string(units)
    1030. 

  1030.           if not self.wind_dir:
    1031. 

  1031.               text = "variable at %s" % wind_speed
    1032. 

  1032.           elif self.wind_dir_from:
    1033. 

  1033.               text = "%s to %s at %s" % \
    1034. 

  1034.                              (self.wind_dir_from.compass(), self.wind_dir_to.compass(), wind_speed)
    1035. 

  1035.           else:
    1036. 

  1036.               text = "%s at %s" % (self.wind_dir.compass(), wind_speed)
    1037. 

  1037.           if self.wind_gust:
    1038. 

  1038.               text += ", gusting to %s" % self.wind_gust.string(units)
    1039. 

  1039.       return text
    1040. 

  1040. 

  1041.   def peak_wind( self, units="KT" ):
    1042. 

  1042.       """
    1043. 

  1043.       Return a textual description of the peak wind conditions.
    1044. 

  1044.       
    1045. 

  1045.       Units may be specified as "MPS", "KT", "KMH", or "MPH".
    1046. 

  1046.       """
    1047. 

  1047.       if self.wind_speed_peak == None:
    1048. 

  1048.           return "missing"
    1049. 

  1049.       elif self.wind_speed_peak.value() == 0.0:
    1050. 

  1050.           text = "calm"
    1051. 

  1051.       else:
    1052. 

  1052.           wind_speed = self.wind_speed_peak.string(units)
    1053. 

  1053.           if not self.wind_dir_peak:
    1054. 

  1054.               text = wind_speed
    1055. 

  1055.           else:
    1056. 

  1056.               text = "%s at %s" % (self.wind_dir_peak.compass(), wind_speed)
    1057. 

  1057.               if not self.peak_wind_time == None:
    1058. 

  1058.                   text += " at %s" % self.peak_wind_time.strftime('%H:%M')
    1059. 

  1059.       return text
    1060. 

  1060. 

  1061.   def wind_shift( self, units="KT" ):
    1062. 

  1062.       """
    1063. 

  1063.       Return a textual description of the wind shift time
    1064. 

  1064.       
    1065. 

  1065.       Units may be specified as "MPS", "KT", "KMH", or "MPH".
    1066. 

  1066.       """
    1067. 

  1067.       if self.wind_shift_time == None:
    1068. 

  1068.           return "missing"
    1069. 

  1069.       else:
    1070. 

  1070.           return self.wind_shift_time.strftime('%H:%M')
    1071. 

  1071. 

  1072.   def visibility( self, units=None ):
    1073. 

  1073.       """
    1074. 

  1074.       Return a textual description of the visibility.
    1075. 

  1075.       
    1076. 

  1076.       Units may be statute miles ("SM") or meters ("M").
    1077. 

  1077.       """
    1078. 

  1078.       if self.vis == None:
    1079. 

  1079.           return "missing"
    1080. 

  1080.       if self.vis_dir:
    1081. 

  1081.           text = "%s to %s" % (self.vis.string(units), self.vis_dir.compass())
    1082. 

  1082.       else:
    1083. 

  1083.           text = self.vis.string(units)
    1084. 

  1084.       if self.max_vis:
    1085. 

  1085.           if self.max_vis_dir:
    1086. 

  1086.               text += "; %s to %s" % (self.max_vis.string(units), self.max_vis_dir.compass())
    1087. 

  1087.           else:
    1088. 

  1088.               text += "; %s" % self.max_vis.string(units)
    1089. 

  1089.       return text
    1090. 

  1090.   
    1091. 

  1091.   def runway_visual_range( self, units=None ):
    1092. 

  1092.       """
    1093. 

  1093.       Return a textual description of the runway visual range.
    1094. 

  1094.       """
    1095. 

  1095.       lines = []
    1096. 

  1096.       for name,low,high in self.runway:
    1097. 

  1097.           if low != high:
    1098. 

  1098.               lines.append("on runway %s, from %d to %s" % (name, low.value(units), high.string(units)))
    1099. 

  1099.           else:
    1100. 

  1100.               lines.append("on runway %s, %s" % (name, low.string(units)))
    1101. 

  1101.       return string.join(lines,"; ")
    1102. 

  1102.   
    1103. 

  1103.   def present_weather( self ):
    1104. 

  1104.       """
    1105. 

  1105.       Return a textual description of the present weather.
    1106. 

  1106.       """
    1107. 

  1107.       text_list = []
    1108. 

  1108.       for weatheri in self.weather:
    1109. 

  1109.           (inteni,desci,preci,obsci,otheri) = weatheri
    1110. 

  1110.           text_parts = []
    1111. 

  1111.           code_parts = []
    1112. 

  1112.           if inteni:
    1113. 

  1113.               code_parts.append(inteni)
    1114. 

  1114.               text_parts.append(WEATHER_INT[inteni])
    1115. 

  1115.           if desci:
    1116. 

  1116.               code_parts.append(desci)
    1117. 

  1117.               if desci != "SH" or not preci:
    1118. 

  1118.                   text_parts.append(WEATHER_DESC[desci[0:2]])
    1119. 

  1119.                   if len(desci) == 4:
    1120. 

  1120.                       text_parts.append(WEATHER_DESC[desci[2:]])
    1121. 

  1121.           if preci:
    1122. 

  1122.               code_parts.append(preci)        
    1123. 

  1123.               if len(preci) == 2:
    1124. 

  1124.                   precip_text = WEATHER_PREC[preci]
    1125. 

  1125.               elif len(preci) == 4:
    1126. 

  1126.                   precip_text = WEATHER_PREC[preci[:2]]+" and "
    1127. 

  1127.                   precip_text += WEATHER_PREC[preci[2:]]
    1128. 

  1128.               elif len(preci) == 6:
    1129. 

  1129.                   precip_text = WEATHER_PREC[preci[:2]]+", "
    1130. 

  1130.                   precip_text += WEATHER_PREC[preci[2:4]]+" and "
    1131. 

  1131.                   precip_text += WEATHER_PREC[preci[4:]]
    1132. 

  1132.               if desci == "TS":
    1133. 

  1133.                   text_parts.append("with")
    1134. 

  1134.               text_parts.append(precip_text)
    1135. 

  1135.               if desci == "SH":
    1136. 

  1136.                   text_parts.append(WEATHER_DESC[desci])
    1137. 

  1137.           if obsci:
    1138. 

  1138.               code_parts.append(obsci)
    1139. 

  1139.               text_parts.append(WEATHER_OBSC[obsci])
    1140. 

  1140.               
    1141. 

  1141.           if otheri:
    1142. 

  1142.               code_parts.append(otheri)
    1143. 

  1143.               text_parts.append(WEATHER_OTHER[otheri])
    1144. 

  1144.           code = string.join(code_parts)
    1145. 

  1145.           if WEATHER_SPECIAL.has_key(code):
    1146. 

  1146.               text_list.append(WEATHER_SPECIAL[code])
    1147. 

  1147.           else:
    1148. 

  1148.               text_list.append(string.join(text_parts," "))
    1149. 

  1149.       return string.join(text_list,"; ")
    1150. 

  1150.   
    1151. 

  1151.   def sky_conditions( self, sep="; " ):
    1152. 

  1152.       """
    1153. 

  1153.       Return a textual description of the sky conditions.
    1154. 

  1154.       """
    1155. 

  1155.       text_list = []
    1156. 

  1156.       for skyi in self.sky:
    1157. 

  1157.           (cover,height,cloud) = skyi
    1158. 

  1158.           if cover == "SKC" or cover == "CLR":
    1159. 

  1159.               text_list.append(SKY_COVER[cover])
    1160. 

  1160.           else:
    1161. 

  1161.               if cloud:
    1162. 

  1162.                   what = CLOUD_TYPE[cloud]
    1163. 

  1163.               elif cover != "OVC":
    1164. 

  1164.                   what = "clouds"
    1165. 

  1165.               else: 
    1166. 

  1166.                   what = ""
    1167. 

  1167.               if cover == "VV":
    1168. 

  1168.                   text_list.append("%s%s, visibility to %s" % 
    1169. 

  1169.                           (SKY_COVER[cover],what,str(height)))
    1170. 

  1170.               else:
    1171. 

  1171.                   text_list.append("%s%s at %s" % 
    1172. 

  1172.                           (SKY_COVER[cover],what,str(height)))
    1173. 

  1173.       return string.join(text_list,sep)
    1174. 

  1174.           
    1175. 

  1175.   def trend( self ):
    1176. 

  1176.       """
    1177. 

  1177.       Return the trend forecast groups
    1178. 

  1178.       """
    1179. 

  1179.       return " ".join(self._trend_groups)
    1180. 

  1180. 

  1181.   def remarks( self, sep="; "):
    1182. 

  1182.       """
    1183. 

  1183.       Return the decoded remarks.
    1184. 

  1184.       """
    1185. 

  1185.       return string.join(self._remarks,sep)
    1186. 

  1186. 

  1187.