aims-convert 2.0__tar.gz → 2.2__tar.gz

{aims_convert-2.0 → aims_convert-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aims-convert
-Version: 2.0
+Version: 2.2
 Summary: Extract useful information from AIMS
 Home-page: https://github.com/JonHurst/aims-convert
 Author: Jon Hurst
@@ -15,6 +15,8 @@ Description-Content-Type: text/markdown
 Requires-Dist: nightflight
 Requires-Dist: bs4
 Requires-Dist: html5lib
+Provides-Extra: unit-tests
+Requires-Dist: freezegun; extra == "unit-tests"
 
 # AIMS Roster Data Extraction #
 

{aims_convert-2.0 → aims_convert-2.2}/aims/cli.py

@@ -5,6 +5,7 @@ import argparse
 
 from aims.parse import parse
 import aims.output as output
+from aims.version import VERSION
 
 
 def _args():
@@ -12,14 +13,17 @@ def _args():
         description=(
             'Process an AIMS detailed roster into various useful formats.'))
     parser.add_argument('format',
-                        choices=['roster', 'efj', 'csv', 'ical'])
+                        choices=['roster', 'efj', 'csv', 'ical', 'version'])
     parser.add_argument('--ade', action="store_true")
     return parser.parse_args()
 
 
 def main() -> int:
     args = _args()
-    duties = parse(sys.stdin.read())
+    if args.format == "version":
+        print(f"Version: {VERSION}")
+        return 0
+    duties, ade = parse(sys.stdin.read())
     if args.format == "roster":
         print(output.roster(duties))
     elif args.format == "efj":
@@ -27,7 +31,9 @@ def main() -> int:
     elif args.format == "csv":
         print(output.csv(duties))
     elif args.format == "ical":
-        print(output.ical(duties, args.ade))
+        if not args.ade:
+            ade = ()
+        print(output.ical(duties, ade))
     return 0
 
 

{aims_convert-2.0 → aims_convert-2.2}/aims/data_structures.py

@@ -2,6 +2,16 @@ from typing import NamedTuple, Optional
 import datetime as dt
 
 
+class AllDayEvent(NamedTuple):
+    date: dt.date
+    code: str
+
+
+class CrewMember(NamedTuple):
+    name: str
+    role: str
+
+
 class Sector(NamedTuple):
     name: str
     reg: Optional[str]
@@ -12,26 +22,18 @@ class Sector(NamedTuple):
     on: dt.datetime
     quasi: bool
     position: bool
-
-
-class CrewMember(NamedTuple):
-    name: str
-    role: str
+    crew: tuple[CrewMember, ...]
 
 
 class Duty(NamedTuple):
-    code: Optional[str]  # only all day event has code
     start: dt.datetime
-    finish: Optional[dt.datetime]  # all day event has None
+    finish: dt.datetime
     sectors: tuple[Sector, ...]
-    crew: tuple[CrewMember, ...]
 
 
 class RosterException(Exception):
-
-    def __str__(self):
-        return self.__doc__
+    "Base class"
 
 
 class InputFileException(RosterException):
-    "Input file does not appear to be an AIMS roster."
+    "Error in input file"

{aims_convert-2.0 → aims_convert-2.2}/aims/gui.py

@@ -9,8 +9,8 @@ import ctypes
 import aims.parse
 from aims.data_structures import RosterException, InputFileException
 from aims.output import csv, ical, efj
+from aims.version import VERSION
 
-VERSION = "2.0"
 
 SETTINGS_FILE = os.path.expanduser("~/.aimsgui")
 
@@ -328,7 +328,7 @@ class MainWindow(ttk.Frame):
         self.txt.insert(tk.END, "Getting registration and type info...")
         self.txt.update()
 
-        duties = aims.parse.parse(html)
+        duties, _ = aims.parse.parse(html)
         # note: normalise newlines for Text widget - will restore on output
         txt = csv(duties).replace("\r\n", "\n")
         self.txt.delete('1.0', tk.END)
@@ -338,9 +338,11 @@ class MainWindow(ttk.Frame):
         html = self.__roster_html()
         if not html:
             return
-        duties = aims.parse.parse(html)
+        duties, ade = aims.parse.parse(html)
         # note: normalise newlines for Text widget - will restore on output
-        txt = ical(duties, self.ms.with_ade.get()).replace("\r\n", "\n")
+        if not self.ms.with_ade.get():
+            ade = ()
+        txt = ical(duties, ade).replace("\r\n", "\n")
         self.txt.delete('1.0', tk.END)
         self.txt.insert(tk.END, txt, 'ical')
 
@@ -351,7 +353,7 @@ class MainWindow(ttk.Frame):
         self.txt.delete('1.0', tk.END)
         self.txt.insert(tk.END, "Working…", 'efj')
         self.txt.update()
-        duties = aims.parse.parse(html)
+        duties, _ = aims.parse.parse(html)
         txt = efj(duties)
         self.txt.delete('1.0', tk.END)
         self.txt.insert(tk.END, txt, 'efj')

{aims_convert-2.0 → aims_convert-2.2}/aims/logbook_report.py

@@ -1,11 +1,10 @@
-#!/usr/bin/python3
 import datetime as dt
-from bs4 import BeautifulSoup  # type: ignore
-import sys
 import re
 from typing import Optional
 
-from aims.data_structures import Duty, Sector, CrewMember
+from bs4 import BeautifulSoup  # type: ignore
+
+from aims.data_structures import Duty, Sector, CrewMember, AllDayEvent
 
 
 DATE, FLTNUM, FROM, OFF, TO, ON, TYPE, REG, BLOCK, CP = range(1, 11)
@@ -23,29 +22,24 @@ def _sector(row: tuple[str, ...]) -> Optional[Sector]:
         dt.datetime.strptime(row[ON], "%H:%M").time())
     if on < off:
         on += dt.timedelta(1)
+    crew = (CrewMember(row[CP], "CP"), )
     return Sector(row[FLTNUM], row[REG], row[TYPE],
                   row[FROM], row[TO],
                   off, on,
-                  False, False)
+                  False, False, crew)
 
 
-def _duty(
-        sectors: tuple[Sector, ...],
-        crew: dict[dt.datetime, str]
-) -> Duty:
+def _duty(sectors: tuple[Sector, ...]) -> Duty:
     lowest_off = min([X.off for X in sectors])
     highest_on = max([X.on for X in sectors])
-    cpt_names = set([crew[X.off].replace("\xa0", " ") for X in sectors])
-    return Duty(None,
-                lowest_off - dt.timedelta(hours=1),
+    return Duty(lowest_off - dt.timedelta(hours=1),
                 highest_on + dt.timedelta(minutes=30),
-                sectors,
-                tuple(CrewMember(X, "CP") for X in sorted(cpt_names) if X))
+                sectors)
 
 
-def duties(soup) -> tuple[Duty, ...]:
+def duties(html) -> tuple[tuple[Duty, ...], tuple[AllDayEvent, ...]]:
+    soup = BeautifulSoup(html, "html5lib")
     sectors: list[Sector] = []
-    crew: dict[dt.datetime, str] = {}
     re_date = re.compile(r"^\d{2}/\d{2}/\d{2}$")
     for row in soup.find_all("tr"):
         strings = tuple(Y[0].replace("\xa0", " ") if Y else "" for Y in
@@ -54,7 +48,6 @@ def duties(soup) -> tuple[Duty, ...]:
             sector = _sector(strings)
             if sector:
                 sectors.append(sector)
-                crew[sector.off] = strings[CP]
     groups = [[sectors[0]]]
     last_on = sectors[0].on
     for sector in sectors[1:]:
@@ -63,13 +56,4 @@ def duties(soup) -> tuple[Duty, ...]:
         else:
             groups[-1].append(sector)
         last_on = sector.on
-    return tuple(_duty(tuple(X), crew) for X in groups)
-
-
-if __name__ == "__main__":
-    soup = BeautifulSoup(sys.stdin.read(), "html5lib")
-    for d in duties(soup):
-        print(d.start, d.finish, d.crew)
-        for s in d.sectors:
-            print("    ", s)
-        print("----")
+    return (tuple(_duty(tuple(X)) for X in groups), ())

{aims_convert-2.0 → aims_convert-2.2}/aims/output.py

@@ -5,12 +5,15 @@ import io
 import csv as libcsv
 import datetime as dt
 import re
-from typing import Optional
+import itertools
 
-from aims.data_structures import Duty, Sector, CrewMember
+from aims.data_structures import Duty, Sector, CrewMember, AllDayEvent
 import nightflight.night as nightcalc  # type: ignore
 from nightflight.airport_nvecs import airfields as nvecs  # type: ignore
 
+UTC = Z("UTC")
+LT = Z("Europe/London")
+
 
 def clean_name(name: str) -> str:
     parts = [X.strip().capitalize() for X in name.split()]
@@ -52,46 +55,68 @@ def _night(sector: Sector) -> tuple[int, bool]:
     return (round(night_duration), night_landing)
 
 
-def _roster_sectors(
-        sectors: tuple[Sector, ...]
-) -> tuple[tuple[str, ...], int]:
-    airports: list[str] = []
+def _build_roster_string(start, end, block, string):
+    start, end = [X.replace(tzinfo=UTC).astimezone(LT)
+                  for X in (start, end)]
+    duration = int((end - start).total_seconds()) // 60
+    duration_str = f"{duration // 60}:{duration % 60:02d}"
+    block_str = f"{block // 60}:{block % 60:02d}"
+    return (f"{start:%d/%m/%Y %H:%M}-{end:%H:%M} "
+            f"{string} {block_str}/{duration_str}")
+
+
+def _roster_quasi(
+        qsectors: tuple[Sector, ...],
+        cursor: dt.datetime
+) -> tuple[tuple[str, ...], dt.datetime]:
+    retval: list[str] = []
+    name = "Brief"
+    for s in qsectors:
+        if cursor < s.off:
+            retval.append(_build_roster_string(cursor, s.off, 0, name))
+            name = "Debrief"
+        retval.append(_build_roster_string(s.off, s.on, 0, s.name))
+        cursor = s.on
+    return (tuple(retval), cursor)
+
+
+def _roster_real(
+        sectors: tuple[Sector, ...],
+        cursor: dt.datetime
+) -> tuple[str, dt.datetime]:
+    assert sectors[0].from_
+    airports: list[str] = [sectors[0].from_]
     block = 0
-    from_: Optional[str] = None
+    start = cursor
     for sector in sectors:
-        if not from_ and sector.from_:
-            from_ = sector.from_
         if sector.position:
             airports.append("[psn]")
-        elif sector.quasi:
-            if sector.from_:
-                airports.append(f"[{sector.name}]")
-            else:
-                airports.append(sector.name)
-        if sector.to:
-            airports.append(sector.to)
-        if not sector.quasi and not sector.position:
+        else:
             block += int((sector.on - sector.off).total_seconds()) // 60
-    if from_:
-        airports = [from_] + airports
-    return tuple(airports), block
+        assert sector.to
+        airports.append(sector.to)
+    cursor = sectors[-1].on + dt.timedelta(minutes=30)
+    return (
+        _build_roster_string(start, cursor, block, '-'.join(airports)),
+        cursor)
 
 
 def roster(duties: tuple[Duty, ...]) -> str:
-    UTC = Z("UTC")
-    LT = Z("Europe/London")
-    output = []
+    output: list[str] = []
     for duty in duties:
-        if not duty.finish:
+        if not duty.finish:  # an all day duty
             continue
-        start, end = [X.replace(tzinfo=UTC).astimezone(LT)
-                      for X in (duty.start, duty.finish)]
-        duration = int((end - start).total_seconds()) // 60
-        airports, block = _roster_sectors(duty.sectors)
-        duration_str = f"{duration // 60}:{duration % 60:02d}"
-        block_str = f"{block // 60}:{block % 60:02d}"
-        output.append(f"{start:%d/%m/%Y %H:%M}-{end:%H:%M} "
-                      f"{'-'.join(airports)} {block_str}/{duration_str}")
+        cursor = duty.start
+        for k, g in itertools.groupby(duty.sectors, key=lambda X: X.quasi):
+            if k:  # group of quasi sectors
+                new_output, cursor = _roster_quasi(tuple(g), cursor)
+                output += new_output
+            else:  # group of real sectors
+                new, cursor = _roster_real(tuple(g), cursor)
+                output.append(new)
+        if cursor < duty.finish:
+            output.append(
+                _build_roster_string(cursor, duty.finish, 0, "Debrief"))
     return "\n".join(output)
 
 
@@ -118,13 +143,16 @@ def efj(duties: tuple[Duty, ...]) -> str:
         if (len(duty.sectors) == 1 and duty.sectors[0].quasi):
             comment = f" #{duty.sectors[0].name}"
         output.append(f"{duty.start:%H%M}/{duty.finish:%H%M}{comment}")
-        if duty.crew:
-            crew = [f"{X.role}:{clean_name(X.name)}" for X in duty.crew]
-            output.append(f"{{ {', '.join(crew)} }}")
         last_airframe = None
+        last_crew = None
         for sector in duty.sectors:
             if sector.position or sector.quasi:
                 continue
+            if sector.crew:
+                crew = [f"{X.role}:{clean_name(X.name)}" for X in sector.crew]
+                if crew != last_crew:
+                    output.append(f"{{ {', '.join(crew)} }}")
+                last_crew = crew
             reg = sector.reg or "?-????"
             type_ = sector.type_ or "???"
             if last_airframe != (reg, type_):
@@ -145,10 +173,10 @@ def csv(duties: tuple[Duty, ...]) -> str:
         extrasaction='ignore')
     writer.writeheader()
     for duty in duties:
-        crew = [CrewMember(clean_name(X[0]), X[1]) for X in duty.crew]
         for sector in duty.sectors:
             if sector.position or sector.quasi:
                 continue
+            crew = [CrewMember(clean_name(X[0]), X[1]) for X in sector.crew]
             out_dict = {
                 'Off Blocks': sector.off,
                 'On Blocks': sector.on,
@@ -243,20 +271,18 @@ def _build_dict(duty: Duty) -> dict[str, str]:
     return event
 
 
-def ical(duties: tuple[Duty, ...], do_ade) -> str:
+def ical(duties: tuple[Duty, ...], ade: tuple[AllDayEvent, ...]) -> str:
     events = []
     for duty in duties:
-        if duty.finish:
-            d = _build_dict(duty)
-            events.append(vevent.format(**d))
-        elif do_ade:
-            date = duty.start.date()
-            uid = "{}{}@HURSTS.ORG.UK".format(
-                date.isoformat(), duty.code)
-            modified = ical_datetime.format(dt.datetime.utcnow())
-            events.append(advevent.format(
-                day=date,
-                ev=duty.code,
+        d = _build_dict(duty)
+        events.append(vevent.format(**d))
+    for e in ade:
+        uid = "{}{}@HURSTS.ORG.UK".format(
+            e.date.isoformat(), e.code)
+        modified = ical_datetime.format(dt.datetime.utcnow())
+        events.append(advevent.format(
+                day=e.date,
+                ev=e.code,
                 modified=modified,
                 uid=uid))
     return vcalendar.format("\r\n".join(events))

aims_convert-2.2/aims/parse.py

@@ -0,0 +1,16 @@
+from aims.data_structures import Duty, AllDayEvent, InputFileException
+import aims.roster
+import aims.logbook_report
+
+
+def parse(html: str) -> tuple[tuple[Duty, ...], tuple[AllDayEvent, ...]]:
+    # check it's an html5 file
+    html5_header = "<!DOCTYPE html><html>"
+    if html[:len(html5_header)] != html5_header:
+        raise InputFileException("HTML5 header not found.")
+    if html.find("Personal&nbsp;Crew&nbsp;Schedule&nbsp;Report") != -1:
+        return aims.roster.duties(html)
+    elif html.find("Pilot&nbsp;Logbook") != -1:
+        return aims.logbook_report.duties(html)
+    else:
+        raise InputFileException("Report type marker not found")

aims_convert-2.2/aims/roster.py

@@ -0,0 +1,239 @@
+"""Processes the data extracted from a 'vertical' HTML AIMS roster.
+
+The module's public interface is the duties() function, which accepts "soup" as
+produced by processing the roster with BeautifulSoup.
+"""
+
+import datetime as dt
+import re
+
+from bs4 import BeautifulSoup  # type: ignore
+
+from aims.data_structures import (
+    Duty, Sector, CrewMember, AllDayEvent, InputFileException)
+
+
+Row = tuple[tuple[str, ...], ...]
+
+# column indices
+DATE, CODES, DETAILS, DSTART, TIMES, DEND, BHR, DHR, IND, CREW = range(1, 11)
+
+
+def _convert_datestring(in_: str) -> dt.date:
+    return dt.datetime.strptime(in_.split()[0], "%d/%m/%Y").date()
+
+
+def _convert_timestring(in_: str, date: dt.date) -> dt.datetime:
+    if in_[-2:] == "⁺¹":
+        in_ = in_[:-2]
+        date = date + dt.timedelta(1)
+    in_ = in_.replace("A", "").replace("E", "")
+    time = dt.datetime.strptime(in_, "%H:%M").time()
+    return dt.datetime.combine(date, time)
+
+
+def _crew(strings: tuple[str, ...]) -> tuple[CrewMember, ...]:
+    """Convert crew cell to a tuple of CrewMember objects.
+
+    Each string may either represent a crew member or be a continuation of a
+    crew member's name if the details didn't all fit on one line. In the first
+    case the line will start with "CP -", "FO -" etc. The line is split on a
+    space if it is split.
+
+    For postioning crew, the string has the form "CP - PAX - 1234 - NAME MY".
+    Positioning crew should not be included in the crew list.
+
+    :param strings: The tuple of strings from the crew field of a duty record.
+    :return: A tuple of CrewMember objects.
+
+    """
+    re_first = re.compile(r"[A-Z]{2} - ")
+    joined_strings: list[str] = []
+    for s in strings:
+        if re_first.match(s):
+            joined_strings.append(s)
+        else:
+            joined_strings[-1] += f" {s}"
+    crew: list[CrewMember] = []
+    for j in joined_strings:
+        fields = j.split(" - ")
+        if len(fields) < 3:
+            raise InputFileException("Bad crew block")
+        if fields[1] != "PAX":
+            crew.append(CrewMember(fields[-1], fields[0]))
+    return tuple(crew)
+
+
+def _sectors(data: Row, date: dt.date) -> tuple[Sector, ...]:
+    retval = []
+    for c, code in enumerate(data[CODES]):
+        code_split = code.split()
+        name = code_split[0]
+        type_ = None
+        if len(code_split) == 2 and code_split[1][0] == "[":
+            type_ = code_split[1][1:-1]
+        airports = [X.strip() for X in data[DETAILS][c].split(" - ")]
+        times = data[TIMES][c].split("/")[0].split(" - ")
+        crew = _crew(data[CREW])
+        if len(airports) == 2:  # Not an all day event or unused standby
+            position = False
+            if airports[0][0] == "*":  # Either ground or air positioning
+                airports[0] = airports[0][1:]
+                position = True
+            quasi = False
+            if not type_:  # If no type in code, assume quasi sector
+                quasi = True
+                crew = ()
+            retval.append(
+                Sector(name, None, type_, airports[0], airports[1],
+                       _convert_timestring(times[0], date),
+                       _convert_timestring(times[1], date),
+                       quasi, position, tuple(crew)))
+        else:
+            retval.append(
+                Sector(name, None, None, None, None,
+                       _convert_timestring(times[0], date),
+                       _convert_timestring(times[1], date),
+                       True, False, tuple(crew)))
+    return tuple(retval)
+
+
+def _duty(row: Row) -> Duty:
+    """Creates a Duty object from a structured representation of an HTML row.
+
+    The input object is a 12 cell tuple with each cell containing the contents
+    of a "td" from the original HTML row. The contents are in the form of a
+    variable length tuple of strings since the original contents of the cells
+    can be multi-line. The first and last items are empty tuples since the
+    original table has empty cells at the beginning and end of each row.
+
+    The items in the row, from index 1 to index 10 are:
+
+    1: Date of the form "01/01/2000 Mon", which may be split over two lines at
+       the space.
+
+    2: Either:
+
+       + An empty tuple for an unpublished duty; or
+
+       + For all day duties, the code for the all day duty; or
+
+       + For normal sectors, the flight number plus aircraft type in square
+         brackets e.g. "1234 [320]", one for each sector in the duty; or
+
+       + For quasi sectors, the code of the quasi sector (e.g. "ESBY", "ADTY",
+         "TAXI123"), one for each quasi sector in the duty. These can be mixed
+         in with normal sectors.
+
+    3: Either:
+
+       + For all day duties, a textual description of the duty; or
+
+       + For sectors, the airports invloved in the form "BRS - FNC", one for
+         each sector or quasi sector in the duty. For quasi sectors the two
+         airports may be the same (e.g. "LGW - LGW" for a sim) or, to indicate
+         postioning, may start with a "*" (e.g "*LGW - BRS" for a taxi ride).
+
+    4: Report time. This is not necessarily duty start time -- there may be
+       standby duties before report, and it is empty for standbys without a
+       call out.
+
+    5: Sector times of the form "11:00 - 13:00", one for each sector in the
+       duty, including for quasi sectors. For duties that have already taken
+       place, the fact that the times are actual times may be indicated with an
+       "A", giving the form "A11:00 - A13:00", although this doesn't seem to be
+       especially consistently done. The string for the last sector may also
+       incorporate the delay in the form "A11:00 - A13:00/01:00". For an all
+       day duty there are no times to record, and hence the cell will be an
+       empty tuple.
+
+    6: Duty end time. Empty for standby without callout.
+
+    7: Block hours
+
+    8: Duty hours
+
+    9: Markers for memos etc.
+
+    10: Crew list, one string per crew member. The crew is associated with the
+        entire duty rather than per sector.
+
+    :param row: A 12 cell tuple, with each cell a tuple of strings.
+    :return: The Duty object represented by the row.
+
+    """
+    try:
+        assert row[CODES] and row[TIMES]
+        date = _convert_datestring(row[DATE][0])
+        if row[DSTART]:
+            assert row[DEND]
+            start = _convert_timestring(row[DSTART][0], date)
+            end = _convert_timestring(row[DEND][0], date)
+        else:
+            # If duty start/finish does not exist, take the times from
+            # the only sector.
+            assert len(row[TIMES]) == 1
+            times = row[TIMES][0].split(" - ")
+            start = _convert_timestring(times[0], date)
+            end = _convert_timestring(times[1], date)
+        sectors = _sectors(row, date)
+        # on duty can be before report if quasi sectors at start
+        for sector in sectors:
+            if not sector.quasi:
+                break
+            start = min(start, sector.off)
+            end = max(end, sector.on)
+        return Duty(start, end, sectors)
+    except (IndexError, ValueError):
+        raise InputFileException(f"Bad Duty Record: {str(row)}")
+
+
+def _ade(row: Row) -> AllDayEvent:
+    try:
+        return AllDayEvent(_convert_datestring(row[DATE][0]), row[CODES][0])
+    except (IndexError, ValueError):
+        raise InputFileException(f"Bad All Day Duty Record: {str(row)}")
+
+
+def duties(html: str) -> tuple[tuple[Duty, ...], tuple[AllDayEvent, ...]]:
+    """Extract the data from an AIMS vertical roster.
+
+    The entire document is a single table (how retro!). The interesting part
+    starts with the row two rows below the row with a cell containing the
+    phrase "Schedule Details" and ends with the row above the first row with a
+    blank date field. Each row between these represents a single duty or an all
+    dat event.
+
+    The date to the left of each row is the date that the duty started on. If
+    duties continue past midnight, relevant times are marked with a superscript
+    '+1' rather than being pushed to the next row of the table. This makes the
+    vertical roster much saner to parse than the alternatives since there are
+    no concerns about missing data at the start and end of the roster period.
+
+    :param html: The html of a 'vertical' HTML AIMS roster.
+    :return: A tuple of Duty objects and a tuple of AllDayEvent objects
+
+    """
+    soup = BeautifulSoup(html, "html5lib")
+    rows = iter(soup.find_all("tr"))
+    try:
+        while "Schedule Details" not in next(rows).stripped_strings:
+            pass
+        next(rows)
+        duty_list: list[Duty] = []
+        ade_list: list[AllDayEvent] = []
+        while True:
+            row: Row = tuple(
+                tuple(Y.replace("\xa0", " ") for Y in X.stripped_strings)
+                for X in next(rows)("td"))
+            if not row[DATE]:  # line without date ends table
+                break
+            if not row[CODES]:  # unpublished duty
+                continue
+            if not row[TIMES]:  # an all day event
+                ade_list.append(_ade(row))
+            elif duty := _duty(row):  # a normal duty
+                duty_list.append(duty)
+        return (tuple(duty_list), tuple(ade_list))
+    except (StopIteration, IndexError):
+        raise InputFileException("Duty table ended unexpectedly")

aims_convert-2.2/aims/version.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+
+VERSION = version("aims-convert")

{aims_convert-2.0 → aims_convert-2.2}/aims_convert.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aims-convert
-Version: 2.0
+Version: 2.2
 Summary: Extract useful information from AIMS
 Home-page: https://github.com/JonHurst/aims-convert
 Author: Jon Hurst
@@ -15,6 +15,8 @@ Description-Content-Type: text/markdown
 Requires-Dist: nightflight
 Requires-Dist: bs4
 Requires-Dist: html5lib
+Provides-Extra: unit-tests
+Requires-Dist: freezegun; extra == "unit-tests"
 
 # AIMS Roster Data Extraction #