efjtk 0.5__py3-none-any.whl

efjtk/cli.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+import sys
+import argparse
+from typing import Optional
+import os.path
+
+import efj_parser
+import efjtk.convert
+import efjtk.modify
+from efjtk.config import build_config, aircraft_classes
+
+
+def _args():
+    parser = argparse.ArgumentParser(
+        description=(
+            """Process an electronic Flight Journal (eFJ) file. Tools to aid in
+            manual creation of eFJ files (expand, night, vfr, ins, fo) and
+            tools to convert to useful formats (logbook, summary) are included.
+            Also included is a tool to help create a config file, which is
+            required for generation of the FCL.050 logbook."""))
+    parser.add_argument('format',
+                        choices=['expand', 'night', 'vfr', 'ins', 'fo',
+                                 'logbook',  'summary',
+                                 'config'])
+    parser.add_argument('-c', '--config', default=None)
+    return parser.parse_args()
+
+
+def _config(filename: Optional[str]) -> str:
+    if filename and os.path.exists(filename):
+        with open(filename) as f:
+            return f.read()
+    else:
+        for filename in (os.path.expanduser("~/.efjtkrc"),
+                         os.path.expanduser("~/.config/efjtkrc")):
+            if os.path.exists(filename):
+                with open(filename) as f:
+                    return f.read()
+    return ""
+
+
+_func_map = {
+    "expand": efjtk.modify.expand_efj,
+    "night": efjtk.modify.add_night_data,
+    "summary": efjtk.convert.build_summary,
+    "vfr": efjtk.modify.add_vfr_flag,
+    "fo": efjtk.modify.add_fo_role_flag,
+    "ins": efjtk.modify.add_ins_flag,
+}
+
+
+def main() -> int:
+    args = _args()
+    data = sys.stdin.read()
+    try:
+        if args.format == "logbook":
+            ac_classes = aircraft_classes(_config(args.config))
+            print(efjtk.convert.build_logbook(data, ac_classes))
+        elif args.format == "config":
+            sys.stdout.write(
+                build_config(data, _config(args.config)))
+        elif args.format in _func_map:
+            print(_func_map[args.format](data))
+        else:
+            return -1
+        return 0
+    except efj_parser.ValidationError as ve:
+        print(str(ve), file=sys.stderr)
+        return -1
+    except efjtk.convert.UnknownAircraftType as t:
+        print(f"No class for type: {t}", file=sys.stderr)
+        return -3
+
+
+if __name__ == "__main__":
+    retval = main()
+    sys.exit(retval)

efjtk/config.py

@@ -0,0 +1,67 @@
+import io
+import efj_parser as ep
+import configparser as cp
+
+
+def _parse_config(config: str) -> cp.ConfigParser:
+    """Create a clean ConfigParser from a string
+
+    :param config: The contents of an INI file as a string
+    :return: A ConfigParser that is guaranteed to have an aircraft.classes
+        section, with the entries within guaranteed to have a valid value.
+    :raises configparser.Error: Any configparser exception when parsing the
+        string is not caught, so must be handled at a higher level
+    """
+    parser = cp.ConfigParser()
+    parser.read_string(config)  # raises cp.Error on failure
+    if "aircraft.classes" not in parser:
+        parser.add_section("aircraft.classes")
+    for name, value in parser.items("aircraft.classes"):
+        if value not in {"spse", "spme", "mc"}:
+            parser.remove_option("aircraft.classes", name)
+    return parser
+
+
+def build_config(in_: str, config: str, raise_on_error: bool = False) -> str:
+    """Build a template for an INI file incorporating any unknown types
+
+    :param in_: An eFJ file in string form
+    :param config: An INI file in string form. This can be an empty string or
+        can be the contents of an existing INI file to update.
+    :param raise_on_error: If an exception occurs while parsing the config
+        string, reraise it rather than continuing with empty parser
+    :return: An updated INI file in string form. Any non pre-existing types are
+        added to the [aircraft.classes] section and assigned "spse" as a value.
+    :raises configparser.Error: Any configparser exception caused by errors in
+        config must be handled at higher level if raise_on_error is True
+    """
+    _, sectors = ep.Parser().parse(in_)
+    try:
+        parser = _parse_config(config)
+    except cp.Error as e:
+        if raise_on_error:
+            raise e
+        parser = cp.ConfigParser()
+        parser.add_section("aircraft.classes")
+    for s in sectors:
+        if s.aircraft.type_ not in parser["aircraft.classes"]:
+            parser["aircraft.classes"][s.aircraft.type_] = "spse"
+    f = io.StringIO()
+    parser.write(f)
+    return f.getvalue()
+
+
+def aircraft_classes(config: str) -> cp.SectionProxy:
+    """Extract the [aircraft.classes] section from an INI string.
+
+    :param config: An INI file in string form
+    :return: A ConfigParser SectionProxy object. This can be treated as a non
+        case-sensitive dict, with the aircraft type as key and its category as
+        value. Uses empty parser if parsing of config fails.
+    """
+    try:
+        parser = _parse_config(config)
+    except cp.Error:
+        parser = cp.ConfigParser()
+        parser.add_section("aircraft_classes")
+    return parser["aircraft.classes"]

efjtk/convert.py

@@ -0,0 +1,167 @@
+import configparser as cp
+import importlib.resources as res
+import datetime as dt
+
+import efj_parser as ep
+
+
+class UnknownAircraftType(Exception):
+    """Aircraft type with no matching class encountered"""
+
+    def __init__(self, type_):
+        self.missing_type = type_
+
+
+def _get_template(filename):
+    template_file = res.files("efjtk").joinpath(filename)
+    with template_file.open() as f:
+        template = f.read()
+    for old, new in (("{", "{{"), ("}", "}}"),
+                     ("<!--{{", "{"), ("}}-->", "}")):
+        template = template.replace(old, new)
+    return template
+
+
+def _duration(minutes):
+    if minutes:
+        return f"{minutes // 60}:{minutes % 60:02}"
+    return ""
+
+
+def _aircraft_class_cells(
+        sector: ep.Sector,
+        ac_classes: cp.SectionProxy,
+        duration: str
+) -> list[str]:
+    if sector.aircraft.class_:
+        aircraft_class = sector.aircraft.class_
+    else:
+        try:
+            aircraft_class = ac_classes[sector.aircraft.type_]
+        except KeyError:
+            raise UnknownAircraftType(sector.aircraft.type_)
+    if aircraft_class == "mc":
+        return ["", "", duration]
+    if aircraft_class == "spse":
+        return ["✓", "", ""]
+    return ["", "✓", ""]  # must be "spme"
+
+
+def build_logbook(in_: str, ac_classes: cp.SectionProxy) -> str:
+    _, sectors = ep.Parser().parse(in_)
+    rows = []
+    for s in sectors:
+        cells = [f"{s.start:%d/%m/%Y}",
+                 s.airports.origin, f"{s.start:%H:%M}",
+                 s.airports.dest,
+                 f"{s.start + dt.timedelta(minutes=s.total):%H:%M}",
+                 s.aircraft.type_, s.aircraft.reg]
+        duration = _duration(s.total)
+        cells.extend(_aircraft_class_cells(s, ac_classes, duration))
+        cells.append(duration)
+        cells.append(s.captain)
+        cells.extend([str(s.landings.day or ""), str(s.landings.night or "")])
+        night, ifr = "", ""
+        if s.conditions.night:
+            night = _duration(s.conditions.night)
+        if s.conditions.ifr:
+            ifr = _duration(s.conditions.ifr)
+        cells.extend([night, ifr])
+        cells.extend([_duration(X) if X else ""
+                      for X in (s.roles.p1 + s.roles.p1s, s.roles.p2,
+                                s.roles.put, s.roles.instructor)])
+        cells.append(s.comment)
+        rows.append(f"<tr><td>{'</td><td>'.join(cells)}</td></tr>")
+    return _get_template("logbook-template.html").format(rows="\n".join(rows))
+
+
+def _build_roles(sectors):
+    rpt = {}
+    for s in sectors:
+        type_ = s.aircraft.type_
+        roles = [s.roles.p1, s.roles.p1s, s.roles.p2, s.roles.put]
+        if s.aircraft.type_ not in rpt:
+            rpt[type_] = roles
+        else:
+            rpt[type_] = [X + Y for X, Y in zip(rpt[type_], roles)]
+    rows = []
+    role_total = [0, 0, 0, 0]
+    for type_ in sorted(rpt.keys()):
+        role_total = [X + Y for X, Y in zip(role_total, rpt[type_])]
+        total = sum(rpt[type_])
+        data = '</td><td>'.join([_duration(X) for X in rpt[type_]])
+        rows.append(f"<tr><th>{type_}</th><td>{data}</td>"
+                    f"<td class='total'>{_duration(total)}</td></tr>")
+    data = '</td><td class="total">'.join([_duration(X) for X in role_total])
+    rows.append(f"<tr class='col_total'><th>Total</th><td class='total'>{data}"
+                f"</td><td class='total'>{_duration(sum(role_total))}"
+                f"</td></tr>")
+    return rows
+
+
+def _build_conditions(sectors):
+    cond_pt = {}
+    for s in sectors:
+        type_ = s.aircraft.type_
+        conditions = [s.total - s.conditions.ifr, s.conditions.ifr,
+                      s.total - s.conditions.night, s.conditions.night]
+        if s.aircraft.type_ not in cond_pt:
+            cond_pt[type_] = conditions
+        else:
+            cond_pt[type_] = [X + Y for X, Y in
+                              zip(cond_pt[type_], conditions)]
+    rows = []
+    cond_total = [0, 0, 0, 0]
+    for type_ in sorted(cond_pt.keys()):
+        cond_total = [X + Y for X, Y in zip(cond_total, cond_pt[type_])]
+        data = '</td><td>'.join([_duration(X) for X in cond_pt[type_]])
+        rows.append(f"<tr><th>{type_}</th><td>{data}</td></tr>")
+    data = '</td><td class="total">'.join([_duration(X) for X in cond_total])
+    rows.append(f"<tr class='col_total'><th>Total</th>"
+                f"<td class='total'>{data}</td></tr>")
+    return rows
+
+
+def _build_landings(sectors):
+    ldg_pt = {}
+    for s in sectors:
+        type_ = s.aircraft.type_
+        landings = [s.landings.day, s.landings.night]
+        if s.aircraft.type_ not in ldg_pt:
+            ldg_pt[type_] = landings
+        else:
+            ldg_pt[type_] = [X + Y for X, Y in
+                             zip(ldg_pt[type_], landings)]
+    rows = []
+    landing_total = [0, 0]
+    for type_ in sorted(ldg_pt.keys()):
+        landing_total = [X + Y for X, Y in zip(landing_total, ldg_pt[type_])]
+        data = '</td><td>'.join([str(X) for X in ldg_pt[type_]])
+        total = sum(ldg_pt[type_])
+        rows.append(f"<tr><th>{type_}</th><td>{data}</td>"
+                    f"<td class='total'>{total}</td></tr>")
+    data = '</td><td class="total">'.join([str(X) for X in landing_total])
+    rows.append(f"<tr class='col_total'><th>Total</th>"
+                f"<td class='total'>{data}</td>"
+                f"<td class='total'>{sum(landing_total)}</td></tr>")
+    return rows
+
+
+def build_summary(in_: str) -> str:
+    """Build an HTML file with a summary table.
+
+    :param in_: An EFJ format text file as a string
+    :return: An HTML file as a string
+    """
+    _, sectors = ep.Parser().parse(in_)
+    roles = _build_roles(sectors)
+    conditions = _build_conditions(sectors)
+    landings = _build_landings(sectors)
+    return _get_template("summary-template.html").format(
+        roles_body="\n".join(roles[:-1]),
+        roles_totals=roles[-1],
+        cond_body="\n".join(conditions[:-1]),
+        cond_totals=conditions[-1],
+        ldg_body="\n".join(landings[:-1]),
+        ldg_totals=landings[-1]
+    )