From fc835ea851d8f655a082e718741f415d39f2513a Mon Sep 17 00:00:00 2001
From: John Ronan <jpronans@users.noreply.github.com>
Date: Thu, 17 Dec 2015 18:29:22 +0000
Subject: [PATCH 1/4] Initial attempt at parsing weather data

---
 aprslib/parsing.py                  | 145 +++++++++++++++-
 tests/test_parse_comment_weather.py | 254 ++++++++++++++++++++++++++++
 2 files changed, 393 insertions(+), 6 deletions(-)
 create mode 100644 tests/test_parse_comment_weather.py

diff --git a/aprslib/parsing.py b/aprslib/parsing.py
index b977129..c402c16 100644
--- a/aprslib/parsing.py
+++ b/aprslib/parsing.py
@@ -243,10 +243,16 @@ def parse(packet):
                     logger.debug("Parsed as normal position report")
                 else:
                     raise ParseError("invalid format")
-
-            # decode comment
-            body, result = _parse_comment(body)
-            parsed.update(result)
+            # check comment for weather information
+            # Page 62 of the spec
+            if parsed['symbol'] == '_':
+                logger.debug("Attempting to parse weather report from comment")
+                body, result = _parse_comment_weather(body)
+                parsed.update(result)
+            else:
+                # decode comment
+                body, result = _parse_comment(body)
+                parsed.update(result)
 
             if packet_type == ';':
                 parsed.update({
@@ -396,9 +402,8 @@ def _parse_timestamp(body, packet_type=''):
 
 def _parse_comment(body):
     parsed = {}
-
     # attempt to parse remaining part of the packet (comment field)
-    # try CRS/SPD/
+    # try CRS/SPD
     match = re.findall(r"^([0-9]{3})/([0-9]{3})", body)
     if match:
         cse, spd = match[0]
@@ -926,3 +931,131 @@ def _parse_normal(body):
             })
 
     return (body, parsed)
+
+
+def _parse_comment_weather(body):
+    wind_multiplier = 0.44704
+    rain_multiplier = 0.254
+
+    parsed = {}
+    match = re.findall(r"^([0-9]{3})/([0-9]{3})", body)
+    if match:
+        wind_direction, wind_speed = match[0]
+        parsed.update({
+            'wind_direction': int(wind_direction),
+            # mph to meters per second
+            'wind_speed': float(int(wind_speed) * wind_multiplier)
+        })
+
+    match = re.findall(r"g([0-9]{3})", body)
+    if match:
+        wind_gust = match[0]
+        parsed.update({
+            # mph to meters per second
+            'wind_gust': float(int(wind_gust) * wind_multiplier)
+        })
+
+    # Positionless Weather report
+    match = re.findall(r"c([0-9]{3})s([0-9]{3})", body)
+    if match:
+        wind_direction, wind_speed = match[0]
+        parsed.update({
+            'wind_direction': int(wind_direction),
+            # mph to meters per second
+            'wind_speed': float(int(wind_speed) * wind_multiplier)
+        })
+
+    match = re.findall(r"(?<!c[0-9. ]{3})s([.0-9]{3})", body)
+    if match:
+        snow = match[0]
+        parsed.update({
+            # inches to mm
+            'snow': float(snow) * 25.4
+        })
+
+    match = re.findall(r"g([0-9]{3})", body)
+    if match:
+        wind_gust = match[0]
+        parsed.update({
+            # mph to meters per second
+            'wind_gust': float(int(wind_gust) * wind_multiplier)
+        })
+
+    match = re.findall(r"t([0-9]{3})", body)
+    if match:
+        degrees_farenheit = match[0]
+        parsed.update({
+            # Farenheight to Centigrade
+            'temp': float(int(degrees_farenheit) - 32) / 1.8
+        })
+
+    # Negative Farenheight
+    match = re.findall(r"t(-[0-9]{2})", body)
+    if match:
+        degrees_farenheit = match[0]
+        parsed.update({
+            # Farenheight to Centigrade
+            'temp': (float(degrees_farenheit) - 32) / 1.8
+        })
+
+    match = re.findall(r"r([0-9]{3})", body)
+    if match:
+        rainfall_hour = match[0]
+        parsed.update({
+            # hundreths of an inch to mm
+            'rain_1h': float(int(rainfall_hour) * rain_multiplier)
+        })
+
+    match = re.findall(r"p([0-9]{3})", body)
+    if match:
+        rainfall_24h = match[0]
+        parsed.update({
+            'rain_24h': float(int(rainfall_24h) * rain_multiplier)
+        })
+
+    match = re.findall(r"P([0-9]{3})", body)
+    if match:
+        rainfall_since_midnight = match[0]
+        parsed.update({
+            # hundreths of an inch to mm
+            'rain_since_mid': float(int(rainfall_since_midnight) * 0.254)
+        })
+
+    match = re.findall(r"h([0-9]{2})", body)
+    if match:
+        humidity = match[0]
+        parsed.update({
+            'humidity': int(humidity)
+        })
+
+    match = re.findall(r"b([0-9]{5})", body)
+    if match:
+        pressure = match[0]
+        parsed.update({
+            # deci hPA to hPa
+            'hPa': float(pressure) / 10
+        })
+
+    match = re.findall(r"l([0-9]{3})", body)
+    if match:
+        luminosity = match[0]
+        parsed.update({
+            # http://www.aprs.org/aprs11/spec-wx.txt
+            'luminosity': int(luminosity) + 1000
+        })
+
+    match = re.findall(r"L([0-9]{3})", body)
+    if match:
+        luminosity = match[0]
+        parsed.update({
+            'luminosity': int(luminosity)
+        })
+
+    match = re.findall(r"\#([0-9]{3})", body)
+    if match:
+        rain_raw = match[0]
+        parsed.update({
+            'rain_raw': int(rain_raw)
+        })
+
+    return (body, parsed)
diff --git a/tests/test_parse_comment_weather.py b/tests/test_parse_comment_weather.py
new file mode 100644
index 0000000..8b634d3
--- /dev/null
+++ b/tests/test_parse_comment_weather.py
@@ -0,0 +1,254 @@
+import unittest2 as unittest
+
+from aprslib.parsing import _parse_comment_weather
+
+wind_multiplier = 0.44704
+mm_multiplier = 0.254
+
+class ParseCommentWeather(unittest.TestCase):
+
+    def test_wind(self):
+        # misc value
+        expected = "009/009", {
+            "wind_speed": (9 * wind_multiplier),
+            "wind_direction": 9
+        }
+        result = _parse_comment_weather("009/009")
+        self.assertEqual(expected, result)
+
+        # Daft result but possible
+        expected = "999/999", {
+            "wind_speed": (999 * wind_multiplier),
+            "wind_direction": 999
+        }
+        result = _parse_comment_weather("999/999")
+        self.assertEqual(expected, result)
+
+        #Positionless packet
+        expected = "c009s009", {
+            "wind_speed": float(9 * wind_multiplier),
+            "wind_direction": 9
+        }
+        result = _parse_comment_weather("c009s009")
+        self.assertEqual(expected, result)
+
+        # Daft result but possible
+        expected = "c999s999", {
+            "wind_speed": (999 * wind_multiplier),
+            "wind_direction": 999
+        }
+        result = _parse_comment_weather("c999s999")
+        self.assertEqual(expected, result)
+
+    def test_temp(self):
+        # Min
+        expected = "t-99", {
+            "temp": float((-99.0 - 32) / 1.8)
+        }
+        result = _parse_comment_weather("t-99")
+        self.assertEqual(expected, result)
+
+        # Misc
+        expected = "t-40", {
+            "temp": -40.0
+        }
+        result = _parse_comment_weather("t-40")
+        self.assertEqual(expected, result)
+
+        # Zero F
+        expected = "t000", {
+            "temp": -17.77777777777778
+        }
+        result = _parse_comment_weather("t000")
+        self.assertEqual(expected, result)
+
+        # Daft, but possible
+        expected = "t999", {
+            "temp": 537.2222222222222
+        }
+        result = _parse_comment_weather("t999")
+        self.assertEqual(expected, result)
+
+    def test_rain_1h(self):
+        expected = "r000", {
+            "rain_1h": 0.0
+        }
+        result = _parse_comment_weather("r000")
+        self.assertEqual(expected, result)
+
+        expected = "r999", {
+            "rain_1h": float(999 * mm_multiplier)
+        }
+        result = _parse_comment_weather("r999")
+        self.assertEqual(expected, result)
+
+    def test_rain_24h(self):
+        expected = "p000", {
+            "rain_24h": 0.0
+        }
+        result = _parse_comment_weather("p000")
+        self.assertEqual(expected, result)
+
+        expected = "p999", {
+            "rain_24h": float(999 * mm_multiplier)
+        }
+        result = _parse_comment_weather("p999")
+        self.assertEqual(expected, result)
+
+    def test_rain_since_mid(self):
+        expected = "P000", {
+            "rain_since_mid": 0.0
+        }
+        result = _parse_comment_weather("P000")
+        self.assertEqual(expected, result)
+
+        expected = "P999", {
+            "rain_since_mid": float(999 * mm_multiplier)
+        }
+        result = _parse_comment_weather("P999")
+        self.assertEqual(expected, result)
+
+    def test_humidity(self):
+        expected = "h00", {
+            "humidity": 0.0
+        }
+        result = _parse_comment_weather("h00")
+        self.assertEqual(expected, result)
+
+        expected = "h99", {
+            "humidity": 99
+        }
+        result = _parse_comment_weather("h99")
+        self.assertEqual(expected, result)
+
+        # Invalid value
+        expected = "h9", {
+        }
+        result = _parse_comment_weather("h9")
+        self.assertEqual(expected, result)
+
+    def test_pressure(self):
+        expected = "b00000", {
+            "hPa": 0.0
+        }
+        result = _parse_comment_weather("b00000")
+        self.assertEqual(expected, result)
+
+        expected = "b99999", {
+            "hPa": 9999.9
+        }
+        result = _parse_comment_weather("b99999")
+        self.assertEqual(expected, result)
+
+    def test_luminosity(self):
+        expected = "L000", {
+            "luminosity": 000
+        }
+        result = _parse_comment_weather("L000")
+        self.assertEqual(expected, result)
+
+        expected = "L999", {
+            "luminosity": 999
+        }
+        result = _parse_comment_weather("L999")
+        self.assertEqual(expected, result)
+
+        expected = "l123", {
+            "luminosity": 1123
+        }
+        result = _parse_comment_weather("l123")
+        self.assertEqual(expected, result)
+
+        expected = "l999", {
+            "luminosity": 1999
+        }
+        result = _parse_comment_weather("l999")
+        self.assertEqual(expected, result)
+
+    def test_snow(self):
+        expected = "s000", {
+            "snow": 000
+        }
+        result = _parse_comment_weather("s000")
+        self.assertEqual(expected, result)
+
+        expected = "s5.5", {
+            "snow": float(5.5 * 25.4)
+        }
+        result = _parse_comment_weather("s5.5")
+        self.assertEqual(expected, result)
+
+        expected = "s999", {
+            "snow": float(999 * 25.4)
+        }
+        result = _parse_comment_weather("s999")
+        self.assertEqual(expected, result)
+
+    def test_rain_raw(self):
+        expected = "#000", {
+            "rain_raw": 000
+        }
+        result = _parse_comment_weather("#000")
+        self.assertEqual(expected, result)
+
+        expected = "#999", {
+            "rain_raw": 999
+        }
+        result = _parse_comment_weather("#999")
+        self.assertEqual(expected, result)
+
+    # Not possible in real world (rain and snow measurements)
+    def test_positionless_packet(self):
+        expected = "10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW", {
+            "hPa": 990.0,
+            "humidity": 50,
+            "rain_1h": float(010.0 * mm_multiplier),
+            "rain_24h": float(020.0 * mm_multiplier),
+            "rain_since_mid": float(030.0 * mm_multiplier),
+            "snow": float(5.5 * 25.4),
+            "temp": float((77.0 - 32) / 1.8),
+            "wind_direction": 220,
+            "wind_gust": 5.0 * wind_multiplier,
+            "wind_speed": 4.0 * wind_multiplier
+        }
+
+        result = _parse_comment_weather("10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW")
+        self.assertEqual(expected, result)
+
+        expected = "10090556c220s112g   t   r   p   P   h  b     wRSW", {
+            "wind_direction": 220,
+            "wind_speed": 112 * wind_multiplier
+        }
+
+        result = _parse_comment_weather("10090556c220s112g   t   r   p   P   h  b     wRSW")
+        self.assertEqual(expected, result)
+
+        expected = "10090556c220s112g...t...r...p...P...h..b.....wRSW", {
+            "wind_direction": 220,
+            "wind_speed": 112 * wind_multiplier
+        }
+        result = _parse_comment_weather("10090556c220s112g...t...r...p...P...h..b.....wRSW")
+        self.assertEqual(expected, result)
+
+        expected = "_10090556s9.9", {
+            "snow": 9.9 * 25.4
+        }
+        result = _parse_comment_weather("_10090556s9.9")
+        self.assertEqual(expected, result)
+
+    def test_position_packet(self):
+        expected = "319/001g004t048r...p   P000h19b10294eCumulusWMR100", {
+            "hPa": 1029.4,
+            "humidity": 19,
+            "rain_since_mid": 0.0,
+            "temp": (48.0 - 32) / 1.8,
+            "wind_direction": 319,
+            "wind_gust": 4.0 * wind_multiplier,
+            "wind_speed": 1 * wind_multiplier
+        }
+
+        result = _parse_comment_weather("319/001g004t048r...p   P000h19b10294eCumulusWMR100")
+        self.assertEqual(expected, result)
+
+if __name__ == '__main__':
+    unittest.main()

From 67b37ca8a1aba4f0eb1298b081d0236f1ce88d6d Mon Sep 17 00:00:00 2001
From: Rossen Georgiev <rossen@rgp.io>
Date: Thu, 7 Jan 2016 15:23:49 +0000
Subject: [PATCH 2/4] refactored wx parsing

---
 aprslib/parsing.py                  | 156 +++++++---------------------
 tests/test_parse_comment_weather.py | 110 +++++++++-----------
 2 files changed, 89 insertions(+), 177 deletions(-)

diff --git a/aprslib/parsing.py b/aprslib/parsing.py
index c402c16..b533077 100644
--- a/aprslib/parsing.py
+++ b/aprslib/parsing.py
@@ -248,7 +248,7 @@ def parse(packet):
             if parsed['symbol'] == '_':
                 logger.debug("Attempting to parse weather report from comment")
                 body, result = _parse_comment_weather(body)
-                parsed.update(result)
+                parsed.update({'weather': result})
             else:
                 # decode comment
                 body, result = _parse_comment(body)
@@ -937,125 +937,49 @@ def _parse_comment_weather(body):
     wind_multiplier = 0.44704
     rain_multiplier = 0.254
 
+    key_map = {
+        'g': 'wind_gust',
+        'c': 'wind_direction',
+        't': 'temperature',
+        'S': 'wind_speed',
+        'r': 'rain_1h',
+        'p': 'rain_24h',
+        'P': 'rain_since_midnight',
+        'h': 'humidity',
+        'b': 'pressure',
+        'l': 'luminosity',
+        'L': 'luminosity',
+        's': 'snow',
+        '#': 'rain_raw',
+    }
+    val_map = {
+        'g': lambda x: int(x) * wind_multiplier,
+        'c': lambda x: int(x),
+        'S': lambda x: int(x) * wind_multiplier,
+        't': lambda x: (float(x) - 32) / 1.8,
+        'r': lambda x: int(x) * rain_multiplier,
+        'p': lambda x: int(x) * rain_multiplier,
+        'P': lambda x: int(x) * rain_multiplier,
+        'h': lambda x: int(x),
+        'b': lambda x: float(x) / 10,
+        'l': lambda x: int(x) + 1000,
+        'L': lambda x: int(x),
+        's': lambda x: float(x) * 25.4,
+        '#': lambda x: int(x),
+    }
+
     parsed = {}
-    match = re.findall(r"^([0-9]{3})/([0-9]{3})", body)
-    if match:
-        wind_direction, wind_speed = match[0]
-        parsed.update({
-            'wind_direction': int(wind_direction),
-            # mph to meters per second
-            'wind_speed': float(int(wind_speed) * wind_multiplier)
-        })
 
-    match = re.findall(r"g([0-9]{3})", body)
-    if match:
-        wind_gust = match[0]
-        parsed.update({
-            # mph to meters per second
-            'wind_gust': float(int(wind_gust) * wind_multiplier)
-        })
+    # parse weather data
+    body = re.sub(r"^([0-9]{3})/([0-9]{3})", "c\\1s\\2", body)
+    body = body.replace('s', 'S', 1)
 
-    # Positionless Weather report
-    match = re.findall(r"c([0-9]{3})s([0-9]{3})", body)
-    if match:
-        wind_direction, wind_speed = match[0]
-        parsed.update({
-            'wind_direction': int(wind_direction),
-            # mph to meters per second
-            'wind_speed': float(int(wind_speed) * wind_multiplier)
-        })
+    data = re.findall(r"([cSgtrpPlLs#]\d{3}|t-\d{2}|h\d{2}|b\d{5}|s\.\d{2}|s\d\.\d)", body)
+    data = map(lambda x: (key_map[x[0]] , val_map[x[0]](x[1:])), data)
 
-    match = re.findall(r"(?<!c[0-9. ]{3})s([.0-9]{3})", body)
-    if match:
-        snow = match[0]
-        parsed.update({
-            # inches to mm
-            'snow': float(snow) * 25.4
-        })
+    parsed.update(dict(data))
 
-    match = re.findall(r"g([0-9]{3})", body)
-    if match:
-        wind_gust = match[0]
-        parsed.update({
-            # mph to meters per second
-            'wind_gust': float(int(wind_gust) * wind_multiplier)
-        })
-
-    match = re.findall(r"t([0-9]{3})", body)
-    if match:
-        degrees_farenheit = match[0]
-        parsed.update({
-            # Farenheight to Centigrade
-            'temp': float(int(degrees_farenheit) - 32) / 1.8
-        })
-
-    # Negative Farenheight
-    match = re.findall(r"t(-[0-9]{2})", body)
-    if match:
-        degrees_farenheit = match[0]
-        parsed.update({
-            # Farenheight to Centigrade
-            'temp': (float(degrees_farenheit) - 32) / 1.8
-        })
-
-    match = re.findall(r"r([0-9]{3})", body)
-    if match:
-        rainfall_hour = match[0]
-        parsed.update({
-            # hundreths of an inch to mm
-            'rain_1h': float(int(rainfall_hour) * rain_multiplier)
-        })
-
-    match = re.findall(r"p([0-9]{3})", body)
-    if match:
-        rainfall_24h = match[0]
-        parsed.update({
-            'rain_24h': float(int(rainfall_24h) * rain_multiplier)
-        })
-
-    match = re.findall(r"P([0-9]{3})", body)
-    if match:
-        rainfall_since_midnight = match[0]
-        parsed.update({
-            # hundreths of an inch to mm
-            'rain_since_mid': float(int(rainfall_since_midnight) * 0.254)
-        })
-
-    match = re.findall(r"h([0-9]{2})", body)
-    if match:
-        humidity = match[0]
-        parsed.update({
-            'humidity': int(humidity)
-        })
-
-    match = re.findall(r"b([0-9]{5})", body)
-    if match:
-        pressure = match[0]
-        parsed.update({
-            # deci hPA to hPa
-            'hPa': float(pressure) / 10
-        })
-
-    match = re.findall(r"l([0-9]{3})", body)
-    if match:
-        luminosity = match[0]
-        parsed.update({
-            # http://www.aprs.org/aprs11/spec-wx.txt
-            'luminosity': int(luminosity) + 1000
-        })
-
-    match = re.findall(r"L([0-9]{3})", body)
-    if match:
-        luminosity = match[0]
-        parsed.update({
-            'luminosity': int(luminosity)
-        })
-
-    match = re.findall(r"\#([0-9]{3})", body)
-    if match:
-        rain_raw = match[0]
-        parsed.update({
-            'rain_raw': int(rain_raw)
-        })
+    # strip weather data
+    body = re.sub(r"([cSgtrpPlLs#][0-9\-\. ]{3}|h[0-9\. ]{2}|b[0-9\. ]{5})", '', body)
 
     return (body, parsed)
diff --git a/tests/test_parse_comment_weather.py b/tests/test_parse_comment_weather.py
index 8b634d3..c2a2abe 100644
--- a/tests/test_parse_comment_weather.py
+++ b/tests/test_parse_comment_weather.py
@@ -9,7 +9,7 @@ class ParseCommentWeather(unittest.TestCase):
 
     def test_wind(self):
         # misc value
-        expected = "009/009", {
+        expected = "", {
             "wind_speed": (9 * wind_multiplier),
             "wind_direction": 9
         }
@@ -17,7 +17,7 @@ class ParseCommentWeather(unittest.TestCase):
         self.assertEqual(expected, result)
 
         # Daft result but possible
-        expected = "999/999", {
+        expected = "", {
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
@@ -25,7 +25,7 @@ class ParseCommentWeather(unittest.TestCase):
         self.assertEqual(expected, result)
 
         #Positionless packet
-        expected = "c009s009", {
+        expected = "", {
             "wind_speed": float(9 * wind_multiplier),
             "wind_direction": 9
         }
@@ -33,7 +33,7 @@ class ParseCommentWeather(unittest.TestCase):
         self.assertEqual(expected, result)
 
         # Daft result but possible
-        expected = "c999s999", {
+        expected = "", {
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
@@ -42,156 +42,150 @@ class ParseCommentWeather(unittest.TestCase):
 
     def test_temp(self):
         # Min
-        expected = "t-99", {
-            "temp": float((-99.0 - 32) / 1.8)
+        expected = "", {
+            "temperature": float((-99.0 - 32) / 1.8)
         }
         result = _parse_comment_weather("t-99")
         self.assertEqual(expected, result)
 
         # Misc
-        expected = "t-40", {
-            "temp": -40.0
+        expected = "", {
+            "temperature": -40.0
         }
         result = _parse_comment_weather("t-40")
         self.assertEqual(expected, result)
 
         # Zero F
-        expected = "t000", {
-            "temp": -17.77777777777778
+        expected = "", {
+            "temperature": -17.77777777777778
         }
         result = _parse_comment_weather("t000")
         self.assertEqual(expected, result)
 
         # Daft, but possible
-        expected = "t999", {
-            "temp": 537.2222222222222
+        expected = "", {
+            "temperature": 537.2222222222222
         }
         result = _parse_comment_weather("t999")
         self.assertEqual(expected, result)
 
     def test_rain_1h(self):
-        expected = "r000", {
+        expected = "", {
             "rain_1h": 0.0
         }
         result = _parse_comment_weather("r000")
         self.assertEqual(expected, result)
 
-        expected = "r999", {
+        expected = "", {
             "rain_1h": float(999 * mm_multiplier)
         }
         result = _parse_comment_weather("r999")
         self.assertEqual(expected, result)
 
     def test_rain_24h(self):
-        expected = "p000", {
+        expected = "", {
             "rain_24h": 0.0
         }
         result = _parse_comment_weather("p000")
         self.assertEqual(expected, result)
 
-        expected = "p999", {
+        expected = "", {
             "rain_24h": float(999 * mm_multiplier)
         }
         result = _parse_comment_weather("p999")
         self.assertEqual(expected, result)
 
-    def test_rain_since_mid(self):
-        expected = "P000", {
-            "rain_since_mid": 0.0
+    def test_rain_since_midnight(self):
+        expected = "", {
+            "rain_since_midnight": 0.0
         }
         result = _parse_comment_weather("P000")
         self.assertEqual(expected, result)
 
-        expected = "P999", {
-            "rain_since_mid": float(999 * mm_multiplier)
+        expected = "", {
+            "rain_since_midnight": float(999 * mm_multiplier)
         }
         result = _parse_comment_weather("P999")
         self.assertEqual(expected, result)
 
     def test_humidity(self):
-        expected = "h00", {
+        expected = "", {
             "humidity": 0.0
         }
         result = _parse_comment_weather("h00")
         self.assertEqual(expected, result)
 
-        expected = "h99", {
+        expected = "", {
             "humidity": 99
         }
         result = _parse_comment_weather("h99")
         self.assertEqual(expected, result)
 
-        # Invalid value
-        expected = "h9", {
-        }
-        result = _parse_comment_weather("h9")
-        self.assertEqual(expected, result)
-
     def test_pressure(self):
-        expected = "b00000", {
-            "hPa": 0.0
+        expected = "", {
+            "pressure": 0.0
         }
         result = _parse_comment_weather("b00000")
         self.assertEqual(expected, result)
 
-        expected = "b99999", {
-            "hPa": 9999.9
+        expected = "", {
+            "pressure": 9999.9
         }
         result = _parse_comment_weather("b99999")
         self.assertEqual(expected, result)
 
     def test_luminosity(self):
-        expected = "L000", {
+        expected = "", {
             "luminosity": 000
         }
         result = _parse_comment_weather("L000")
         self.assertEqual(expected, result)
 
-        expected = "L999", {
+        expected = "", {
             "luminosity": 999
         }
         result = _parse_comment_weather("L999")
         self.assertEqual(expected, result)
 
-        expected = "l123", {
+        expected = "", {
             "luminosity": 1123
         }
         result = _parse_comment_weather("l123")
         self.assertEqual(expected, result)
 
-        expected = "l999", {
+        expected = "", {
             "luminosity": 1999
         }
         result = _parse_comment_weather("l999")
         self.assertEqual(expected, result)
 
     def test_snow(self):
-        expected = "s000", {
+        expected = "", {
             "snow": 000
         }
-        result = _parse_comment_weather("s000")
+        result = _parse_comment_weather("s...s000")
         self.assertEqual(expected, result)
 
-        expected = "s5.5", {
+        expected = "", {
             "snow": float(5.5 * 25.4)
         }
-        result = _parse_comment_weather("s5.5")
+        result = _parse_comment_weather("s...s5.5")
         self.assertEqual(expected, result)
 
-        expected = "s999", {
+        expected = "", {
             "snow": float(999 * 25.4)
         }
-        result = _parse_comment_weather("s999")
+        result = _parse_comment_weather("s...s999")
         self.assertEqual(expected, result)
 
     def test_rain_raw(self):
-        expected = "#000", {
+        expected = "", {
             "rain_raw": 000
         }
         result = _parse_comment_weather("#000")
         self.assertEqual(expected, result)
 
-        expected = "#999", {
+        expected = "", {
             "rain_raw": 999
         }
         result = _parse_comment_weather("#999")
@@ -199,14 +193,14 @@ class ParseCommentWeather(unittest.TestCase):
 
     # Not possible in real world (rain and snow measurements)
     def test_positionless_packet(self):
-        expected = "10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW", {
-            "hPa": 990.0,
+        expected = "10090556wRSW", {
+            "pressure": 990.0,
             "humidity": 50,
             "rain_1h": float(010.0 * mm_multiplier),
             "rain_24h": float(020.0 * mm_multiplier),
-            "rain_since_mid": float(030.0 * mm_multiplier),
+            "rain_since_midnight": float(030.0 * mm_multiplier),
             "snow": float(5.5 * 25.4),
-            "temp": float((77.0 - 32) / 1.8),
+            "temperature": float((77.0 - 32) / 1.8),
             "wind_direction": 220,
             "wind_gust": 5.0 * wind_multiplier,
             "wind_speed": 4.0 * wind_multiplier
@@ -215,7 +209,7 @@ class ParseCommentWeather(unittest.TestCase):
         result = _parse_comment_weather("10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW")
         self.assertEqual(expected, result)
 
-        expected = "10090556c220s112g   t   r   p   P   h  b     wRSW", {
+        expected = "10090556wRSW", {
             "wind_direction": 220,
             "wind_speed": 112 * wind_multiplier
         }
@@ -223,25 +217,19 @@ class ParseCommentWeather(unittest.TestCase):
         result = _parse_comment_weather("10090556c220s112g   t   r   p   P   h  b     wRSW")
         self.assertEqual(expected, result)
 
-        expected = "10090556c220s112g...t...r...p...P...h..b.....wRSW", {
+        expected = "10090556wRSW", {
             "wind_direction": 220,
             "wind_speed": 112 * wind_multiplier
         }
         result = _parse_comment_weather("10090556c220s112g...t...r...p...P...h..b.....wRSW")
         self.assertEqual(expected, result)
 
-        expected = "_10090556s9.9", {
-            "snow": 9.9 * 25.4
-        }
-        result = _parse_comment_weather("_10090556s9.9")
-        self.assertEqual(expected, result)
-
     def test_position_packet(self):
-        expected = "319/001g004t048r...p   P000h19b10294eCumulusWMR100", {
-            "hPa": 1029.4,
+        expected = "eCumulusWMR100", {
+            "pressure": 1029.4,
             "humidity": 19,
-            "rain_since_mid": 0.0,
-            "temp": (48.0 - 32) / 1.8,
+            "rain_since_midnight": 0.0,
+            "temperature": (48.0 - 32) / 1.8,
             "wind_direction": 319,
             "wind_gust": 4.0 * wind_multiplier,
             "wind_speed": 1 * wind_multiplier

From e06fadaecc7385139e4892aa635d6721ba441614 Mon Sep 17 00:00:00 2001
From: Rossen Georgiev <rossen@rgp.io>
Date: Thu, 7 Jan 2016 15:37:36 +0000
Subject: [PATCH 3/4] put remaining text in 'comment' for wx prase

---
 aprslib/parsing.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/aprslib/parsing.py b/aprslib/parsing.py
index b533077..5171f2d 100644
--- a/aprslib/parsing.py
+++ b/aprslib/parsing.py
@@ -248,7 +248,10 @@ def parse(packet):
             if parsed['symbol'] == '_':
                 logger.debug("Attempting to parse weather report from comment")
                 body, result = _parse_comment_weather(body)
-                parsed.update({'weather': result})
+                parsed.update({
+                    'comment': body.strip(' '),
+                    'weather': result,
+                    })
             else:
                 # decode comment
                 body, result = _parse_comment(body)

From dc66940fb81719ad8a82a250e28b94a38df88848 Mon Sep 17 00:00:00 2001
From: Rossen Georgiev <rossen@rgp.io>
Date: Sat, 9 Jan 2016 14:53:31 +0000
Subject: [PATCH 4/4] added parsing of positionless wx reports + tests

---
 aprslib/parsing.py                            |  24 +++-
 ..._weather.py => test_parse_weather_data.py} | 114 ++++++++++--------
 2 files changed, 86 insertions(+), 52 deletions(-)
 rename tests/{test_parse_comment_weather.py => test_parse_weather_data.py} (62%)

diff --git a/aprslib/parsing.py b/aprslib/parsing.py
index 5171f2d..d63d93a 100644
--- a/aprslib/parsing.py
+++ b/aprslib/parsing.py
@@ -162,10 +162,9 @@ def parse(packet):
         # \ - unused
         # ] - unused
         # ^ - unused
-        # _ - positionless weather report
         # { - user defined
         # } - 3rd party traffic
-        if packet_type in '#$%)*,<?T[_{}':
+        if packet_type in '#$%)*,<?T[{}':
             raise UnknownFormat("format is not supported", packet)
 
         # STATUS PACKET
@@ -197,6 +196,23 @@ def parse(packet):
             body, result = _parse_message(body)
             parsed.update(result)
 
+        # POSITIONLESS WEATHER REPORT
+        elif packet_type == '_':
+            logger.debug("Attempting to parse as positionless weather report")
+
+            match = re.match("^(\d{8})c[\. \d]{3}s[\. \d]{3}g[\. \d]{3}t[\. \d]{3}", body)
+            if not match:
+                raise ParseError("invalid positionless weather report format")
+
+            comment, weather = _parse_weather_data(body[8:])
+
+            parsed.update({
+                'format': 'wx',
+                'wx_raw_timestamp': match.group(1),
+                'comment': comment.strip(' '),
+                'weather': weather,
+                })
+
         # postion report (regular or compressed)
         elif (packet_type in '!=/@;' or
               0 <= body.find('!') < 40):  # page 28 of spec (PDF)
@@ -247,7 +263,7 @@ def parse(packet):
             # Page 62 of the spec
             if parsed['symbol'] == '_':
                 logger.debug("Attempting to parse weather report from comment")
-                body, result = _parse_comment_weather(body)
+                body, result = _parse_weather_data(body)
                 parsed.update({
                     'comment': body.strip(' '),
                     'weather': result,
@@ -936,7 +952,7 @@ def _parse_normal(body):
     return (body, parsed)
 
 
-def _parse_comment_weather(body):
+def _parse_weather_data(body):
     wind_multiplier = 0.44704
     rain_multiplier = 0.254
 
diff --git a/tests/test_parse_comment_weather.py b/tests/test_parse_weather_data.py
similarity index 62%
rename from tests/test_parse_comment_weather.py
rename to tests/test_parse_weather_data.py
index c2a2abe..cbc74b7 100644
--- a/tests/test_parse_comment_weather.py
+++ b/tests/test_parse_weather_data.py
@@ -1,11 +1,14 @@
 import unittest2 as unittest
 
-from aprslib.parsing import _parse_comment_weather
+from aprslib.parsing import _parse_weather_data
+from aprslib.parsing import parse
 
 wind_multiplier = 0.44704
 mm_multiplier = 0.254
 
 class ParseCommentWeather(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
 
     def test_wind(self):
         # misc value
@@ -13,7 +16,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (9 * wind_multiplier),
             "wind_direction": 9
         }
-        result = _parse_comment_weather("009/009")
+        result = _parse_weather_data("009/009")
         self.assertEqual(expected, result)
 
         # Daft result but possible
@@ -21,7 +24,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
-        result = _parse_comment_weather("999/999")
+        result = _parse_weather_data("999/999")
         self.assertEqual(expected, result)
 
         #Positionless packet
@@ -29,7 +32,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": float(9 * wind_multiplier),
             "wind_direction": 9
         }
-        result = _parse_comment_weather("c009s009")
+        result = _parse_weather_data("c009s009")
         self.assertEqual(expected, result)
 
         # Daft result but possible
@@ -37,7 +40,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
-        result = _parse_comment_weather("c999s999")
+        result = _parse_weather_data("c999s999")
         self.assertEqual(expected, result)
 
     def test_temp(self):
@@ -45,184 +48,199 @@ class ParseCommentWeather(unittest.TestCase):
         expected = "", {
             "temperature": float((-99.0 - 32) / 1.8)
         }
-        result = _parse_comment_weather("t-99")
+        result = _parse_weather_data("t-99")
         self.assertEqual(expected, result)
 
         # Misc
         expected = "", {
             "temperature": -40.0
         }
-        result = _parse_comment_weather("t-40")
+        result = _parse_weather_data("t-40")
         self.assertEqual(expected, result)
 
         # Zero F
         expected = "", {
             "temperature": -17.77777777777778
         }
-        result = _parse_comment_weather("t000")
+        result = _parse_weather_data("t000")
         self.assertEqual(expected, result)
 
         # Daft, but possible
         expected = "", {
             "temperature": 537.2222222222222
         }
-        result = _parse_comment_weather("t999")
+        result = _parse_weather_data("t999")
         self.assertEqual(expected, result)
 
     def test_rain_1h(self):
         expected = "", {
             "rain_1h": 0.0
         }
-        result = _parse_comment_weather("r000")
+        result = _parse_weather_data("r000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_1h": float(999 * mm_multiplier)
         }
-        result = _parse_comment_weather("r999")
+        result = _parse_weather_data("r999")
         self.assertEqual(expected, result)
 
     def test_rain_24h(self):
         expected = "", {
             "rain_24h": 0.0
         }
-        result = _parse_comment_weather("p000")
+        result = _parse_weather_data("p000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_24h": float(999 * mm_multiplier)
         }
-        result = _parse_comment_weather("p999")
+        result = _parse_weather_data("p999")
         self.assertEqual(expected, result)
 
     def test_rain_since_midnight(self):
         expected = "", {
             "rain_since_midnight": 0.0
         }
-        result = _parse_comment_weather("P000")
+        result = _parse_weather_data("P000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_since_midnight": float(999 * mm_multiplier)
         }
-        result = _parse_comment_weather("P999")
+        result = _parse_weather_data("P999")
         self.assertEqual(expected, result)
 
     def test_humidity(self):
         expected = "", {
             "humidity": 0.0
         }
-        result = _parse_comment_weather("h00")
+        result = _parse_weather_data("h00")
         self.assertEqual(expected, result)
 
         expected = "", {
             "humidity": 99
         }
-        result = _parse_comment_weather("h99")
+        result = _parse_weather_data("h99")
         self.assertEqual(expected, result)
 
     def test_pressure(self):
         expected = "", {
             "pressure": 0.0
         }
-        result = _parse_comment_weather("b00000")
+        result = _parse_weather_data("b00000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "pressure": 9999.9
         }
-        result = _parse_comment_weather("b99999")
+        result = _parse_weather_data("b99999")
         self.assertEqual(expected, result)
 
     def test_luminosity(self):
         expected = "", {
             "luminosity": 000
         }
-        result = _parse_comment_weather("L000")
+        result = _parse_weather_data("L000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 999
         }
-        result = _parse_comment_weather("L999")
+        result = _parse_weather_data("L999")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 1123
         }
-        result = _parse_comment_weather("l123")
+        result = _parse_weather_data("l123")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 1999
         }
-        result = _parse_comment_weather("l999")
+        result = _parse_weather_data("l999")
         self.assertEqual(expected, result)
 
     def test_snow(self):
         expected = "", {
             "snow": 000
         }
-        result = _parse_comment_weather("s...s000")
+        result = _parse_weather_data("s...s000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "snow": float(5.5 * 25.4)
         }
-        result = _parse_comment_weather("s...s5.5")
+        result = _parse_weather_data("s...s5.5")
         self.assertEqual(expected, result)
 
         expected = "", {
             "snow": float(999 * 25.4)
         }
-        result = _parse_comment_weather("s...s999")
+        result = _parse_weather_data("s...s999")
         self.assertEqual(expected, result)
 
     def test_rain_raw(self):
         expected = "", {
             "rain_raw": 000
         }
-        result = _parse_comment_weather("#000")
+        result = _parse_weather_data("#000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_raw": 999
         }
-        result = _parse_comment_weather("#999")
+        result = _parse_weather_data("#999")
         self.assertEqual(expected, result)
 
     # Not possible in real world (rain and snow measurements)
     def test_positionless_packet(self):
-        expected = "10090556wRSW", {
-            "pressure": 990.0,
-            "humidity": 50,
-            "rain_1h": float(010.0 * mm_multiplier),
-            "rain_24h": float(020.0 * mm_multiplier),
-            "rain_since_midnight": float(030.0 * mm_multiplier),
-            "snow": float(5.5 * 25.4),
-            "temperature": float((77.0 - 32) / 1.8),
-            "wind_direction": 220,
-            "wind_gust": 5.0 * wind_multiplier,
-            "wind_speed": 4.0 * wind_multiplier
+
+        expected = {
+            'comment': 'wRSW',
+            'format': 'wx',
+            'from': 'A',
+            'path': [],
+            'raw': 'A>B:_10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW',
+            'to': 'B',
+            'via': '',
+            'wx_raw_timestamp': '10090556',
+            "weather": {
+                "pressure": 990.0,
+                "humidity": 50,
+                "rain_1h": float(010.0 * mm_multiplier),
+                "rain_24h": float(020.0 * mm_multiplier),
+                "rain_since_midnight": float(030.0 * mm_multiplier),
+                "snow": float(5.5 * 25.4),
+                "temperature": float((77.0 - 32) / 1.8),
+                "wind_direction": 220,
+                "wind_gust": 5.0 * wind_multiplier,
+                "wind_speed": 4.0 * wind_multiplier
+            }
         }
 
-        result = _parse_comment_weather("10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW")
-        self.assertEqual(expected, result)
+        packet = "A>B:_10090556c220s004g005t077r010p020P030h50b09900s5.5wRSW"
 
-        expected = "10090556wRSW", {
+        self.assertEqual(expected, parse(packet))
+
+        packet2 = "A>B:_10090556c220s112g   t   r   h  b     wRSW"
+        expected['raw'] = packet2
+        expected['weather'] = {
             "wind_direction": 220,
             "wind_speed": 112 * wind_multiplier
         }
 
-        result = _parse_comment_weather("10090556c220s112g   t   r   p   P   h  b     wRSW")
-        self.assertEqual(expected, result)
+        self.assertEqual(expected, parse(packet2))
 
-        expected = "10090556wRSW", {
+        packet3 = "A>B:_10090556c220s112g...t...r...p...P...b.....wRSW"
+        expected['raw'] = packet3
+        expected['weather'] = {
             "wind_direction": 220,
             "wind_speed": 112 * wind_multiplier
         }
-        result = _parse_comment_weather("10090556c220s112g...t...r...p...P...h..b.....wRSW")
-        self.assertEqual(expected, result)
+
+        self.assertEqual(expected, parse(packet3))
 
     def test_position_packet(self):
         expected = "eCumulusWMR100", {
@@ -235,7 +253,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": 1 * wind_multiplier
         }
 
-        result = _parse_comment_weather("319/001g004t048r...p   P000h19b10294eCumulusWMR100")
+        result = _parse_weather_data("319/001g004t048r...p   P000h19b10294eCumulusWMR100")
         self.assertEqual(expected, result)
 
 if __name__ == '__main__':