initial commit

scorer.py

@@ -0,0 +1,129 @@
+from typing import Dict, List
+import yaml
+import dacite
+from dataclasses import dataclass
+
+
+@dataclass
+class FingerTrick:
+    name: str
+    move: str
+    grip_pre: Dict[str, str]
+    grip_post: Dict[str, str]
+    score: float
+
+
+@dataclass
+class Regrip:
+    finger: str
+    pre: str
+    post: str
+    score: float
+
+
+@dataclass
+class Config:
+    finger_tricks: List[FingerTrick]
+    regrips: List[Regrip]
+
+
+def home_grip() -> Dict[str, str]:
+    return {
+        "index": "B",  # this could also be BL
+        "ring": "B",
+        "pinky": "BD",
+    }
+
+
+def load_config(file_path: str) -> Config:
+    with open(file_path, "r") as f:
+        data_dict = yaml.safe_load(f.read())
+    return dacite.from_dict(data_class=Config, data=data_dict)
+
+
+def grip_correct(current_grip: Dict[str, str], required_grip: Dict[str, str]):
+    return all(item in current_grip.items() for item in required_grip.items())
+
+
+@dataclass
+class FingerTrickWithRegrip:
+    finger_trick: FingerTrick
+    regrips: List[Regrip]
+
+    def score(self) -> float:
+        score = 0.0
+        score += self.finger_trick.score
+        if self.regrips:
+            longest_regrip = max(self.regrips, key=lambda regrip: regrip.score)
+            score += longest_regrip.score
+        return score
+
+
+def calculate_finger_trick_regrips(
+    config: Config, finger_trick: FingerTrick, grip: Dict[str, str]
+) -> List[Regrip]:
+    regrips = []
+    for finger in finger_trick.grip_pre.keys():
+        current_location = grip[finger]
+        desired_location = finger_trick.grip_pre.get(finger)
+        if current_location != desired_location:
+            regrip = next(
+                (
+                    regrip
+                    for regrip in config.regrips
+                    if regrip.finger == finger
+                    and regrip.pre == current_location
+                    and regrip.post == desired_location
+                ),
+                None,
+            )
+            if regrip:
+                regrips.append(regrip)
+    return regrips
+
+
+def generate_finger_tricks(
+    config: Config, moves: List[str]
+) -> List[FingerTrickWithRegrip]:
+    grip = home_grip()
+    alg = []
+    for move in moves:
+        # print("current grip:", grip)
+        # prit("current move:", move)
+        possible_finger_tricks = [
+            finger_trick
+            for finger_trick in config.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),
+            )
+            for finger_trick in possible_finger_tricks
+        ]
+        best_finger_trick = min(
+            finger_tricks_with_regrips, key=lambda item: item.score()
+        )
+        # print("best finger trick:", best_finger_trick)
+        # apply regrips
+        for regrip in best_finger_trick.regrips:
+            grip[regrip.finger] = regrip.post
+        # apply move
+        grip.update(best_finger_trick.finger_trick.grip_post)
+        alg.append(best_finger_trick)
+    return alg
+
+
+def build_pretty_string_from_finger_tricks_with_regrips(
+    finger_tricks_with_regrips: List[FingerTrickWithRegrip],
+) -> List[str]:
+    elems = []
+
+    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(finger_trick_with_regrips.finger_trick.name)
+
+    return elems