implement keypad ABC

tests/test_benchmark.py

@@ -1,6 +1,14 @@
 from src.utils import passcode_generator
+from src.keypad.keypad import (
+    RandomShuffleKeypad,
+    RandomSplitShuffleKeypad,
+    SlidingTowerShuffleKeypad,
+    SlidingSplitShuffleKeypad
+)
+from src.benchmark import benchmark
 import pytest
 
+
 @pytest.mark.parametrize(
     "k, p, n, c, d, runs",
     [
@@ -10,6 +18,29 @@ import pytest
 def test_passcode_generator(k, p, n, c, d, runs):
     for _ in range(runs):
         passcode = passcode_generator(k=k, p=p, n=n, c=c, d=d)
-        passcode_sets = [el//p for el in passcode]
-        assert  c <= len(set(passcode))
+        passcode_sets = [el // p for el in passcode]
+        assert c <= len(set(passcode))
         assert d <= len(set(passcode_sets))
+
+
+@pytest.mark.parametrize(
+    "number_of_keys,properties_per_key,passcode_len,max_tries_before_lockout,complexity,disparity,run_count,keypad",
+    [
+        (6, 8, 4, 5, 4, 4, 100, RandomShuffleKeypad),
+        (6, 8, 4, 5, 4, 4, 100, RandomSplitShuffleKeypad),
+        (6, 8, 4, 5, 4, 4, 100, SlidingSplitShuffleKeypad),
+        (6, 8, 4, 5, 4, 4, 100, SlidingTowerShuffleKeypad),
+    ]
+)
+def test_benchmark(number_of_keys, properties_per_key, passcode_len, max_tries_before_lockout, complexity, disparity,
+                   run_count, keypad):
+    benchmark(
+        number_of_keys=number_of_keys,
+        properties_per_key=properties_per_key,
+        passcode_len=passcode_len,
+        max_tries_before_lockout=max_tries_before_lockout,
+        run_count=run_count,
+        complexity=complexity,
+        disparity=disparity,
+        keypad=keypad.new_keypad(number_of_keys, properties_per_key)
+    )

tests/test_evilkode.py

@@ -1,45 +1,34 @@
 import random
 import pytest
 
-from src.evilkode import Evilkode, Observation
-from src.keypad import Keypad
+from src.evilnkode import EvilNKode
+from src.keypad.keypad import (
+    RandomShuffleKeypad,
+)
+from src.utils import observations
 
 
 @pytest.fixture
-def observations(number_of_keys, properties_per_key, passcode_len):
-    k = number_of_keys
-    p = properties_per_key
-    n = passcode_len
-    nkode = [random.randint(0, k*p-1) for _ in range(n)]
-    keypad = Keypad.new_keypad(k, p)
-
-    def obs_gen():
-        for _ in range(100):  # finite number of yields
-            yield Observation(
-                keypad=keypad.keypad.copy(),
-                key_selection=keypad.key_entry(target_passcode=nkode)
-            )
-            keypad.split_shuffle()
-
-    return obs_gen()
-
+def passcode(number_of_keys, properties_per_key, passcode_len):
+    return [random.randint(0, number_of_keys * properties_per_key - 1) for _ in range(passcode_len)]
 
 
 @pytest.mark.parametrize(
     "number_of_keys, properties_per_key, passcode_len",
     [
-        (5, 3, 4),  # Test case 1
+        (5, 4, 4),  # Test case 1
         (10, 5, 6),  # Test case 2
-        (8, 4, 5),   # Test case 3
+        (8, 4, 5),  # Test case 3
     ]
 )
-def test_evilkode(number_of_keys, properties_per_key, passcode_len, observations):
-    evilkode = Evilkode(
-        observations=observations,
+def test_evilkode(number_of_keys, properties_per_key, passcode_len, passcode):
+    keypad = RandomShuffleKeypad.new_keypad(number_of_keys, properties_per_key)
+    obs = observations(passcode, keypad)
+    evilkode = EvilNKode(
+        observations=obs,
         number_of_keys=number_of_keys,
         properties_per_key=properties_per_key,
         passcode_len=passcode_len,
     )
-
     evilout = evilkode.run()
     assert evilout.iterations_to_break > 1

tests/test_keypad.py

@@ -1,41 +1,34 @@
+import pytest
 import numpy as np
-
-from src.keypad import Keypad
-from src.tower_shuffle import TowerShuffle
+from src.keypad.keypad import (
+    RandomSplitShuffleKeypad,
+    RandomShuffleKeypad,
+    SlidingSplitShuffleKeypad,
+    SlidingTowerShuffleKeypad,
+)
 
 
-def test_keypad():
-    keypad = Keypad(
+def test_key_entry():
+    keypad = RandomShuffleKeypad(
         keypad=np.array([
             [8, 9, 10, 11],
             [0, 5, 2, 3],
-            [4, 1, 6,7]
-        ]), k= 3, p=4, keypad_cache=[], tower_shuffler=TowerShuffle.new(3*4))
+            [4, 1, 6, 7]
+        ]), k=3, p=4)
+    assert keypad.key_entry([8, 5, 6, 11]) == [0, 1, 2, 0]
 
-    assert keypad.key_entry([8, 5, 6, 11]) == [0,1,2,0]
 
-def test_split_shuffle():
-    p = 4  # properties_per_key
-    k = 3  # number_of_keys
-    keypad = Keypad.new_keypad(k, p)
+@pytest.mark.parametrize(
+    "keypad_type, number_of_keys, properties_per_key",
+    [
+        (RandomShuffleKeypad, 3, 4),
+        (RandomSplitShuffleKeypad, 3, 4),
+        (SlidingTowerShuffleKeypad, 3, 4),
+        (SlidingSplitShuffleKeypad, 3, 4),
+    ]
+)
+def test_keypad_shuffle(keypad_type, number_of_keys, properties_per_key):
+    keypad = keypad_type.new_keypad(number_of_keys, properties_per_key)
     print(keypad.keypad)
-    keypad.split_shuffle()
+    keypad.shuffle()
     print(keypad.keypad)
-
-
-def test_full_shuffle():
-    p = 4  # properties_per_key
-    k = 3  # number_of_keys
-    keypad = Keypad.new_keypad(k, p)
-    print(keypad.keypad)
-    keypad.full_shuffle()
-    print(keypad.keypad)
-
-def test_tower_shuffle():
-    p = 4  # properties_per_key
-    k = 3  # number_of_keys
-    keypad = Keypad.new_keypad(k, p)
-    print()
-    for _ in range(10):
-        print(keypad.keypad)
-        keypad.tower_shuffle()

tests/test_tower_shuffle.py

@@ -1,4 +1,4 @@
-from src.tower_shuffle import TowerShuffle
+from src.keypad.tower_shuffle import TowerShuffle
 
 def test_tower_shuffle():
     tower = TowerShuffle.new(9)