flightdata 0.2.26__tar.gz → 0.2.28__tar.gz

{flightdata-0.2.26 → flightdata-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flightdata
-Version: 0.2.26
+Version: 0.2.28
 Summary: Python tools for handling flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License-File: LICENSE

{flightdata-0.2.26 → flightdata-0.2.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flightdata"
-version = "0.2.26"
+version = "0.2.28"
 description = "Python tools for handling flight data"
 readme = "README.md"
 authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
@@ -11,6 +11,10 @@ dependencies = [
     "pfc-geometry>=0.2.13",
 ]
 
+[project.scripts]
+collect_logs = "flightdata.scripts.collect_logs:main"
+flightline = "flightdata.scripts.flightline:main"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{flightdata-0.2.26 → flightdata-0.2.28}/src/flightdata/__init__.py

@@ -1,7 +1,6 @@
-from .schemas import fcj
 from .base import *
 from .bindata import BinData
-from .origin import Origin, FCJOrigin
+from .origin import Origin
 from .flight import *
 from .environment import *
 from .coefficients import Coefficients

{flightdata-0.2.26 → flightdata-0.2.28}/src/flightdata/base/collection.py

@@ -52,6 +52,7 @@ class Collection:
     def to_list(self) -> list[T]:
         return list(self.data.values())
     
+
     def to_dicts(self, *args, **kwargs) -> list[dict[str, Any]]:
         return [v.to_dict(*args, **kwargs) for v in self.data.values()]
 
@@ -86,6 +87,13 @@ class Collection:
             coll.add(v)
         return coll
     
+    @classmethod
+    def merge(Cls, vs: list[Self]) -> Self:
+        coll = vs[0].data
+        for v in vs[1:]:
+            coll = coll | v.data
+        return Cls(coll)
+
     def add_start(self, v: T | Self, inplace=True) -> Self:
         ocol = self.copy() if not inplace else self
         if isinstance(v, self.VType):

{flightdata-0.2.26 → flightdata-0.2.28}/src/flightdata/flight/flight.py

@@ -21,7 +21,8 @@ from time import time
 from json import load, dump
 from flightdata.base.numpy_encoder import NumpyEncoder
 from .ardupilot import flightmodes
-from flightdata import Origin, fcj
+from flightdata import Origin
+from schemas import fcj
 from numbers import Number
 from scipy.signal import filtfilt, butter
 from datetime import datetime

{flightdata-0.2.26 → flightdata-0.2.28}/src/flightdata/origin.py

@@ -1,12 +1,11 @@
+from __future__ import annotations
 import geometry as g
 import numpy as np
 from json import load, dump
 from typing import Self
-import json_stream
-from pathlib import Path
 from dataclasses import dataclass   
-from pydantic import BaseModel
-from flightdata import fcj  
+from schemas import fcj  
+
 
 @dataclass
 class Origin(object):
@@ -141,35 +140,26 @@ class Origin(object):
             ),
             float(parms.rotation)
         )
-        
+    
     def gps_to_point(self, gps: g.GPS) -> g.Point:
         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."""
+    @staticmethod
+    def from_fcj_origin(fcj_origin: fcj.Origin):
         return Origin(
             "fcj",
-            g.GPS(self.lat, self.lng, self.alt).offset(
-                g.Point(self.move_north, self.move_east, 0)
+            g.GPS(fcj_origin.lat, fcj_origin.lng, fcj_origin.alt).offset(
+                g.Point(fcj_origin.move_north, fcj_origin.move_east, 0)
             ),
-            np.radians(self.heading),
+            np.radians(fcj_origin.heading),
         )
 
-    def shift(self):
-        return self.origin().rotation.transform_point(
-            g.Point(self.move_east, -self.move_north, 0)
-        )
     
-    @staticmethod
-    def zero():
-        return FCJOrigin(lat=0, lng=0, alt=0, heading=0)
+    @property
+    def fcj_origin(self):
+        return fcj.Origin(
+            lat=self.lat,
+            lng=self.long,
+            alt=self.alt,
+            heading=np.degrees(self.heading),
+        )

{flightdata-0.2.26 → flightdata-0.2.28}/src/flightdata/state.py

@@ -8,7 +8,8 @@ import numpy.typing as npt
 import pandas as pd
 
 import geometry as g
-from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table, fcj
+from flightdata import Constructs, Environment, Flight, Flow, Origin, SVar, Table
+from schemas import fcj
 
 
 class State(Table):

flightdata-0.2.26/src/flightdata/schemas/fcj.py

@@ -1,174 +0,0 @@
-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()