PFCSchemas 0.1.1__py3-none-any.whl

pfcschemas/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from pfcschemas!"

pfcschemas/ajson.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from pydantic import BaseModel
+from pfcschemas import fcj
+import pandas as pd
+from datetime import datetime
+from pfcschemas.utils.files import validate_json
+from pfcschemas.ma import MA
+from pfcschemas.sinfo import ScheduleInfo
+
+
+class AJson(BaseModel):
+    origin: fcj.Origin | None = None
+    isComp: bool
+    sourceBin: str | None = None
+    sourceFCJ: str | None = None
+    bootTime: datetime | None = None
+    mans: list[MA]
+
+    def schedule(self):
+        schedules = [man.schedule for man in self.mans]
+        if all([s == schedules[0] for s in schedules[1:]]):
+            return schedules[0].fcj_to_pfc()
+        else:
+            return ScheduleInfo.mixed()
+
+    def all_versions(self):
+        versions = set()
+        for man in self.mans:
+            versions |= set(man.history.keys())
+        return list(versions)
+
+    def get_scores(self, version: str, props: fcj.ScoreProperties=None, group="total"):
+        if props is None:
+            props = fcj.ScoreProperties()
+        scores = {}
+        for man in self.mans:
+            if version in man.history:
+                scores[man.name] = man.history[version].get_score(props).__dict__[group]
+        return pd.Series(scores, name=version)
+
+    def create_score_df(
+        self, props: fcj.ScoreProperties, group="total", version: str = "All"
+    ):
+        versions = self.all_versions() if version == "All" else [version]
+        return pd.concat([self.get_scores(ver, props, group) for ver in versions], axis=1)
+
+    def check_version(self, version: str):
+        version = version[1:] if version.startswith('v') else version
+        return all([man.history is not None and version in man.history.keys() for man in self.mans])
+
+    @staticmethod
+    def parse_json(json: dict|str):
+        return AJson.model_validate(validate_json(json))

pfcschemas/fcj.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import datetime
+import re
+
+import pandas as pd
+from pydantic import BaseModel
+from typing import Annotated
+
+
+class FCJ(BaseModel):
+    version: str
+    comments: str
+    name: str
+    view: View
+    parameters: Parameters
+    scored: bool
+    scores: list[float]
+    human_scores: list[HumanResult] = []
+    fcs_scores: list[Result] = []
+    mans: list[Man]
+    data: list[Data]
+    jhash: int | None = None
+
+    def score_df(self):
+        return pd.concat(
+            {fcjr.fa_version: fcjr.to_df() for fcjr in self.fcs_scores},
+            axis=0,
+            names=["version", "manoeuvre", "difficulty", "truncate"],
+        )
+
+    def man_df(self):
+        return pd.DataFrame(
+            [man.__dict__ for man in self.mans[1:-1]],
+            index=pd.Index(range(len(self.mans[1:-1])), name="manoeuvre"),
+        )
+
+    def pfc_version_df(self):
+        sdf = self.score_df().loc[pd.IndexSlice[:, :, 3, False]]
+        return pd.concat(
+            [sdf, sdf.mul(self.man_df().k, axis=0)], axis=1, keys=["raw", "kfac"]
+        )
+
+    def version_summary_df(self):
+        return self.pfc_version_df().groupby("version").kfac.sum()
+
+    def latest_version(self):
+        return max([fcjr.fa_version for fcjr in self.fcs_scores])
+
+    @property
+    def id(self):
+        return re.search(r"\d{8}", self.name)[0]
+
+    @property
+    def created(self):
+        try:
+            return datetime.datetime.strptime(
+                re.search(r"_\d{2}_\d{2}_\d{2}_", self.name)[0], "_%y_%m_%d_"
+            )
+        except Exception:
+            return None
+
+
+class View(BaseModel):
+    position: dict
+    target: dict
+
+
+class Parameters(BaseModel):
+    rotation: float
+    start: int
+    stop: int
+    moveEast: float
+    moveNorth: float
+    wingspan: float
+    modelwingspan: float
+    elevate: float
+    originLat: float
+    originLng: float
+    originAlt: float
+    pilotLat: str | float
+    pilotLng: str | float
+    pilotAlt: str | float
+    centerLat: str | float
+    centerLng: str | float
+    centerAlt: str | float
+    schedule: list[str]
+
+
+class HumanResult(BaseModel):
+    name: str
+    date: datetime.date
+    scores: list[float]
+
+
+class Result(BaseModel):
+    fa_version: str
+    manresults: list[ManResult | None]
+
+    def to_df(self) -> pd.DataFrame:
+        return pd.concat(
+            {i: fcjmr.to_df() for i, fcjmr in enumerate(self.manresults[1:]) if fcjmr},
+            axis=0,
+            names=["manoeuvre", "difficulty", "truncate"],
+        )
+
+
+class ManResult(BaseModel):
+    els: list[El]
+    results: list[Score] = []
+
+    def to_df(self) -> pd.DataFrame:
+        return pd.DataFrame(
+            data=[res.score.__dict__ for res in self.results],
+            index=pd.MultiIndex.from_frame(
+                pd.DataFrame([res.properties.__dict__ for res in self.results])
+            ),
+        )
+
+    def get_score(self, props: ScoreProperties):
+        for r in self.results:
+            if r.properties == props:
+                return r.score
+
+
+class El(BaseModel):
+    name: str
+    start: int
+    stop: int
+
+
+class Score(BaseModel):
+    score: ScoreValues
+    properties: ScoreProperties
+
+
+class ScoreValues(BaseModel):
+    intra: float
+    inter: float
+    positioning: float
+    total: float
+
+
+class ScoreProperties(BaseModel):
+    difficulty: int = 3
+    truncate: bool = False
+
+    def __eq__(self, other):
+        if not isinstance(other, ScoreProperties):
+            return False
+        return self.difficulty == other.difficulty and self.truncate == other.truncate
+
+
+class Man(BaseModel):
+    name: str
+    k: float
+    id: str
+    sp: int
+    wd: float
+    start: int
+    stop: int
+    sel: bool
+    background: str
+
+
+class Data(BaseModel):
+    VN: float = None
+    VE: float = None
+    VD: float = None
+    dPD: float = None  #
+    r: float
+    p: float
+    yw: float
+    N: float
+    E: float
+    D: float
+    time: int
+    roll: float
+    pitch: float
+    yaw: float
+
+
+def get_scores(file: str) -> pd.DataFrame:
+    fcj = FCJ.model_validate_json(open(file, "r").read())
+    return fcj.pfc_version_df()
+
+
+class Origin(BaseModel):
+    lat: Annotated[float, "latitude in degrees"]
+    lng: Annotated[float, "latitude in degrees"]
+    alt: Annotated[float, "height AMSL in meters"]
+    heading: Annotated[float, "heading (direction of box Y axis) in degrees from North"] 
+    move_north: Annotated[float, "non-standard offset of box"]=0
+    move_east: Annotated[float, "non-standard offset of box"]=0
+    move_down: Annotated[float, "non-standard offset of box"]=0
+    

pfcschemas/ma.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import pandas as pd
+from pydantic import BaseModel
+
+from pfcschemas import fcj
+from pfcschemas.sinfo import ScheduleInfo
+from pfcschemas.maninfo import ManInfo
+
+class MDef(BaseModel):
+    info: ManInfo
+    mps: dict
+    eds: dict
+    box: dict
+
+
+class MA(BaseModel):
+    name: str
+    id: int
+    schedule: ScheduleInfo
+    schedule_direction: str | None
+    flown: list[dict] | dict
+
+    history: dict[str, fcj.ManResult] | None = None
+
+    mdef: MDef | None = None
+    manoeuvre: dict | None = None
+    template: list[dict] | dict | None = None
+    corrected: dict | None = None
+    corrected_template: list[dict] | dict | None = None
+    scores: dict | None = None
+
+    def basic(self):
+        return MA(
+            name=self.name,
+            id=self.id,
+            schedule=self.schedule,
+            schedule_direction=self.schedule_direction,
+            flown=self.flown,
+            history=self.history,
+        )
+
+    def add_mdef(self, mdef: MDef) -> MA:
+        return MA(**(self.__dict__ | dict(mdef=mdef)))
+
+    def simplify_history(self):
+        vnames = [v[1:] if v.startswith("v") else v for v in self.history.keys()]
+        vnames_old = vnames[::-1]
+        vnids = [
+            len(vnames) - vnames_old.index(vn) - 1
+            for vn in list(pd.Series(vnames).unique())
+        ]
+
+        return MA(
+            **(
+                self.__dict__
+                | dict(
+                    history={vnames[i]: list(self.history.values())[i] for i in vnids}
+                )
+            )
+        )
+
+
+#        vids = [vnames.rindex(vn) for vn in set(vnames)]

pfcschemas/maninfo.py

@@ -0,0 +1,53 @@
+from .positioning import Position, BoxLocation
+from typing import Tuple, Annotated
+from pydantic import BaseModel
+
+
+class ManInfo(BaseModel):
+    name: str
+    short_name: str
+    k: float
+    position: Position
+    start: BoxLocation
+    end: BoxLocation
+    centre_points: Annotated[
+        list[int],
+        "points that should be centered, ids correspond to the previous element",
+    ] = []
+    centred_els: Annotated[
+        list[Tuple[int, float]], "element ids that should be centered"
+    ] = []
+
+    def to_dict(self):
+        return self.model_dump()
+    
+    @staticmethod
+    def from_dict(data: dict):
+        return ManInfo.model_validate(data)
+
+
+def maninfomaker(
+    name: str,
+    short_name: str,
+    k: float,
+    position: Position,
+    start: BoxLocation,
+    end: BoxLocation,
+    centre_points: Annotated[
+        list[int],
+        "points that should be centered, ids correspond to the previous element",
+    ] = None,
+    centred_els: Annotated[
+        list[Tuple[int, float]], "element ids that should be centered"
+    ] = None,
+):
+    return ManInfo(
+        name=name,
+        short_name=short_name,
+        k=k,
+        position=position,
+        start=start,
+        end=end,
+        centre_points=centre_points if centre_points is not None else [],
+        centred_els=centred_els if centred_els is not None else [],
+    )

pfcschemas/positioning.py

@@ -0,0 +1,100 @@
+import numpy as np
+from pydantic import BaseModel
+from typing import Annotated
+from .utils.enum import EnumStr
+
+
+class Orientation(EnumStr):
+    UPRIGHT = np.pi
+    INVERTED = 0
+
+
+class Heading(EnumStr):
+    RTOL = np.pi
+    LTOR = 0
+    OUTTOIN = 3 * np.pi / 2
+    INTOOUT = np.pi / 2
+
+    @staticmethod
+    def values():
+        return np.array(list(Heading.__members__.values()))
+
+    @staticmethod
+    def infer(bearing: Annotated[float, "in radians from north"]):
+        def check(bearing: float, heading: Heading):
+            return (
+                np.round(np.abs(4 * (bearing - heading.value)) / (2 * np.pi)).astype(
+                    int
+                )
+                % 4
+            ) == 0
+
+        for head in Heading.__members__.values():
+            if check(bearing, head):
+                return head
+        else:
+            raise ValueError(f"Invalid bearing {bearing}")
+
+    def reverse(self):
+        return {
+            Heading.RTOL: Heading.LTOR,
+            Heading.LTOR: Heading.RTOL,
+            Heading.OUTTOIN: Heading.INTOOUT,
+            Heading.INTOOUT: Heading.OUTTOIN,
+        }[self]
+
+
+class Direction(EnumStr):
+    UPWIND = 1
+    DOWNWIND = -1
+    CROSS = 0
+
+    def wind_swap_heading(self, d_or_w: Heading) -> int:
+        match self:
+            case Direction.UPWIND:
+                return d_or_w
+            case Direction.DOWNWIND:
+                return d_or_w.reverse()
+            case Direction.CROSS:
+                return d_or_w
+
+    @staticmethod
+    def parse(s: str):
+        match s[0].lower():
+            case "u":
+                return Direction.UPWIND
+            case "d":
+                return Direction.DOWNWIND
+            case "c":
+                return Direction.CROSS
+            case _:
+                raise ValueError(f"Invalid wind {s}")
+
+
+class Height(EnumStr):
+    BTM = 0.2
+    MID = 0.6
+    TOP = 1.0
+
+
+class Position(EnumStr):
+    CENTRE = 0
+    END = 1
+
+
+class BoxLocation(BaseModel):
+    height: Height
+    direction: Direction | None = None
+    orientation: Orientation | None = None
+
+
+def boxlocationmaker(
+    height: Height,
+    direction: Direction | None = None,
+    orientation: Orientation | None = None,
+):
+    return BoxLocation(
+        height=height,
+        direction=direction,
+        orientation=orientation,
+    )

pfcschemas/sdef.py

@@ -0,0 +1,31 @@
+from flightanalysis import SchedDef
+from pydantic import BaseModel
+
+from pfcschemas.sinfo import ScheduleInfo
+
+
+class DirectionDefinition(BaseModel):
+    manid: int
+    direction: str
+
+    @staticmethod
+    def from_sdef(sdef: SchedDef):
+        manid = sdef.wind_def_manoeuvre()
+        return DirectionDefinition(
+            manid=manid, direction=sdef[manid].info.start.direction.name
+        )
+
+
+class SDefFile(BaseModel):
+    category: str
+    schedule: str
+    direction_definition: DirectionDefinition
+    fa_version: str
+    mdefs: dict[str, dict | list[dict]]
+
+    @property
+    def sinfo(self):
+        return ScheduleInfo(self.category, self.schedule)
+
+    def create_definition(self):
+        return SchedDef.from_dict(self.mdefs)

pfcschemas/sinfo.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Literal
+
+
+fcj_categories = {
+    "F3A FAI": "f3a",
+    "F3A": "f3a",
+    "US AMA": "nsrca",
+    "F3A UK": "f3auk",
+    "F3A US": "nsrca",
+    "IMAC": "imac",
+}
+
+fcj_schedules = {
+    "P23": "p23",
+    "F23": "f23",
+    "P25": "p25",
+    "F25": "f25",
+    "Unlimited 2024": "unlimited2024",
+}
+
+
+def lookup(val, data):
+    val = val.replace("_", " ")
+    return data[val] if val in data else val
+
+
+@dataclass
+class ManDetails:
+    name: str
+    id: int
+    k: float
+    entry: Literal["UPWIND", "DOWNWIND", "CROSS"]
+
+
+@dataclass
+class ScheduleInfo:
+    category: str
+    name: str
+
+    @staticmethod
+    def from_str(fname):
+        if fname.endswith(".sdef"):
+            fname = fname[:-6]
+        info = fname.split("_")
+        if len(info) == 1:
+            return ScheduleInfo("f3a", info[0].lower())
+        else:
+            return ScheduleInfo(info[0].lower(), info[1].lower())
+
+    def __str__(self):
+        return f"{self.category}_{self.name}".lower()
+
+    @staticmethod
+    def lookupCategory(category):
+        return lookup(category, fcj_categories)
+
+    @staticmethod
+    def lookupSchedule(schedule):
+        return lookup(schedule, fcj_schedules)
+
+    @staticmethod
+    def mixed():
+        return ScheduleInfo("na", "mixed")
+
+    def fcj_to_pfc(self):
+        return ScheduleInfo(
+            lookup(self.category, fcj_categories), lookup(self.name, fcj_schedules)
+        )
+
+    def pfc_to_fcj(self):
+        def rev_lookup(val, data):
+            return (
+                next(k for k, v in data.items() if v == val)
+                if val in data.values()
+                else val
+            )
+
+        return ScheduleInfo(
+            rev_lookup(self.category, fcj_categories),
+            rev_lookup(self.name, fcj_schedules),
+        )
+
+    @staticmethod
+    def from_fcj_sch(sch):
+        return ScheduleInfo(*sch).fcj_to_pfc()
+
+    def to_fcj_sch(self):
+        return list(self.pfc_to_fcj().__dict__.values())
+
+    @staticmethod
+    def build(category, name):
+        return ScheduleInfo(category.lower(), name.lower())
+
+    def manoeuvre_details(self) -> list[ManDetails]:
+        mds = []
+
+        for i, (k, v) in enumerate(self.json_data().items()):
+            if isinstance(v, list):
+                v = v[0]
+            mds.append(
+                ManDetails(
+                    v["info"]["short_name"],
+                    i + 1,
+                    v["info"]["k"],
+                    v["info"]["start"]["direction"],
+                )
+            )
+        return mds
+
+    def __eq__(self, other: ScheduleInfo):
+        return str(self.fcj_to_pfc()) == str(other.fcj_to_pfc())

pfcschemas/utils/enum.py

@@ -0,0 +1,31 @@
+from enum import Enum
+from pydantic_core import CoreSchema, core_schema
+from pydantic import GetCoreSchemaHandler
+from typing import Any
+
+##https://github.com/pydantic/pydantic/discussions/6466#discussioncomment-8219585
+class EnumStr(float, Enum):
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, _source_type: Any, _handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls.validate,
+            core_schema.any_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: x.name
+            ),
+        )
+
+    @classmethod
+    def validate(cls, v: Any):
+        if isinstance(v, cls):
+            return v
+        elif isinstance(v, str):
+            try:
+                return cls[v]
+            except KeyError:
+                return None
+#                raise ValueError(f"Invalid {cls.__name__}: {v}")
+        else:
+            raise ValueError(f"Unexpected type: {type(v)}")

pfcschemas/utils/files.py

@@ -0,0 +1,13 @@
+import os
+from json import load
+
+
+def validate_json(file: dict|str|os.PathLike) -> dict:
+    if isinstance(file, dict):
+        return file
+    elif isinstance(file, str) or isinstance(file, os.PathLike):
+        with open(file, 'r') as f:
+            return load(f)
+    else:
+        raise ValueError("expected a dict, str or os.PathLike")
+    

pfcschemas-0.1.1.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: PFCSchemas
+Version: 0.1.1
+Summary: Pydantic schemas for the pyflightcoach libraries
+Author-email: Thomas David <thomasdavid0@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: numpy>=2.1.3
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pydantic>=2.9.2
+Description-Content-Type: text/markdown
+
+# PFCSchemas
+
+Pydantic schemas for the pyflightcoach libraries

pfcschemas-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+pfcschemas/__init__.py,sha256=5_H9g39iYb1gwU5zqH24Vysl7xRPESgeHYm6MvPGRUA,56
+pfcschemas/ajson.py,sha256=DYL8wJPOXcV23tuFcq4VeRWGz8RYwdbpBCGIzYZLP3o,1852
+pfcschemas/fcj.py,sha256=bh9MQ4SUm-HCiS6pYMwl30TJbucqhc0Cohb0o2x3xS0,4553
+pfcschemas/ma.py,sha256=Qqjdvd_rwiNxJiG-HgmGfmwkpyt_8plO0GXg0EnMtRE,1623
+pfcschemas/maninfo.py,sha256=eAsL4udEqXTyXt4QyqGOH64Sfes2LKEGXeUdo78wrlA,1360
+pfcschemas/positioning.py,sha256=2sdZGCh91fqN8jvxsplz4LQFcJVzQVWnSINVNgQpk70,2318
+pfcschemas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfcschemas/sdef.py,sha256=ebiBoo5ZGzYIionyl4qAP0O0j9pemE9bsySfg1ASJFY,744
+pfcschemas/sinfo.py,sha256=9B4zRasA3w_7k1q_GDmZIhk9qp_uzm1MsKVzpegNsWo,2704
+pfcschemas/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfcschemas/utils/enum.py,sha256=xmtyjq6uizAJfDIyyzg9iAGQ9cIjm8DsB04OYmZGQtU,1023
+pfcschemas/utils/files.py,sha256=GBGcptZ3obpY8yvlzEOv7p5H3y9en58zGfTQWLn5Ans,346
+pfcschemas-0.1.1.dist-info/METADATA,sha256=vGWeQ59lehH2FcUnN4Ij0RpkCGdTAwqu1oXTb_W4Pic,379
+pfcschemas-0.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pfcschemas-0.1.1.dist-info/RECORD,,

pfcschemas-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any