flightdata 0.2.20__tar.gz → 0.2.22__tar.gz

{flightdata-0.2.20/flightdata.egg-info → flightdata-0.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.20
+Version: 0.2.22
 Summary: Module for handling UAV flight log data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -11,13 +11,13 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: simplejson
-Requires-Dist: pfc-geometry>=0.2.11
+Requires-Dist: pfc-geometry>=0.2.12
 Requires-Dist: json_stream
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
 Requires-Dist: simplejson; extra == "dev"
-Requires-Dist: pfc-geometry>=0.2.11; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.12; extra == "dev"
 Requires-Dist: ardupilot-log-reader>=0.3.3; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/__init__.py

@@ -1,9 +1,12 @@
+from .schemas import fcj
 from .base import *
 from .bindata import BinData
-from .origin import Origin
+from .origin import Origin, FCJOrigin
 from .flight import *
 from .environment import *
 from .coefficients import Coefficients
 from .flow import Flow, Attack
 from .state import State
-from .model import *
+from .model import *
+
+

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/base/constructs.py

@@ -8,9 +8,7 @@
     rvel = rotational velocity (body axis rates)
 
     """
-import numpy as np
-import pandas as pd
-from typing import List, Dict, Union
+from typing import Union
 from .collection import Collection
 from itertools import chain
 
@@ -31,18 +29,18 @@ class Constructs(Collection):
         super().__init__(data)
         self._cols = list(chain(*[c.keys for c in self.data.values()]))
 
-    def subset(self, names: List[str]):
+    def subset(self, names: list[str]):
         """get a subset of the constructs"""
         return Constructs({key: value for key, value in self.data.items() if key in names})
 
-    def existing(self, vars: List[str]):
+    def existing(self, vars: list[str]):
         """return a subset that is fully populated by the list of keys input"""
         return self.subset([
             key for key, value in self.data.items() 
             if all(val in vars for val in value.keys)
         ])
 
-    def missing(self, vars: List[str]):
+    def missing(self, vars: list[str]):
         """return a subset that has not been populated by the list of vars"""
         return self.subset([
             key for key, value in self.data.items() 

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/bindata.py

@@ -4,7 +4,8 @@ import numpy as np
 import pandas as pd
 import logging
 
-logger = logging.getLogger(__name__)    
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class BinData:
@@ -15,6 +16,14 @@ class BinData:
             return self.dfs[name]
         raise AttributeError(f"No such attribute: {name}")
 
+    def get_dft(self, df_name: str, t: float, coren: str|None='C', coreid: int=0) -> pd.DataFrame:
+        bdx = self.dfs[df_name].copy()
+        bdx['TimeUS'] = bdx.TimeUS / 1e6
+        if coren and coren in bdx.columns:
+            bdx = bdx.loc[bdx[coren]==coreid]
+        bdx = bdx.set_index('TimeUS')
+        return bdx.iloc[bdx.index.get_indexer([t], method='nearest')]
+
     def parameters(self) -> dict[str, pd.DataFrame]:
         gb = self.PARM.groupby("Name")
 
@@ -35,11 +44,10 @@ class BinData:
     @staticmethod
     def parse_json(bindata: dict[str, dict[str, list]]) -> BinData:
         # dfs = {k: pd.DataFrame(v) for k,v in bindata.items()}
-        
+
         dfs: dict[str, pd.DataFrame] = {}
         groups = {}
         for k, v in bindata.items():
-
             if k == "PARM":
                 new_df = pd.DataFrame(
                     [
@@ -49,17 +57,23 @@ class BinData:
                     ],
                     index=["time_boot_s", "Name", "Value"],
                 ).T
-                if 'Default' in v:
+                if "Default" in v:
                     new_df["Default"] = v["Default"]
-
-
+            elif k == "MSG":
+                new_df = pd.DataFrame(
+                    [
+                        pd.Series(v["time_boot_s"]).reset_index(drop=True),
+                        pd.Series(v["Message"]),
+                    ],
+                    index=["time_boot_s", "Message"],
+                ).T
             else:
                 try:
-                    new_df = pd.DataFrame(v)    
+                    new_df = pd.DataFrame(v)
                 except Exception as ex:
                     logger.info(f"Error parsing {k}: {ex}")
                     new_df = None
-            
+
             if new_df is not None:
                 if "[" not in k:
                     dfs[k] = new_df
@@ -68,7 +82,7 @@ class BinData:
                     if nk not in groups:
                         groups[nk] = []
                     groups[nk].append(new_df)
-            
+
         for k, v in groups.items():
             dfs[k] = pd.concat(v).sort_values("time_boot_s")
 
@@ -76,12 +90,12 @@ class BinData:
             start_time = (
                 BinData._gpsTimeToTime(dfs["GPS"].GWk.iloc[0], dfs["GPS"].GMS.iloc[0])
                 - dfs["GPS"].time_boot_s.iloc[0]
-            ) 
+            )
         else:
-            start_time = 0 
+            start_time = 0
 
         def process_df(df: pd.DataFrame) -> pd.DataFrame:
-            df.insert(0, "TimeUS", np.floor(df.time_boot_s * 1e6)) # ms
+            df.insert(0, "TimeUS", np.floor(df.time_boot_s * 1e6))  # ms
             df.insert(0, "timestamp", start_time + df.time_boot_s)
 
             return df.drop(columns="time_boot_s")

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/flight/fields.py

@@ -29,7 +29,7 @@ class Fields:
         self.data = data
         self.groups = {}
         for v in data.values():
-            if not v.field in self.groups:
+            if v.field not in self.groups:
                 self.groups[v.field] = []
             self.groups[v.field].append(v)
         

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/flight/flight.py

@@ -21,9 +21,11 @@ from time import time
 from json import load, dump
 from flightdata.base.numpy_encoder import NumpyEncoder
 from .ardupilot import flightmodes
-from flightdata import Origin
+from flightdata import Origin, fcj
 from numbers import Number
 from scipy.signal import filtfilt, butter
+from datetime import datetime
+
 
 def filter(data, cutoff=25, order=5, fs=25):
     return filtfilt(
@@ -32,6 +34,7 @@ def filter(data, cutoff=25, order=5, fs=25):
         padlen=len(data) - 1,
     )
 
+
 class Flight:
     ardupilot_types = [
         "XKF1",
@@ -92,10 +95,11 @@ class Flight:
                     ]
             except KeyError:
                 if isinstance(cols, Field):
-                    cols = [cols]
-                return pd.DataFrame(
-                    data=np.empty((len(self), len(cols))), columns=[f.col for f in cols]
-                )
+                    return pd.Series(np.full(len(self), np.nan), name=cols.col)
+                else:
+                    return pd.DataFrame(
+                        data=np.full((len(self), len(cols)), np.nan), columns=[f.col for f in cols]
+                    )
         raise AttributeError(f"'Flight' object has no attribute '{name}'")
 
     def make_param_labels(
@@ -132,23 +136,17 @@ class Flight:
             if sli < 0:
                 return self.data.iloc[sli]
             else:
-                gl = self.data.index.get_loc(sli + self.data.index[0])
+                gl = self.data.index.get_indexer([sli], method="nearest")
                 return Flight(
                     self.data.iloc[gl],
-                    self.parameters.loc[:gl],
+                    self.parameters[:sli] if self.parameters else None,
+                    self.origin,
+                    self.primary_pos_source,
                 )
         elif isinstance(sli, slice):
             return Flight(
-                self.data.loc[
-                    slice(
-                        None if sli.start is None else sli.start + self.data.index[0],
-                        None if sli.stop is None else sli.stop + self.data.index[0],
-                        sli.step,
-                    )
-                ],
-                self.parameters.loc[
-                    : None if sli.stop is None else sli.stop + self.data.index[0]
-                ],
+                self.data.loc[slice(sli.start, sli.stop, sli.step)],
+                self.parameters[:sli.stop] if self.parameters else None,
                 self.origin,
                 self.primary_pos_source,
             )
@@ -312,6 +310,10 @@ class Flight:
         except Exception:
             return False
 
+    def boot_time(self):
+        timestamp = self.time_actual.iloc[0]
+        return datetime.fromtimestamp(timestamp) if not np.isnan(timestamp) else None
+
     @staticmethod
     def from_log(
         log: str,
@@ -324,8 +326,9 @@ class Flight:
         ppsource = xkf or pos
         """
         parser = log
-        if not hasattr(log, 'dfs'):
+        if not hasattr(log, "dfs"):
             from ardupilot_log_reader.reader import Ardupilot
+
             parser = Ardupilot.parse(
                 str(log),
                 types=list(
@@ -400,15 +403,13 @@ class Flight:
             )
 
             for i, df in enumerate(newdfs):
-
                 ekffs = 1 / np.mean(np.diff(df.time_actual))
-                ps = '' if i == 0 else f"_{i}"
-                df[f'velocity_N{ps}'] = filter(df[f'velocity_N{ps}'], 5, 5, ekffs)
-                df[f'velocity_E{ps}'] = filter(df[f'velocity_E{ps}'], 5, 5, ekffs)
-                df[f'velocity_D{ps}'] = filter(df[f'velocity_D{ps}'], 5, 5, ekffs)
+                ps = "" if i == 0 else f"_{i}"
+                df[f"velocity_N{ps}"] = filter(df[f"velocity_N{ps}"], 5, 5, ekffs)
+                df[f"velocity_E{ps}"] = filter(df[f"velocity_E{ps}"], 5, 5, ekffs)
+                df[f"velocity_D{ps}"] = filter(df[f"velocity_D{ps}"], 5, 5, ekffs)
                 dfs.append(df)
 
-
         if ekf2 is not None:
             dfs = dfs + Flight.parse_instances(
                 ekf2,
@@ -439,7 +440,10 @@ class Flight:
             if ekf1 is not None:
                 if "C" in ekf1.columns:
                     imu = pd.merge_asof(
-                        imu, ekf1.loc[ekf1.C == imu_instance], on="timestamp", direction="nearest"
+                        imu,
+                        ekf1.loc[ekf1.C == imu_instance],
+                        on="timestamp",
+                        direction="nearest",
                     )
                 else:
                     imu = pd.merge_asof(imu, ekf1, on="timestamp", direction="nearest")
@@ -463,18 +467,18 @@ class Flight:
                     imu["AccX"] = imu.AccX + imu.AX / 100
                     imu["AccY"] = imu.AccY + imu.AY / 100
                     imu["AccZ"] = imu.AccZ + imu.AZ / 100
-            
+
             _imufs = 1 / np.mean(np.diff(imu.timestamp))
-            
+
             dfs.append(
                 Flight.build_cols(
                     time_actual=imu.timestamp,
-                    acceleration_x=filter(imu.AccX,10, 5, _imufs),
-                    acceleration_y=filter(imu.AccY,10, 5, _imufs),
-                    acceleration_z=filter(imu.AccZ,10, 5, _imufs),
-                    axisrate_roll=filter(imu.GyrX,10, 5, _imufs),
-                    axisrate_pitch=filter(imu.GyrY,10, 5, _imufs),
-                    axisrate_yaw=filter(imu.GyrZ,10, 5, _imufs),
+                    acceleration_x=filter(imu.AccX, 10, 5, _imufs),
+                    acceleration_y=filter(imu.AccY, 10, 5, _imufs),
+                    acceleration_z=filter(imu.AccZ, 10, 5, _imufs),
+                    axisrate_roll=filter(imu.GyrX, 10, 5, _imufs),
+                    axisrate_pitch=filter(imu.GyrY, 10, 5, _imufs),
+                    axisrate_yaw=filter(imu.GyrZ, 10, 5, _imufs),
                 )
             )
 
@@ -608,7 +612,9 @@ class Flight:
         indf: pd.DataFrame, colmap: dict[str, str], instancecol="Instance"
     ):
         """Where an instance column exists in an input df split the values into two columns"""
-        instances = sorted(indf[instancecol].unique()) if instancecol in indf.columns else [0]
+        instances = (
+            sorted(indf[instancecol].unique()) if instancecol in indf.columns else [0]
+        )
         dfs = []
         for i in instances:
             _subdf = (
@@ -629,11 +635,23 @@ class Flight:
         return dfs
 
     @staticmethod
-    def parse_fcj_data(df: pd.DataFrame | dict, origin: Origin, shift: Point = None):
-        df = pd.DataFrame(df, dtype=float) if isinstance(df, dict) else df
+    def from_fc_json(fc_json: fcj.FCJ) -> Flight:
+        if fc_json.parameters:
+            origin = Origin.from_fcjson_parameters(fc_json.parameters)
+            shift = origin.rotation.transform_point(
+                Point(
+                    fc_json.parameters.moveEast,
+                    -fc_json.parameters.moveNorth,
+                    0,
+                )
+            )
+        else:
+            origin = Origin("dummy_origin", GPS(0, 0, 0), -np.pi / 2)
+            shift = P0()
+
+        df = pd.DataFrame([d.__dict__ for d in fc_json.data], dtype=float)
 
         df = Flight.build_cols(
-            time_actual=df["time"] / 1e6 + int(time()),
             time_flight=df["time"] / 1e6,
             attitude_roll=np.radians(df["r"]),
             attitude_pitch=np.radians(df["p"]),
@@ -653,31 +671,6 @@ class Flight:
         df["position_D"] = df["position_D"] + shift.z
         return Flight(df.set_index("time_flight", drop=False), None, origin, "xkf_c0")
 
-    @staticmethod
-    def from_fc_json(fc_json: Union[str, dict, IO]) -> Self:
-        if isinstance(fc_json, str):
-            with open(fc_json, "r") as f:
-                fc_json = load(f)
-        elif isinstance(fc_json, IO):
-            fc_json = load(f)
-
-        if "parameters" in fc_json:
-            origin = Origin.from_fcjson_parameters(fc_json["parameters"])
-            shift = origin.rotation.transform_point(
-                Point(
-                    fc_json["parameters"]["moveEast"],
-                    -fc_json["parameters"]["moveNorth"],
-                    0,
-                )
-            )
-        else:
-            origin = Origin("dummy_origin", GPS(0, 0, 0), -np.pi / 2)
-            shift = P0()
-
-        return Flight.parse_fcj_data(
-            pd.DataFrame(fc_json["data"], dtype=float), origin, shift
-        )
-
     def remove_time_flutter(self):
         # I think the best option is just to take the average of the timestep.
         # FC loop rate seems consistent but there is noise in the time that is recorded
@@ -745,6 +738,3 @@ class Flight:
         T = (ts[-1] - ts[0]) / N
         fs = 1 / T
         return self.filter(*butter(order, cutoff, fs=fs, btype="low", analog=False))
-
-
-    

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/origin.py

@@ -5,7 +5,8 @@ from typing import Self
 import json_stream
 from pathlib import Path
 from dataclasses import dataclass   
-
+from pydantic import BaseModel
+from flightdata import fcj  
 
 @dataclass
 class Origin(object):
@@ -15,6 +16,18 @@ class Origin(object):
     pos: g.GPS # position of pilot
     heading: float# direction pilot faces in radians from North (clockwise)
 
+    @property
+    def lat(self):
+        return self.pos.lat[0] 
+    
+    @property
+    def long(self):
+        return self.pos.long[0]
+    
+    @property
+    def alt(self):
+        return self.pos.alt[0]
+
     @property
     def rotation(self):
         # converts NED to x right, y heading direction, z up
@@ -72,7 +85,7 @@ class Origin(object):
         This is a convenient, but not very accurate way to setup the box. 
         '''
         
-        position = g.GPS(flight.gps_latitude[0], flight.gps_longitude[0], flight.gps_altitude[0])
+        position = g.GPS(flight.gps_latitude.iloc[0], flight.gps_longitude.iloc[0], flight.gps_altitude.iloc[0])
         heading = g.Euler(flight.attitude)[0].transform_point(g.PX())
 
         return Origin('origin', position, np.arctan2(heading.y, heading.x)[0])
@@ -118,26 +131,41 @@ class Origin(object):
         )
 
     @staticmethod
-    def from_fcjson_parameters(data: dict | str | Path):
-        if not isinstance(data, dict):
-            data = json_stream.to_standard_types(
-                json_stream.load(open(data, 'r'))['parameters']
-            )
+    def from_fcjson_parameters(parms: fcj.Parameters):
         return Origin(
             "FCJ_box",
             g.GPS(
-                float(data['pilotLat']), 
-                float(data['pilotLng']), 
-                float(data['pilotAlt'])
+                float(parms.pilotLat), 
+                float(parms.pilotLng), 
+                float(parms.pilotAlt)
             ),
-            float(data['rotation'])
+            float(parms.rotation)
         )
         
-
-
     def gps_to_point(self, gps: g.GPS) -> g.Point:
-        pned = gps - self.pilot_position
-        return self.rotation.transform_point(g.Point(pned.y, pned.x, -pned.z ))
+        return self.rotation.transform_point(gps - self.pos)
 
     
-    
+
+class FCJOrigin(BaseModel):
+    lat: float
+    lng: float
+    alt: float
+    heading: float
+    move_east: float=0
+    move_north: float=0
+
+    def origin(self):
+        """Create a flightdata.Origin object from the FCJOrigin object."""
+        return Origin(
+            "fcj",
+            g.GPS(self.lat, self.lng, self.alt).offset(
+                g.Point(self.move_north, self.move_east, 0)
+            ),
+            np.radians(self.heading),
+        )
+
+    def shift(self):
+        return self.origin().rotation.transform_point(
+            g.Point(self.move_east, -self.move_north, 0)
+        )

flightdata-0.2.22/flightdata/schemas/fcj.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+from pydantic import BaseModel
+import pandas as pd
+import datetime
+import re
+
+
+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()

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata/state.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 import pandas as pd
 
 import geometry as g
-from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table
+from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table, fcj
 
 
 class State(Table):
@@ -199,7 +199,7 @@ class State(Table):
 
     def splitter_labels(
         self: State,
-        mans: list[dict],
+        mans: list[fcj.Man],
         better_names: list[str] = None,
         target_col="manoeuvre",
         t0=0,
@@ -217,31 +217,31 @@ class State(Table):
         """
         i0 = self.data.index.get_indexer([t0], "nearest")[0]
 
-        takeoff = self.data.iloc[0 : int(mans[0]["stop"]) + i0 + 1]
+        takeoff = self.data.iloc[0 : int(mans[0].stop) + i0 + 1]
 
-        labels = [mans[0]["name"]]
+        labels = [mans[0].name]
         labelled = [State(takeoff).label(**{target_col: labels[0]})]
         if better_names:
             better_names.append("land")
 
         for i, split_man in enumerate(mans[1:]):
-            while split_man["name"] in labels:
-                split_man["name"] = split_man["name"] + "2"
+            while split_man.name in labels:
+                split_man.name = split_man.name + "2"
 
-            name = better_names[i] if better_names else split_man["name"]
+            name = better_names[i] if better_names else split_man.name
 
             labelled.append(
                 State(
                     self.data.iloc[
-                        int(split_man["start"]) + i0 : int(split_man["stop"]) + i0 + 1
+                        int(split_man.start) + i0 : int(split_man.stop) + i0 + 1
                     ]
                 ).label(**{target_col: name})
             )
-            labels.append(split_man["name"])
+            labels.append(split_man.name)
 
         return State.stack(labelled)
 
-    def label_els(self, els: dict):
+    def label_els(self, els: list[fcj.El]):
         return self.splitter_labels(
             pd.DataFrame(els).to_dict('records'), target_col='element'
         ).str_replace_label(

{flightdata-0.2.20 → flightdata-0.2.22/flightdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightdata
-Version: 0.2.20
+Version: 0.2.22
 Summary: Module for handling UAV flight log data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -11,13 +11,13 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: simplejson
-Requires-Dist: pfc-geometry>=0.2.11
+Requires-Dist: pfc-geometry>=0.2.12
 Requires-Dist: json_stream
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
 Requires-Dist: simplejson; extra == "dev"
-Requires-Dist: pfc-geometry>=0.2.11; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.12; extra == "dev"
 Requires-Dist: ardupilot-log-reader>=0.3.3; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata.egg-info/SOURCES.txt

@@ -48,6 +48,8 @@ flightdata/flight/parameters.py
 flightdata/model/__init__.py
 flightdata/model/aerodynamic.py
 flightdata/model/thrust.py
+flightdata/schemas/__init__.py
+flightdata/schemas/fcj.py
 flightdata/scripts/collect_logs.py
 flightdata/scripts/flightline.py
 test/EmailedBox.f3a

{flightdata-0.2.20 → flightdata-0.2.22}/flightdata.egg-info/requires.txt

@@ -1,13 +1,13 @@
 numpy
 pandas
 simplejson
-pfc-geometry>=0.2.11
+pfc-geometry>=0.2.12
 json_stream
 
 [dev]
 numpy
 pandas
 simplejson
-pfc-geometry>=0.2.11
+pfc-geometry>=0.2.12
 ardupilot-log-reader>=0.3.3
 pytest

{flightdata-0.2.20 → flightdata-0.2.22}/requirements-dev.txt

@@ -1,6 +1,6 @@
 numpy
 pandas
 simplejson
-pfc-geometry>=0.2.11
+pfc-geometry>=0.2.12
 ardupilot-log-reader>=0.3.3
 pytest

{flightdata-0.2.20 → flightdata-0.2.22}/requirements.txt

@@ -1,5 +1,5 @@
 numpy
 pandas
 simplejson
-pfc-geometry>=0.2.11
+pfc-geometry>=0.2.12
 json_stream

{flightdata-0.2.20 → flightdata-0.2.22}/test/conftest.py

@@ -1,7 +1,9 @@
 from pytest import fixture
-from flightdata import Flight, Origin
-from flightdata import State
+from flightdata import Flight, Origin, State, fcj
 
+@fixture(scope='session')
+def fcjson():
+    return Flight.from_fc_json(fcj.FCJ.model_validate_json(open('test/data/p23_fc.json', 'r').read()))
 
 @fixture(scope="session")
 def flight():

{flightdata-0.2.20 → flightdata-0.2.22}/test/test_flight.py

@@ -1,10 +1,10 @@
 from flightdata import Flight, Origin, BinData
-from io import open
 from json import load
 from pytest import fixture, approx, mark
 import numpy as np
 import pandas as pd
 from ardupilot_log_reader import Ardupilot
+from .conftest import fcjson
 
 @fixture(scope='session')
 def parser():
@@ -14,9 +14,6 @@ def parser():
 def fl(parser):
     return Flight.from_log(parser)
 
-@fixture(scope='session')
-def fcj():
-    return Flight.from_fc_json('test/data/p23_fc.json')
 
 def test_duration(fl):
     assert fl.duration == approx(687, rel=1e-3)
@@ -30,10 +27,10 @@ def test_to_from_dict(fl):
     fl2 = Flight.from_dict(data)
     assert fl == fl2
     
-def test_from_fc_json(fcj):
-    assert isinstance(fcj, Flight)
-    assert fcj.duration > 200
-    assert fcj.position_D.max() < -10
+def test_from_fc_json(fcjson):
+    assert isinstance(fcjson, Flight)
+    assert fcjson.duration > 200
+    assert fcjson.position_D.max() < -10
   
 @mark.skip
 def test_unique_identifier():

{flightdata-0.2.20 → flightdata-0.2.22}/test/test_state/test_state_builders.py

@@ -1,11 +1,11 @@
-from flightdata import Flight, State, Origin, BinData
+from flightdata import Flight, State, Origin, BinData, fcj
 from pytest import approx, fixture
 from geometry import Transformation, PX, PY, P0, Time
 from geometry.testing import assert_almost_equal
 import numpy as np
 from time import sleep, time
 from json import load
-from ..conftest import state, flight, origin
+from ..conftest import state, flight, origin, fcjson
 
 def test_extrapolate():
     initial = State.from_transform(
@@ -16,7 +16,7 @@ def test_extrapolate():
     extrapolated = initial.extrapolate(10)
     assert extrapolated.x[-1] == approx(300)
     
-    assert len(extrapolated) == 300
+    assert len(extrapolated) == 250
     assert_almost_equal(extrapolated.pos[0], initial.pos)
 
 
@@ -49,11 +49,9 @@ def test_from_flight_pos(flight: Flight, state: State, origin: Origin):
     #pd.testing.assert_frame_equal(state.data, st2.data)
     assert st2.z.mean() > 0
 
-def test_fc_json():
-    with open('test/data/manual_F3A_P23.json', 'r') as f:
-        fcj = load(f)
-    fl = Flight.from_fc_json(fcj)
-    origin = Origin.from_fcjson_parmameters(fcj['parameters'])
+def test_fc_json(fcjson: fcj.FCJ):
+    fl = Flight.from_fc_json(fcjson)
+    origin = Origin.from_fcjson_parameters(fcjson.parameters)
     st = State.from_flight(fl, origin)
     assert st.z.mean() > 0