flightanalysis 0.2.13__tar.gz → 0.2.15__tar.gz

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.13
+Version: 0.2.15
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -16,7 +16,7 @@ Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
 Requires-Dist: pfc-geometry>=0.2.6
-Requires-Dist: flightdata>=0.2.11
+Requires-Dist: flightdata>=0.2.14
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
@@ -26,7 +26,7 @@ Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
 Requires-Dist: pfc-geometry>=0.2.6; extra == "dev"
-Requires-Dist: flightdata>=0.2.11; extra == "dev"
+Requires-Dist: flightdata>=0.2.14; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.1; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
 

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/examples/scoring/f3a_criteria_maker.py

@@ -1,20 +1,20 @@
 from flightanalysis.scoring.criteria import Single, Exponential, ContAbs, ContRat, InsideBound, MaxBound, Comparison, free, OutsideBound
 import numpy as np
-from itertools import chain
+
 
 f3a=dict(
     single=dict(
-        track=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 100)),
-        roll=Single(Exponential.fit_points(np.radians([30, 90]), [1, 6], 100)),
-        angle=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 100)),
+        track=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
+        roll=Single(Exponential.fit_points(np.radians([30, 90]), [1, 6], 6)),
+        angle=Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
 #        distance = Single(Exponential.fit_points([20, 40], [0.5, 1]))
     ),
     intra=dict(
-        track=ContAbs(Exponential.fit_points(np.radians([30, 90]), [2, 6])),
-        roll=ContAbs(Exponential.fit_points(np.radians([30, 90]), [1.5, 6])),
-        radius=ContRat(Exponential.fit_points([1,5], [0.5, 4], 2)),
+        track=ContAbs(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6)),
+        roll=ContAbs(Exponential.fit_points(np.radians([30, 90]), [1.5, 6], 6)),
+        radius=ContRat(Exponential.fit_points([1,5], [0.5, 4], 3)),
         speed=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 1)),
-        roll_rate=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 1)),
+        roll_rate=ContRat(Exponential.fit_points([1,5], [0.15, 0.75], 2)),
         stallturn_speed=InsideBound(Exponential.fit_points([2, 5], [0.3,1.5]), [-2,2]),
         stallturn_width=InsideBound(Exponential.fit_points([2, 5], [0.5,2.5]), [-2,2]),
         spin_entry_length=InsideBound(Exponential.fit_points([2, 5], [0.3,1.5]), [-5,5]),
@@ -25,10 +25,10 @@ f3a=dict(
         depth=MaxBound(Exponential.fit_points([20, 40], [0.5, 1]), 170)
     ),
     inter=dict(
-        radius=Comparison(Exponential.fit_points([1,2], [1.5, 3])),
-        speed=Comparison(Exponential.fit_points([1,5], [0.25, 1.0])),
-        roll_rate=Comparison(Exponential.fit_points([1,5], [0.25, 1.5])),
-        length=Comparison(Exponential.fit_points([1,2], [1.5, 3])),
+        radius=Comparison(Exponential.fit_points([1,2], [1, 2], 2)),
+        speed=Comparison(Exponential.fit_points([1,2], [0.25, 0.5], 1)),
+        roll_rate=Comparison(Exponential.fit_points([1,2], [0.25, 0.5], 1)),
+        length=Comparison(Exponential.fit_points([1,2], [1, 2], 2)),
         free=Comparison(free),
     )
 )

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/analysis/el_analysis.py

@@ -16,9 +16,9 @@ class ElementAnalysis:
     tp: State
     ref_frame: g.Transformation
 
-    def plot_3d(self, origin=False, **kwargs):
+    def plot_3d(self, **kwargs):
         from flightplotting import plotsec
-        return plotsec([self.fl, self.tp], 2, 5, origin=origin, **kwargs)
+        return plotsec([self.fl, self.tp], **kwargs)
 
     def to_dict(self):
         return {k: v.to_dict() for k, v in self.__dict__.items()}

flightanalysis-0.2.15/flightanalysis/analysis/manoeuvre_analysis/__init__.py

@@ -0,0 +1,14 @@
+from .analysis import Analysis
+from .basic import Basic
+from .alignment import Alignment
+from .complete import Complete, Scored
+
+
+def parse_dict(data: dict) -> Analysis:
+    return Scored.from_dict(data)
+
+def parse(data: dict) -> Basic | Alignment | Complete | Scored:
+    if 'parameters' in data:
+        return Basic.from_mindict(data).proceed()
+    else:
+        return parse_dict(data).proceed()

flightanalysis-0.2.15/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from flightdata import State
+from flightanalysis.manoeuvre import Manoeuvre
+from loguru import logger
+from .basic import Basic
+from flightanalysis.definition import ManDef, ScheduleInfo
+from ..el_analysis import ElementAnalysis
+
+@dataclass
+class Alignment(Basic):
+    manoeuvre: Manoeuvre | None
+    template: State | None
+
+    def __getattr__(self, name) -> ElementAnalysis:
+        return ElementAnalysis(
+            self.mdef.data[name],
+            self.mdef.mps,
+            self.manoeuvre.elements.data[name],
+            self.flown.get_element(name),
+            self.template.get_element(name),
+            self.template.get_element(name)[0].transform
+        )
+
+    def run_all(self, optimise_aligment=True, force=False) -> Alignment | Complete | Scored:
+        if self.__class__.__name__ == 'Scored' and force:
+            self = self.downgrade()
+        new = self
+        while self.__class__.__name__ != 'Scored':
+            new = self.run(optimise_aligment) if isinstance(self, Complete) else self.run()
+            if new.__class__.__name__ == self.__class__.__name__:
+                break
+            self = new
+        return new
+    
+    @staticmethod
+    def from_dict(data: dict, fallback=True):
+        ia = Basic.from_dict(data)
+        try:    
+            ia = Alignment(
+                manoeuvre=Manoeuvre.from_dict(data['manoeuvre']),
+                template=State.from_dict(data['template']),
+                **ia.__dict__
+            )
+        except Exception as e:
+            if fallback:
+                logger.debug(f'Failed to parse Alignment {repr(e)}')
+            else:
+                raise e
+        return ia
+
+    def run(self) -> Alignment | Complete:
+        if 'element' not in self.flown.data.columns:
+            try:
+                self = self._run(True)[1]
+            except Exception as e:
+                logger.error(f'Failed to run alignment stage 1: {repr(e)}')
+                return self
+        try:
+            return self._run(False)[1].proceed()
+        except Exception as e:
+            logger.error(f'Failed to run alignment stage 2: {repr(e)}')
+            return self
+
+    def _run(self, mirror=False, radius=10) -> Alignment:
+        dist, aligned = State.align(self.flown, self.template, radius, mirror)
+        return dist, self.update(aligned)
+
+    def update(self, aligned: State) -> Alignment:
+        man, tp = self.manoeuvre.match_intention(self.template[0], aligned)
+        mdef = ManDef(self.mdef.info, self.mdef.mps.update_defaults(man), self.mdef.eds)
+        return Alignment(self.id, mdef, aligned, self.direction, man, tp)
+
+    def _proceed(self) -> Complete:
+        if 'element' in self.flown.data.columns:
+            correction = self.mdef.create(self.template[0].transform)
+            return Complete(
+                self.id, self.mdef, self.flown, self.direction, 
+                self.manoeuvre, self.template, correction, 
+                correction.create_template(self.template[0], self.flown)
+            )
+        else:
+            return self
+
+    def to_mindict(self, sinfo: ScheduleInfo=None, full=False):
+        data = dict(
+            els = self.flown.label_ranges('element').to_dict('records')
+        )
+        if full:
+            data = dict(
+                **super().to_mindict(sinfo),
+                **data
+            )
+        return data
+
+    def fcj_results(self):
+        df = self.flown.label_ranges('element').iloc[:,:3]
+        df.columns = ['name', 'start', 'stop']
+        return dict(
+            els=df.to_dict('records')
+        )
+
+from .complete import Complete  # noqa: E402
+from .scored import Scored  # noqa: E402

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/analysis/manoeuvre_analysis/analysis.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 from dataclasses import dataclass
-
-class AlinmentStage:
-    SETUP=0
-    PRELIM=1
-    SECONDARY=2
-    OPTIMISED=3
-
+from flightanalysis.definition import ScheduleInfo
 
 @dataclass
 class Analysis:
+    id: int
+
     def to_dict(self):
         return {k: (v.to_dict() if hasattr(v, 'to_dict') else v) for k, v in self.__dict__.items()}
 
-
+    def to_mindict(self, sinfo: ScheduleInfo):
+        return {
+            "sinfo": sinfo.__dict__,
+        }
+        

flightanalysis-0.2.15/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from flightdata import State, Flight, Origin
+from flightanalysis.definition import ManDef, SchedDef, ManOption
+import geometry as g
+from json import load
+from .analysis import Analysis
+from flightanalysis.definition.scheduleinfo import ScheduleInfo
+import numpy as np
+import pandas as pd
+
+
+@dataclass
+class Basic(Analysis):
+    mdef: ManDef | ManOption
+    flown: State
+    direction: int
+
+    @property
+    def name(self):
+        return self.mdef.uid
+
+    def run_all(self, optimise_aligment=True, force=False) -> Scored:
+        """Run the analysis to the final stage, for the case where the elements have not been labelled"""
+        drs = [r._run(True) for r in self.run()]
+        
+        dr = drs[np.argmin([dr[0] for dr in drs])]
+
+        return dr[1].run_all(optimise_aligment, force)
+
+    def proceed(self) -> Complete:
+        """Proceed the analysis to the final stage for the case where the elements have already been labelled"""
+        if 'element' not in self.flown.data.columns:
+            return self
+        mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
+        elnames = self.flown.data.element.unique()
+        for md in mopt:
+            if np.all(elnames[1:-1] == list( md.eds.data.keys())):
+                mdef = md
+                break
+        else:
+            raise ValueError(f"{self.mdef.info.short_name} element sequence doesn't agree with {self.flown.data.element.unique()}")
+
+        itrans = self.create_itrans()
+        man, tp = mdef.create(itrans).add_lines().match_intention(
+            State.from_transform(itrans),
+            self.flown
+        )
+        mdef = ManDef(mdef.info, mdef.mps.update_defaults(man), mdef.eds)
+        corr = mdef.create(itrans).add_lines()
+        return Complete(
+            self.id, mdef, self.flown, self.direction,
+            man, tp, corr, corr.create_template(itrans, self.flown)
+        )
+
+    @classmethod
+    def from_dict(Cls, data:dict) -> Basic:
+        return Basic(
+            -1,
+            ManDef.from_dict(data["mdef"]),
+            State.from_dict(data["flown"]),
+            data['direction']
+        )
+
+    def create_itrans(self) -> g.Transformation:
+        return g.Transformation( 
+            self.flown[0].pos, 
+            self.mdef.info.start.initial_rotation(self.direction)
+        )
+
+    @staticmethod
+    def from_fcj(file: str, mid: int):
+        with open(file, 'r') as f:
+            data = load(f)
+        flight = Flight.from_fc_json(data)
+        box = Origin.from_fcjson_parmameters(data["parameters"])
+
+        sdef = SchedDef.load(data["parameters"]["schedule"][1])
+
+        state = State.from_flight(flight, box).splitter_labels(
+            data["mans"],
+            [m.info.short_name for m in sdef]
+        )
+        mdef= sdef[mid]
+        return Basic(mid, mdef, state.get_manoeuvre(mdef.uid))
+
+    def run(self) -> list[Alignment]:
+        itrans = self.create_itrans()
+        mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
+
+        als = []        
+        for mdef in mopt:
+            man = mdef.create(itrans).add_lines()
+            als.append(Alignment(
+                self.id, mdef, self.flown, self.direction, 
+                man, man.create_template(itrans)
+            ))
+        return als
+
+    def to_mindict(self, sinfo: ScheduleInfo):
+        data = dict(
+            **super().to_mindict(sinfo),
+            name=self.name,
+            id=self.id,
+            data=self.flown._create_json_data().to_dict('records'),
+            direction=self.direction,
+        ) 
+        return data
+
+    @staticmethod
+    def from_mindict(data: dict):
+        info = ScheduleInfo.from_str(data["parameters"]["schedule"][1])
+        
+        st = State.from_flight(
+            Flight.from_fc_json(data), 
+            Origin.from_fcjson_parmameters(data["parameters"])
+        )
+        
+        mdef = SchedDef.load(info)[data['id']] 
+        
+        if 'els' in data:
+            df = pd.DataFrame(data['els'])
+            df.columns = ['name', 'start', 'stop', 'length']
+            st = st.splitter_labels(df.to_dict('records'), target_col='element').label(manoeuvre=data['name'])
+
+        return Basic(data['id'], mdef, st, data['direction'])
+    
+
+from .alignment import Alignment  # noqa: E402
+from .complete import Complete  # noqa: E402
+from .scored import Scored  # noqa: E402

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from ..el_analysis import ElementAnalysis
 from flightdata import State
-from flightanalysis.definition import ManDef
+from flightanalysis.definition import ManDef, ScheduleInfo
 from flightanalysis.manoeuvre import Manoeuvre
 from flightanalysis.scoring import Results, ManoeuvreResults, Measurement
 from flightanalysis.scoring.criteria.f3a_criteria import F3A
 from flightanalysis.definition.maninfo import Position
 import numpy as np
-from .alignment import Alignment, AlinmentStage
+from .alignment import Alignment
 from loguru import logger
 
 
@@ -34,7 +34,7 @@ class Complete(Alignment):
         return pa
 
     def run(self, optimise_aligment=True) -> Scored:
-        if self.stage < AlinmentStage.OPTIMISED and optimise_aligment:
+        if optimise_aligment:
             self = self.optimise_alignment()
         self = self.update_templates()
         return Scored(**self.__dict__, 
@@ -63,6 +63,7 @@ class Complete(Alignment):
         tp = el.get_data(self.template).relocate(st.pos[0])
         return ElementAnalysis(edef, self.mdef.mps, el, st, tp, el.ref_frame(tp))
 
+
     def update_templates(self):
         if not np.all(self.flown.element == self.template.element):    
             manoeuvre, template = self.manoeuvre.match_intention(self.template[0], self.flown)
@@ -70,8 +71,9 @@ class Complete(Alignment):
             correction = mdef.create(self.template[0].transform).add_lines()
 
             return Complete(
-                mdef, self.flown, self.direction, AlinmentStage.OPTIMISED, self.dist,
-                manoeuvre, template, correction, correction.create_template(template[0])
+                self.id, mdef, self.flown, self.direction,
+                manoeuvre, template, correction, 
+                correction.create_template(template[0])
             )
         else:
             return self
@@ -127,13 +129,6 @@ class Complete(Alignment):
             Measurement.depth(self.flown)
         )
         
-#        val = self.flown.pos.y.mean()
-#        id = np.abs(self.flown.pos.y - val).argmin()
-#        m = Measurement.depth(self.flown[id])
-#        error = np.maximum(m.value, 170) - 170
-#        dist_dg = F3A.single.distance.lookup(error) * m.visibility
-#        return Result("distance", m, m.value, error, dist_dg, [id])
-
     def intra(self):
         return self.manoeuvre.analyse(self.flown, self.template)
 
@@ -160,4 +155,6 @@ class Complete(Alignment):
         fig = plotdtw(self.flown, self.flown.data.element.unique())
         return plotsec(self.flown, color="blue", nmodels=20, fig=fig, **kwargs)
 
+
+
 from .scored import Scored  # noqa: E402

flightanalysis-0.2.15/flightanalysis/analysis/manoeuvre_analysis/scored.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from .complete import Complete
+from flightanalysis.scoring import ManoeuvreResults
+from flightanalysis.definition.scheduleinfo import ScheduleInfo
+from loguru import logger
+
+
+@dataclass
+class Scored(Complete):
+    scores: ManoeuvreResults
+
+    def downgrade(self) -> Complete:
+        return Complete(
+            self.id, self.mdef, self.flown, self.direction, 
+            self.manoeuvre, self.template, self.corrected, 
+            self.corrected_template
+        )
+    
+    @staticmethod
+    def from_dict(data:dict, fallback=True):
+        ca = Complete.from_dict(data, fallback)
+        try:
+            ca = Scored(
+                **ca.__dict__,
+                scores=ManoeuvreResults.from_dict(data["scores"])
+            )
+        except Exception as e:
+            if fallback:
+                logger.debug(f"Failed to read scores, {repr(e)}")
+            else:
+                raise e
+        return ca
+        
+    def to_mindict(self, sinfo: ScheduleInfo=None, full=False):
+        data = dict(
+            **super().to_mindict(sinfo, full),
+            scores=dict(
+                **self.scores.summary(),
+                total=self.scores.score(),
+                k=self.mdef.info.k
+            )
+        )
+        
+        return data
+    
+    def fcj_results(self):
+        return dict(
+            **super().fcj_results(),
+            results=self.scores.fcj_results()
+        )

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/analysis/sch_analysis.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from typing import Self, Union
-from json import load
+from json import load, dump
 from flightdata import Flight, State, Origin, Collection
 from flightanalysis.definition import SchedDef, ScheduleInfo
 from . import manoeuvre_analysis as analysis
@@ -9,7 +9,7 @@ from joblib import Parallel, delayed
 import os
 import pandas as pd
 from importlib.metadata import version
-import geometry as g
+from packaging import version as pkgversion
 
 
 class ScheduleAnalysis(Collection):
@@ -22,10 +22,8 @@ class ScheduleAnalysis(Collection):
 
     @staticmethod
     def from_fcj(file: Union[str, dict], info: ScheduleInfo=None) -> ScheduleAnalysis:
-        if isinstance(file, str):
-            data = load(open(file, 'r'))
-        else:
-            data = file
+        data = load(open(file, 'r')) if isinstance(file, str) else file
+
         flight = Flight.from_fc_json(data)
         
         if info is None:
@@ -33,26 +31,50 @@ class ScheduleAnalysis(Collection):
         
         sdef = SchedDef.load(info)
         box = Origin.from_fcjson_parmameters(data["parameters"])
-        state = State.from_flight(flight, box).splitter_labels(
-            data["mans"],
-            sdef.uids
-        )
+        state = State.from_flight(flight, box).splitter_labels(data["mans"],sdef.uids)
         direction = -state.get_manoeuvre(1)[0].direction()[0]
 
-        return ScheduleAnalysis(
-            [analysis.Basic(
-                mdef, 
-                state.get_manoeuvre(mdef.uid), 
-                direction,
-                analysis.AlinmentStage.SETUP
-            ) for mdef in sdef],
-            info
-        )
+        if 'fcs_scores' in data:
+            versions = [pkgversion.parse(res['fa_version']) for res in data['fcs_scores']]
+            ilatest = versions.index(max(versions))
+
+        mas = []
+        for i, mdef in enumerate(sdef):
+            st = state.get_manoeuvre(mdef.uid)
+
+            if 'fcs_scores' in data and len(data['fcs_scores']) > 0:
+                df = pd.DataFrame(data['fcs_scores'][ilatest]['manresults'][i+1]['els'])
+                st = st.splitter_labels(df.to_dict('records'), target_col='element')
+            
+            mas.append(analysis.Basic(i, mdef, st, direction).proceed())
+
+        return ScheduleAnalysis(mas,info)
     
-    def run_all(self) -> Self:
+    def append_scores_to_fcj(self, file: Union[str, dict]) -> dict:
+        data = load(open(file, 'r')) if isinstance(file, str) else file
+
+        new_results = dict(
+            fa_version = version('flightanalysis'),
+            manresults = [None] + \
+                [man.fcj_results() if hasattr(man, 'fcj_results') else None for man in self]
+        )
+
+        if 'fcs_scores' not in data:
+            data['fcs_scores'] = []
 
+        for res in data['fcs_scores']:
+            if res['fa_version'] == new_results['fa_version']:
+                res['manresults'] = new_results['manresults']
+                break
+        else:
+            data['fcs_scores'].append(new_results)
+
+        return data
+        
+
+    def run_all(self) -> Self:
         def parse_analyse_serialise(pad):
-            res = analysis.Basic.from_dict(pad).run_all()
+            res = analysis.parse_dict(pad).run_all()
             logger.info(f'Completed {res.name}')
             return res.to_dict()
         
@@ -67,7 +89,6 @@ class ScheduleAnalysis(Collection):
 
         def parse_analyse_serialise(mad):
             an = analysis.Complete.from_dict(mad)
-            an.stage = analysis.AlinmentStage.SECONDARY
             return an.run_all().to_dict()
 
         logger.info(f'Starting {os.cpu_count()} alinment optimisation processes')
@@ -75,23 +96,6 @@ class ScheduleAnalysis(Collection):
         madicts = Parallel(n_jobs=os.cpu_count())(delayed(parse_analyse_serialise)(mad) for mad in inmadicts)
         return ScheduleAnalysis([analysis.Scored.from_dict(mad) for mad in madicts], self.sinfo)
     
-    @staticmethod
-    def from_fcscore(file: Union[str, dict], fallback=True) -> ScheduleAnalysis:
-        if isinstance(file, str) or isinstance(file, os.PathLike):
-            data = load(open(file, 'r'))
-        else:
-            data = file
-        sinfo = ScheduleInfo(**data['sinfo'])
-        sdef = SchedDef.load(sinfo)
-
-        mas = []
-        for mdef in sdef:
-            mas.append(analysis.Scored.from_dict(
-                data['data'][mdef.info.short_name],
-                fallback
-            ))
-
-        return ScheduleAnalysis(mas, sinfo)
     
     def scores(self):
         scores = {}
@@ -103,16 +107,4 @@ class ScheduleAnalysis(Collection):
     def summarydf(self):
         return pd.DataFrame([ma.scores.summary() if hasattr(ma, 'scores') else {} for ma in self])
 
-    def to_fcscore(self, name: str) -> dict:        
-        total, scores = self.scores()
-       
-        odata = dict(
-            name = name,
-            client_version = 'Py',
-            server_version = version('flightanalysis'),
-            sinfo = self.sinfo.__dict__,
-            score = total,
-            manscores = scores,
-            data = self.to_dict()
-        )
-        return odata
+    

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/definition/__init__.py

@@ -12,6 +12,6 @@ from .manparm import ManParm, ManParms, DummyMPs
 from .eldef import ElDef, ElDefs
 from .mandef import ManDef
 from .manoption import ManOption
-from .scheduleinfo import ScheduleInfo, fcj_schedule_names, schedule_library
+from .scheduleinfo import ScheduleInfo, schedule_library
 from .scheddef import SchedDef
 from .builders.manbuilder import ManBuilder, f3amb, MBTags, centred, imacmb, r, c45, dp

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/definition/mandef.py

@@ -34,6 +34,9 @@ class ManDef:
         self.mps: ManParms = ManParms.create_defaults_f3a() if mps is None else mps
         self.eds: ElDefs = ElDefs() if eds is None else eds
 
+    def __repr__(self):
+        return f"ManDef({self.info.name})"
+
     @property
     def uid(self):
         return self.info.short_name

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/definition/manparm.py

@@ -25,7 +25,7 @@ class ManParm(Opp):
 
     """
     criteria: Criteria
-    defaul:Any=None
+    defaul:Number=None
     collectors:Collectors=field(default_factory=lambda : Collectors())
 
 
@@ -78,7 +78,7 @@ class ManParm(Opp):
             [c(els) for c in self.collectors],
             self.defaul,
             direction,
-            [vis[0]] + [max(va, vb) for va, vb in zip(vis[:-1], vis[1:])],
+            np.array([vis[0]] + [max(va, vb) for va, vb in zip(vis[:-1], vis[1:])]),
             [str(c) for c in self.collectors]
         )
 

{flightanalysis-0.2.13 → flightanalysis-0.2.15}/flightanalysis/definition/scheddef.py

@@ -1,4 +1,4 @@
-from . import ManDef, ManInfo, ManOption, ScheduleInfo, fcj_schedule_names
+from . import ManDef, ManInfo, ManOption, ScheduleInfo
 from flightdata import State
 from typing import Tuple, Union, Self
 from geometry import Transformation
@@ -95,7 +95,7 @@ class SchedDef(Collection):
         fcj = self.label_exit_lines(template).create_fc_json(
             [0] + [man.info.k for man in self] + [0],
             sname,
-            fcj_schedule_names[kind.lower()][-1]
+            kind.lower()
         )
             
         with open(path, 'w') as f: