107 lines
4.9 KiB
Python
107 lines
4.9 KiB
Python
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 UserInterface:
|
|
interface: list[int]
|
|
keypad_size: KeypadSize
|
|
|
|
@classmethod
|
|
def create(cls, keypad_size: KeypadSize) -> 'UserInterface':
|
|
interface = UserInterface(
|
|
interface=list(range(keypad_size.numb_of_attrs)),
|
|
keypad_size=keypad_size
|
|
)
|
|
interface.random_interface_shuffle()
|
|
return interface
|
|
|
|
def sign_up_interface(self):
|
|
if self.keypad_size.is_dispersable:
|
|
raise ValueError("Keypad size is dispersable")
|
|
self.random_interface_shuffle()
|
|
interface_matrix = self.interface_keypad_matrix()
|
|
attr_set_view = matrix_transpose(interface_matrix)
|
|
attr_set_view = secure_fisher_yates_shuffle(attr_set_view)
|
|
attr_set_view = attr_set_view[:self.keypad_size.numb_of_keys]
|
|
interface_matrix = matrix_transpose(attr_set_view)
|
|
return UserInterface(
|
|
interface=matrix_to_list(interface_matrix),
|
|
keypad_size=KeypadSize(
|
|
numb_of_keys=self.keypad_size.numb_of_keys,
|
|
attrs_per_key=self.keypad_size.numb_of_keys
|
|
)
|
|
)
|
|
|
|
def interface_keypad_matrix(self) -> list[list[int]]:
|
|
return list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
|
|
|
|
def random_interface_shuffle(self):
|
|
keypad_view = self.interface_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.interface = matrix_to_list(keypad_view)
|
|
|
|
def disperse_interface(self):
|
|
if not self.keypad_size.is_dispersable:
|
|
raise ValueError("Keypad size is not dispersable")
|
|
user_interface_matrix = list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
|
|
shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
|
|
|
|
attr_rotation = secure_fisher_yates_shuffle(list(range(self.keypad_size.numb_of_keys)))[
|
|
:self.keypad_size.attrs_per_key]
|
|
dispersed_interface = self.random_attribute_rotation(
|
|
shuffled_keys,
|
|
attr_rotation,
|
|
)
|
|
self.interface = matrix_to_list(dispersed_interface)
|
|
|
|
def partial_interface_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_interface_matrix = self.interface_keypad_matrix()
|
|
shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
|
|
interface_by_sets = []
|
|
for idx, attrs in enumerate(matrix_transpose(shuffled_keys)):
|
|
if idx in selected_sets:
|
|
interface_by_sets.append(secure_fisher_yates_shuffle(attrs))
|
|
else:
|
|
interface_by_sets.append(attrs)
|
|
self.interface = matrix_to_list(matrix_transpose(interface_by_sets))
|
|
|
|
@staticmethod
|
|
def random_attribute_rotation(
|
|
user_interface: list[list[int]],
|
|
attr_rotation: list[int]
|
|
) -> list[list[int]]:
|
|
transposed_user_interface = matrix_transpose(user_interface)
|
|
if len(attr_rotation) != len(transposed_user_interface):
|
|
raise ValueError("attr_rotation must be the same length as the transposed user interface")
|
|
for idx, attr_set in enumerate(transposed_user_interface):
|
|
rotation = attr_rotation[idx]
|
|
transposed_user_interface[idx] = attr_set[rotation:] + attr_set[:rotation]
|
|
return matrix_transpose(transposed_user_interface)
|
|
|
|
def attribute_adjacency_graph(self) -> dict[int, set[int]]:
|
|
user_interface_keypad = self.interface_keypad_matrix()
|
|
graph = {}
|
|
for key in user_interface_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.interface_keypad_matrix()
|
|
return keypad_attr_idx[key_numb][set_idx]
|