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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: efj-parser
-Version: 0.9.2
+Version: 0.9.3
 Summary: Parse an electronic Flight Journal file
 Home-page: https://github.com/JonHurst/efj_parser
 Author: Jon Hurst
@@ -13,6 +13,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
 
 # eFJ Parser #
 

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

@@ -12,7 +12,7 @@ class Duty(NamedTuple):
 
 
 class Crewmember(NamedTuple):
-    role: str  #: The crewmember's role (e.g. CP, FO, PU, FA)
+    role: str  #: The crewmember's role (e.g. ``CP``, ``FO``, ``PU``, ``FA``)
     name: str  #: The crewmember's name
 
 
@@ -37,7 +37,7 @@ class Landings(NamedTuple):
 class Aircraft(NamedTuple):
     reg: str  #: The registration of the aircraft
     type_: str  #: The type of the aircraft
-    class_: str = ""  #: Override to class based on type: spse, spme or mc
+    class_: str  #: Class: ``spse``, ``spme`` or ``mc``
 
 
 class Airports(NamedTuple):
@@ -51,12 +51,12 @@ class Sector(NamedTuple):
     roles: Roles  #: Minutes operating in each role
     conditions: Conditions  #: Minutes operating in ifr and at night
     landings: Landings  #: Number of day and night landings
-    aircraft: Aircraft  #: Type and registration of the aircraft
+    aircraft: Aircraft  #: Type, registration and class of the aircraft
     airports: Airports  #: Origin and destination airports
     captain: str  #: Name(s) of captain(s), Self for oneself
     extra_flags: tuple[str, ...]  #: Any flags not processed by the parser
     comment: str  #: Remarks
-    crew: tuple[Crewmember, ...]  #: A (possible empty) list of crew
+    crew: tuple[Crewmember, ...]  #: A (possibly empty) list of crew
 
 
 class ValidationError(Exception):
@@ -82,6 +82,8 @@ class _VE(Exception):
 
 ParseRet = Union[dt.date, Duty, Aircraft, list[Crewmember], Sector, str]
 ParseHook = Optional[Callable[[str, int, str, ParseRet], None]]
+Flag = tuple[str, Optional[int]]
+Flags = tuple[Flag, ...]
 
 
 class Parser():
@@ -89,13 +91,14 @@ class Parser():
     def __init__(self) -> None:
         self.date: Optional[dt.date] = None
         self.airports = Airports("", "")
-        self.aircraft = Aircraft("", "")
+        self.aircraft = Aircraft("", "", "")
+        self.class_lookup: dict[str, str] = {}
         self.captain = ""
         self.crewlist: list[Crewmember] = []
 
     def __parse_date(self, mo: re.Match) -> dt.date:
         try:
-            self.date = dt.datetime.strptime(mo.group(1), "%Y-%m-%d")
+            self.date = dt.date.fromisoformat(mo.group(1))
             return self.date
         except ValueError:
             raise _VE("Incorrect Date entry")
@@ -110,8 +113,8 @@ class Parser():
         if not self.date:
             raise _VE("Duty entry without preceding Date entry")
         try:
-            t_start = dt.datetime.strptime(mo.group(1), '%H%M').time()
-            t_end = dt.datetime.strptime(mo.group(2), '%H%M').time()
+            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)
@@ -119,23 +122,23 @@ class Parser():
         if dt_end < dt_start:
             dt_end += dt.timedelta(days=1)
         duration = int((dt_end - dt_start).total_seconds() / 60)
-        flags = tuple(X.strip() for X in mo.group(3).split())
         ftl_correction = 0
         unused_flags = []
-        for f in flags:
-            if f and (mo_cor := re.match(r"r(:\d+)?", f)):
-                if mo_cor.group(1):
-                    ftl_correction = int(mo_cor.group(1)[1:])
-                else:
-                    ftl_correction = duration
+        for f in _split_flags(mo.group(3)):
+            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,
-                    tuple(unused_flags), comment)
+                    _join_flags(tuple(unused_flags)), comment)
 
     def __parse_aircraft(self, mo: re.Match) -> Aircraft:
-        self.aircraft = Aircraft(mo.group(1).strip(), mo.group(2).strip())
+        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_, "")
+        self.aircraft = Aircraft(reg, type_, class_)
         return self.aircraft
 
     def __parse_crewlist(self, mo: re.Match) -> list[Crewmember]:
@@ -170,22 +173,27 @@ class Parser():
         if not mo.group(2) and not self.airports.origin:  # Blank origin
             raise _VE("Blank To without previous From")
 
-    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)
+    def __parse_sector_times(
+            self, t_start: str, t_end: str
+    ) -> tuple[dt.datetime, int]:
         try:
-            ts = dt.datetime.strptime(mo.group(3), '%H%M').time()  # Off blocks
-            te = dt.datetime.strptime(mo.group(4), '%H%M').time()  # On blocks
+            ts = dt.time.fromisoformat(t_start)  # Off blocks
+            te = dt.time.fromisoformat(t_end)  # On blocks
         except ValueError:
             raise _VE("Incorrect time field")
-        flags = tuple(mo.group(5).split())
         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)
         if duration < 0:
             duration += 1440
+        return (start, duration)
+
+    def __parse_sector_flags(
+            self,
+            flags: Flags,
+            duration: int
+    ) -> tuple[Conditions, Roles, Landings, Flags]:
         conditions, unused_flags = _process_conditions(flags, duration)
         roles, unused_flags = _process_roles(unused_flags, duration)
         if roles.p2 == duration:
@@ -193,7 +201,19 @@ class Parser():
         else:
             landings, unused_flags = _process_landings(unused_flags, duration,
                                                        conditions.night)
-        aircraft_class, unused_flags = _process_class_override(unused_flags)
+        return conditions, roles, landings, unused_flags
+
+    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))
+        try:
+            flags = _split_flags(mo.group(5))
+        except ValueError:
+            raise _VE("Bad flags")
+        conditions, roles, landings, unused_flags = (
+            self.__parse_sector_flags(flags, duration))
         if roles.p1 == duration:
             self.captain = "Self"
         else:
@@ -210,19 +230,16 @@ class Parser():
             roles,
             conditions,
             landings,
-            self.aircraft._replace(class_=aircraft_class),
+            self.aircraft,
             self.airports,
             self.captain,
-            unused_flags,
+            _join_flags(unused_flags),
             comment,
             tuple(self.crewlist))
 
     def __parse_comment(self, mo: re.Match) -> str:
         return mo.group(1) or ""
 
-    def __invalid_syntax(self, mo: re.Match) -> None:
-        raise _VE("Bad syntax")
-
     def parse(self, s: str, hook: ParseHook = None
               ) -> tuple[tuple[Duty, ...], tuple[Sector, ...]]:
         """Extract duties and sectors from an eFJ string
@@ -240,22 +257,21 @@ class Parser():
         duties: list[Duty] = []
         sectors: list[Sector] = []
         func_map = [
-            (re.compile(r"\A#(.*)\Z"),
-             self.__parse_comment, "comment"),
-            (re.compile(r"\A(\d{4}-\d{2}-\d{2})\Z"),
+            (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"\A\s*(\++)\s*\Z"),
-             self.__parse_nextdate, "short_date"),
-            (re.compile(r"\A(\d{4})/(\d{4})([^#]*)(#.+)?\Z"),
+            (re.compile(r"(\d{4})/(\d{4})([^#]*+)#?(.*)"),
              self.__parse_duty, "duty"),
-            (re.compile(r"([-\w]{2,10})\s*:\s*([-\w]+)"),
+            (re.compile(r"([-\w]{2,10})(?>\s*:\s*)([-\w]+)"
+                        r"(?:\s*:\s*(mc|spse|spme))?"),
              self.__parse_aircraft, "aircraft"),
-            (re.compile(r"\{([^}]*)}\Z"),
-             self.__parse_crewlist, "crewlist"),
-            (re.compile(r"(\w+)?/(\w+)?\s*(\d{4})/(\d{4})([^#]*)?(#.+)?"),
-             self.__parse_sector, "sector"),
-            (re.compile(r".+"),
-             self.__invalid_syntax, "invalid"),
+            (re.compile(r"(\++)"),
+             self.__parse_nextdate, "short_date"),
+            (re.compile(r"#(.*)"),
+             self.__parse_comment, "comment"),
         ]
         for c, line in enumerate(s.splitlines()):
             line = line.strip()
@@ -264,13 +280,15 @@ class Parser():
                 continue
             ret = None
             for rexp, func, entry_type in func_map:
-                if mo := rexp.match(line):
+                if mo := rexp.fullmatch(line):
                     try:
                         ret = func(mo)
                     except _VE as e:
                         raise ValidationError(c + 1, e.message, mo.group(0))
                     hook and hook(line, c + 1, entry_type, cast(ParseRet, ret))
                     break
+            else:
+                raise _VE("Bad syntax")
             if isinstance(ret, Duty):
                 duties.append(ret)
             elif isinstance(ret, Sector):
@@ -278,29 +296,43 @@ class Parser():
         return (tuple(duties), tuple(sectors))
 
 
+def _split_flags(flag_str: str) -> Flags:
+    """Clean and split flag string.
+
+    :param flag_str: Input string such as "p2:20 ln:1 ins"
+    :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()
+    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"""
+    return tuple(f"{X[0]}:{X[1]}" if X[1] else X[0] for X in flags)
+
+
 def _process_landings(
-        flags: tuple[str, ...],
+        flags: Flags,
         duration: int,
         night: int
-) -> tuple[Landings, tuple[str, ...]]:
+) -> tuple[Landings, Flags]:
     night_ldg, day_ldg = 0, 0
     found_landing_flag = False
-    re_day = re.compile(r"\Ald(:\d+)?\Z")
-    re_night = re.compile(r"\Aln(:\d+)?\Z")
-    unused = []
+    unused: list[Flag] = []
     for f in flags:
-        if f == "m":
-            night_ldg, day_ldg = 0, 0
-            found_landing_flag = True
-            break
-        if mo := re_day.match(f):
-            day_ldg = int(mo.group(1)[1:]) if mo.group(1) else 1
-            found_landing_flag = True
-        elif mo := re_night.match(f):
-            night_ldg = int(mo.group(1)[1:]) if mo.group(1) else 1
-            found_landing_flag = True
-        else:
-            unused.append(f)
+        match f[0]:
+            case "m":
+                found_landing_flag = True
+            case "ld":
+                day_ldg += 1 if f[1] is None else f[1]
+                found_landing_flag = True
+            case "ln":
+                night_ldg += 1 if f[1] is None else f[1]
+                found_landing_flag = True
+            case _:
+                unused.append(f)
     if not found_landing_flag:
         if duration == night:
             night_ldg = 1
@@ -309,75 +341,58 @@ def _process_landings(
     return Landings(day_ldg, night_ldg), tuple(unused)
 
 
-def _process_roles(
-        flags: tuple[str, ...],
-        duration: int
-) -> tuple[Roles, tuple[str, ...]]:
-    """Extract role durations from flags
+def _process_roles(flags: Flags, duration: int) -> tuple[Roles, Flags]:
+    """Extract role durations from sector flags
 
     :param flags: Sector flags
+    :param duration: Total duration of sector
     :return: A Roles object and the flags input parameter with processed flags
         removed.
     """
-    p1, inst = duration, 0
-    roles = [0, 0, 0, 0]
-    re_role = re.compile(r"\A(p1s|p2|put|p0)(:\d+)?\Z")
-    re_inst = re.compile(r"\A(ins)(:\d+)?\Z")
-    unused: list[str] = []
+    p1s, p2, put, p0, ins = 0, 0, 0, 0, 0
+    unused: list[Flag] = []
     for f in flags:
-        if mo := re_role.match(f):
-            idx = ("p1s", "p2", "put", "p0").index(mo.group(1))
-            roles[idx] = int(mo.group(2)[1:]) if mo.group(2) else duration
-            p1 -= roles[idx]
-            if p1 < 0:
-                raise _VE("Too many roles")
-        elif mo := re_inst.match(f):
-            inst = int(mo.group(2)[1:]) if mo.group(2) else duration
-        else:
-            unused.append(f)
-    return Roles(p1, roles[0], roles[1], roles[2], inst), tuple(unused)
-
-
-def _process_conditions(
-        flags: tuple[str, ...], duration: int
-) -> tuple[Conditions, tuple[str, ...]]:
-    """Processes sector condition flags
+        match f[0]:
+            case "p1s":
+                p1s += f[1] if f[1] else duration
+            case "p2":
+                p2 += f[1] if f[1] else duration
+            case "put":
+                put += f[1] if f[1] else duration
+            case "p0":
+                p0 += f[1] if f[1] else duration
+            case "ins":
+                ins += f[1] if f[1] else duration
+                if ins > duration:
+                    raise _VE("Bad instructor flag")
+            case _:
+                unused.append(f)
+    p1 = duration - (p1s + p2 + put + p0)
+    if p1 < 0:
+        raise _VE("Too many roles")
+    return Roles(p1, p1s, p2, put, ins), tuple(unused)
+
+
+def _process_conditions(flags: Flags, dur: int) -> tuple[Conditions, Flags]:
+    """Extract sector conditions from sector flags
 
     :param flags: The flags as a tuple of strings
+    :param dur: The total duration of the sector
     :return: A tuple of the form (Conditions, unused_flags) where unused flags
         is the input tuple with used flags removed.
     """
     night, vfr = 0, 0
-    unused: list[str] = []
-    re_flag = re.compile(r"\A(n|v)(:\d+)?\Z")
+    unused: list[Flag] = []
     for f in flags:
-        mo = re_flag.match(f)
-        if not mo:
-            unused.append(f)
-            continue
-        if mo.group(1) == "n":
-            night = duration
-            if mo.group(2):
-                night = int(mo.group(2)[1:])
-                if night > duration:
+        match f[0]:
+            case "n":
+                night += f[1] if f[1] else dur
+                if night > dur:
                     raise _VE("Night duration more than flight duration")
-        elif mo.group(1) == "v":
-            vfr = duration
-            if mo.group(2):
-                vfr = int(mo.group(2)[1:])
-                if vfr > duration:
+            case "v":
+                vfr += f[1] if f[1] else dur
+                if vfr > dur:
                     raise _VE("VFR duration more than flight duration")
-    return Conditions(night, duration - vfr), tuple(unused)
-
-
-def _process_class_override(
-        flags: tuple[str, ...]
-) -> tuple[str, tuple[str, ...]]:
-    retval = ""
-    unused = []
-    for f in flags:
-        if f in {"spse", "spme", "mc"}:
-            retval = f
-        else:
-            unused.append(f)
-    return retval, tuple(unused)
+            case _:
+                unused.append(f)
+    return Conditions(night, dur - vfr), tuple(unused)

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: efj-parser
-Version: 0.9.2
+Version: 0.9.3
 Summary: Parse an electronic Flight Journal file
 Home-page: https://github.com/JonHurst/efj_parser
 Author: Jon Hurst
@@ -13,6 +13,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
 
 # eFJ Parser #
 

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

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

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

@@ -10,10 +10,11 @@ class TestParser(unittest.TestCase):
         data = """\
 2024-01-21
 1000/1430
-N1:320
+N1:320: mc
 {FO: Bloggs}
 BRS/BFS 1100/1200 ins #belfast
-/ 1300/1400 ins:20 test spme
+N2:320
+/ 1300/1400 ins:20 test
 {}
 +
 1000/1610  # Comment
@@ -47,7 +48,7 @@ OB-T-1274:A-321
                 efj.Roles(p1=60, instructor=60),
                 efj.Conditions(ifr=60),
                 efj.Landings(day=1),
-                efj.Aircraft("N1", "320"),
+                efj.Aircraft("N1", "320", "mc"),
                 efj.Airports("BRS", "BFS"),
                 "Self", (), "belfast",
                 (efj.Crewmember("FO", "Bloggs"),)),
@@ -56,7 +57,7 @@ OB-T-1274:A-321
                 efj.Roles(p1=60, instructor=20),
                 efj.Conditions(ifr=60),
                 efj.Landings(day=1),
-                efj.Aircraft("N1", "320", "spme"),
+                efj.Aircraft("N2", "320", "mc"),
                 efj.Airports("BFS", "BRS"),
                 "Self", ("test",), "",
                 (efj.Crewmember("FO", "Bloggs"),)),
@@ -65,7 +66,7 @@ OB-T-1274:A-321
                 efj.Roles(p1=120),
                 efj.Conditions(ifr=120),
                 efj.Landings(day=3),
-                efj.Aircraft("OB-T-1274", "A-321"),
+                efj.Aircraft("OB-T-1274", "A-321", ""),
                 efj.Airports("BRS", "NCE"),
                 "Self", (), "", ()),
             efj.Sector(
@@ -73,7 +74,7 @@ OB-T-1274:A-321
                 efj.Roles(p1=120),
                 efj.Conditions(night=10, ifr=90),
                 efj.Landings(night=1),
-                efj.Aircraft("OB-T-1274", "A-321"),
+                efj.Aircraft("OB-T-1274", "A-321", ""),
                 efj.Airports("NCE", "BRS"),
                 "Self", (), "", ()))
         self.assertEqual(
@@ -110,7 +111,7 @@ G-EFGH:321
                 efj.Roles(p1s=60),
                 efj.Conditions(ifr=60),
                 efj.Landings(day=1),
-                efj.Aircraft("G-ABCD", "320"),
+                efj.Aircraft("G-ABCD", "320", ""),
                 efj.Airports("BRS", "BFS"),
                 "Bloggs Joe", (), "belfast",
                 (efj.Crewmember("CP", "Bloggs Joe"),)),
@@ -119,7 +120,7 @@ G-EFGH:321
                 efj.Roles(p2=60),
                 efj.Conditions(ifr=60),
                 efj.Landings(),
-                efj.Aircraft("G-ABCD", "320"),
+                efj.Aircraft("G-ABCD", "320", ""),
                 efj.Airports("BFS", "BRS"),
                 "Bloggs Joe", (), "",
                 (efj.Crewmember("CP", "Bloggs Joe"),)),
@@ -128,7 +129,7 @@ G-EFGH:321
                 efj.Roles(p2=120),
                 efj.Conditions(ifr=120),
                 efj.Landings(),
-                efj.Aircraft("G-EFGH", "321"),
+                efj.Aircraft("G-EFGH", "321", ""),
                 efj.Airports("BRS", "NCE"),
                 "Pugwash", (), "", (
                     efj.Crewmember("CP", "Pugwash"),
@@ -138,7 +139,7 @@ G-EFGH:321
                 efj.Roles(p1=90, p1s=30),
                 efj.Conditions(ifr=120),
                 efj.Landings(day=1),
-                efj.Aircraft("G-EFGH", "321"),
+                efj.Aircraft("G-EFGH", "321", ""),
                 efj.Airports("NCE", "BRS"),
                 "Self, Pugwash", (), "", (
                     efj.Crewmember("CP", "Pugwash"),
@@ -149,7 +150,7 @@ G-EFGH:321
             (expected_duties, expected_sectors))
 
     def test_flags(self):
-        aircraft = efj.Aircraft("G-ABCD", "320")
+        aircraft = efj.Aircraft("G-ABCD", "320", "")
         roles = efj.Roles(p1=60)
         airports = efj.Airports("BRS", "BFS")
         with self.subTest("Instructor flag"):
@@ -294,7 +295,7 @@ class TestSectorFlags (unittest.TestCase):
                 (efj.Landings(day=1, night=0), ()))
         with self.subTest("PM, day"):
             self.assertEqual(
-                efj._process_landings(("m",), 1, 0),
+                efj._process_landings((("m", None),), 1, 0),
                 (efj.Landings(day=0, night=0), ()))
         with self.subTest("No flags, night"):
             self.assertEqual(
@@ -302,7 +303,7 @@ class TestSectorFlags (unittest.TestCase):
                 (efj.Landings(day=0, night=1), ()))
         with self.subTest("PM, night"):
             self.assertEqual(
-                efj._process_landings(("m",), 1, 1),
+                efj._process_landings((("m", None),), 1, 1),
                 (efj.Landings(day=0, night=0), ()))
         with self.subTest("Partial night, day landing"):
             self.assertEqual(
@@ -310,41 +311,37 @@ class TestSectorFlags (unittest.TestCase):
                 (efj.Landings(day=1, night=0), ()))
         with self.subTest("Partial night, night landing"):
             self.assertEqual(
-                efj._process_landings(("ln",), 2, 1),
+                efj._process_landings((("ln", None),), 2, 1),
                 (efj.Landings(day=0, night=1), ()))
         with self.subTest("Multiple day landings"):
             self.assertEqual(
-                efj._process_landings(("ld:2",), 2, 0),
+                efj._process_landings((("ld", 2),), 2, 0),
                 (efj.Landings(day=2, night=0), ()))
         with self.subTest("Multiple night landings"):
             self.assertEqual(
-                efj._process_landings(("ln:2",), 2, 1),
+                efj._process_landings((("ln", 2),), 2, 1),
                 (efj.Landings(day=0, night=2), ()))
         with self.subTest("Mix of landings, single"):
             self.assertEqual(
-                efj._process_landings(("ln", "ld"), 2, 1),
+                efj._process_landings((("ln", None), ("ld", None)), 2, 1),
                 (efj.Landings(day=1, night=1), ()))
         with self.subTest("Mix of landings, multi"):
             self.assertEqual(
-                efj._process_landings(("ln:2", "ld"), 2, 1),
+                efj._process_landings((("ln", 2), ("ld", None)), 2, 1),
                 (efj.Landings(day=1, night=2), ()))
         with self.subTest("Zero landings, day flag"):
             self.assertEqual(
-                efj._process_landings(("ld:0",), 2, 1),
+                efj._process_landings((("ld", 0),), 2, 1),
                 (efj.Landings(day=0, night=0), ()))
         with self.subTest("Zero landings, night flag"):
             self.assertEqual(
-                efj._process_landings(("ln:0",), 2, 1),
+                efj._process_landings((("ln", 0),), 2, 1),
                 (efj.Landings(day=0, night=0), ()))
         with self.subTest("Day landing, night flight"):
             # Assume that user did this for a reason
             self.assertEqual(
-                efj._process_landings(("ld",), 2, 2),
+                efj._process_landings((("ld", None),), 2, 2),
                 (efj.Landings(day=1, night=0), ()))
-        with self.subTest("Bad quantity"):
-            self.assertEqual(
-                efj._process_landings(("ln:xyz",), 1, 0),
-                (efj.Landings(1, 0), ("ln:xyz",)))
 
     def test_roles(self):
         with self.subTest("All p1"):
@@ -353,56 +350,52 @@ class TestSectorFlags (unittest.TestCase):
                 (efj.Roles(p1=1), ()))
         with self.subTest("All p1s"):
             self.assertEqual(
-                efj._process_roles(("p1s",), 1),
+                efj._process_roles((("p1s", None),), 1),
                 (efj.Roles(p1s=1), ()))
         with self.subTest("All p2"):
             self.assertEqual(
-                efj._process_roles(("p2",), 1),
+                efj._process_roles((("p2", None),), 1),
                 (efj.Roles(p2=1), ()))
         with self.subTest("All put"):
             self.assertEqual(
-                efj._process_roles(("put",), 1),
+                efj._process_roles((("put", None),), 1),
                 (efj.Roles(put=1), ()))
         with self.subTest("Split roles, put & p1"):
             self.assertEqual(
-                efj._process_roles(("put:1",), 2),
+                efj._process_roles((("put", 1),), 2),
                 (efj.Roles(p1=1, put=1), ()))
         with self.subTest("Split roles, p1s & p1"):
             self.assertEqual(
-                efj._process_roles(("p1s:1",), 2),
+                efj._process_roles((("p1s", 1),), 2),
                 (efj.Roles(p1=1, p1s=1), ()))
         with self.subTest("Split roles, p2 & p1"):
             self.assertEqual(
-                efj._process_roles(("p2:1",), 2),
+                efj._process_roles((("p2", 1),), 2),
                 (efj.Roles(p1=1, p2=1), ()))
         with self.subTest("Split roles, p1s & put"):
             self.assertEqual(
-                efj._process_roles(("p1s:1", "put:1"), 2),
+                efj._process_roles((("p1s", 1), ("put", 1)), 2),
                 (efj.Roles(p1s=1, put=1), ()))
         with self.subTest("Role duration > duration"):
             with self.assertRaises(efj._VE) as ve:
-                efj._process_roles(("p1s:2",), 1)
+                efj._process_roles((("p1s", 2),), 1)
                 self.assertEqual(ve.exception.message, "Too many roles")
         with self.subTest("Two untimed roles"):
             with self.assertRaises(efj._VE) as ve:
-                efj._process_roles(("p1s", "put"), 1)
+                efj._process_roles((("p1s", None), ("put", None)), 1)
             self.assertEqual(ve.exception.message, "Too many roles")
         with self.subTest("Instructor flag"):
             self.assertEqual(
-                efj._process_roles(("ins",), 1),
+                efj._process_roles((("ins", None),), 1),
                 (efj.Roles(p1=1, instructor=1), ()))
         with self.subTest("Instructor flag, partial"):
             self.assertEqual(
-                efj._process_roles(("ins:1",), 2),
+                efj._process_roles((("ins", 1),), 2),
                 (efj.Roles(p1=2, instructor=1), ()))
         with self.subTest("Unknown role"):
             self.assertEqual(
-                efj._process_roles(("p3",), 2),
-                (efj.Roles(p1=2), ("p3",)))
-        with self.subTest("Bad duration"):
-            self.assertEqual(
-                efj._process_roles(("p1s:xyz",), 1),
-                (efj.Roles(p1=1), ("p1s:xyz",)))
+                efj._process_roles((("p3", None),), 2),
+                (efj.Roles(p1=2), (("p3", None),)))
 
     def test_conditions(self):
         with self.subTest("No flags"):
@@ -411,57 +404,48 @@ class TestSectorFlags (unittest.TestCase):
                 (efj.Conditions(ifr=1, night=0), ()))
         with self.subTest("VFR flag"):
             self.assertEqual(
-                efj._process_conditions(("v",), 1),
+                efj._process_conditions((("v", None),), 1),
                 (efj.Conditions(ifr=0, night=0), ()))
         with self.subTest("Night flag"):
             self.assertEqual(
-                efj._process_conditions(("n",), 1),
+                efj._process_conditions((("n", None),), 1),
                 (efj.Conditions(ifr=1, night=1), ()))
         with self.subTest("VFR at night"):
             self.assertEqual(
-                efj._process_conditions(("n", "v"), 1),
+                efj._process_conditions((("n", None), ("v", None)), 1),
                 (efj.Conditions(ifr=0, night=1), ()))
         with self.subTest("Part VFR"):
             self.assertEqual(
-                efj._process_conditions(("v:1",), 2),
+                efj._process_conditions((("v", 1),), 2),
                 (efj.Conditions(ifr=1, night=0), ()))
         with self.subTest("Part Night"):
             self.assertEqual(
-                efj._process_conditions(("n:1",), 2),
+                efj._process_conditions((("n", 1),), 2),
                 (efj.Conditions(ifr=2, night=1), ()))
-        with self.subTest("Bad duration"):
-            self.assertEqual(
-                efj._process_conditions(("v:xyz",), 2),
-                (efj.Conditions(ifr=2, night=0), ("v:xyz",)))
         with self.subTest("VFR duration > duration"):
             with self.assertRaises(efj._VE) as ve:
-                efj._process_conditions(("v:2",), 1),
+                efj._process_conditions((("v", 2),), 1),
             self.assertEqual(ve.exception.message,
                              "VFR duration more than flight duration")
         with self.subTest("Night duration > duration"):
             with self.assertRaises(efj._VE) as ve:
-                efj._process_conditions(("n:2",), 1),
+                efj._process_conditions((("n", 2),), 1),
             self.assertEqual(ve.exception.message,
                              "Night duration more than flight duration")
 
-    def test_class_override(self):
-        with self.subTest("SPSE"):
-            self.assertEqual(
-                efj._process_class_override(("spse",)),
-                ("spse", ()))
-        with self.subTest("SPME"):
-            self.assertEqual(
-                efj._process_class_override(("spme",)),
-                ("spme", ()))
-        with self.subTest("MC"):
-            self.assertEqual(
-                efj._process_class_override(("mc",)),
-                ("mc", ()))
-        with self.subTest("SPSE"):
-            self.assertEqual(
-                efj._process_class_override(("test",)),
-                ("", ("test",)))
-        with self.subTest("Multiple overrides"):
-            self.assertEqual(
-                efj._process_class_override(("spse", "spme", "mc")),
-                ("mc", ()))
+
+class TestUtility(unittest.TestCase):
+
+    def test_split_flags(self):
+        res = tuple(efj._split_flags("  p2 put:20 ln:1 ins  "))
+        exp = (("p2", None), ("put", 20), ("ln", 1), ("ins", None))
+        self.assertEqual(res, exp)
+        with self.assertRaises(ValueError):
+            tuple(efj._split_flags("ln:1 ab:no"))
+
+    def test_join_flags(self):
+        res = efj._join_flags(
+            (("p2", None), ("put", 20), ("ln", 1), ("ins", None))
+        )
+        exp = ("p2", "put:20", "ln:1", "ins")
+        self.assertEqual(res, exp)