Merge pull request #73 from springblock-org/bh/793-error-parsing-taf-time-string

fix: Fix parsing of TAF if the delivery time is absent

Author: mivek

metar_taf_parser/command/common.py

@@ -163,10 +163,10 @@ def can_parse(self, visibility_string: str):
 
 
 class MinimalVisibilityCommand:
-    regex = r'^(\d{4}[NnEeSsWw])$'
+    regex = r'^(\d{4})(N|NE|E|SE|S|SW|W|NW)$'
 
     def __init__(self):
-        self._pattern = re.compile(MinimalVisibilityCommand.regex)
+        self._pattern = re.compile(MinimalVisibilityCommand.regex, re.IGNORECASE)
 
     def can_parse(self, visibility_string: str):
         return self._pattern.search(visibility_string)
@@ -179,8 +179,10 @@ def execute(self, container: AbstractWeatherContainer, visibility_string: str):
         :return:
         """
         matches = self._pattern.search(visibility_string).groups()
-        container.visibility.min_distance = int(matches[0][0:4])
-        container.visibility.min_direction = matches[0][4]
+        if container.visibility is None:
+            container.visibility = Visibility()
+        container.visibility.min_distance = int(matches[0])
+        container.visibility.min_direction = matches[1]
         return True
 
 

metar_taf_parser/parser/parser.py

@@ -15,13 +15,22 @@
 
 def parse_delivery_time(abstract_weather_code, time_string):
     """
-    Parses the delivery time of a METAR/TAF
+    Parses the delivery time of a METAR/TAF. It will return False
+    if it is not a delivery time but a validity time. If the delivery time
+    is not specified, we can assume the start of the validity time is the delivery time.
     :param abstract_weather_code: The TAF or METAR object
     :param time_string: The string representing the delivery time
     :return: None
     """
-    abstract_weather_code.day = int(time_string[0:2])
-    abstract_weather_code.time = time(int(time_string[2:4]), int(time_string[4:6]))
+    if len(time_string) > 6 and "/" in time_string:
+        # This is a validity string, not a delivery time.
+        abstract_weather_code.day = int(time_string[0:2])
+        abstract_weather_code.time = time(hour=int(time_string[2:4]))
+        return False
+    else:
+        abstract_weather_code.day = int(time_string[0:2])
+        abstract_weather_code.time = time(int(time_string[2:4]), int(time_string[4:6]))
+        return True
 
 
 def _parse_flags(abstract_weather_code, flag_string):
@@ -246,12 +255,7 @@ def __init__(self):
         self._validity_pattern = re.compile(r'^\d{4}/\d{4}$')
         self._taf_command_supplier = TAFCommandSupplier()
 
-    def parse(self, input: str):
-        """
-        Parses a message into a TAF
-        :param input: the message to parse
-        :return: a TAF object or None if the message is invalid
-        """
+    def _parse_initial_taf(self, input: str):
         taf = TAF()
         lines = self._extract_lines_tokens(input)
         if TAFParser.TAF != lines[0][0]:
@@ -265,10 +269,20 @@ def parse(self, input: str):
         taf.station = lines[0][index]
         index += 1
         taf.message = input
-        parse_delivery_time(taf, lines[0][index])
-        index += 1
+        if parse_delivery_time(taf, lines[0][index]):
+            index += 1
         taf.validity = _parse_validity(lines[0][index])
 
+        return taf, lines, index
+
+    def parse(self, input: str):
+        """
+        Parses a message into a TAF
+        :param input: the message to parse
+        :return: a TAF object or None if the message is invalid
+        """
+        taf, lines, index = self._parse_initial_taf(input)
+
         for i in range(index + 1, len(lines[0])):
             token = lines[0][i]
             command = self._taf_command_supplier.get(token)
@@ -311,7 +325,7 @@ def _extract_lines_tokens(self, taf_code: str):
                 lines_token[len(lines) - 1] = list(filter(lambda x: not x.startswith(TAFParser.TX) and not x.startswith(TAFParser.TN), last_line))
         return lines_token
 
-    def _parse_line(self, taf: TAF, line_tokens: list):
+    def _parse_line(self, taf: 'TAF', line_tokens: list):
         """
         Parses the tokens of the line and updates the TAF object.
         :param taf: TAF object to update

metar_taf_parser/tests/command/test_common.py

@@ -1,8 +1,14 @@
 import unittest
 
-from metar_taf_parser.command.common import CloudCommand, MainVisibilityNauticalMilesCommand, WindCommand, CommandSupplier
+from metar_taf_parser.command.common import (
+    CloudCommand,
+    CommandSupplier,
+    MainVisibilityNauticalMilesCommand,
+    MinimalVisibilityCommand,
+    WindCommand,
+)
 from metar_taf_parser.model.enum import CloudQuantity, CloudType
-from metar_taf_parser.model.model import Metar
+from metar_taf_parser.model.model import TAF, Metar
 
 
 class CommonTestCase(unittest.TestCase):
@@ -90,6 +96,19 @@ def test_execute(self):
         metar = Metar()
         self.assertTrue(command.execute(metar, 'VRB08KT'))
 
+    def test_minimal_visibility_command(self):
+        command = MinimalVisibilityCommand()
+
+        for dir in ['N', 'ne', 's', 'SW']:
+            with self.subTest(dir):
+                vis_str = f'3000{dir}'
+                self.assertTrue(command.can_parse(vis_str))
+
+                taf = TAF()
+                self.assertTrue(command.execute(taf, vis_str))
+                self.assertEqual(taf.visibility.min_distance, 3000)
+                self.assertEqual(taf.visibility.min_direction, dir)
+
     def test_main_visibility_nautical_miles_command_with_greater_than(self):
         command = MainVisibilityNauticalMilesCommand()
         self.assertTrue(command.can_parse('P3SM'))

metar_taf_parser/tests/parser/test_parser.py

@@ -303,7 +303,7 @@ def test_parse_recent_rain(self):
         self.assertEqual('LTAE', metar.station)
         self.assertEqual(1, len(metar.weather_conditions))
         self.assertEqual(Intensity.RECENT, metar.weather_conditions[0].intensity)
-        self.assertEquals(Descriptive.SHOWERS, metar.weather_conditions[0].descriptive)
+        self.assertEqual(Descriptive.SHOWERS, metar.weather_conditions[0].descriptive)
         self.assertEqual(1, len(metar.weather_conditions[0].phenomenons))
         self.assertEqual(Phenomenon.RAIN, metar.weather_conditions[0].phenomenons[0])
 
@@ -334,6 +334,25 @@ def test_parse_temperature_min(self):
 
 class TAFParserTestCase(unittest.TestCase):
 
+    def test_parse_without_delivery_time(self):
+        code = """
+        TAF KNYL 2603/2703 20006KT 9999 SKC QNH2974INS
+            FM261000 14004KT 9999 SKC QNH2977INS
+            FM261700 17007KT 9999 SKC QNH2974INS
+            FM262100 19013KT 9999 SKC QNH2967INS AUTOMATED SENSOR METWATCH 2606 TIL 2614 TX42/2623Z TN24/2614Z
+        """
+        taf = TAFParser().parse(code)
+
+        self.assertEqual('KNYL', taf.station)
+        self.assertEqual(26, taf.day)
+        self.assertEqual(3, taf.time.hour)
+        self.assertEqual(0, taf.time.minute)
+
+        self.assertEqual(26, taf.validity.start_day)
+        self.assertEqual(3, taf.validity.start_hour)
+        self.assertEqual(27, taf.validity.end_day)
+        self.assertEqual(3, taf.validity.end_hour)
+
     def test_parse_with_invalid_line_breaks(self):
         code = 'TAF LFPG 150500Z 1506/1612 17005KT 6000 SCT012 \n' + 'TEMPO 1506/1509 3000 BR BKN006 PROB40 \n' + 'TEMPO 1506/1508 0400 BCFG BKN002 PROB40 \n' + 'TEMPO 1512/1516 4000 -SHRA FEW030TCU BKN040 \n' + 'BECMG 1520/1522 CAVOK \n' + 'TEMPO 1603/1608 3000 BR BKN006 PROB40 \n TEMPO 1604/1607 0400 BCFG BKN002 TX17/1512Z TN07/1605Z'