flightanalysis 0.4.0__tar.gz → 0.4.1__tar.gz

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: flightanalysis
-Version: 0.4.0
+Version: 0.4.1
 Summary: Python tools for Analysis of Flight Data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: fastdtw>=0.3.4
-Requires-Dist: flightdata>=0.3.5
+Requires-Dist: flightdata>=0.3.6
 Requires-Dist: joblib>=1.4.2
 Requires-Dist: json-stream>=2.3.2
 Requires-Dist: loguru>=0.7.2

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flightanalysis"
-version="0.4.0"
+version="0.4.1"
 description = "Python tools for Analysis of Flight Data"
 readme = "README.md"
 authors = [{ name = "Thomas David", email = "thomasdavid0@gmail.com" }]
 requires-python = ">=3.12"
 dependencies = [
     "fastdtw>=0.3.4",
-    "flightdata>=0.3.5",
+    "flightdata>=0.3.6",
     "joblib>=1.4.2",
     "json-stream>=2.3.2",
     "loguru>=0.7.2",

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/__init__.py

@@ -5,18 +5,3 @@ from .schedule import Schedule  # noqa: F401
 from .definition import *  # noqa: F403
 from .scoring import *  # noqa: F403
 from .analysis import ScheduleAnalysis, ElementAnalysis, Analysis  # noqa: F401
-
-import sys
-from loguru import logger
-
-logger.disable('flightanalysis')
-
-def enable_logging(level: str = 'INFO'):
-    logger.enable('flightanalysis')
-    logger.remove()
-    logger.add(
-        sys.stderr,
-        level=level
-    )
-    return logger
-

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/analysis/el_analysis.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
+from flightanalysis.definition.manparms import ManParms
 import numpy as np
 
 from flightanalysis.scoring.results import Results, Result
 from flightdata import State
 from typing import Self
-from flightanalysis import ElDef, Element, ManParms
+from flightanalysis import ElDef, Element, Elements
 from dataclasses import dataclass
 import geometry as g
-
+from flightanalysis.scoring.downgrade.dg_testing import DGTest
 
 @dataclass
 class ElementAnalysis:
@@ -47,7 +48,7 @@ class ElementAnalysis:
         )
 
     def score_dg(self, dg: str, limits: bool = True) -> Result:
-        return self.edef.dgs[dg](self.el, self.fl, self.tp, limits)
+        return self.edef.dgs[dg](self.el, self.fl, self.tp)
 
     def intra_score(self) -> Results:
         try:
@@ -69,6 +70,15 @@ class ElementAnalysis:
             **(dict(intra=f"{self.results.total:.4f}") if self.results is not None else {}),
         )  # fmt: skip
 
+
+    def create_test_dataset(self, dg: str):
+        return DGTest(
+            self.edef.dgs[dg],
+            Elements([self.el]),
+            self.fl,
+            self.tp,
+        )
+
     def full_result_plot(self, name: str, showlegend=True, textposition: str = "bottom left"):
         """plot the actual result and the uncropped result on the same figure,
         include some info from the ddowngrade"""

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/analysis/manoeuvre_analysis.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
+from json import dumps
 from typing import Annotated, Self, Literal
 from flightanalysis.definition import ManDef, ManOption
 from flightanalysis.elements import AnyElement
 from flightanalysis.manoeuvre import Manoeuvre
 from flightanalysis.analysis.el_analysis import ElementAnalysis
 from flightanalysis.scoring.results import ElementsResults, ManoeuvreResults
-
-from .aligment_optimisation import optimise_alignment
 import numpy as np
 
 import geometry as g
@@ -32,6 +31,7 @@ class Analysis:
     ]
     flown: State
     mdef: ManDef | ManOption
+    option: int | None = None
     itrans: g.Transformation | None = None
     manoeuvre: Manoeuvre | None = None
     templates: dict[str, State] | None = None
@@ -46,38 +46,49 @@ class Analysis:
         optimise: bool = True,
         throw_errors: bool = False,
         stop_after: str = None,
+        force: bool = True,
         **kwargs,
     ) -> Self:
-        stages = []
-        stages.append("create_itrans")
-        if "element" in self.flown.labels.keys():
-            stages.append("select_mdef")
-        elif "element" not in self.flown.labels.keys():
-            stages.extend(["preliminary_alignment", "secondary_alignment"])
-        if optimise:
-            stages.extend(["prepare_scoring", "optimise_alignment"])
-        stages.extend(["prepare_scoring", "calculate_score"])
-
-        for stage, fun in enumerate(stages):
-            try:
-                logger.debug(f"Running step {stage}: {fun}")
-                self = getattr(self, fun)(**kwargs.get(fun, {}))
-                if stop_after == fun:
-                    logger.debug(f"Stopping after step {stage}: {fun}")
-                    break
-            except ElSequenceError as ese:
-                logger.warning(f"{self.name}, {fun}: {ese}")
-                self = self.preliminary_alignment(
-                    **kwargs.get("preliminary_alignment", {})
-                )
-                self = self.secondary_alignment(**kwargs.get("secondary_alignment", {}))
-            except Exception as e:
-                if throw_errors:
-                    raise Exception(f"Error running {self.name}, {fun}: {e}") from e
-                else:
-                    logger.error(f"{self.name}, {fun}: {e}")
-                    break
-
+        if self.scores and not force:
+            logger.info(f"Analysis {self.id} already has scores, skipping run.")
+            return self
+        stages = [
+            ("create_itrans", True),
+            ("select_mdef", "element" in self.flown.labels.keys()),
+            ("preliminary_alignment", "element" not in self.flown.labels.keys()),
+            ("secondary_alignment", "element" not in self.flown.labels.keys()),
+            ("prepare_scoring", optimise),
+            ("optimise_alignment", optimise),
+            ("prepare_scoring", True),
+            ("calculate_score", True),
+        ]
+        for stage, (fun_name, run) in enumerate(stages):
+            if run:
+                try:
+                    logger.debug(f"Running step {stage}: {fun_name}")
+                    self = getattr(self, fun_name)(**kwargs.get(fun_name, {}))
+                    if stop_after == fun_name:
+                        logger.debug(f"Stopping after step {stage}: {fun_name}")
+                        break
+                except ElSequenceError as ese:
+                    if throw_errors:
+                        raise ElSequenceError(
+                            f"Error running {self.name}, {fun_name}: {ese}"
+                        ) from ese
+                    else:
+                        logger.warning(f"{self.name}, {fun_name}: {ese}")
+                        stages[2] = (stages[2][0], True)
+                        stages[3] = (stages[3][0], True)
+                except Exception as e:
+                    if throw_errors:
+                        raise Exception(
+                            f"Error running {self.name}, {fun_name}: {e}"
+                        ) from e
+                    else:
+                        logger.error(f"{self.name}, {fun_name}: {e}")
+                        break
+            else:
+                logger.debug(f"Skipping step {stage}: {fun_name}")
         return self
 
     def _create_itrans(self) -> g.Transformation:
@@ -105,6 +116,13 @@ class Analysis:
         """If the elements are labelled it should be possible to select the correct option.
         First find all the options that match the element sequence.
         If more than one option matches, select the one with the best score.
+
+        There is a problem if both options have the same element names
+        in this case we need to score both and choose the best.
+
+        NOTE (0.5.1 on) - added option index to the class, so if that exists use that.
+        If not then do the old check and set the option for next time.
+        This function can be simplified once all the old analyses have been updated with the option.
         """
         mopt = ManOption([self.mdef]) if isinstance(self.mdef, ManDef) else self.mdef
 
@@ -112,7 +130,7 @@ class Analysis:
 
         options = []
         for md in mopt:
-            if len(elnames) == len(md.eds) + 1 and np.all(
+            if len(elnames) == len(md.eds) and np.all(
                 [elnames[i] == k for i, k in enumerate(md.eds.data.keys())]
             ):
                 options.append(md)
@@ -120,7 +138,8 @@ class Analysis:
             raise ElSequenceError(
                 f"{self.mdef.info.short_name} element sequence doesn't agree with {elnames}"
             )
-
+        elif self.option is not None:
+            option_id = self.option
         elif len(options) == 1:
             option_id = 0
         else:
@@ -128,12 +147,12 @@ class Analysis:
             for option in options:
                 scores.append(replace(self, mdef=option).run(False).scores.score())
             option_id = np.argmax(scores)
-        return replace(self, mdef=options[option_id])
+        return replace(self, mdef=options[option_id], option=option_id)
 
     def _preliminary_alignment(
         self, mdef: ManDef, freq: int = 25, radius: AlignRadiusOption = 10
     ):
-        manoeuvre = mdef.create().add_lines()
+        manoeuvre = mdef.create()
         templates = manoeuvre.create_template(self.itrans, None, freq, "min")
         template = State.stack(templates, "element")
         res = Alignment.align(self.flown, template, radius, True)
@@ -172,22 +191,24 @@ class Analysis:
         )
 
     def prepare_scoring(self) -> Self:
-        manoeuvre = (self.manoeuvre or self.mdef.create().add_lines()).match_intention(
+        manoeuvre = (self.manoeuvre or self.mdef.create()).match_intention(
             self.itrans, self.flown, 0, "min", True
         )[0]
 
         mdef = self.mdef.update_defaults(manoeuvre)
-        corrected = mdef.create().add_lines()
+        corrected = mdef.create()
 
         manoeuvre = manoeuvre.copy_directions(corrected)
         templates = manoeuvre.create_template(self.itrans, self.flown)
 
         return replace(self, mdef=mdef, manoeuvre=manoeuvre, templates=templates)
 
-    def optimise_alignment(self):
-        fl = optimise_alignment(self.flown, self.mdef, self.manoeuvre, self.templates)
-
-        return replace(self, flown=fl)
+    def optimise_alignment(self, include_inter: bool = True) -> Self:
+        steps = {}
+        for el in list(self.manoeuvre.elements.keys())[:-1]:
+            steps[el], self = self.optimise_boundary(el, include_inter)
+        logger.debug(f"optimisation result:\n{dumps(steps, indent=2)}")
+        return self
 
     def intra(self):
         return ElementsResults([ea.intra_score() for ea in self])
@@ -196,7 +217,9 @@ class Analysis:
         return self.mdef.mps.collect(self.manoeuvre, self.flown, self.mdef.box)
 
     def positioning(self):
-        return self.mdef.box.score(self.mdef.info, self.flown, self.template)
+        return self.mdef.box.score(
+            self.mdef.info, self.manoeuvre.elements, self.flown, self.template
+        )
 
     def calculate_score(self) -> Self:
         def fun(group: Literal["inter", "intra", "positioning"]):
@@ -210,6 +233,97 @@ class Analysis:
             scores=ManoeuvreResults(fun("inter"), fun("intra"), fun("positioning")),
         )
 
+    def reload_element(self, name: str | int) -> Self:
+        ist = self.templates[name][0].relocate(self.flown.element[name][0].pos)
+        new_man = self.manoeuvre.replace_elements(
+            **{
+                name: self.manoeuvre.elements[name].match_intention(
+                    ist, self.flown.element[name]
+                )
+            }
+        )
+        new_templates = self.templates | {
+            name: new_man.elements[name].create_template(ist, self.flown.element[name])
+        }
+
+        return replace(
+            self,
+            mdef=replace(self.mdef, mps=self.mdef.mps.update_defaults(new_man)),
+            manoeuvre=new_man,
+            templates=new_templates,
+            scores=None,
+        )
+
+    def update_boundaries(self, new_fl: State) -> Self:
+        changes = [
+            k
+            for k in self.manoeuvre.elements.keys()
+            if new_fl.labels.element[k] != self.flown.labels.element[k]
+        ]
+        _new: Self = replace(self, flown=new_fl)
+        for change in changes:
+            _new = _new.reload_element(change)
+        return _new
+
+    def shift_boundary(self, boundary: str, t: float) -> Self:
+        return self.update_boundaries(
+            self.flown.move_label(
+                "element", boundary, self.flown.labels.element[boundary].stop + t
+            )
+        )
+
+    def step_boundary(self, boundary: str, steps: int) -> Self:
+        return self.update_boundaries(
+            self.flown.step_label("element", boundary, steps, self.flown.t, 3)
+        )
+
+    def score_boundary(self, boundary: str, include_inter: bool = True):
+        next_el = self.manoeuvre.elnames[self.manoeuvre.elnames.index(boundary) + 1]
+        return ElementsResults(
+            {
+                boundary: self[boundary].intra_score(),
+                next_el: self[next_el].intra_score(),
+                **({"inter": self.inter()} if include_inter else {}),
+            }
+        )
+
+    def optimise_boundary(
+        self, boundary: str, include_inter: bool = True
+    ) -> list[Self | int]:
+        next_el = self.manoeuvre.elnames[self.manoeuvre.elnames.index(boundary) + 1]
+
+        def score_step(_steps: int):
+            try:
+                _new = self.step_boundary(boundary, _steps)
+                _results = _new.score_boundary(boundary, include_inter)
+                return [_results.total, _new]
+            except Exception as _:
+                return None
+
+        best = score_step(0)
+        direction = (
+            -1
+            if self.flown.labels.element[boundary].width
+            > self.flown.labels.element[next_el].width
+            else 1
+        )
+
+        _check = score_step(direction)
+        if _check is not None and _check[0] < best[0]:
+            best = _check
+            steps = direction
+        else:
+            direction = -direction
+            steps = 0
+
+        while True:
+            steps += direction
+            _check = score_step(steps)
+            if _check is not None and _check[0] < best[0]:
+                best = _check
+            else:
+                return steps, best[1]
+
     def get_ea(self, name: str | int) -> ElementAnalysis:
         el: AnyElement = self.manoeuvre.elements[name]
         fl = self.flown.element[el.uid]
@@ -224,7 +338,7 @@ class Analysis:
             self.scores.intra[name] if self.scores else None,
         )
 
-    def __getattr__(self, name: str):
+    def __getattr__(self, name: str) -> ElementAnalysis:
         if name in self.flown.labels.element.keys():
             return self.get_ea(name)
         raise AttributeError(f"{self.__class__.__name__} has no attribute {name}")
@@ -272,22 +386,21 @@ class Analysis:
 
     @staticmethod
     def from_dict(data: dict):
-        if "manoeuvre" in data and data["manoeuvre"]:
-            manoeuvre = Manoeuvre.from_dict(data["manoeuvre"])
-        else:
-            manoeuvre = None
+        manoeuvre = (
+            Manoeuvre.from_dict(data["manoeuvre"]) if data.get("manoeuvre") else None
+        )
 
-        if "templates" in data and data["templates"]:
-            templates = {k: State.from_dict(v) for k, v in data["templates"].items()}
-        else:
-            templates = None
+        templates = (
+            {k: State.from_dict(v) for k, v in data["templates"].items()}
+            if data.get("templates")
+            else None
+        )
 
         itrans = list(templates.values())[0][0].transform if templates else None
 
-        if "scores" in data and data["scores"]:
-            scores = ManoeuvreResults.from_dict(data["scores"])
-        else:
-            scores = None
+        scores = (
+            ManoeuvreResults.from_dict(data["scores"]) if data.get("scores") else None
+        )
 
         return Analysis(
             data["id"],
@@ -296,6 +409,7 @@ class Analysis:
             else None,
             State.from_dict(data["flown"]),
             ManDef.from_dict(data["mdef"]),
+            data.get("option"),
             itrans,
             manoeuvre,
             templates,
@@ -309,6 +423,7 @@ class Analysis:
             if self.schedule_direction
             else None,
             flown=self.flown.to_dict(True),
+            option=self.option,
             **(
                 {}
                 if basic

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/analysis/schedule_analysis.py

@@ -13,8 +13,7 @@ import numpy as np
 import pandas as pd
 
 
-class ScheduleAnalysis(Collection):
-    VType = Analysis
+class ScheduleAnalysis(Collection[Analysis]):
     uid = "name"
 
     @property
@@ -25,9 +24,6 @@ class ScheduleAnalysis(Collection):
     def template(self):
         return State.stack([m.template for m in self])
 
-    def proceed(self):
-        return ScheduleAnalysis([m.proceed() for m in self])
-
     @staticmethod
     def parse_ajson(ajson: AJson, sdef: SchedDef = None) -> ScheduleAnalysis:
         if not all([ajson.mdef for ajson in ajson.mans]) and sdef is None:
@@ -36,11 +32,17 @@ class ScheduleAnalysis(Collection):
         if sdef is None:
             sdef = [ManDef.from_dict(man.mdef) for man in ajson.mans]
         for man, mdef in zip(ajson.mans, sdef):
-            analyses.append(Analysis.from_dict(man.model_dump() | dict(mdef=mdef.to_dict())))
+            analyses.append(
+                Analysis.from_dict(man.model_dump() | dict(mdef=mdef.to_dict()))
+            )
         return ScheduleAnalysis(analyses)
 
     def run(
-        self, optimise: bool = False, sync: boolean = False, throw_errors: bool = False, subset: list = None
+        self,
+        optimise: bool = False,
+        sync: boolean = False,
+        throw_errors: bool = False,
+        subset: list = None,
     ) -> Self:
         if subset is None:
             subset = range(len(self))
@@ -54,41 +56,37 @@ class ScheduleAnalysis(Collection):
             ]
         else:
             madicts = Parallel(n_jobs=os.cpu_count() * 2 - 1)(
-                delayed(Analysis.parse_analyse_serialise)(man.to_dict(), optimise, throw_errors)
+                delayed(Analysis.parse_analyse_serialise)(
+                    man.to_dict(), optimise, throw_errors
+                )
                 for i, man in enumerate(self)
                 if i in subset
             )
 
         return ScheduleAnalysis(
             [
-                Analysis.from_dict(madicts[subset.index(i)])
-                if i in subset
-                else self[i]
+                Analysis.from_dict(madicts[subset.index(i)]) if i in subset else self[i]
                 for i in range(len(self))
             ]
         )
 
-
     def scores(self):
         scores = {}
         total = 0
         scores = {
-            ma.name: (ma.scores.score() if hasattr(ma, "scores") and ma.scores else 0) for ma in self
+            ma.name: (ma.scores.score() if hasattr(ma, "scores") and ma.scores else 0)
+            for ma in self
         }
         total = sum([ma.mdef.info.k * v for ma, v in zip(self, scores.values())])
         return total, scores
 
     def summarydf(self):
-        return pd.DataFrame(
-            [m.scores.summary() if m.scores else {} for m in self]
-        )
+        return pd.DataFrame([m.scores.summary() if m.scores else {} for m in self])
 
     def score_summary_df(self, difficulty=3, truncate=False):
         return pd.DataFrame(
             [
-                ma.scores.score_summary(difficulty, truncate)
-                if ma.scores
-                else {}
+                ma.scores.score_summary(difficulty, truncate) if ma.scores else {}
                 for ma in self
             ]
         )
@@ -96,7 +94,10 @@ class ScheduleAnalysis(Collection):
     def basic(self, sdef: SchedDef = None, remove_labels: bool = True) -> Self:
         return ScheduleAnalysis(
             [
-                man.basic(sdef[man.mdef.info.short_name] if sdef is not None else None, remove_labels)
+                man.basic(
+                    sdef[man.mdef.info.short_name] if sdef is not None else None,
+                    remove_labels,
+                )
                 for man in self
             ]
         )
@@ -104,11 +105,11 @@ class ScheduleAnalysis(Collection):
     @property
     def mnames(self):
         return [m.name for m in self]
-    
+
     @property
     def fls(self):
         return {m.name: m.flown for m in self}
-    
+
     @property
     def tps(self):
-        return {m.name: m.template for m in self}
+        return {m.name: m.template for m in self}

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/base/ref_funcs.py

@@ -96,8 +96,7 @@ class RefFunc:
         return description
 
 
-class RefFuncs(Collection):
-    VType = RefFunc
+class RefFuncs(Collection[RefFunc]):
     uid = "name"
 
     def to_list(self):

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/base/utils.py

@@ -5,6 +5,7 @@ import pandas as pd
 from pathlib import Path
 import numpy as np
 from typing import Any
+import re
 
 
 def combine_args(names: list[str], *args, **kwargs) -> dict:
@@ -43,10 +44,12 @@ def df_insert(df: pd.DataFrame, **kwargs) -> pd.DataFrame:
 
 def tryval(val):
     try:
-        if val[-1] == "°":
-            return np.radians(float(val[:-1]))
-        else:
-            return float(val)
+        hasdeg = val.find("°")
+        val = float(val.split("°")[0].strip())
+        if hasdeg >= 0:
+            val = np.radians(val)
+        return val
+
     except Exception:
         return val if len(val) else None
 
@@ -54,24 +57,27 @@ def tryval(val):
 def process_series(ser: pd.Series):
     if sum(ser == "True") + sum(ser == "False") == len(ser):
         return ser == "True"
-    elif ser.dtype == object:
+    elif ser.dtype == object or ser.dtype == "string":
+
         try:
-            deglocs = ser.str.endswith("°")
-            if sum(deglocs):
-                vals = ser.str.rstrip("°").astype(float)
-                return np.where(deglocs, np.radians(vals), vals)
-            else:
-                return ser.astype(float)
+            vals = ser.str.extract(r'^([\d+]*\.?[\d]+)').iloc[:,0].astype(np.float64)
+            if np.isnan(vals).any():
+                return ser.values
+            deglocs = ser.str.contains("°")
+            if deglocs.any():
+                pass
+            return np.where(deglocs, np.radians(vals), vals)
+            
         except Exception:
             return ser
     else:
-        return ser
+        return ser.values
 
 
 def parse_csv(file: Path | str | pd.DataFrame, **kwargs) -> pd.DataFrame:
     path = Path(file)
     df: pd.DataFrame = pd.read_csv(path, **({"comment": "#"} | kwargs), keep_default_na=False).apply(
-        lambda x: x.str.strip() if x.dtype == object else x
+        lambda x: x.str.strip() if x.dtype == object or x.dtype == "string" else x
     )
     df.columns = [c.strip() for c in df.columns]
     return df.apply(process_series)
@@ -105,3 +111,12 @@ def replace_any_depth_value(d: Any, old_value: Any, new_value: Any) -> dict:
         return new_value
     else:
         return d
+
+
+def display_unit(value: Number, unit: str="", precision: int = 2) -> str:
+    new_unit = re.sub(r"radians|radian|rad", "°", unit)
+    if unit.find("rad") >= 0:
+        val = f"{np.degrees(value):.{precision}f}"
+    else:
+        val = f"{value:.{precision}f}"
+    return f"{val} {new_unit}"

{flightanalysis-0.4.0 → flightanalysis-0.4.1}/src/flightanalysis/builders/elbuilders.py

@@ -1,11 +1,12 @@
 from numbers import Number
 
+from flightanalysis.definition.manparms import ManParms
 import numpy as np
 import pandas as pd
 
 from flightanalysis.definition import ItemOpp, Opp, maxopp
 from flightanalysis.definition.collectors import Collectors
-from flightanalysis.definition.eldef import ElDef, ElDefs, ManParm, ManParms
+from flightanalysis.definition.eldef import ElDef, ElDefs, ManParm
 from flightanalysis.elements import Line, Loop, Snap, Spin, StallTurn, TailSlide
 from flightanalysis.scoring import inter_visors as visors
 from flightanalysis.scoring.criteria.inter.comparison import free_comparison