refactor; remove the term interface

src/user_keypad.py

@@ -0,0 +1,106 @@
+from dataclasses import dataclass
+from secrets import choice
+from src.models import KeypadSize
+from src.utils import list_to_matrix, secure_fisher_yates_shuffle, matrix_to_list, matrix_transpose
+
+@dataclass
+class UserKeypad:
+    keypad: list[int]
+    keypad_size: KeypadSize
+
+    @classmethod
+    def create(cls, keypad_size: KeypadSize) -> 'UserKeypad':
+        keypad = UserKeypad(
+            keypad=list(range(keypad_size.numb_of_attrs)),
+            keypad_size=keypad_size
+        )
+        keypad.random_keypad_shuffle()
+        return keypad
+
+    def sign_up_keypad(self):
+        if self.keypad_size.is_dispersable:
+            raise ValueError("Keypad size is dispersable")
+        self.random_keypad_shuffle()
+        keypad_matrix = self.keypad_matrix()
+        attr_set_view = matrix_transpose(keypad_matrix)
+        attr_set_view = secure_fisher_yates_shuffle(attr_set_view)
+        attr_set_view = attr_set_view[:self.keypad_size.numb_of_keys]
+        keypad_matrix = matrix_transpose(attr_set_view)
+        return UserKeypad(
+            keypad=matrix_to_list(keypad_matrix),
+            keypad_size=KeypadSize(
+                numb_of_keys=self.keypad_size.numb_of_keys,
+                attrs_per_key=self.keypad_size.numb_of_keys
+            )
+        )
+
+    def keypad_matrix(self) -> list[list[int]]:
+        return list_to_matrix(self.keypad, self.keypad_size.attrs_per_key)
+
+    def random_keypad_shuffle(self):
+        keypad_view = self.keypad_matrix()
+        keypad_view = secure_fisher_yates_shuffle(keypad_view)
+        set_view = matrix_transpose(keypad_view)
+        set_view = [secure_fisher_yates_shuffle(attr_set) for attr_set in set_view]
+        keypad_view = matrix_transpose(set_view)
+        self.keypad = matrix_to_list(keypad_view)
+
+    def disperse_keypad(self):
+        if not self.keypad_size.is_dispersable:
+            raise ValueError("Keypad size is not dispersable")
+        user_keypad_matrix = list_to_matrix(self.keypad, self.keypad_size.attrs_per_key)
+        shuffled_keys = secure_fisher_yates_shuffle(user_keypad_matrix)
+
+        attr_rotation = secure_fisher_yates_shuffle(list(range(self.keypad_size.numb_of_keys)))[
+                        :self.keypad_size.attrs_per_key]
+        dispersed_keypad = self.random_attribute_rotation(
+            shuffled_keys,
+            attr_rotation,
+        )
+        self.keypad = matrix_to_list(dispersed_keypad)
+
+    def partial_keypad_shuffle(self):
+        # TODO: this should be split shuffle
+        numb_of_selected_sets = self.keypad_size.attrs_per_key // 2
+        # randomly shuffle half the sets. if attrs_per_key is odd, randomly add one 50% of the time
+        numb_of_selected_sets += choice([0, 1]) if (self.keypad_size.attrs_per_key & 1) == 1 else 0
+        selected_sets = secure_fisher_yates_shuffle(list(range(self.keypad_size.attrs_per_key)))[:numb_of_selected_sets]
+        user_keypad_matrix = self.keypad_matrix()
+        shuffled_keys = secure_fisher_yates_shuffle(user_keypad_matrix)
+        keypad_by_sets = []
+        for idx, attrs in enumerate(matrix_transpose(shuffled_keys)):
+            if idx in selected_sets:
+                keypad_by_sets.append(secure_fisher_yates_shuffle(attrs))
+            else:
+                keypad_by_sets.append(attrs)
+        self.keypad = matrix_to_list(matrix_transpose(keypad_by_sets))
+
+    @staticmethod
+    def random_attribute_rotation(
+            user_keypad: list[list[int]],
+            attr_rotation: list[int]
+    ) -> list[list[int]]:
+        transposed_user_keypad = matrix_transpose(user_keypad)
+        if len(attr_rotation) != len(transposed_user_keypad):
+            raise ValueError("attr_rotation must be the same length as the transposed user keypad")
+        for idx, attr_set in enumerate(transposed_user_keypad):
+            rotation = attr_rotation[idx]
+            transposed_user_keypad[idx] = attr_set[rotation:] + attr_set[:rotation]
+        return matrix_transpose(transposed_user_keypad)
+
+    def attribute_adjacency_graph(self) -> dict[int, set[int]]:
+        user_keypad_keypad = self.keypad_matrix()
+        graph = {}
+        for key in user_keypad_keypad:
+            for attr in key:
+                graph[attr] = set(key)
+                graph[attr].remove(attr)
+        return graph
+
+    def get_attr_idx_by_keynumb_setidx(self, key_numb: int, set_idx: int) -> int:
+        if not (0 <= key_numb < self.keypad_size.numb_of_keys):
+            raise ValueError(f"key_numb must be between 0 and {self.keypad_size.numb_of_keys - 1}")
+        if not (0 <= set_idx < self.keypad_size.attrs_per_key):
+            raise ValueError(f"set_idx must be between 0 and {self.keypad_size.attrs_per_key - 1}")
+        keypad_attr_idx = self.keypad_matrix()
+        return keypad_attr_idx[key_numb][set_idx]