From 2d0c18a40348c3efed78cc323ed03b0873d7486a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB=20=D0=9A=D0=B0=D0=BF?= =?UTF-8?q?=D0=B5=D0=BB=D1=8C=D0=BA=D0=BE?= Date: Thu, 18 Apr 2024 22:29:00 +0300 Subject: [PATCH] d --- v2/entities.py | 3 + v2/functions.py | 215 +++++++++++++++++++++++++++++++++++++++++++++--- v2/llm.py | 10 +++ v2/main.py | 10 ++- 4 files changed, 223 insertions(+), 15 deletions(-) create mode 100644 v2/llm.py diff --git a/v2/entities.py b/v2/entities.py index 2be6efd..025a913 100644 --- a/v2/entities.py +++ b/v2/entities.py @@ -1,10 +1,13 @@ class MemoryContext: def __init__(self): + self.hiddenItems = [] + self.mismatchedItems = [] self.playfieldItems = {} self.playfieldSize = 0 self.recentField = None self.selectedId = None self.selectedItems = [] + self.victory = False def __repr__(self): return self.__str__() diff --git a/v2/functions.py b/v2/functions.py index 2c4c47c..cc231d8 100644 --- a/v2/functions.py +++ b/v2/functions.py @@ -1,5 +1,51 @@ from entities import * +from llm import * +# Detect victory +# +# Conditions: +# 1. Matching items have just been hidden and all items are hidden now +@llm_by_value +def memory_detectVictory( + c: MemoryContext +) -> MemoryContext: + if ( + c.recentField == "hiddenItems" and + len(c.hiddenItems) == len(c.playfieldItems) + ): + c.victory = True + c.recentField = "victory" + return c + + c.recentField = None + return c +#} + +# Deselect mismatched items +# +# Conditions: +# 1. Two items are selected and they are of different groups +@llm_by_value +def memory_deselectMismatchedItems( + c: MemoryContext +) -> MemoryContext: + if ( + c.recentField == "selectedItems" and + len(c.selectedItems) == 2 and + c.playfieldItems[c.selectedItems[0]] != c.playfieldItems[c.selectedItems[1]] + ): + c.mismatchedItems.clear() + c.mismatchedItems.append(c.selectedItems[0]) + c.mismatchedItems.append(c.selectedItems[1]) + c.recentField = "mismatchedItems" + return c + + c.recentField = None + return c +#} + +# Generate constant playfield suitable for testing and debugging +@llm_by_value def memory_generateConstPlayfield( c: MemoryContext ) -> MemoryContext: @@ -16,12 +62,34 @@ def memory_generateConstPlayfield( return c #} +# Hide matching selected items +# +# Conditions: +# 1. Two items are selected and they are of the same group +@llm_by_value +def memory_hideMatchingItems( + c: MemoryContext +) -> MemoryContext: + if ( + c.recentField == "selectedItems" and + len(c.selectedItems) == 2 and + c.playfieldItems[c.selectedItems[0]] == c.playfieldItems[c.selectedItems[1]] + ): + c.hiddenItems.append(c.selectedItems[0]) + c.hiddenItems.append(c.selectedItems[1]) + c.recentField = "hiddenItems" + return c + + c.recentField = None + return c +#} + # Select item # # Conditions: -# 0. Remove obsolete selected items -# 1. If selectedId is recent -# 2. If it's not recent +# 1. There are already two selected items +# 2. Item has just been selected +@llm_by_value def memory_selectItem( c: MemoryContext ) -> MemoryContext: @@ -61,7 +129,7 @@ def test_memory_generateConstPlayfield( return "ERR: memory_generateConstPlayfield" #} -def test_memory_selectOneItem( +def test_memory_selectItem( ) -> str: c = memory_createEmptyContext() c.playfieldSize = 2 @@ -78,12 +146,12 @@ def test_memory_selectOneItem( len(c.selectedItems) == 1 and c.selectedItems[0] == 0 ): - return "OK: memory_selectOneItem" + return "OK: selectItem" #} - return "ERR: memory_selectOneItem" + return "ERR: selectItem" #} -def test_memory_selectTwoItems( +def test_selectTwoItems( ) -> str: c = memory_createEmptyContext() c.playfieldSize = 2 @@ -104,12 +172,12 @@ def test_memory_selectTwoItems( c.selectedItems[0] == 0 and c.selectedItems[1] == 1 ): - return "OK: memory_selectTwoItems" + return "OK: selectTwoItems" #} - return "ERR: memory_selectTwoItems" + return "ERR: selectTwoItems" #} -def test_memory_selectThreeItems( +def test_selectThreeItems( ) -> str: c = memory_createEmptyContext() c.playfieldSize = 2 @@ -132,7 +200,130 @@ def test_memory_selectThreeItems( len(c.selectedItems) == 1 and c.selectedItems[0] == 2 ): - return "OK: memory_selectThreeItems" + return "OK: selectThreeItems" + #} + return "ERR: selectThreeItems" +#} + +def test_memory_hideMatchingItems( +) -> str: + c = memory_createEmptyContext() + c.playfieldSize = 2 + c = memory_generateConstPlayfield(c) + + # Select two items of the same group. + c.selectedId = 0 + c.recentField = "selectedId" + c = memory_selectItem(c) + c.selectedId = 1 + c.recentField = "selectedId" + c = memory_selectItem(c) + + # Hide matching items. + c = memory_hideMatchingItems(c) + + # See if the two selected items match. + if ( + c.recentField == "hiddenItems" and + len(c.hiddenItems) == 2 and + c.hiddenItems[0] == 0 and + c.hiddenItems[1] == 1 + ): + return "OK: memory_hideMatchingItems" #} - return "ERR: memory_selectThreeItems" + return "ERR: memory_hideMatchingItems" #} + +def test_memory_deselectMismatchedItems( +) -> str: + c = memory_createEmptyContext() + c.playfieldSize = 2 + c = memory_generateConstPlayfield(c) + + # Select two items of different groups. + c.selectedId = 0 + c.recentField = "selectedId" + c = memory_selectItem(c) + c.selectedId = 2 + c.recentField = "selectedId" + c = memory_selectItem(c) + + # Detect mismatching. + c = memory_deselectMismatchedItems(c) + + # See if the two selected items do not match. + if ( + c.recentField == "mismatchedItems" and + len(c.mismatchedItems) == 2 and + c.mismatchedItems[0] == 0 and + c.mismatchedItems[1] == 2 + ): + return "OK: memory_deselectMismatchedItems" + #} + return "ERR: memory_deselectMismatchedItems" +#} + +def test_memory_detectVictory( +) -> str: + c = memory_createEmptyContext() + c.playfieldSize = 2 + c = memory_generateConstPlayfield(c) + + # Select the first two items of the same group. + c.selectedId = 0 + c.recentField = "selectedId" + c = memory_selectItem(c) + c.selectedId = 1 + c.recentField = "selectedId" + c = memory_selectItem(c) + + # Hide the first pair. + c = memory_hideMatchingItems(c) + + # Select the last two items of the same group. + c.selectedId = 2 + c.recentField = "selectedId" + c = memory_selectItem(c) + c.selectedId = 3 + c.recentField = "selectedId" + c = memory_selectItem(c) + + # Hide the second pair. + c = memory_hideMatchingItems(c) + + # Detect victory. + c = memory_detectVictory(c) + + # See if victory has been detected. + if ( + c.recentField == "victory" and + c.victory == True + ): + return "OK: memory_detectVictory" + #} + return "ERR: memory_detectVictory" +#} + +def test_passContextByValue( +) -> str: + c = memory_createEmptyContext() + c.playfieldSize = 2 + c = memory_generateConstPlayfield(c) + + c.selectedId = 0 + c.recentField = "selectedId" + c1 = memory_selectItem(c) + + c.selectedId = 1 + c.recentField = "selectedId" + c2 = memory_selectItem(c) + + # See if c1 and c2 have different recentField. + if ( + c1.selectedId != c2.selectedId + ): + return "OK: passContextByValue" + + return "ERR: passContextByValue" +#} + diff --git a/v2/llm.py b/v2/llm.py new file mode 100644 index 0000000..ab3067e --- /dev/null +++ b/v2/llm.py @@ -0,0 +1,10 @@ +import copy + +# Make deep copies of arguments to mimic behaviour of strongly typed languages. +# https://stackoverflow.com/a/15398021 +def llm_by_value(f): + def _f(*args, **kwargs): + argsCopy = copy.deepcopy(args) + kwargsCopy = copy.deepcopy(kwargs) + return f(*argsCopy, **kwargsCopy) + return _f diff --git a/v2/main.py b/v2/main.py index 6da1910..f83e394 100644 --- a/v2/main.py +++ b/v2/main.py @@ -2,6 +2,10 @@ from entities import * from functions import * print(test_memory_generateConstPlayfield()) -print(test_memory_selectOneItem()) -print(test_memory_selectTwoItems()) -print(test_memory_selectThreeItems()) +print(test_selectOneItem()) +print(test_selectTwoItems()) +print(test_selectThreeItems()) +print(test_memory_hideMatchingItems()) +print(test_memory_deselectMismatchedItems()) +print(test_memory_detectVictory()) +print(test_passContextByValue())