flightanalysis 0.2.16__tar.gz → 0.2.17__tar.gz

{flightanalysis-0.2.16/flightanalysis.egg-info → flightanalysis-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.2.16
+Version: 0.2.17
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -15,8 +15,9 @@ Requires-Dist: fastdtw
 Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
-Requires-Dist: pfc-geometry>=0.2.7
-Requires-Dist: flightdata>=0.2.15
+Requires-Dist: pfc-geometry>=0.2.8
+Requires-Dist: flightdata>=0.2.16
+Requires-Dist: GitPython
 Provides-Extra: dev
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: pandas; extra == "dev"
@@ -25,10 +26,11 @@ Requires-Dist: fastdtw; extra == "dev"
 Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
-Requires-Dist: pfc-geometry>=0.2.7; extra == "dev"
-Requires-Dist: flightdata>=0.2.15; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.8; extra == "dev"
+Requires-Dist: flightdata>=0.2.16; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.3; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
+Requires-Dist: GitPython; extra == "dev"
 
 # FlightAnalysis
 

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/create_all.py

@@ -2,16 +2,16 @@ from f3a_p23 import p23_def
 from f3a_a25 import a25_def
 from f3a_p25 import p25_def
 from f3a_f25 import f25_def
-from imac_unlim2024 import sdef as imac_unl2024_def
+#from imac_unlim2024 import sdef as imac_unl2024_def
 from f3auk_clubman import clubman_def as f3auk_club_def
-from f3auk_Intermediate import intermediate_def as f3auk_int_def
+from f3auk_intermediate import intermediate_def as f3auk_int_def
 
 sdefs = {
     'f3a_p23_schedule': p23_def, 
     'f3a_a25_schedule': a25_def, 
     'f3a_p25_schedule': p25_def, 
     'f3a_f25_schedule': f25_def, 
-    'IMAC_Unlimited2024_schedule': imac_unl2024_def, 
+    #'IMAC_Unlimited2024_schedule': imac_unl2024_def, 
     'f3auk_clubman_schedule': f3auk_club_def, 
     'f3auk_inter_schedule': f3auk_int_def
 }

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3a_a25.py

@@ -1,9 +1,13 @@
 '''Author Vince Beesley 18/11/2023'''
 
-from flightanalysis import *
+from flightanalysis import (
+    SchedDef, ManInfo, BoxLocation, Position, Orientation, 
+    Height, Direction, MBTags, f3amb, centred, r, c45
+)
+from flightanalysis.scoring.f3a_downgrades import DGGrps
+
 import numpy as np
 
-c45 = np.cos(np.radians(45))
 
 a25_def = SchedDef([
      f3amb.create(ManInfo
@@ -233,6 +237,10 @@ a25_def = SchedDef([
     ]  
 )
  
+a25_def.stall.eds.e_1.dgs = DGGrps.st_line_decel
+a25_def.stall.eds.e_3_pad1.dgs = DGGrps.st_line_accel
+a25_def.iSpin.eds.e_1.dgs = DGGrps.sp_line_accel
+
 
 if __name__ == "__main__":
     

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3a_f25.py

@@ -3,7 +3,7 @@ from flightanalysis import (
     Height, Direction, MBTags, f3amb, centred, r, ManParm,
     ManOption, Combination, c45
 )
-
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 import numpy as np
 
 
@@ -253,7 +253,9 @@ f25_def = SchedDef([
     )
 ])
 
-
+f25_def.spin.eds.e_1_pad1.dgs = DGGrps.sp_line_accel
+f25_def.stall.eds.e_3_pad2.dgs = DGGrps.st_line_decel
+f25_def.stall.eds.e_5_pad1.dgs = DGGrps.st_line_accel
 
 if __name__ == "__main__":
 

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3a_p23.py

@@ -1,12 +1,12 @@
 """This file defines a P23 sequence using the ManDef Classes and helper functions."""
-from flightanalysis.definition import *
-from flightanalysis.elements import *
-from flightanalysis.scoring import *
+from flightanalysis import (
+    SchedDef, ManInfo, BoxLocation, Position, Orientation, 
+    Height, Direction, MBTags, f3amb, centred, r, ManParm,
+    Combination, c45
+)
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 import numpy as np
 
-c45 = np.cos(np.radians(45))
-
-
 
 p23_def = SchedDef([
     f3amb.create(ManInfo(
@@ -222,6 +222,13 @@ p23_def = SchedDef([
         ))
 ])
 
+
+p23_def.iSp.eds.e_1.dgs = DGGrps.sp_line_accel
+p23_def.M.eds.e_1_pad2.dgs = DGGrps.st_line_decel
+p23_def.M.eds.e_3.dgs = DGGrps.st_line_accel
+p23_def.M.eds.e_5.dgs = DGGrps.st_line_decel
+p23_def.M.eds.e_7_pad1.dgs = DGGrps.st_line_accel
+
 if __name__ == "__main__":
     
  #   p23_def.plot().show()

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3a_p25.py

@@ -3,12 +3,9 @@ from flightanalysis import (
     Height, Direction, MBTags, f3amb, centred, r, ManParm,
     ManOption, Combination, c45
 )
-
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 import numpy as np
 
-
-
-
 p25_def = SchedDef([
     f3amb.create(ManInfo(
             "Triangle", "trgle", k=3, position=Position.CENTRE, 
@@ -222,8 +219,8 @@ p25_def = SchedDef([
             f3amb.loop(r(3/8)),
             f3amb.loop(r(1/8), rolls="rke_opt[0]"),
             MBTags.CENTRE,
-            f3amb.loop("rke_opt[1]", ke=True),
-            f3amb.loop("rke_opt[2]", ke=True, rolls="rke_opt[3]"),
+            f3amb.loop("rke_opt[1]", ke=np.pi/2),
+            f3amb.loop("rke_opt[2]", ke=np.pi/2, rolls="rke_opt[3]"),
             MBTags.CENTRE
         ],
         rke_opt=ManParm("rke_opt", 
@@ -233,6 +230,10 @@ p25_def = SchedDef([
         ])), 0)),
 ])
 
+p25_def.stall.eds.e_1.dgs = DGGrps.st_line_decel
+p25_def.stall.eds.e_3_pad1.dgs = DGGrps.st_line_accel
+p25_def.iSpin.eds.e_1_pad1.dgs = DGGrps.sp_line_accel
+
 
 if __name__ == "__main__":
 

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3auk_clubman.py

@@ -2,7 +2,12 @@
 UKF3A Clubman template
 Author Vince Beesley
 '''
-from flightanalysis import *
+from flightanalysis import (
+    SchedDef, ManInfo, BoxLocation, Position, Orientation, 
+    Height, Direction, MBTags, f3amb, centred, r, ManParm,
+    ManOption, Combination, c45
+)
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 import numpy as np
 
 clubman_def = SchedDef([  
@@ -106,11 +111,9 @@ clubman_def = SchedDef([
         ),
         [
             f3amb.loop(np.pi/2),
-            f3amb.line(length=150),                       
-            f3amb.line(speed = 3, length = 10),
-            f3amb.line(speed = 1, length = 5),
+            f3amb.line(),
             f3amb.stallturn(),
-            f3amb.line(length=165), 
+            f3amb.line(), 
             f3amb.loop(np.pi/2)
         ]),
 
@@ -196,7 +199,9 @@ clubman_def = SchedDef([
     ]
 )
 
-
+clubman_def.stall.eds.e_1.dgs = DGGrps.st_line_decel
+clubman_def.stall.eds.e_3.dgs = DGGrps.st_line_accel
+clubman_def.spin.eds.e_1.dgs = DGGrps.sp_line_decel
 
 if __name__ == "__main__":
 

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/examples/schedule_construction/f3auk_intermediate.py

@@ -2,13 +2,15 @@
 UKF3A Intermediate Template
 Author Vince Beesley
 '''
-from flightanalysis import *
+from flightanalysis import (
+    SchedDef, ManInfo, BoxLocation, Position, Orientation, 
+    Height, Direction, MBTags, f3amb, centred, r, ManParm,
+    ManOption, Combination, c45
+)
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 import numpy as np
 
 
-
-c45 = np.cos(np.radians(45))
-
 intermediate_def = SchedDef([  
    
     f3amb.create(ManInfo
@@ -75,12 +77,12 @@ intermediate_def = SchedDef([
             end=BoxLocation(Height.TOP)            
         ),
         [   
-            f3amb.loop(-np.pi/2),            
-            f3amb.line(roll=np.pi),
+            f3amb.loop(-np.pi/2),     
+            f3amb.roll(np.pi),
             f3amb.loop(np.pi/2), 
             centred(f3amb.line()),
             f3amb.loop(np.pi/2), 
-            f3amb.line(roll=np.pi),       
+            f3amb.roll(np.pi),       
             f3amb.loop(-np.pi/2),                               
            ], line_length = 100
         ),

flightanalysis-0.2.17/examples/schedule_construction/make_manoeuvre.py

@@ -0,0 +1,48 @@
+from flightplotting import plotsec, plot_regions
+from flightplotting.traces import axis_rate_trace
+from flightanalysis import (
+    ManDef, BoxLocation, Position, Height, Direction, 
+    Orientation, ManInfo, r, MBTags, c45, centred, ManParm, Combination)
+import numpy as np
+from flightanalysis.definition import f3amb
+from flightdata import NumpyEncoder
+import plotly.graph_objects as go
+from json import dumps
+
+mdef: ManDef = f3amb.create(ManInfo(
+            "Figure S", "figS", k=5, position=Position.CENTRE, 
+            start=BoxLocation(Height.BTM, Direction.UPWIND, Orientation.UPRIGHT),
+            end=BoxLocation(Height.TOP)
+        ),[
+            MBTags.CENTRE,
+            f3amb.loop(r(3/8)),
+            f3amb.loop(r(1/8), rolls="rke_opt[0]"),
+            MBTags.CENTRE,
+            f3amb.loop("rke_opt[1]", ke=np.pi/2),
+            f3amb.loop("rke_opt[2]", ke=np.pi/2, rolls="rke_opt[3]"),
+            MBTags.CENTRE
+        ],
+        rke_opt=ManParm("rke_opt", 
+            Combination(desired=r([
+                [1/4, 3/8, 1/8, 1/4], 
+                [-1/4, -3/8, -1/8, -1/4]
+        ])), 0))
+
+
+data = mdef.to_dict()
+print(dumps(data, indent=2, cls=NumpyEncoder))
+mdef = ManDef.from_dict(data)
+
+it = mdef.info.initial_transform(170, 1)
+
+man = mdef.create(it)
+
+tp = man.create_template(it)
+
+fig = plot_regions(tp, 'element')
+fig = plotsec(tp, fig=fig, nmodels=10, scale=2)
+#fig.add_traces(boxtrace())
+fig.show()
+
+fig = go.Figure(data=axis_rate_trace(tp))
+fig.show()

flightanalysis-0.2.17/flightanalysis/__init__.py

@@ -0,0 +1,21 @@
+from .version import __version__  # noqa: F401
+from .elements import *  # noqa: F403
+from .manoeuvre import Manoeuvre  # noqa: F401
+from .schedule import Schedule  # noqa: F401
+from .definition import *  # noqa: F403
+from .scoring import *  # noqa: F403
+from .analysis import ScheduleAnalysis, ElementAnalysis  # noqa: F401
+from .analysis import manoeuvre_analysis as ma  # 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
+    )
+

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/flightanalysis/analysis/el_analysis.py

@@ -1,8 +1,8 @@
-
+from __future__ import annotations
 from flightdata import State
 from typing import Self
 from flightanalysis import ElDef, Element, ManParms
-
+import numpy as np
 from dataclasses import dataclass
 import geometry as g
 
@@ -33,4 +33,8 @@ class ElementAnalysis:
             State.from_dict(data['fl']),
             State.from_dict(data['tp']),
             g.Transformation.from_dict(data['ref_frame'])
-        )
+        )
+    
+    def intra_score(self):
+        return self.edef.dgs.apply(self.el, self.fl, self.tp)
+    

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/flightanalysis/analysis/manoeuvre_analysis/alignment.py

@@ -14,7 +14,7 @@ class Alignment(Basic):
 
     def __getattr__(self, name) -> ElementAnalysis:
         return ElementAnalysis(
-            self.mdef.data[name],
+            self.mdef.eds.data[name],
             self.mdef.mps,
             self.manoeuvre.elements.data[name],
             self.flown.get_element(name),

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -2,14 +2,19 @@ from __future__ import annotations
 from dataclasses import dataclass
 from ..el_analysis import ElementAnalysis
 from flightdata import State
-from flightanalysis.definition import ManDef, ScheduleInfo
+from flightanalysis.definition import ManDef, ElDef
 from flightanalysis.manoeuvre import Manoeuvre
-from flightanalysis.scoring import Results, ManoeuvreResults, Measurement
+from flightanalysis.scoring import Results, ManoeuvreResults, Measurement, ElementsResults
 from flightanalysis.scoring.criteria.f3a_criteria import F3A
+from flightanalysis.scoring.f3a_downgrades import DGGrps
 from flightanalysis.definition.maninfo import Position
+from flightanalysis.elements import Line, Element
+import geometry as g
 import numpy as np
+from .basic import Basic
 from .alignment import Alignment
 from loguru import logger
+from typing import Union
 
 
 @dataclass
@@ -46,22 +51,33 @@ class Complete(Alignment):
         return list(self.mdef.eds.data.keys())
 
     def __iter__(self):
-        for elname in self.manoeuvre.all_elements().data.keys():
-            yield self.get_ea(self.mdef.eds[elname])
+        for edn in ['entry_line'] + list(self.mdef.eds.data.keys()):
+            yield self.get_ea(edn)
 
     def __getitem__(self, i):
-        return self.get_ea(['entry_line'] + self.mdef.eds[i] + ['exit_line'])
+        return self.get_ea('entry_line' if i == 0 else self.mdef.eds[i+1].name)
 
     def __getattr__(self, name):
-        if name in self.mdef.eds.data.keys():
-            return self.get_ea(self.mdef.eds[name])
+        if name in self.mdef.eds.data.keys() or name == 'entry_line':
+            return self.get_ea(name)
         raise AttributeError(f'Attribute {name} not found in {self.__class__.__name__}')
 
-    def get_ea(self, edef):
-        el = getattr(self.manoeuvre.all_elements(), edef.name)
+    def get_edef(self, name):
+        if name == 'entry_line':
+            el = getattr(self.manoeuvre.all_elements(), name)
+            return ElDef('entry_line', Line, 
+                dict(speed=el.speed,length=el.length,roll=0),
+                DGGrps.exits
+            )
+        else:
+            return self.mdef.eds[name]
+        
+    def get_ea(self, name):
+        el = getattr(self.manoeuvre.all_elements(), name)
         st = el.get_data(self.flown)
         tp = el.get_data(self.template).relocate(st.pos[0])
-        return ElementAnalysis(edef, self.mdef.mps, el, st, tp, el.ref_frame(tp))
+
+        return ElementAnalysis(self.get_edef(name), self.mdef.mps, el, st, tp, el.ref_frame(tp))
 
 
     def update_templates(self):
@@ -73,14 +89,86 @@ class Complete(Alignment):
             return Complete(
                 self.id, mdef, self.flown, self.direction,
                 manoeuvre, template, correction, 
-                correction.create_template(template[0])
+                correction.create_template(template[0], self.flown)
             )
         else:
             return self
     
+    def get_score(self, eln: str, itrans: g.Transformation, fl: State) -> tuple[Results, g.Transformation]:
+        ed: ElDef = self.get_edef(eln)
+        el: Element = self.manoeuvre.all_elements()[eln].match_intention(itrans, fl)        
+        tp = el.create_template(State.from_transform(itrans), fl.time)
+        
+        return ed.dgs.apply(el, fl, tp, False), tp[-1].att
+
+    def optimise_split(self, itrans: g.Transformation, eln1: str, eln2: str, fl: State) -> int:
+        
+        def score_split(steps: int) -> float:
+            new_fl = fl.shift_label(steps, 2, manoeuvre=self.name, element=eln1)
+            res1, new_iatt = self.get_score(eln1, itrans, new_fl.get_element(eln1))
+            
+            el2fl = new_fl.get_element(eln2)
+            res2 = self.get_score(
+                eln2, 
+                g.Transformation(new_iatt,  el2fl[0].pos ), 
+                el2fl
+            )[0]
+            logger.debug(f'split {steps} {res1.total + res2.total:.2f}')
+            
+            return res1.total + res2.total  
+
+        dgs = {0: score_split(0)}
+        
+        steps=int(len(fl.get_element(eln1)) > len(fl.get_element(eln2))) * 2 - 1
+
+        new_dg = score_split(steps)
+        if new_dg > dgs[0]:
+            steps=-steps
+        else:
+            steps+=np.sign(steps)
+            dgs[steps] = new_dg
+            
+        while True:
+            if (steps>0 and len(fl.get_element(eln2))<=steps+3) or (steps<0 and len(fl.get_element(eln1)) <=-steps+3):
+                break
+            new_dg = score_split(steps)
+            if new_dg < list(dgs.values())[-1]:
+                dgs[steps] = new_dg
+                steps+=np.sign(steps)
+            else:
+                break
+        min_dg_step = np.argmin(np.array(list(dgs.values())))
+        out_steps = list(dgs.keys())[min_dg_step]
+        return out_steps
+
     def optimise_alignment(self):
-        self.flown = self.manoeuvre.optimise_alignment(self.template, self.flown)
-        return self.update_templates()
+        fl = self.flown.copy()
+        elns = ['entry_line'] + list(self.mdef.eds.data.keys())
+        
+        padjusted = set(elns)
+        count=0
+        while len(padjusted) > 0 and count < 2:
+            adjusted = set()
+            for eln1, eln2 in zip(elns[:-1], elns[1:]):
+                if (eln1 in padjusted) or (eln2 in padjusted):
+                    itrans = g.Transformation(
+                        self.template.get_element(eln1)[0].att,
+                        fl.get_element(eln1)[0].pos
+                    )
+                    steps = self.optimise_split(itrans, eln1, eln2, fl)
+                    
+                    if not steps == 0:
+                        logger.debug(f'Adjusting split between {eln1} and {eln2} by {steps} steps')    
+                        
+                        fl = fl.shift_label(steps, 2, manoeuvre=self.name, element=eln1)
+
+                        adjusted.update([eln1, eln2])
+
+            padjusted = adjusted
+            count+=1
+            logger.debug(f'pass {count}, {len(padjusted)} elements adjusted:\n{padjusted}')
+        
+        return Basic(self.id, self.mdef, fl, self.direction).proceed()
     
     def side_box(self):
         return F3A.intra.box(
@@ -130,7 +218,7 @@ class Complete(Alignment):
         )
         
     def intra(self):
-        return self.manoeuvre.analyse(self.flown, self.template)
+        return ElementsResults([ea.intra_score() for ea in self])
 
     def inter(self):
         return self.mdef.mps.collect(self.manoeuvre, self.template)

{flightanalysis-0.2.16 → flightanalysis-0.2.17}/flightanalysis/analysis/sch_analysis.py

@@ -3,14 +3,12 @@ from typing import Self, Union
 from json import load, dump
 from flightdata import Flight, State, Origin, Collection, NumpyEncoder
 from flightanalysis.definition import SchedDef, ScheduleInfo
+from flightanalysis import __version__
 from . import manoeuvre_analysis as analysis
 from loguru import logger
 from joblib import Parallel, delayed
 import os
 import pandas as pd
-from importlib.metadata import version
-from packaging import version as pkgversion
-from pathlib import Path
 
 class ScheduleAnalysis(Collection):
     VType=analysis.Analysis
@@ -21,7 +19,7 @@ class ScheduleAnalysis(Collection):
         self.sinfo = sinfo
 
     @staticmethod
-    def from_fcj(file: Union[Union[str, bytes, os.PathLike], dict], info: ScheduleInfo=None) -> ScheduleAnalysis:
+    def from_fcj(file: Union[str | bytes, dict], info: ScheduleInfo=None, proceed=True) -> ScheduleAnalysis:
         data = file if isinstance(file, dict) else load(open(file, 'r'))
 
         flight = Flight.from_fc_json(data)
@@ -30,12 +28,12 @@ class ScheduleAnalysis(Collection):
             info = ScheduleInfo.from_str(data["parameters"]["schedule"][1])
         
         sdef = SchedDef.load(info)
-        box = Origin.from_fcjson_parmameters(data["parameters"])
+        box = Origin.from_fcjson_parameters(data["parameters"])
         state = State.from_flight(flight, box).splitter_labels(data["mans"],sdef.uids)
         direction = -state.get_manoeuvre(1)[0].direction()[0]
 
-        if 'fcs_scores' in data:
-            versions = [pkgversion.parse(res['fa_version']) for res in data['fcs_scores']]
+        if 'fcs_scores' in data and len(data['fcs_scores']) > 0:
+            versions = [res['fa_version'] for res in data['fcs_scores']]
             ilatest = versions.index(max(versions))
 
         mas = []
@@ -46,7 +44,10 @@ class ScheduleAnalysis(Collection):
                 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())
+            nma = analysis.Basic(i, mdef, st, direction)
+            if proceed:
+                nma = nma.proceed()
+            mas.append(nma)
 
         return ScheduleAnalysis(mas,info)
     
@@ -54,7 +55,7 @@ class ScheduleAnalysis(Collection):
         data = file if isinstance(file, dict) else load(open(file, 'r'))
 
         new_results = dict(
-            fa_version = version('flightanalysis'),
+            fa_version = __version__,
             manresults = [None] + \
                 [man.fcj_results() if hasattr(man, 'fcj_results') else None for man in self]
         )
@@ -70,17 +71,10 @@ class ScheduleAnalysis(Collection):
             data['fcs_scores'].append(new_results)
 
         if ofile:
-            if ofile=='same':
-                ofile = file
-            dump(data, open(ofile, 'w'), cls=NumpyEncoder, indent=2)
+            dump(data, open(file if ofile=='same' else ofile, 'w'), cls=NumpyEncoder, indent=2)
 
         return data
     
-#    def export_fcj_and_internals(self, file: Union[str, dict]):
-#        data = load(open(file, 'r')) if isinstance(file, str) else file
-#        fcj = self.append_scores_to_fcj(data)
-
-
     def run_all(self) -> Self:
         def parse_analyse_serialise(pad):
             try:

flightanalysis-0.2.17/flightanalysis/base/utils.py

@@ -0,0 +1,13 @@
+
+
+
+
+def combine_args(names: list[str], *args, **kwargs) -> dict:
+    """Combine the args and kwargs into a dict with the names as keys"""
+    _kwargs = {}
+    for i, n in enumerate(names):
+        if i < len(args):
+            _kwargs[n] = args[i]
+        if n in kwargs:
+            _kwargs[n] = kwargs[n]
+    return _kwargs