rewrite the config format

scorer.py

@@ -15,7 +15,7 @@ class FingerTrick:
 
 
 @dataclass
-class Regrip:
+class Grip:
     finger: str
     pre: str
     post: str
@@ -23,23 +23,66 @@ class Regrip:
 
 
 @dataclass
-class Config:
-    finger_tricks: List[FingerTrick]
+class Regrip:
+    finger: str
+    start: str
+    end: str
+    score: float
+
+
+@dataclass
+class Finger:
+    name: str
+    default_score: int
+    home_grips: List[str]
+    grips: Dict[str, List[str]]
     regrips: List[Regrip]
 
 
-def home_grip() -> Dict[str, str]:
-    return {
-        "index": "B",  # this could also be BL
-        "ring": "B",
-        "pinky": "BD",
-    }
+@dataclass
+class Config:
+    fingers: List[Finger]
+    finger_tricks: List[FingerTrick]
 
 
-def load_config(file_path: str) -> Config:
+@dataclass
+class Definitions:
+    fingers: List[Finger]
+    finger_tricks: List[FingerTrick]
+    finger_regrips: List[Regrip]
+
+
+def build_regrips_from_fingers(fingers: List[Finger]) -> List[Regrip]:
+    regrips = []
+    for finger in fingers:
+        finger_regrips = {}
+        for grip_set in finger.grips.values():
+            # reate a dict with distances of every two elements in a list
+            for i in range(len(grip_set)):
+                for j in range(len(grip_set)):
+                    if i != j:
+                        finger_regrips[(grip_set[i], grip_set[j])] = Regrip(
+                            start=grip_set[i],
+                            end=grip_set[j],
+                            score=abs(j - i) * finger.default_score,
+                            finger=finger.name,
+                        )
+        for regrip in finger.regrips:
+            finger_regrips[(regrip.start, regrip.end)] = regrip
+        regrips.extend(finger_regrips.values())
+
+    return regrips
+
+
+def load_definitions(file_path: str) -> Definitions:
     with open(file_path, "r") as f:
         data_dict = yaml.safe_load(f.read())
-    return dacite.from_dict(data_class=Config, data=data_dict)
+    config = dacite.from_dict(data_class=Config, data=data_dict)
+    return Definitions(
+        fingers=config.fingers,
+        finger_tricks=config.finger_tricks,
+        finger_regrips=build_regrips_from_fingers(config.fingers),
+    )
 
 
 def grip_correct(current_grip: Dict[str, str], required_grip: Dict[str, str]):
@@ -60,50 +103,69 @@ class FingerTrickWithRegrip:
         return score
 
 
-def calculate_finger_trick_regrips(
-    config: Config, finger_trick: FingerTrick, grip: Dict[str, str]
+@dataclass
+class Algorithm:
+    score: float
+    finger_tricks_with_regrips: List[FingerTrickWithRegrip]
+
+
+def find_finger_trick_regrips(
+    regrips: List[Regrip], finger_trick: FingerTrick, grip: Dict[str, str]
 ) -> List[Regrip]:
-    regrips = []
+    alg_regrips = []
     for finger in finger_trick.grip_pre.keys():
         current_location = grip[finger]
         desired_location = finger_trick.grip_pre.get(finger)
         blacklisted_locations = finger_trick.grip_pre_blacklist.get(finger, [])
         if current_location != desired_location:
-            # TODO: check the minimal regrip?
-            regrip = next(
+            # print("FINGA", finger)
+            # print("CURRENT", current_location)
+            # print("DESIRED", desired_location)
+            # print("BLACK", blacklisted_locations)
+            # __import__("pprint").pprint(regrips)
+            alg_regrip = next(
                 (
                     regrip
-                    for regrip in config.regrips
+                    for regrip in regrips
                     if regrip.finger == finger
-                    and regrip.pre == current_location
-                    and regrip.post == desired_location
-                    and regrip.pre not in blacklisted_locations
+                    and regrip.start == current_location
+                    and regrip.end == desired_location
+                    and regrip.start not in blacklisted_locations
                 ),
-                None,
             )
-            if regrip:
-                regrips.append(regrip)
-    return regrips
+            if alg_regrip:
+                alg_regrips.append(alg_regrip)
+    return alg_regrips
+
+
+def generate_home_grip(fingers: List[Finger]) -> Dict[str, str]:
+    # TODO: make this smarter
+    home_grip = {}
+    for finger in fingers:
+        home_grip[finger.name] = finger.home_grips[0]
+    return home_grip
 
 
 def generate_finger_tricks(
-    config: Config, moves: List[str]
+    definitions: Definitions, moves: List[str]
 ) -> List[FingerTrickWithRegrip]:
-    grip = home_grip()
+    grip = generate_home_grip(definitions.fingers)
     alg: List[FingerTrickWithRegrip] = []
     for move in moves:
         # print("current grip:", grip)
         # prit("current move:", move)
         possible_finger_tricks = [
             finger_trick
-            for finger_trick in config.finger_tricks
+            for finger_trick in definitions.finger_tricks
             if move == finger_trick.move
         ]
         # print("possible finger tricks:", possible_finger_tricks)
         finger_tricks_with_regrips = [
             FingerTrickWithRegrip(
                 finger_trick=finger_trick,
-                regrips=calculate_finger_trick_regrips(config, finger_trick, grip),
+                regrips=find_finger_trick_regrips(
+                    definitions.finger_regrips, finger_trick, grip
+                ),
             )
             for finger_trick in possible_finger_tricks
         ]
@@ -113,7 +175,7 @@ def generate_finger_tricks(
         # print("best finger trick:", best_finger_trick)
         # apply regrips
         for regrip in best_finger_trick.regrips:
-            grip[regrip.finger] = regrip.post
+            grip[regrip.finger] = regrip.end
         # apply move
         grip.update(best_finger_trick.finger_trick.grip_post)
         alg.append(best_finger_trick)
@@ -131,7 +193,7 @@ def build_pretty_string_from_finger_tricks_with_regrips(
 
     for finger_trick_with_regrips in finger_tricks_with_regrips:
         for regrip in finger_trick_with_regrips.regrips:
-            elems.append(f"regrip {regrip.finger} from {regrip.pre} to {regrip.post}")
+            elems.append(f"regrip {regrip.finger} from {regrip.start} to {regrip.end}")
         elems.append(finger_trick_with_regrips.finger_trick.name)
 
     return elems