efj-parser 0.9.3__tar.gz → 0.9.4__tar.gz

{efj_parser-0.9.3 → efj_parser-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: efj-parser
-Version: 0.9.3
+Version: 0.9.4
 Summary: Parse an electronic Flight Journal file
 Home-page: https://github.com/JonHurst/efj_parser
 Author: Jon Hurst

{efj_parser-0.9.3 → efj_parser-0.9.4}/efj_parser/__init__.py

@@ -1,4 +1,5 @@
 import re
+from enum import IntEnum
 from typing import NamedTuple, Optional, Callable, Union, cast
 import datetime as dt
 
@@ -77,7 +78,38 @@ class ValidationError(Exception):
 
 class _VE(Exception):
 
-    def __init__(self, message): self.message = message
+    class Code(IntEnum):
+        BAD_CREWLIST = 100
+        BAD_DATE = 110
+        BAD_FLAGS = 120
+        BAD_ROLE_FLAGS = 121
+        BAD_CONDITION_FLAGS = 122
+        BAD_SYNTAX = 130
+        BAD_TIME = 140
+        MISSING_AIRCRAFT = 200
+        MISSING_CAPTAIN = 210
+        MISSING_DATE = 220
+        MISSING_DEST = 230
+        MISSING_ORIGIN = 240
+
+    message_lookup = {
+        Code.BAD_CREWLIST: "Invalid crew list",
+        Code.BAD_DATE: "Invalid date format",
+        Code.BAD_FLAGS: "Invalid flags",
+        Code.BAD_ROLE_FLAGS: "Invalid role flags",
+        Code.BAD_CONDITION_FLAGS: "Invalid flight condition flags",
+        Code.BAD_SYNTAX: "Invalid syntax",
+        Code.BAD_TIME: "Invalid time format",
+        Code.MISSING_AIRCRAFT: "Prior aircraft specifier required",
+        Code.MISSING_AIRCRAFT: "No Captain specified",
+        Code.MISSING_DATE: "Prior date specifier required",
+        Code.MISSING_DEST: "No destination airfield specified",
+        Code.MISSING_ORIGIN: "No origin airfield specified",
+    }
+
+    def __init__(self, code: Code):
+        self.code = code
+        self.message = _VE.message_lookup.get(code, "Unknown error")
 
 
 ParseRet = Union[dt.date, Duty, Aircraft, list[Crewmember], Sector, str]
@@ -88,56 +120,76 @@ Flags = tuple[Flag, ...]
 
 class Parser():
     """Parser for electronic Flight Journal (eFJ) files."""
+
+    __RE_SECTOR = re.compile(
+        r"""(\w*)/(\w*)        # origin/dest (both optional)
+            \s+(\d{4})/(\d{4}) # times
+            (?>\s+([^#]+))?    # flags
+            (?>\s*\#(.*))?      # comment
+        """, re.VERBOSE)
+    __RE_CREWLIST = re.compile(r"\{([^}]*)}")
+    __RE_DATE = re.compile(r"(\d{4}-\d{2}-\d{2})")
+    __RE_AIRCRAFT = re.compile(
+        r"""(?>([-\w]+)       # registration
+            \s*:\s*
+            ([-\w]+))         # type
+            (?:\s*:\s*
+            (mc|spse|spme))?  # optional class""", re.VERBOSE)
+    __RE_DUTY = re.compile(
+        r"""(\d{4})/(\d{4})   # times
+            (?>\s+([^#]+))?   # flags
+            (?>\s*\#(.*))?    # comment
+        """, re.VERBOSE)
+    __RE_SHORTDATE = re.compile(r"(\++)")
+    __RE_COMMENT = re.compile(r"#(.*)")
+
     def __init__(self) -> None:
         self.date: Optional[dt.date] = None
         self.airports = Airports("", "")
         self.aircraft = Aircraft("", "", "")
         self.class_lookup: dict[str, str] = {}
-        self.captain = ""
         self.crewlist: list[Crewmember] = []
 
     def __parse_date(self, mo: re.Match) -> dt.date:
+        assert mo
         try:
             self.date = dt.date.fromisoformat(mo.group(1))
             return self.date
         except ValueError:
-            raise _VE("Incorrect Date entry")
+            raise _VE(_VE.Code.BAD_DATE)
 
     def __parse_nextdate(self, mo: re.Match) -> dt.date:
+        assert mo
         if not self.date:
-            raise _VE("Short date without preceding Date entry")
+            raise _VE(_VE.Code.MISSING_DATE)
         self.date += dt.timedelta(len(mo.group(1)))
         return self.date
 
     def __parse_duty(self, mo: re.Match) -> Duty:
+        assert mo
         if not self.date:
-            raise _VE("Duty entry without preceding Date entry")
-        try:
-            t_start = dt.time.fromisoformat(mo.group(1))
-            t_end = dt.time.fromisoformat(mo.group(2))
-        except ValueError:
-            raise _VE("Invalid time string")
-        dt_start = dt.datetime.combine(self.date, t_start)
-        dt_end = dt.datetime.combine(self.date, t_end)
-        if dt_end < dt_start:
-            dt_end += dt.timedelta(days=1)
-        duration = int((dt_end - dt_start).total_seconds() / 60)
+            raise _VE(_VE.Code.MISSING_DATE)
+        start_str, end_str, flags, comment = (
+            X.strip() if X else "" for X in mo.group(1, 2, 3, 4))
+        dt_start, duration = self.__parse_times(start_str, end_str)
         ftl_correction = 0
         unused_flags = []
-        for f in _split_flags(mo.group(3)):
+        for f in _split_flags(flags):
             if f[0] == "r":
                 ftl_correction += f[1] if f[1] else duration
             else:
                 unused_flags.append(f)
-        comment = mo.group(4)[1:].strip() if mo.group(4) else ""
         return Duty(dt_start, duration, ftl_correction,
                     _join_flags(tuple(unused_flags)), comment)
 
     def __parse_aircraft(self, mo: re.Match) -> Aircraft:
-        reg, type_ = mo.group(1).strip(), mo.group(2).strip()
-        if mo.lastindex == 3:
-            self.class_lookup[type_] = mo.group(3).strip()
-        class_ = self.class_lookup.get(type_, "")
+        assert mo
+        reg, type_, class_ = (X.strip() if X else ""
+                              for X in mo.group(1, 2, 3))
+        if class_:
+            self.class_lookup[type_] = class_
+        else:
+            class_ = self.class_lookup.get(type_, "")
         self.aircraft = Aircraft(reg, type_, class_)
         return self.aircraft
 
@@ -157,37 +209,24 @@ class Parser():
                     raise ValueError
                 self.crewlist.append(Crewmember(role, name))
         except ValueError:
-            raise _VE("Incorrect crew listing format")
-        captains = [X.name for X in self.crewlist if X.role == "CP"]
-        if captains:
-            self.captain = ", ".join(captains)
+            raise _VE(_VE.Code.BAD_CREWLIST)
         return self.crewlist
 
-    def __pre_validate_sector(self, mo: re.Match) -> None:
-        if not self.date:
-            raise _VE("Sector with no preceding Date entry")
-        if not (self.aircraft.reg and self.aircraft.type_):
-            raise _VE("Sector with no preceding Aircraft entry")
-        if not mo.group(1) and not self.airports.dest:  # Blank destination
-            raise _VE("Blank From without previous To")
-        if not mo.group(2) and not self.airports.origin:  # Blank origin
-            raise _VE("Blank To without previous From")
-
-    def __parse_sector_times(
+    def __parse_times(
             self, t_start: str, t_end: str
     ) -> tuple[dt.datetime, int]:
+        assert self.date
+        assert t_start and t_end
+        assert t_start.isnumeric() and t_end.isnumeric()
         try:
             ts = dt.time.fromisoformat(t_start)  # Off blocks
             te = dt.time.fromisoformat(t_end)  # On blocks
-        except ValueError:
-            raise _VE("Incorrect time field")
-        start = dt.datetime.combine(cast(dt.date, self.date), ts)
-        duration = int(
-            (dt.datetime.combine(cast(dt.date, self.date), te) - start)
-            .total_seconds() // 60)
+        except (ValueError, TypeError):
+            raise _VE(_VE.Code.BAD_TIME)
+        duration = (te.hour - ts.hour) * 60 + (te.minute - ts.minute)
         if duration < 0:
             duration += 1440
-        return (start, duration)
+        return (dt.datetime.combine(self.date, ts), duration)
 
     def __parse_sector_flags(
             self,
@@ -203,45 +242,53 @@ class Parser():
                                                        conditions.night)
         return conditions, roles, landings, unused_flags
 
+    def __captain(self, roles, duration) -> str:
+        captains = ["Self"] if roles.p1 else []
+        if roles.p1 < duration:
+            for m in self.crewlist:
+                if m.role.upper() == "CP":
+                    captains.append(m.name)
+        return ", ".join(captains)
+
     def __parse_sector(self, mo: re.Match) -> Sector:
-        self.__pre_validate_sector(mo)
-        self.airports = Airports(mo.group(1) or self.airports.dest,
-                                 mo.group(2) or self.airports.origin)
-        start, duration = self.__parse_sector_times(mo.group(3), mo.group(4))
+        if not self.date:
+            raise _VE(_VE.Code.MISSING_DATE)
+        if not (self.aircraft.reg and self.aircraft.type_):
+            raise _VE(_VE.Code.MISSING_AIRCRAFT)
+        (origin, dest, start_str, end_str, flag_str, comment
+         ) = (X.strip() if X else "" for X in mo.group(*range(1, 7)))
+        self.airports = Airports(
+            origin or self.airports.dest,
+            dest or self.airports.origin
+        )
+        if not self.airports.origin:
+            raise _VE(_VE.Code.MISSING_ORIGIN)
+        if not self.airports.dest:
+            raise _VE(_VE.Code.MISSING_DEST)
+        start, duration = self.__parse_times(start_str, end_str)
         try:
-            flags = _split_flags(mo.group(5))
+            flags = _split_flags(flag_str)
         except ValueError:
-            raise _VE("Bad flags")
+            raise _VE(_VE.Code.BAD_FLAGS)
         conditions, roles, landings, unused_flags = (
             self.__parse_sector_flags(flags, duration))
-        if roles.p1 == duration:
-            self.captain = "Self"
-        else:
-            if not self.captain:
-                raise _VE("No Captain specified")
-            if roles.p1:
-                self.captain = f"Self, {self.captain}"
-        comment = ""
-        if mo.group(6):  # Comment
-            comment = mo.group(6)[1:].strip()
+        captain = self.__captain(roles, duration)
+        if not captain:
+            raise _VE(_VE.Code.MISSING_CAPTAIN)
         return Sector(
-            start,
-            duration,
-            roles,
-            conditions,
-            landings,
-            self.aircraft,
-            self.airports,
-            self.captain,
-            _join_flags(unused_flags),
+            start, duration, roles, conditions,
+            landings, self.aircraft, self.airports,
+            captain, _join_flags(unused_flags),
             comment,
             tuple(self.crewlist))
 
     def __parse_comment(self, mo: re.Match) -> str:
         return mo.group(1) or ""
 
-    def parse(self, s: str, hook: ParseHook = None
-              ) -> tuple[tuple[Duty, ...], tuple[Sector, ...]]:
+    def parse(
+            self, s: str,
+            hook: ParseHook = None
+    ) -> tuple[tuple[Duty, ...], tuple[Sector, ...]]:
         """Extract duties and sectors from an eFJ string
 
         :param s: A string containing data in eFJ format
@@ -257,21 +304,13 @@ class Parser():
         duties: list[Duty] = []
         sectors: list[Sector] = []
         func_map = [
-            (re.compile(r"(\w*)/(\w*)\s*(\d{4})/(\d{4})([^#]*+)#?(.*)"),
-             self.__parse_sector, "sector"),
-            (re.compile(r"\{([^}]*)}"),
-             self.__parse_crewlist, "crewlist"),
-            (re.compile(r"(\d{4}-\d{2}-\d{2})"),
-             self.__parse_date, "date"),
-            (re.compile(r"(\d{4})/(\d{4})([^#]*+)#?(.*)"),
-             self.__parse_duty, "duty"),
-            (re.compile(r"([-\w]{2,10})(?>\s*:\s*)([-\w]+)"
-                        r"(?:\s*:\s*(mc|spse|spme))?"),
-             self.__parse_aircraft, "aircraft"),
-            (re.compile(r"(\++)"),
-             self.__parse_nextdate, "short_date"),
-            (re.compile(r"#(.*)"),
-             self.__parse_comment, "comment"),
+            (Parser.__RE_SECTOR, self.__parse_sector, "sector"),
+            (Parser.__RE_CREWLIST, self.__parse_crewlist, "crewlist"),
+            (Parser.__RE_DATE, self.__parse_date, "date"),
+            (Parser.__RE_DUTY, self.__parse_duty, "duty"),
+            (Parser.__RE_AIRCRAFT, self.__parse_aircraft, "aircraft"),
+            (Parser.__RE_SHORTDATE, self.__parse_nextdate, "short_date"),
+            (Parser.__RE_COMMENT, self.__parse_comment, "comment"),
         ]
         for c, line in enumerate(s.splitlines()):
             line = line.strip()
@@ -288,7 +327,8 @@ class Parser():
                     hook and hook(line, c + 1, entry_type, cast(ParseRet, ret))
                     break
             else:
-                raise _VE("Bad syntax")
+                raise ValidationError(
+                    c + 1, _VE(_VE.Code.BAD_SYNTAX).message, line)
             if isinstance(ret, Duty):
                 duties.append(ret)
             elif isinstance(ret, Sector):
@@ -303,13 +343,17 @@ def _split_flags(flag_str: str) -> Flags:
     :returns: tuple of pairs like (("p2", 20), ("ln", 1), ("ins", None), ...)
     :raises: ValueError if RHS of : is not convertible to integer
     """
-    fields = flag_str.strip().split()
+    fields = flag_str.split()
+    if not fields:
+        return ()
     return tuple((L[0], int(L[1])) if len(L) == 2 else (L[0], None)
                  for L in (X.split(":", 1) for X in fields))
 
 
 def _join_flags(flags: Flags) -> tuple[str, ...]:
     """Join Flags into a tuple of str"""
+    if not flags:
+        return ()
     return tuple(f"{X[0]}:{X[1]}" if X[1] else X[0] for X in flags)
 
 
@@ -364,12 +408,12 @@ def _process_roles(flags: Flags, duration: int) -> tuple[Roles, Flags]:
             case "ins":
                 ins += f[1] if f[1] else duration
                 if ins > duration:
-                    raise _VE("Bad instructor flag")
+                    raise _VE(_VE.Code.BAD_ROLE_FLAGS)
             case _:
                 unused.append(f)
     p1 = duration - (p1s + p2 + put + p0)
     if p1 < 0:
-        raise _VE("Too many roles")
+        raise _VE(_VE.Code.BAD_ROLE_FLAGS)
     return Roles(p1, p1s, p2, put, ins), tuple(unused)
 
 
@@ -388,11 +432,11 @@ def _process_conditions(flags: Flags, dur: int) -> tuple[Conditions, Flags]:
             case "n":
                 night += f[1] if f[1] else dur
                 if night > dur:
-                    raise _VE("Night duration more than flight duration")
+                    raise _VE(_VE.Code.BAD_CONDITION_FLAGS)
             case "v":
                 vfr += f[1] if f[1] else dur
                 if vfr > dur:
-                    raise _VE("VFR duration more than flight duration")
+                    raise _VE(_VE.Code.BAD_CONDITION_FLAGS)
             case _:
                 unused.append(f)
     return Conditions(night, dur - vfr), tuple(unused)

{efj_parser-0.9.3 → efj_parser-0.9.4}/efj_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: efj-parser
-Version: 0.9.3
+Version: 0.9.4
 Summary: Parse an electronic Flight Journal file
 Home-page: https://github.com/JonHurst/efj_parser
 Author: Jon Hurst

{efj_parser-0.9.3 → efj_parser-0.9.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="efj-parser",
-    version="0.9.3",
+    version="0.9.4",
     author="Jon Hurst",
     author_email="jon.a@hursts.org.uk",
     description="Parse an electronic Flight Journal file",

{efj_parser-0.9.3 → efj_parser-0.9.4}/tests/test_parser.py

@@ -4,6 +4,134 @@ import datetime as dt
 import efj_parser as efj
 
 
+class TestRegexp(unittest.TestCase):
+
+    def test_shortdate(self):
+        f = efj.Parser._Parser__RE_SHORTDATE.fullmatch
+        # Next day
+        self.assertEqual(f("+").group(1), "+")
+        # Next next next day
+        self.assertEqual(f("+++").group(1), "+++")
+        # Can only be +
+        self.assertIsNone(f("++-+"))
+        # Empty gives None
+        self.assertIsNone(f(""))
+
+    def test_date(self):
+        f = efj.Parser._Parser__RE_DATE.fullmatch
+        self.assertEqual(f("2025-01-01").group(1), "2025-01-01")
+        # Must be ISO format
+        self.assertIsNone(f("01/01/2025"))
+        # Bad dates are OK -- will be detected when processing
+        self.assertEqual(f("2025-21-01").group(1), "2025-21-01")
+        # Can't be anything on the end
+        self.assertIsNone(f("2025-01-01A"))
+        # ... or the start
+        self.assertIsNone(f("A2025-01-01"))
+        # Dashes are mandatory
+        self.assertIsNone(f("20250101"))
+        # Empty gives None
+        self.assertIsNone(f(""))
+
+    def test_aircraft(self):
+        f = efj.Parser._Parser__RE_AIRCRAFT.fullmatch
+        for class_ in ["mc", "spse", "spme"]:
+            self.assertEqual(
+                f("G-ABCD:A320:" + class_).group(1, 2, 3),
+                ("G-ABCD", "A320", class_)
+            )
+        # Other classes are no good
+        self.assertIsNone(f("G-ABCD:A320:mcme"))
+        # No class is fine
+        self.assertEqual(
+            f("G-ABCD:A320").group(1, 2, 3),
+            ("G-ABCD", "A320", None)
+        )
+        # ... although trailing colon not allowed
+        self.assertIsNone(f("G-ABCD:A320:"))
+        # Space around colons is fine
+        self.assertEqual(
+            f("G-ABCD : A320 : mc").group(1, 2, 3),
+            ("G-ABCD", "A320", "mc")
+        )
+        # Empty gives None
+        self.assertIsNone(f(""))
+
+    def test_comment(self):
+        f = efj.Parser._Parser__RE_COMMENT.fullmatch
+        self.assertEqual(f("# my comment").group(1), " my comment")
+        # Multiple #
+        self.assertEqual(f("## my #comment").group(1), "# my #comment")
+        # Empty comment
+        self.assertEqual(f("#").group(1), "")
+        # Empty
+        self.assertIsNone(f(""))
+
+    def test_crew(self):
+        f = efj.Parser._Parser__RE_CREWLIST.fullmatch
+        self.assertEqual(f("{ cp: Pugwash, fo: Bloggs}").group(1),
+                         " cp: Pugwash, fo: Bloggs")
+        # Double close shouldn't match
+        self.assertIsNone(f("{ cp: Pugwash, fo: Bloggs}}"))
+        # Otherwise pretty much anything goes -- errors detected later
+        self.assertEqual(f("{{sdkfjl cp: :fo}").group(1),
+                         "{sdkfjl cp: :fo")
+        # Empty
+        self.assertIsNone(f(""))
+
+    def test_duty(self):
+        f = efj.Parser._Parser__RE_DUTY.fullmatch
+        # just times
+        self.assertEqual(f("1000/1100").group(1, 2, 3, 4),
+                         ("1000", "1100", None, None))
+        # with a comment
+        self.assertEqual(f("1000/1100#test").group(1, 2, 3, 4),
+                         ("1000", "1100", None, "test"))
+        # with flags
+        self.assertEqual(f("1000/1100 r a:10").group(1, 2, 3, 4),
+                         ("1000", "1100", "r a:10", None))
+        # comment and flags
+        self.assertEqual(f("1000/1100 r:30 # test").group(1, 2, 3, 4),
+                         ("1000", "1100", "r:30 ", " test"))
+        # empty
+        self.assertIsNone(f(""))
+        # flag without space
+        self.assertIsNone(f("1000/1100r "))
+        # times with suffix
+        self.assertIsNone(f("1000z/1100z "))
+        # letters
+        self.assertIsNone(f("abcd/efgh"))
+
+    def test_sector(self):
+        f = efj.Parser._Parser__RE_SECTOR.fullmatch
+        # simplest
+        self.assertEqual(
+            f("BRS/FNC 1000/1300").group(1, 2, 3, 4, 5, 6),
+            ("BRS", "FNC", "1000", "1300", None, None))
+        # flags
+        self.assertEqual(
+            f("BRS/FNC 1000/1300 n:30 m").group(1, 2, 3, 4, 5, 6),
+            ("BRS", "FNC", "1000", "1300", "n:30 m", None))
+        # comment
+        self.assertEqual(
+            f("BRS/FNC 1000/1300 #  test").group(1, 2, 3, 4, 5, 6),
+            ("BRS", "FNC", "1000", "1300", None, "  test"))
+        # flags and comment
+        self.assertEqual(
+            f("BRS/FNC 1000/1300 m#  test").group(1, 2, 3, 4, 5, 6),
+            ("BRS", "FNC", "1000", "1300", "m", "  test"))
+        # underscore
+        self.assertEqual(
+            f("my_house/FNC 1000/1300"). group(1, 2, 3, 4, 5, 6),
+            ("my_house", "FNC", "1000", "1300", None, None))
+        # no underscore
+        self.assertIsNone(f("my house/FNC 1000/1300"))
+        # time zones
+        self.assertIsNone(f("BRS/FNC 1000z/1300z"))
+        # empty
+        self.assertIsNone(f(""))
+
+
 class TestParser(unittest.TestCase):
 
     def test_basic(self):
@@ -215,21 +343,21 @@ BRS/BFS 1100/1200 v n:30
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 1: [Incorrect crew listing format] {just a string}")
+                "Line 1: [Invalid crew list] {just a string}")
         with self.subTest("No name"):
             data = "2024-01-22\n{CP:, FO:Bloggs}"
             with self.assertRaises(efj.ValidationError) as e:
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 2: [Incorrect crew listing format] {CP:, FO:Bloggs}")
+                "Line 2: [Invalid crew list] {CP:, FO:Bloggs}")
         with self.subTest("No comma"):
             data = "{ CP: Bloggs1 FO:Bloggs2}"
             with self.assertRaises(efj.ValidationError) as e:
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 1: [Incorrect crew listing format]"
+                "Line 1: [Invalid crew list]"
                 " { CP: Bloggs1 FO:Bloggs2}")
         with self.subTest("No colon"):
             data = "{just a, string}"
@@ -237,14 +365,14 @@ BRS/BFS 1100/1200 v n:30
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 1: [Incorrect crew listing format] {just a, string}")
+                "Line 1: [Invalid crew list] {just a, string}")
         with self.subTest("Multi word role"):
             data = "{just a: string}"
             with self.assertRaises(efj.ValidationError) as e:
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 1: [Incorrect crew listing format] {just a: string}")
+                "Line 1: [Invalid crew list] {just a: string}")
 
     def test_bad_date(self):
         data = "2024-02-30"
@@ -252,7 +380,7 @@ BRS/BFS 1100/1200 v n:30
             efj.Parser().parse(data)
         self.assertEqual(
             str(e.exception),
-            "Line 1: [Incorrect Date entry] 2024-02-30")
+            "Line 1: [Invalid date format] 2024-02-30")
 
     def test_bad_nextdate(self):
         data = "2024-02-01\n++-"
@@ -260,7 +388,7 @@ BRS/BFS 1100/1200 v n:30
             efj.Parser().parse(data)
         self.assertEqual(
             str(e.exception),
-            "Line 2: [Bad syntax] ++-")
+            "Line 2: [Invalid syntax] ++-")
 
     def test_bad_duty(self):
         with self.subTest("No preceding date"):
@@ -269,21 +397,21 @@ BRS/BFS 1100/1200 v n:30
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 1: [Duty entry without preceding Date entry] 1000/1100")
+                "Line 1: [Prior date specifier required] 1000/1100")
         with self.subTest("Bad time format"):
             data = "2024-02-01\n2200/2400"
             with self.assertRaises(efj.ValidationError) as e:
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 2: [Invalid time string] 2200/2400")
+                "Line 2: [Invalid time format] 2200/2400")
         with self.subTest("Hyphen instead of slash"):
             data = "2024-02-01\n2200-2400"
             with self.assertRaises(efj.ValidationError) as e:
                 efj.Parser().parse(data)
             self.assertEqual(
                 str(e.exception),
-                "Line 2: [Bad syntax] 2200-2400")
+                "Line 2: [Invalid syntax] 2200-2400")
 
 
 class TestSectorFlags (unittest.TestCase):
@@ -379,11 +507,11 @@ class TestSectorFlags (unittest.TestCase):
         with self.subTest("Role duration > duration"):
             with self.assertRaises(efj._VE) as ve:
                 efj._process_roles((("p1s", 2),), 1)
-                self.assertEqual(ve.exception.message, "Too many roles")
+                self.assertEqual(ve.exception.message, "Invalid role flags")
         with self.subTest("Two untimed roles"):
             with self.assertRaises(efj._VE) as ve:
                 efj._process_roles((("p1s", None), ("put", None)), 1)
-            self.assertEqual(ve.exception.message, "Too many roles")
+            self.assertEqual(ve.exception.message, "Invalid role flags")
         with self.subTest("Instructor flag"):
             self.assertEqual(
                 efj._process_roles((("ins", None),), 1),
@@ -426,12 +554,12 @@ class TestSectorFlags (unittest.TestCase):
             with self.assertRaises(efj._VE) as ve:
                 efj._process_conditions((("v", 2),), 1),
             self.assertEqual(ve.exception.message,
-                             "VFR duration more than flight duration")
+                             "Invalid flight condition flags")
         with self.subTest("Night duration > duration"):
             with self.assertRaises(efj._VE) as ve:
                 efj._process_conditions((("n", 2),), 1),
             self.assertEqual(ve.exception.message,
-                             "Night duration more than flight duration")
+                             "Invalid flight condition flags")
 
 
 class TestUtility(unittest.TestCase):
@@ -449,3 +577,182 @@ class TestUtility(unittest.TestCase):
         )
         exp = ("p2", "put:20", "ln:1", "ins")
         self.assertEqual(res, exp)
+
+
+class TestPrivateMethods(unittest.TestCase):
+
+    def test_parse_times(self):
+        parser = efj.Parser()
+        if __debug__:
+            with self.assertRaises(AssertionError) as e:
+                efj.Parser._Parser__parse_times(parser, "1000", "1100")
+        parser.date = dt.date(2025, 1, 1)
+        ret = efj.Parser._Parser__parse_times(parser, "1000", "1100")
+        self.assertEqual(ret, (dt.datetime(2025, 1, 1, 10, 0), 60))
+        ret = efj.Parser._Parser__parse_times(parser, "2300", "0100")
+        self.assertEqual(ret, (dt.datetime(2025, 1, 1, 23, 0), 120))
+        with self.assertRaises(efj._VE) as e:
+            efj.Parser._Parser__parse_times(parser, "1000", "3100")
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_TIME)
+        if __debug__:
+            with self.assertRaises(AssertionError) as e:
+                efj.Parser._Parser__parse_times(parser, "abcd", "1100")
+            with self.assertRaises(AssertionError) as e:
+                efj.Parser._Parser__parse_times(parser, None, "1100")
+        if not __debug__:
+            with self.assertRaises(efj._VE) as e:
+                efj.Parser._Parser__parse_times(parser, "abcd", "1100")
+            self.assertEqual(e.exception.code, efj._VE.Code.BAD_TIME)
+            with self.assertRaises(efj._VE) as e:
+                efj.Parser._Parser__parse_times(parser, None, "1100")
+            self.assertEqual(e.exception.code, efj._VE.Code.BAD_TIME)
+
+    def test_parse_date(self):
+        parser = efj.Parser()
+        mo = efj.Parser._Parser__RE_DATE.fullmatch("2025-01-01")
+        self.assertEqual(
+            efj.Parser._Parser__parse_date(parser, mo),
+            dt.date(2025, 1, 1))
+        mo = efj.Parser._Parser__RE_DATE.fullmatch("2025-21-01")
+        with self.assertRaises(efj._VE) as e:
+            efj.Parser._Parser__parse_date(parser, mo)
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_DATE)
+        if __debug__:
+            with self.assertRaises(AssertionError):
+                efj.Parser._Parser__parse_date(parser, None)
+
+    def test_nextdate(self):
+        parser = efj.Parser()
+        parser.date = dt.date(2024, 12, 31)
+        mo = efj.Parser._Parser__RE_SHORTDATE.fullmatch("+")
+        efj.Parser._Parser__parse_nextdate(parser, mo)
+        self.assertEqual(parser.date, dt.date(2025, 1, 1))
+        mo = efj.Parser._Parser__RE_SHORTDATE.fullmatch("+++")
+        efj.Parser._Parser__parse_nextdate(parser, mo)
+        self.assertEqual(parser.date, dt.date(2025, 1, 4))
+        if __debug__:
+            with self.assertRaises(AssertionError):
+                efj.Parser._Parser__parse_nextdate(parser, None)
+
+    def test_duty(self):
+        parser = efj.Parser()
+        parser.date = dt.date(2024, 12, 31)
+        mo = efj.Parser._Parser__RE_DUTY.fullmatch("1000/1100")
+        res = efj.Parser._Parser__parse_duty(parser, mo)
+        expected = efj.Duty(dt.datetime(2024, 12, 31, 10, 0), 60)
+        self.assertEqual(res, expected)
+        mo = efj.Parser._Parser__RE_DUTY.fullmatch("1000/1100 r:30")
+        res = efj.Parser._Parser__parse_duty(parser, mo)
+        expected = expected._replace(ftl_correction=30)
+        self.assertEqual(res, expected)
+        mo = efj.Parser._Parser__RE_DUTY.fullmatch("1000/1100 r")
+        res = efj.Parser._Parser__parse_duty(parser, mo)
+        expected = expected._replace(ftl_correction=60)
+        self.assertEqual(res, expected)
+        mo = efj.Parser._Parser__RE_DUTY.fullmatch(
+            "1000/1100 r t1 t2:10 # comment")
+        res = efj.Parser._Parser__parse_duty(parser, mo)
+        expected = expected._replace(
+            extra_flags=("t1", "t2:10"), comment="comment")
+        self.assertEqual(res, expected)
+        mo = efj.Parser._Parser__RE_DUTY.fullmatch("1000/1100#comment")
+        res = efj.Parser._Parser__parse_duty(parser, mo)
+        expected = efj.Duty(
+            dt.datetime(2024, 12, 31, 10, 0), 60, 0, (), "comment")
+        self.assertEqual(res, expected)
+        if __debug__:
+            with self.assertRaises(AssertionError):
+                efj.Parser._Parser__parse_duty(parser, None)
+
+    def test_aircraft(self):
+        parser = efj.Parser()
+        mo = efj.Parser._Parser__RE_AIRCRAFT.fullmatch("G-ABCD:A320:mc")
+        res = efj.Parser._Parser__parse_aircraft(parser, mo)
+        exp = efj.Aircraft("G-ABCD", "A320", "mc")
+        self.assertEqual(res, exp)
+        mo = efj.Parser._Parser__RE_AIRCRAFT.fullmatch("GA-BC-DE : A-320-neo")
+        res = efj.Parser._Parser__parse_aircraft(parser, mo)
+        exp = efj.Aircraft("GA-BC-DE", "A-320-neo", "")
+        self.assertEqual(res, exp)
+
+    def test_crewlist(self):
+        parser = efj.Parser()
+        c = efj.Parser._Parser__RE_CREWLIST.fullmatch
+        f = efj.Parser._Parser__parse_crewlist
+        res = f(parser, c("{ cp: pugwash, fo: bloggs}"))
+        exp = [
+            efj.Crewmember("cp", "pugwash"),
+            efj.Crewmember("fo", "bloggs")
+        ]
+        self.assertEqual(res, exp)
+        res = efj.Parser._Parser__parse_crewlist(parser, c("{}"))
+        self.assertEqual(res, [])
+        with self.assertRaises(efj._VE) as e:
+            f(parser, c("{ cp: fo: bloggs }"))
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_CREWLIST)
+        with self.assertRaises(efj._VE) as e:
+            f(parser, c("{ cp fo: bloggs }"))
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_CREWLIST)
+        with self.assertRaises(efj._VE) as e:
+            f(parser, c("{{sdkfjl cp: :fo}"))
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_CREWLIST)
+
+    def test_sector(self):
+        parser = efj.Parser()
+        default_sector = efj.Sector(
+            start=dt.datetime(2025, 1, 1, 10),
+            total=60,
+            roles=efj.Roles(p1=60),
+            conditions=efj.Conditions(ifr=60),
+            landings=efj.Landings(1, 0),
+            aircraft=efj.Aircraft("G-ABCD", "A320", ""),
+            airports=efj.Airports("BRS", "FNC"),
+            captain="Self",
+            extra_flags=(),
+            comment="",
+            crew=())
+        r = efj.Parser._Parser__RE_SECTOR.fullmatch
+        f = efj.Parser._Parser__parse_sector
+        # parse errors
+        parser.date = dt.date(2025, 1, 1)
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("BRS/FNC 1000/1100"))
+        self.assertEqual(e.exception.code, efj._VE.Code.MISSING_AIRCRAFT)
+        parser.date = None
+        parser.aircraft = efj.Aircraft("G-ABCD", "A320", "")
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("BRS/FNC 1000/1100"))
+        self.assertEqual(e.exception.code, efj._VE.Code.MISSING_DATE)
+        parser.date = dt.date(2025, 1, 1)
+        parser.airports = efj.Airports("", "FNC")
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("/ 1000/1100"))
+        self.assertEqual(e.exception.code, efj._VE.Code.MISSING_DEST)
+        parser.airports = efj.Airports("BRS", "")
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("/ 1000/1100"))
+        self.assertEqual(e.exception.code, efj._VE.Code.MISSING_ORIGIN)
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("BRS/FNC 1000/1100 n:a"))
+        self.assertEqual(e.exception.code, efj._VE.Code.BAD_FLAGS)
+        with self.assertRaises(efj._VE) as e:
+            f(parser, r("BRS/FNC 1000/1100 p1s"))
+        self.assertEqual(e.exception.code, efj._VE.Code.MISSING_CAPTAIN)
+        # successful parse
+        self.assertEqual(f(parser, r("BRS/FNC 1000/1100")), default_sector)
+        self.assertEqual(
+            f(parser, r("/BHX 1000/1100")),
+            default_sector._replace(airports=efj.Airports("FNC", "BHX")))
+        self.assertEqual(
+            f(parser, r("/ 1000/1100")),
+            default_sector._replace(airports=efj.Airports("BHX", "FNC")))
+        self.assertEqual(f(parser, r("BRS/FNC 1000/1100#test comment")),
+                         default_sector._replace(comment="test comment"))
+        parser.crewlist = [efj.Crewmember(role="cp", name="bloggs"),]
+        self.assertEqual(f(parser, r("BRS/FNC 1000/1100 p1s v n")),
+                         default_sector._replace(
+                             roles=efj.Roles(p1=0, p1s=60),
+                             landings=efj.Landings(day=0, night=1),
+                             captain="bloggs",
+                             crew=(efj.Crewmember("cp", "bloggs"),),
+                             conditions=efj.Conditions(night=60)))