PFCSchemas 0.1.1__tar.gz

pfcschemas-0.1.1/.github/workflows/publish_pypi.yml

@@ -0,0 +1,52 @@
+name: Publish to PyPI and create GH release
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: "Set up Python"
+      uses: actions/setup-python@v4
+      with:
+        python-version-file: "pyproject.toml"
+
+    - name: Install dependencies
+      run: pip install .
+
+    - name: Install pypa / build
+      run: python3 -m pip install build --user
+    
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+  
+  publish-to-pypi:
+    name: Publish Python distribution to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/PFCSchemas
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

pfcschemas-0.1.1/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

pfcschemas-0.1.1/.python-version

@@ -0,0 +1 @@
+3.12

pfcschemas-0.1.1/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

pfcschemas-0.1.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,3 @@
+# PFCSchemas
+
+Pydantic schemas for the pyflightcoach libraries

pfcschemas-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "PFCSchemas"
+description = "Pydantic schemas for the pyflightcoach libraries"
+readme = "README.md"
+authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = ["numpy>=2.1.3", "pandas>=2.2.3", "pydantic>=2.9.2"]
+dynamic = ["version"]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[dependency-groups]
+dev = ["pytest>=8.3.3"]
+lint = ["ruff>=0.7.3"]

pfcschemas-0.1.1/src/pfcschemas/__init__.py

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

pfcschemas-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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)