From 42ed9a072e604e490b8d27ccc9852e6bb64c68b5 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 20 Sep 2024 16:07:56 -0300
Subject: [PATCH 01/59] Fix Memory/MO data types
timestamp and id float->int
---
src/cst_python/core/entities/memory.py | 8 ++++----
src/cst_python/core/entities/memory_object.py | 18 +++++++++---------
2 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/src/cst_python/core/entities/memory.py b/src/cst_python/core/entities/memory.py
index 30e0160..bbaa0a6 100644
--- a/src/cst_python/core/entities/memory.py
+++ b/src/cst_python/core/entities/memory.py
@@ -38,7 +38,7 @@ def set_evaluation(self, evaluation:float) -> None:
#@alias.alias("getTimestamp")
@abc.abstractmethod
- def get_timestamp(self) -> float:
+ def get_timestamp(self) -> int:
...
#@alias.alias("addMemoryObserver")
@@ -53,17 +53,17 @@ def remove_memory_observer(self, observer:MemoryObserver) -> None:
#@alias.alias("getId")
@abc.abstractmethod
- def get_id(self) -> float:
+ def get_id(self) -> int:
...
#@alias.alias("setId")
@abc.abstractmethod
- def set_id(self, memory_id:float) -> None:
+ def set_id(self, memory_id:int) -> None:
...
#@alias.alias("getTimestamp")
@abc.abstractmethod
- def get_timestamp(self) -> float:
+ def get_timestamp(self) -> int:
...
diff --git a/src/cst_python/core/entities/memory_object.py b/src/cst_python/core/entities/memory_object.py
index 9ab855d..48a8160 100644
--- a/src/cst_python/core/entities/memory_object.py
+++ b/src/cst_python/core/entities/memory_object.py
@@ -10,8 +10,8 @@
class MemoryObject(Memory):
def __init__(self) -> None:
- self._id = 0.0
- self._timestamp = 0.0
+ self._id = 0
+ self._timestamp = 0
self._evaluation = 0.0
self._info : Any = None
self._name = ""
@@ -24,10 +24,10 @@ def __getstate__(self) -> object:
return state
- def get_id(self) -> float:
+ def get_id(self) -> int:
return self._id
- def set_id(self, memory_id: float) -> None:
+ def set_id(self, memory_id: int) -> None:
self._id = memory_id
def get_info(self) -> Any:
@@ -35,7 +35,7 @@ def get_info(self) -> Any:
def set_info(self, value: Any) -> int:
self._info = value
- self._timestamp = time.time()
+ self._timestamp = int(time.time()*1000)
self._notify_memory_observers()
return -1
@@ -47,16 +47,16 @@ def _notify_memory_observers(self) -> None:
def update_info(self, info:Any) -> None:
self.set_info(info)
- def get_timestamp(self) -> float:
+ def get_timestamp(self) -> int:
return self._timestamp
@property
- def timestamp(self) -> float:
+ def timestamp(self) -> int:
return self._timestamp
#@alias.alias("setTimestamp")
@timestamp.setter
- def timestamp(self, value:float) -> None:
+ def timestamp(self, value:int) -> None:
self._timestamp = value
def get_name(self) -> str:
@@ -72,7 +72,7 @@ def get_evaluation(self) -> float:
return self._evaluation
def set_evaluation(self, evaluation: float) -> None:
- return self._evaluation
+ self._evaluation = evaluation
#@alias.alias("toString", "to_string")
def __str__(self) -> str:
From 8e4ca84e6c771a230e74aee97a5dfe7d7f6ded2d Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 4 Oct 2024 15:32:29 -0300
Subject: [PATCH 02/59] "threshould" typo fix
---
src/cst_python/core/entities/codelet.py | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/src/cst_python/core/entities/codelet.py b/src/cst_python/core/entities/codelet.py
index d0eaff2..27ef6ea 100644
--- a/src/cst_python/core/entities/codelet.py
+++ b/src/cst_python/core/entities/codelet.py
@@ -107,16 +107,16 @@ def outputs(self) -> List[Memory]:
def outputs(self, value:List[Memory]):
self._outputs = value
- #@alias.alias("get_threshould", "getThreshould")
+ #@alias.alias("get_threshold", "getThreshold")
@property
- def threshould(self) -> float:
+ def threshold(self) -> float:
return self._threshold
- #@alias.alias("set_threshould", "setThreshould")
- @threshould.setter
- def threshould(self, value:float):
+ #@alias.alias("set_threshold", "setThreshold")
+ @threshold.setter
+ def threshold(self, value:float):
if value > 1.0 or value < 1.0:
- raise ValueError(f"Codelet threshould must be in (0.0 , 1.0) \
+ raise ValueError(f"Codelet threshold must be in (0.0 , 1.0) \
(value {value} is not allowed).")
self._threshold = value
@@ -408,7 +408,7 @@ def notify_codelet(self) -> None:
if self._enable_count == 0:
self.calculate_activation()
- if self.activation >= self.threshould:
+ if self.activation >= self.threshold:
self.proc()
else:
self._raise_exception()
From f1862014b2ec132fc4db1a6b8902b65a8dd16f55 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 4 Oct 2024 15:36:21 -0300
Subject: [PATCH 03/59] Remove unused files
---
src/cst_python/python/manager.py | 17 ----------
tests/common.py | 56 --------------------------------
tests/test_ms1.py | 40 -----------------------
tests/test_ms2_migration.py | 44 -------------------------
4 files changed, 157 deletions(-)
delete mode 100644 src/cst_python/python/manager.py
delete mode 100644 tests/common.py
delete mode 100644 tests/test_ms1.py
delete mode 100644 tests/test_ms2_migration.py
diff --git a/src/cst_python/python/manager.py b/src/cst_python/python/manager.py
deleted file mode 100644
index a27ef53..0000000
--- a/src/cst_python/python/manager.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from typing import Any
-
-from cst_python.core.entities.codelet import Codelet
-from cst_python.core.entities.memory_object import MemoryObject
-
-
-def create_memory_object(name:str, info:Any) -> MemoryObject:
- pass
-
-def use_memory_storage(enable:bool) -> None:
- pass
-
-def insert_codelet(codelet:Codelet) -> None:
- pass
-
-def start() -> None:
- pass
\ No newline at end of file
diff --git a/tests/common.py b/tests/common.py
deleted file mode 100644
index 26c373d..0000000
--- a/tests/common.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from multiprocessing import Queue
-
-from cst_python import Codelet, MemoryObject
-
-
-class PrintMessageCodelet(Codelet):
-
- def __init__(self, print_queue:Queue) -> None:
- super().__init__()
-
- self._print_queue = print_queue
-
- self._trigger : MemoryObject = None
- self._msg : MemoryObject = None
-
-
- def proc(self) -> None:
- if self._trigger.get_info():
- msg = self._msg.get_info()
- print(msg)
- self._print_queue.put(msg)
- self._trigger.set_info(False)
-
- def access_memory_objects(self) -> None:
- self._trigger = self.get_input("trigger")
- self._msg = self.get_output("message")
-
- def calculate_activation(self) -> None:
- pass
-
-
-class ChangeMessageCodelet(Codelet):
-
- def __init__(self, new_msg:str) -> None:
- super().__init__()
-
- self._new_msg = new_msg
-
- self._trigger : MemoryObject = None
- self._msg : MemoryObject = None
-
- self._changed = False
-
- def proc(self) -> None:
- if not self._changed:
- self._trigger.set_info(True)
- self._msg.set_info(self._new_msg)
-
- self._changed = True
-
- def access_memory_objects(self) -> None:
- self._trigger = self.get_output("trigger")
- self._msg = self.get_output("message")
-
- def calculate_activation(self) -> None:
- pass
diff --git a/tests/test_ms1.py b/tests/test_ms1.py
deleted file mode 100644
index 63e003a..0000000
--- a/tests/test_ms1.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from multiprocessing import Queue
-
-from cst_python import use_memory_storage, create_memory_object, insert_codelet, start
-
-from .common import PrintMessageCodelet, ChangeMessageCodelet
-
-use_memory_storage(True)
-
-msg = create_memory_object("message", "", ms=True) #Set the memory to use the MS
-trigger = create_memory_object("trigger", False, ms=True) #Set the memory to use the MS
-
-msg_queue = Queue()
-
-codelet = PrintMessageCodelet(msg_queue)
-codelet.add_input(msg)
-codelet.add_input(trigger)
-codelet.add_output(trigger) #Works in Java?
-
-codelet2 = ChangeMessageCodelet("Python message")
-codelet2.add_output(msg)
-codelet2.add_output(trigger)
-
-insert_codelet(codelet)
-insert_codelet(codelet2)
-
-start()
-
-# Python print "Python message"
-
-msg = msg_queue.get()
-assert msg == "Python message"
-
-# Start java code
-...
-
-# Java changes message and trigger=True
-# Python prints "Java message"
-
-msg = msg_queue.get()
-assert msg == "Java message"
\ No newline at end of file
diff --git a/tests/test_ms2_migration.py b/tests/test_ms2_migration.py
deleted file mode 100644
index c4fa0fa..0000000
--- a/tests/test_ms2_migration.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import time
-from multiprocessing import Queue
-
-from cst_python import use_memory_storage, create_memory_object, insert_codelet, start
-
-from .common import PrintMessageCodelet, ChangeMessageCodelet
-
-use_memory_storage(True)
-
-msg_memory = create_memory_object("message", "") #The memory location starts in the Python
-trigger = create_memory_object("trigger", False, ms=True) #Starts the memory on the MS, for avoiding later copy
-
-msg_queue = Queue()
-
-codelet = PrintMessageCodelet(msg_queue)
-codelet.add_input(msg_memory)
-codelet.add_input(trigger)
-codelet.add_output(trigger) #Works in Java?
-
-codelet2 = ChangeMessageCodelet("Python message")
-codelet2.add_output(msg_memory)
-codelet2.add_output(trigger)
-
-insert_codelet(codelet)
-insert_codelet(codelet2)
-
-start()
-
-# Python print "Python message"
-msg = msg_queue.get()
-assert msg == "Python message"
-
-# Start java code
-...
-
-# Java see message and trigger on the MS registry, migrate message to MS as it will be used in another node
-# Python memories are migrated to the MS
-# Codelets run "access_memory_objects" again as previous memories was invalidated?
-# Java changes message and trigger=True
-
-# Python prints "Java message"
-
-msg = msg_queue.get()
-assert msg == "Java message"
\ No newline at end of file
From 44ceb1b99c1cc1b5ed063c834ad496fc6e9c936b Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 4 Oct 2024 18:29:26 -0300
Subject: [PATCH 04/59] Core tests implementation (partial)
- MemoryObjectTest
- MemoryTest
- MindTest
- RawMemoryTest
- CodeletTest
---
pytest.ini | 2 +
src/cst_python/__init__.py | 3 +-
src/cst_python/core/entities/__init__.py | 3 +-
src/cst_python/core/entities/codelet.py | 40 ++-
src/cst_python/core/entities/memory.py | 4 -
tests/core/__init__.py | 0
tests/core/entities/CoalitionTest.py | 15 +
tests/core/entities/CodeRackTest.py | 15 +
tests/core/entities/CodeletContainerTest.py | 15 +
tests/core/entities/CodeletTest.py | 313 ++++++++++++++++++
.../core/entities/DisconnectedCodeletTest.py | 15 +
tests/core/entities/MemoryBufferTest.py | 15 +
tests/core/entities/MemoryContainerTest.py | 15 +
tests/core/entities/MemoryObjectTest.py | 150 +++++++++
tests/core/entities/MemoryTest.py | 82 +++++
tests/core/entities/MindTest.py | 55 +++
tests/core/entities/RawMemoryTest.py | 55 +++
tests/core/entities/__init__.py | 0
tests/core/entities/utils.py | 11 +
19 files changed, 787 insertions(+), 21 deletions(-)
create mode 100644 pytest.ini
create mode 100644 tests/core/__init__.py
create mode 100644 tests/core/entities/CoalitionTest.py
create mode 100644 tests/core/entities/CodeRackTest.py
create mode 100644 tests/core/entities/CodeletContainerTest.py
create mode 100644 tests/core/entities/CodeletTest.py
create mode 100644 tests/core/entities/DisconnectedCodeletTest.py
create mode 100644 tests/core/entities/MemoryBufferTest.py
create mode 100644 tests/core/entities/MemoryContainerTest.py
create mode 100644 tests/core/entities/MemoryObjectTest.py
create mode 100644 tests/core/entities/MemoryTest.py
create mode 100644 tests/core/entities/MindTest.py
create mode 100644 tests/core/entities/RawMemoryTest.py
create mode 100644 tests/core/entities/__init__.py
create mode 100644 tests/core/entities/utils.py
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..fd17cc9
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,2 @@
+[pytest]
+addopts = --ignore=examples --ignore=docs --doctest-modules
\ No newline at end of file
diff --git a/src/cst_python/__init__.py b/src/cst_python/__init__.py
index 0fa67dc..756ee08 100644
--- a/src/cst_python/__init__.py
+++ b/src/cst_python/__init__.py
@@ -1,5 +1,4 @@
from . import python
from . import core
-from .core.entities import Codelet, Mind, MemoryObject
-from .python.manager import *
\ No newline at end of file
+from .core.entities import Codelet, Mind, MemoryObject
\ No newline at end of file
diff --git a/src/cst_python/core/entities/__init__.py b/src/cst_python/core/entities/__init__.py
index fb71558..0a004b8 100644
--- a/src/cst_python/core/entities/__init__.py
+++ b/src/cst_python/core/entities/__init__.py
@@ -7,4 +7,5 @@
from .memory_container import MemoryContainer
from .rest_memory_container import RESTMemoryContainer
from .rest_memory_object import RESTMemoryObject
-from .mind import Mind
\ No newline at end of file
+from .mind import Mind
+from .raw_memory import RawMemory
\ No newline at end of file
diff --git a/src/cst_python/core/entities/codelet.py b/src/cst_python/core/entities/codelet.py
index 27ef6ea..749097e 100644
--- a/src/cst_python/core/entities/codelet.py
+++ b/src/cst_python/core/entities/codelet.py
@@ -26,7 +26,7 @@ def __init__(self) -> None:
self._time_step = 300
self._enabled = True
self._enable_count = 0
- self._name = threading.currentThread().name+"|"+type(self).__name__+str(Codelet._last_id)
+ self._name = threading.current_thread().name+"|"+type(self).__name__+str(Codelet._last_id)
self._last_start_time = 0.0
self._lock = threading.RLock()
self._activation = 0.0
@@ -82,8 +82,13 @@ def activation(self) -> float:
@activation.setter
def activation(self, value:float):
if value > 1.0 or value < 0.0:
+ if value > 1.0:
+ self._activation = 1.0
+ else:
+ self._activation = 0.0
+
raise ValueError(f"Codelet activation must be in (0.0 , 1.0) \
- (value {value} is not allowed).")
+(value {value} is not allowed).")
self._activation = value
@@ -115,9 +120,14 @@ def threshold(self) -> float:
#@alias.alias("set_threshold", "setThreshold")
@threshold.setter
def threshold(self, value:float):
- if value > 1.0 or value < 1.0:
+ if value > 1.0 or value < 0.0:
+ if value > 1.0:
+ self._threshold = 1.0
+ else:
+ self._threshold = 0.0
+
raise ValueError(f"Codelet threshold must be in (0.0 , 1.0) \
- (value {value} is not allowed).")
+(value {value} is not allowed).")
self._threshold = value
@@ -145,12 +155,12 @@ def broadcast(self, value:List[Memory]) -> None:
#@alias.alias("IsProfiling")
@property
- def is_profiling(self) -> bool:
+ def profiling(self) -> bool:
return self._is_profiling
#@alias.alias("set_profiling", "setProfiling")
- @is_profiling.setter
- def is_profiling(self, value:bool):
+ @profiling.setter
+ def profiling(self, value:bool):
if value is True:
raise NotImplementedError("Profiling is not implemented")
@@ -299,7 +309,7 @@ def add_broadcasts(self, memories:List[Memory]) -> None:
#@alias.alias("getThreadName")
def get_thread_name(self) -> str:
- return threading.currentThread().name
+ return threading.current_thread().name
#@alias.alias("to_string", "toString")
def __str__(self) -> str:
@@ -308,16 +318,18 @@ def __str__(self) -> str:
result = f"Codelet [activation={self._activation}, name={self._name}, "
if self._broadcast is not None:
- result += self._broadcast[min(len(self._broadcast), max_len)]
+ result += "broadcast="
+ result += str(self._broadcast[:min(len(self._broadcast), max_len)])
result += ", "
-
+
if self._inputs is not None:
- result += self._inputs[min(len(self._outputs), max_len)]
+ result += "inputs="
+ result += str(self._inputs[:min(len(self.inputs), max_len)])
result += ", "
if self._outputs is not None:
- result += self._outputs[min(len(self._outputs), max_len)]
- result += ", "
+ result += "outputs="
+ result += str(self._outputs[:min(len(self._outputs), max_len)])
result += "]"
@@ -414,7 +426,7 @@ def notify_codelet(self) -> None:
self._raise_exception()
except Exception as e:
- #Logging
+ #TODO Logging
pass
finally:
diff --git a/src/cst_python/core/entities/memory.py b/src/cst_python/core/entities/memory.py
index bbaa0a6..15da8a9 100644
--- a/src/cst_python/core/entities/memory.py
+++ b/src/cst_python/core/entities/memory.py
@@ -61,10 +61,6 @@ def get_id(self) -> int:
def set_id(self, memory_id:int) -> None:
...
- #@alias.alias("getTimestamp")
- @abc.abstractmethod
- def get_timestamp(self) -> int:
- ...
def compare_name(self, other_name:str) -> bool:
diff --git a/tests/core/__init__.py b/tests/core/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/core/entities/CoalitionTest.py b/tests/core/entities/CoalitionTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/CoalitionTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/CodeRackTest.py b/tests/core/entities/CodeRackTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/CodeRackTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/CodeletContainerTest.py b/tests/core/entities/CodeletContainerTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/CodeletContainerTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/CodeletTest.py b/tests/core/entities/CodeletTest.py
new file mode 100644
index 0000000..4e7a6ee
--- /dev/null
+++ b/tests/core/entities/CodeletTest.py
@@ -0,0 +1,313 @@
+from contextlib import redirect_stdout
+import math
+import unittest
+import time
+import threading
+import io
+
+from cst_python import MemoryObject, Mind
+from .utils import CodeletMock
+
+class TestCodelet(unittest.TestCase):
+ def setUp(self) -> None:
+ self.test_codelet = CodeletMock()
+
+
+ def test_get_is_loop_test(self) -> None:
+ # Any instantiated Codelet, if not changed, should be looping
+ assert self.test_codelet.loop == True
+
+
+ def test_upper_activation_bound_exception(self) -> None:
+
+ with self.assertRaises(ValueError) as ve:
+ self.test_codelet.activation = 2.0
+
+ assert str(ve.exception) == "Codelet activation must be in (0.0 , 1.0) (value 2.0 is not allowed)."
+
+ assert math.isclose(1.0, self.test_codelet.activation)
+
+
+ def test_lowerActivationBoundException(self) -> None:
+ with self.assertRaises(ValueError) as ve:
+ self.test_codelet.activation = -0.8
+
+ assert str(ve.exception) == "Codelet activation must be in (0.0 , 1.0) (value -0.8 is not allowed)."
+
+ assert math.isclose(0.0, self.test_codelet.activation)
+
+
+
+ def test_setInputs(self) -> None:
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.inputs = dummy_inputs
+ self.assertEqual(2, len(self.test_codelet.inputs))
+
+
+
+ def test_getInput(self) -> None:
+
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ dummy_inputs[0].set_name("testName1")
+ self.test_codelet.inputs = dummy_inputs
+
+
+ self.assertEqual(dummy_inputs[0], self.test_codelet.get_input(name="testName1"))
+
+
+
+ def test_getInputNull(self) -> None:
+
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.inputs = dummy_inputs
+
+ self.assertIsNone(self.test_codelet.get_input(name="testName2"))
+
+
+
+ def test_add_inputs(self) -> None:
+
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.add_inputs(dummy_inputs)
+ self.assertEqual(2, len(self.test_codelet.inputs))
+
+
+
+
+ def test_removes_input(self) -> None:
+
+ to_remove = MemoryObject()
+
+ self.test_codelet.add_input(to_remove)
+ self.assertEqual(1, len(self.test_codelet.inputs))
+
+ self.test_codelet.removes_input(to_remove)
+ self.assertEqual(0, len(self.test_codelet.inputs))
+
+
+
+ def test_remove_from_input(self) -> None:
+
+ to_remove = [MemoryObject(), MemoryObject()]
+
+ self.test_codelet.add_inputs(to_remove)
+ self.assertEqual(2, len(self.test_codelet.inputs))
+
+ self.test_codelet.remove_from_input(to_remove)
+ self.assertEqual(0, len(self.test_codelet.inputs))
+
+
+
+ def test_remove_from_output(self) -> None:
+
+ to_remove = [MemoryObject(), MemoryObject()]
+
+ self.test_codelet.add_outputs(to_remove)
+ self.assertEqual(2, len(self.test_codelet.outputs))
+
+ self.test_codelet.remove_from_output(to_remove)
+ self.assertEqual(0, len(self.test_codelet.outputs))
+
+
+
+ def test_add_outputs(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.add_outputs(dummy_outputs)
+ self.assertEqual(2, len(self.test_codelet.outputs))
+
+
+
+ def test_get_outputs(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.add_outputs(dummy_outputs)
+ self.assertEqual(dummy_outputs, self.test_codelet.outputs)
+
+
+
+ def test_get_output(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ dummy_outputs[0].set_name("testName3")
+ self.test_codelet.add_outputs(dummy_outputs)
+ self.assertEqual(dummy_outputs[0], self.test_codelet.get_output(name="testName3"))
+
+
+
+ def test_get_outputNullReturn(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.add_outputs(dummy_outputs)
+ self.assertIsNone(self.test_codelet.get_output("testName4"))
+
+
+
+ def test_get_outputEnableFalse(self) -> None:
+ self.test_codelet.time_step = 100
+ #with self.assertRaises(Exception): #TODO Fix test after Java correction
+ with redirect_stdout(io.StringIO()):
+ self.test_codelet.name = "thisCodeletWillFail"
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.outputs = dummy_outputs
+
+
+ self.test_codelet.get_output("testType", 3) # This line will raise an exception
+
+
+ mind = Mind()
+ mind.insert_codelet(self.test_codelet)
+ mind.start()
+ time.sleep(0.1)
+
+ mind.shutdown()
+
+
+ self.assertFalse(self.test_codelet.enabled)
+ self.test_codelet.enabled = True
+ self.assertTrue(self.test_codelet.enabled)
+
+
+
+ def test_set_outputs(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.outputs = dummy_outputs
+ self.assertEqual(2, len(self.test_codelet.outputs))
+
+
+
+ def test_getInputsOfType(self) -> None:
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject(), MemoryObject(), MemoryObject()]
+
+ dummy_inputs[0].set_name("toGet")
+ dummy_inputs[1].set_name("toGet")
+
+ self.test_codelet.add_inputs(dummy_inputs)
+ self.assertEqual(2, len(self.test_codelet.get_inputs_of_type("toGet")))
+
+
+
+ def test_get_outputs_of_type(self) -> None:
+
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject(), MemoryObject(), MemoryObject()]
+
+ dummy_outputs[0].set_name("toGet")
+ dummy_outputs[1].set_name("toGet")
+
+ self.test_codelet.add_outputs(dummy_outputs)
+ self.assertEqual(2, len(self.test_codelet.get_outputs_of_type("toGet")))
+
+
+
+ def test_get_broadcastNull(self) -> None:
+
+ self.assertIsNone(self.test_codelet.get_broadcast("testName5"))
+
+
+
+ def test_get_broadcastType(self) -> None:
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ dummy_outputs[0].set_name("testName6")
+ self.test_codelet.add_broadcasts(dummy_outputs)
+ self.assertEqual(dummy_outputs[0], self.test_codelet.get_broadcast("testName6", 0))
+
+
+
+ def test_get_broadcastTypeIndex(self) -> None:
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ dummy_outputs[0].set_name("testName")
+ dummy_outputs[1].set_name("testName")
+ self.test_codelet.add_broadcasts(dummy_outputs)
+ self.assertEqual(dummy_outputs[1], self.test_codelet.get_broadcast("testName", 1))
+
+
+
+ def test_addBroadcasts(self) -> None:
+ dummy_outputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ self.test_codelet.add_broadcasts(dummy_outputs)
+ self.assertEqual(2, len(self.test_codelet.broadcast))
+
+
+
+ def test_get_thread_name(self) -> None:
+ threading.current_thread().name = "newThreadName"
+ self.assertEqual("newThreadName", self.test_codelet.get_thread_name())
+
+
+
+ def test_toString(self) -> None:
+
+ dummy_inputs : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+ dummy_broadcasts : list[MemoryObject] = [MemoryObject(), MemoryObject()]
+
+ expected_string = ("Codelet [activation=" + str(0.5) + ", " + "name=" + "testName" + ", "
+ + ("broadcast=" + str(dummy_broadcasts[0:min(len(dummy_broadcasts), 10)]) + ", ")
+ + ("inputs=" + str(dummy_inputs[0:min(len(dummy_inputs), 10)])) + ", "
+ + ("outputs=" + "[]") + "]")
+
+ self.test_codelet.name = "testName"
+
+ self.test_codelet.activation = 0.5
+
+ self.test_codelet.inputs = dummy_inputs
+ self.test_codelet.broadcast = dummy_broadcasts
+
+ self.assertEqual(expected_string, str(self.test_codelet))
+
+
+
+ def test_setThreshold(self) -> None:
+ self.test_codelet.threshold = 0.5
+
+
+ assert math.isclose(0.5, self.test_codelet.threshold)
+
+
+
+ def test_upperThresholdBound(self) -> None:
+
+ with self.assertRaises(ValueError) as ve:
+ self.test_codelet.threshold = 2.0
+
+ assert str(ve.exception) == "Codelet threshold must be in (0.0 , 1.0) (value 2.0 is not allowed)."
+
+ assert math.isclose(1.0, self.test_codelet.threshold)
+
+
+
+
+ def test_lowerThresholdBound(self) -> None:
+
+ with self.assertRaises(ValueError) as ve:
+ self.test_codelet.threshold = -1.0
+
+ assert str(ve.exception) == "Codelet threshold must be in (0.0 , 1.0) (value -1.0 is not allowed)."
+
+ assert math.isclose(0.0, self.test_codelet.threshold)
+
+
+
+ def test_getTimeStep(self) -> None:
+
+ self.test_codelet.time_step = 222
+ self.assertEqual(222, self.test_codelet.time_step)
+
+
+
+ @unittest.skip("Codelet profiling not implemented")
+ def test_runProfiling(self) -> None:
+
+ self.test_codelet.profiling = True
+ self.test_codelet.time_step = 100
+
+ with redirect_stdout(io.StringIO()):
+ mind = Mind()
+ mind.insert_codelet(self.test_codelet)
+ mind.start()
+
+ time.sleep(0.1)
+
+
+ self.assertTrue(self.test_codelet.profiling)
+
diff --git a/tests/core/entities/DisconnectedCodeletTest.py b/tests/core/entities/DisconnectedCodeletTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/DisconnectedCodeletTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/MemoryBufferTest.py b/tests/core/entities/MemoryBufferTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/MemoryBufferTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/MemoryContainerTest.py b/tests/core/entities/MemoryContainerTest.py
new file mode 100644
index 0000000..64459e5
--- /dev/null
+++ b/tests/core/entities/MemoryContainerTest.py
@@ -0,0 +1,15 @@
+import unittest
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ super().setUp()
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+ @classmethod
+ def tearDownClass(cls):
+ ...
+
+ def test_(self) -> None:
+ ...
\ No newline at end of file
diff --git a/tests/core/entities/MemoryObjectTest.py b/tests/core/entities/MemoryObjectTest.py
new file mode 100644
index 0000000..18052cc
--- /dev/null
+++ b/tests/core/entities/MemoryObjectTest.py
@@ -0,0 +1,150 @@
+import unittest
+
+from cst_python import MemoryObject, Mind
+
+class MemoryObjectTest(unittest.TestCase):
+ def setUp(self) -> None:
+ self.mo = MemoryObject()
+
+ def test_id(self) -> None:
+ self.mo.set_id(2000)
+
+ assert 2000 == self.mo.get_id()
+
+ def test_to_string(self) -> None:
+ I = object()
+
+ self.mo.set_id(2000)
+ self.mo.set_evaluation(0.8)
+ self.mo.set_info(I)
+ self.mo.set_type("testName")
+
+ expected_string = f'''MemoryObject [idmemoryobject={2000}, timestamp={self.mo.get_timestamp()}, evaluation={0.8}, I={I}, name={"testName"}]'''
+
+ assert expected_string == str(self.mo)
+
+ def test_hash_code(self):
+ I = object()
+ self.mo_eval = 0.8
+ self.mo_id = 2000
+ name = "test_name"
+
+ self.mo.set_id(self.mo_id)
+ self.mo.set_evaluation(self.mo_eval)
+ self.mo.set_info(I)
+ self.mo.set_type(name)
+
+ prime = 31
+ excepted_value = 1
+ excepted_value = prime * excepted_value + (hash(I))
+ excepted_value = prime * excepted_value + (hash(self.mo_eval))
+ excepted_value = prime * excepted_value + (hash(self.mo_id))
+ excepted_value = prime * excepted_value + (hash(name))
+ excepted_value = prime * excepted_value + (0 if self.mo.get_timestamp() is None else hash(self.mo.get_timestamp()))
+
+ #Python truncates the __hash__ return if is too long hashing it, so here we need hash(expected_value)
+ assert hash(excepted_value) == hash(self.mo)
+
+ def test_equals(self):
+ other_mo = MemoryObject()
+ third_mo = MemoryObject()
+ fourth_mo = MemoryObject()
+
+ self.mo.set_info(0.0)
+ other_mo.set_info(0.0)
+ third_mo.set_info(1.0)
+
+ assert self.mo != fourth_mo
+ assert self.mo != third_mo
+
+ self.mo.set_evaluation(0.0)
+ other_mo.set_evaluation(0.0)
+ third_mo.set_evaluation(1.0)
+
+ fourth_mo.set_info(0.0)
+ fourth_mo.set_evaluation(None)
+
+ assert self.mo != fourth_mo
+ assert self.mo != third_mo
+
+ self.mo.set_id(1000)
+ other_mo.set_id(2000)
+ third_mo.set_id(2000)
+
+
+ fourth_mo.set_evaluation(0.0)
+ fourth_mo.set_id(None)
+
+ assert fourth_mo != self.mo
+ assert self.mo != other_mo
+
+ other_mo.set_id(1000)
+ fourth_mo.set_id(1000)
+
+ self.mo.set_type("firstName")
+ other_mo.set_type("firstName")
+ third_mo.set_type("secondName")
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+ fourth_mo.set_type("firstName")
+
+ self.mo.timestamp = 100
+ other_mo.timestamp = 100
+ third_mo.timestamp = 200
+ fourth_mo.timestamp = None
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+ fourth_mo.timestamp = 200
+ assert fourth_mo != self.mo
+
+ assert self.mo == other_mo
+
+ def test_equals_false_None(self) -> None:
+ other_mo = MemoryObject()
+ third_mo = MemoryObject()
+ fourth_mo = MemoryObject()
+
+ self.mo.set_info(0.0)
+ other_mo.set_info(0.0)
+ third_mo.set_info(1.0)
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+ self.mo.set_evaluation(0.0)
+ other_mo.set_evaluation(0.0)
+ third_mo.set_evaluation(1.0)
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+
+ self.mo.set_id(100)
+ other_mo.set_id(100)
+ third_mo.set_id(200)
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+
+ self.mo.set_type("firstName")
+ other_mo.set_type("firstName")
+ third_mo.set_type("secondName")
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+
+ self.mo.timestamp = 10
+ other_mo.timestamp = 10
+ third_mo.timestamp = 20
+ fourth_mo.timestamp = None
+
+ assert fourth_mo != self.mo
+ assert self.mo != third_mo
+
+ assert self.mo == other_mo
\ No newline at end of file
diff --git a/tests/core/entities/MemoryTest.py b/tests/core/entities/MemoryTest.py
new file mode 100644
index 0000000..4e68f76
--- /dev/null
+++ b/tests/core/entities/MemoryTest.py
@@ -0,0 +1,82 @@
+import math
+import unittest
+from typing import Any
+
+from cst_python.core.entities import Memory, MemoryObject, MemoryObserver
+
+class MemorySubclass(Memory):
+ def __init__(self) -> None:
+ super().__init__()
+
+ self.I = None
+ self.evaluation = 0.0
+ self.name = ""
+ self.timestamp = 10
+ self.id = None
+
+ def get_id(self) -> int:
+ return self.id
+
+ def set_id(self, memory_id: int) -> None:
+ self.id = memory_id
+
+ def get_info(self) -> Any:
+ return self.I
+
+ def set_info(self, value: Any) -> int:
+ self.I = value
+
+ def get_evaluation(self) -> float:
+ return self.evaluation
+
+ def get_name(self) -> str:
+ return self.name
+
+ def set_name(self, name: str) -> None:
+ self.name = name
+
+ def set_evaluation(self, evaluation: float) -> None:
+ self.evaluation = evaluation
+
+ def get_timestamp(self) -> int:
+ return self.timestamp
+
+ def add_memory_observer(self, observer: MemoryObserver) -> None:
+ # TODO copy from CST when implemented
+ pass
+
+ def remove_memory_observer(self, observer: MemoryObserver) -> None:
+ # TODO copy from CST when implemented
+ pass
+
+class MemoryTest(unittest.TestCase):
+ def setUp(self) -> None:
+ self.test_memory = MemorySubclass()
+ super().setUp()
+
+ def test_get_set_info(self) -> None:
+ assert self.test_memory.get_info() is None
+
+ test_value = 100.0
+ self.test_memory.set_info(test_value)
+
+ assert math.isclose(test_value, self.test_memory.get_info())
+
+ test_list : list[Memory] = [MemoryObject(), MemoryObject()]
+ self.test_memory.set_info(test_list)
+
+ assert test_list == self.test_memory.get_info()
+
+
+
+ def test_get_set_eval(self) -> None:
+
+ test_value = 100.0
+ self.test_memory.set_evaluation(test_value)
+
+ assert math.isclose(test_value, self.test_memory.get_evaluation())
+
+
+ def test_get_timestamp(self) -> None:
+ assert 10 == self.test_memory.get_timestamp()
+
\ No newline at end of file
diff --git a/tests/core/entities/MindTest.py b/tests/core/entities/MindTest.py
new file mode 100644
index 0000000..d23628d
--- /dev/null
+++ b/tests/core/entities/MindTest.py
@@ -0,0 +1,55 @@
+import unittest
+
+from cst_python import Mind, MemoryObject
+from .utils import CodeletMock
+
+
+class MindTest(unittest.TestCase):
+ def setUp(self) -> None:
+ self.test_codelet = CodeletMock()
+ self.mind = Mind()
+
+ def test_create_codelet_group(self) -> None:
+ self.mind.create_codelet_group("testGroup")
+
+ assert "testGroup" in self.mind.codelet_groups
+
+
+ def test_create_memory_group(self) -> None:
+ self.mind.create_memory_group("testGroup")
+
+ assert "testGroup" in self.mind.memory_groups
+
+
+ def test_insert_codelet_group(self) -> None:
+ self.mind.create_codelet_group("testGroup")
+ self.mind.insert_codelet(self.test_codelet, "testGroup")
+
+
+ assert 1 == len(self.mind.code_rack.all_codelets)
+ assert "testGroup" in self.mind.codelet_groups
+ assert self.test_codelet == self.mind.get_codelet_group_list("testGroup")[0]
+
+ def test_register_memory_group(self) -> None:
+ mo = MemoryObject()
+
+ self.mind.create_memory_group("testGroup")
+ self.mind.register_memory(mo, "testGroup")
+
+ assert "testGroup" in self.mind.memory_groups
+ assert mo == self.mind.memory_groups["testGroup"][0]
+ assert 1 == len(self.mind.get_memory_group_list("testGroup"))
+
+
+ def test_register_memory_by_name(self) -> None:
+ mo = MemoryObject()
+ mo.set_name("testName")
+
+ self.mind.create_memory_group("testGroup")
+ self.mind.raw_memory.add_memory(mo)
+ self.mind.register_memory("testName", "testGroup")
+
+ assert "testGroup" in self.mind.memory_groups
+ assert mo == self.mind.memory_groups.get("testGroup")[0]
+ assert 1 == len(self.mind.memory_groups.get("testGroup"))
+
\ No newline at end of file
diff --git a/tests/core/entities/RawMemoryTest.py b/tests/core/entities/RawMemoryTest.py
new file mode 100644
index 0000000..52f55af
--- /dev/null
+++ b/tests/core/entities/RawMemoryTest.py
@@ -0,0 +1,55 @@
+import unittest
+import io
+from contextlib import redirect_stdout
+
+from cst_python.core.entities import RawMemory, MemoryObject, Memory
+
+class TestRawMemory(unittest.TestCase):
+ def setUp(self) -> None:
+ self.raw_memory = RawMemory()
+
+
+ def test_getAllOfType(self) -> None:
+ test_list : list[Memory] = [MemoryObject(), MemoryObject(), MemoryObject(), MemoryObject()]
+ test_list[0].set_name("TYPE")
+ test_list[1].set_name("TYPE")
+ self.raw_memory.all_memories = test_list
+
+ assert 2 == len(self.raw_memory.get_all_of_type("TYPE"))
+ assert test_list[0:2] == self.raw_memory.get_all_of_type("TYPE")
+
+
+ def test_printContent(self) -> None:
+ mem = MemoryObject()
+ mem.set_name("TYPE")
+ self.raw_memory.add_memory(mem)
+ expected_message = f'''MemoryObject [idmemoryobject={mem.get_id()}, timestamp={mem.get_timestamp()}, evaluation={0.0}, I={None}, name={"TYPE"}]'''
+
+ with redirect_stdout(io.StringIO()) as f:
+ self.raw_memory.print_content()
+
+ printed = f.getvalue().splitlines()[0]
+
+ assert printed == expected_message
+
+
+
+ def test_createAndDestroyMemoryObject(self) -> None:
+ self.raw_memory.create_memory_object("TYPE")
+
+ assert 1 == len(self.raw_memory)
+ self.raw_memory.destroy_memory(self.raw_memory.all_memories[0])
+
+ assert 0 == len(self.raw_memory)
+
+
+
+ def test_shutdown(self) -> None:
+ test_list : list[Memory] = [MemoryObject(), MemoryObject(), MemoryObject(), MemoryObject()]
+ self.raw_memory.all_memories = test_list
+
+ assert 4 == len(self.raw_memory)
+
+ self.raw_memory.shutdown()
+ assert 0 == len(self.raw_memory)
+
\ No newline at end of file
diff --git a/tests/core/entities/__init__.py b/tests/core/entities/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/core/entities/utils.py b/tests/core/entities/utils.py
new file mode 100644
index 0000000..6b229bb
--- /dev/null
+++ b/tests/core/entities/utils.py
@@ -0,0 +1,11 @@
+from cst_python import Codelet
+
+class CodeletMock(Codelet):
+ def access_memory_objects(self) -> None: #NOSONAR
+ pass
+
+ def calculate_activation(self) -> None: #NOSONAR
+ pass
+
+ def proc(self) -> None: #NOSONAR
+ pass
\ No newline at end of file
From 45b79c64b49f9540720bf5f8b0aa15d28aaa6f48 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 11 Oct 2024 14:59:43 -0300
Subject: [PATCH 05/59] Core tests
---
src/cst_python/core/entities/__init__.py | 13 +-
src/cst_python/core/entities/coalition.py | 4 +
src/cst_python/core/entities/codelet.py | 10 +-
.../core/entities/codelet_container.py | 7 +
tests/core/entities/CoalitionTest.py | 15 -
tests/core/entities/CodeRackTest.py | 15 -
tests/core/entities/CodeletContainerTest.py | 15 -
.../core/entities/DisconnectedCodeletTest.py | 15 -
tests/core/entities/MemoryBufferTest.py | 15 -
tests/core/entities/MemoryContainerTest.py | 15 -
tests/core/entities/test_CoalitionTest.py | 53 ++
tests/core/entities/test_CodeRackTest.py | 62 ++
.../entities/test_CodeletContainerTest.py | 823 ++++++++++++++++++
.../{CodeletTest.py => test_CodeletTest.py} | 0
.../entities/test_DisconnectedCodeletTest.py | 27 +
tests/core/entities/test_MemoryBufferTest.py | 109 +++
.../core/entities/test_MemoryContainerTest.py | 511 +++++++++++
...ObjectTest.py => test_MemoryObjectTest.py} | 0
.../{MemoryTest.py => test_MemoryTest.py} | 0
...RawMemoryTest.py => test_RawMemoryTest.py} | 0
.../entities/{MindTest.py => test_mind.py} | 2 +-
21 files changed, 1610 insertions(+), 101 deletions(-)
create mode 100644 src/cst_python/core/entities/coalition.py
create mode 100644 src/cst_python/core/entities/codelet_container.py
delete mode 100644 tests/core/entities/CoalitionTest.py
delete mode 100644 tests/core/entities/CodeRackTest.py
delete mode 100644 tests/core/entities/CodeletContainerTest.py
delete mode 100644 tests/core/entities/DisconnectedCodeletTest.py
delete mode 100644 tests/core/entities/MemoryBufferTest.py
delete mode 100644 tests/core/entities/MemoryContainerTest.py
create mode 100644 tests/core/entities/test_CoalitionTest.py
create mode 100644 tests/core/entities/test_CodeRackTest.py
create mode 100644 tests/core/entities/test_CodeletContainerTest.py
rename tests/core/entities/{CodeletTest.py => test_CodeletTest.py} (100%)
create mode 100644 tests/core/entities/test_DisconnectedCodeletTest.py
create mode 100644 tests/core/entities/test_MemoryBufferTest.py
create mode 100644 tests/core/entities/test_MemoryContainerTest.py
rename tests/core/entities/{MemoryObjectTest.py => test_MemoryObjectTest.py} (100%)
rename tests/core/entities/{MemoryTest.py => test_MemoryTest.py} (100%)
rename tests/core/entities/{RawMemoryTest.py => test_RawMemoryTest.py} (100%)
rename tests/core/entities/{MindTest.py => test_mind.py} (98%)
diff --git a/src/cst_python/core/entities/__init__.py b/src/cst_python/core/entities/__init__.py
index 0a004b8..ed3a2ac 100644
--- a/src/cst_python/core/entities/__init__.py
+++ b/src/cst_python/core/entities/__init__.py
@@ -1,11 +1,14 @@
+from .coalition import Coalition
+from .code_rack import CodeRack
from .codelet import Codelet
+from .codelet_container import CodeletContainer
+from .memory import Memory
from .memory import Memory
from .memory_buffer import MemoryBuffer
+from .memory_container import MemoryContainer
from .memory_object import MemoryObject
-from .memory import Memory
from .memory_observer import MemoryObserver
-from .memory_container import MemoryContainer
-from .rest_memory_container import RESTMemoryContainer
-from .rest_memory_object import RESTMemoryObject
from .mind import Mind
-from .raw_memory import RawMemory
\ No newline at end of file
+from .raw_memory import RawMemory
+from .rest_memory_container import RESTMemoryContainer
+from .rest_memory_object import RESTMemoryObject
\ No newline at end of file
diff --git a/src/cst_python/core/entities/coalition.py b/src/cst_python/core/entities/coalition.py
new file mode 100644
index 0000000..f6b9733
--- /dev/null
+++ b/src/cst_python/core/entities/coalition.py
@@ -0,0 +1,4 @@
+class Coalition:
+
+ def __init__(self) -> None:
+ raise NotImplementedError()
\ No newline at end of file
diff --git a/src/cst_python/core/entities/codelet.py b/src/cst_python/core/entities/codelet.py
index 749097e..bead8ff 100644
--- a/src/cst_python/core/entities/codelet.py
+++ b/src/cst_python/core/entities/codelet.py
@@ -32,7 +32,7 @@ def __init__(self) -> None:
self._activation = 0.0
#self._timer =
self._is_profiling = False
- self._thread : threading.Thread = None
+ self._thread : threading.Thread = threading.Thread(target=self.run, daemon=True)
self._codelet_profiler = None
self._additional_wait = 0.0
@@ -199,17 +199,17 @@ def run(self) -> None:
traceback.print_exception(e)
def start(self) -> None:
- thread = threading.Thread(target=self.run, daemon=True)
- self._thread = thread
- thread.start()
+ self._thread.start()
#thread.join(0.0)
def stop(self):
self.loop = False
- self._thread.join(0.0)
+
+ if self._thread.is_alive():
+ self._thread.join(0.0)
#@alias.alias("impendingAccess")
def impending_acess(self, accessing:Codelet) -> bool:
diff --git a/src/cst_python/core/entities/codelet_container.py b/src/cst_python/core/entities/codelet_container.py
new file mode 100644
index 0000000..bcf29c4
--- /dev/null
+++ b/src/cst_python/core/entities/codelet_container.py
@@ -0,0 +1,7 @@
+from .memory import Memory
+
+class CodeletContainer(Memory):
+
+ def __init__(self) -> None:
+ super().__init__()
+ raise NotImplementedError()
\ No newline at end of file
diff --git a/tests/core/entities/CoalitionTest.py b/tests/core/entities/CoalitionTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/CoalitionTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/CodeRackTest.py b/tests/core/entities/CodeRackTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/CodeRackTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/CodeletContainerTest.py b/tests/core/entities/CodeletContainerTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/CodeletContainerTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/DisconnectedCodeletTest.py b/tests/core/entities/DisconnectedCodeletTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/DisconnectedCodeletTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/MemoryBufferTest.py b/tests/core/entities/MemoryBufferTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/MemoryBufferTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/MemoryContainerTest.py b/tests/core/entities/MemoryContainerTest.py
deleted file mode 100644
index 64459e5..0000000
--- a/tests/core/entities/MemoryContainerTest.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import unittest
-
-class Test(unittest.TestCase):
- def setUp(self) -> None:
- super().setUp()
-
- def tearDown(self) -> None:
- super().tearDown()
-
- @classmethod
- def tearDownClass(cls):
- ...
-
- def test_(self) -> None:
- ...
\ No newline at end of file
diff --git a/tests/core/entities/test_CoalitionTest.py b/tests/core/entities/test_CoalitionTest.py
new file mode 100644
index 0000000..e1b842b
--- /dev/null
+++ b/tests/core/entities/test_CoalitionTest.py
@@ -0,0 +1,53 @@
+import unittest
+
+from cst_python.core.entities import Coalition
+from .utils import CodeletMock
+
+@unittest.skip("Coalition not implemented")
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ self.test_codelet = CodeletMock()
+ self.other_codelet = CodeletMock()
+
+
+ def test_calculateActivationTest(self) -> None:
+ coalition = Coalition([self.test_codelet, self.other_codelet])
+ try:
+ coalition.getCodeletsList().get(0).setActivation(1.0)
+ except CodeletActivationBoundsException as e:
+ e.printStackTrace()
+
+
+ self.assertEqual(0.5, coalition.calculateActivation(), 0)
+
+
+
+ def test_setCodeletListTest(self) -> None:
+ coalition = Coalition([self.test_codelet])
+
+ list_test = [self.test_codelet, self.other_codelet]
+ coalition.setCodeletsList(list_test)
+
+ self.assertEqual(list_test, coalition.getCodeletsList())
+
+
+
+ def test_activation_test(self) -> None:
+ coalition = Coalition([self.test_codelet])
+
+ activation_test = 0.8
+ coalition.setActivation(activation_test)
+
+ self.assertEqual(0.8, coalition.getActivation(), 0)
+
+
+
+ def test_toStringTest(self) -> None:
+ list_test = [self.test_codelet, self.other_codelet]
+ coalition = Coalition([self.test_codelet, self.other_codelet])
+ coalition.setActivation(0.8)
+
+ expect_message = f"Coalition [activation={0.8}, codeletsList={list_test}]"
+
+ self.assertIn(str(coalition), expect_message)
+
\ No newline at end of file
diff --git a/tests/core/entities/test_CodeRackTest.py b/tests/core/entities/test_CodeRackTest.py
new file mode 100644
index 0000000..ca8969b
--- /dev/null
+++ b/tests/core/entities/test_CodeRackTest.py
@@ -0,0 +1,62 @@
+import unittest
+
+from cst_python.core.entities import CodeRack, MemoryObject, Codelet
+from .utils import CodeletMock
+
+class Test(unittest.TestCase):
+ def setUp(self) -> None:
+ self.test_codelet = CodeletMock()
+ self.other_codelet = CodeletMock()
+
+
+ def test_setAllCodeletTest(self) -> None:
+ code_rack = CodeRack()
+ test_list : list[Codelet] = [self.test_codelet, self.other_codelet]
+
+ code_rack.all_codelets = test_list
+ self.assertEqual(test_list, code_rack.all_codelets)
+
+
+
+ def test_insertCodeletTest(self) -> None:
+ code_rack = CodeRack()
+ test_list : list[Codelet] = [self.test_codelet]
+
+ code_rack.insert_codelet(self.test_codelet)
+
+ self.assertEqual(test_list, code_rack.all_codelets)
+
+
+
+ def test_createCodeletTest(self) -> None:
+ code_rack = CodeRack()
+ mem_input_test = [MemoryObject(), MemoryObject()]
+ mem_output_test = [MemoryObject()]
+
+ code_rack.create_codelet(0.5, None, mem_input_test, mem_output_test, self.test_codelet)
+
+ self.assertEqual(self.test_codelet, code_rack.all_codelets[0])
+
+ def test_destroyCodeletTest(self) -> None:
+ code_rack = CodeRack()
+ mem_input_test = [MemoryObject(), MemoryObject()]
+ mem_output_test = [MemoryObject()]
+
+ code_rack.create_codelet(0.5, None, mem_input_test, mem_output_test, self.test_codelet)
+
+ code_rack.destroy_codelet(self.test_codelet)
+
+ self.assertEqual(0, len(code_rack.all_codelets))
+
+
+ def test_startStopTest(self) -> None:
+ code_rack = CodeRack()
+ test_list : list[Codelet] = [self.test_codelet, self.other_codelet]
+
+ code_rack.all_codelets = test_list
+ code_rack.start()
+ self.assertTrue(code_rack.all_codelets[0].loop)
+
+ code_rack.stop()
+ self.assertFalse(code_rack.all_codelets[0].loop)
+
\ No newline at end of file
diff --git a/tests/core/entities/test_CodeletContainerTest.py b/tests/core/entities/test_CodeletContainerTest.py
new file mode 100644
index 0000000..076efec
--- /dev/null
+++ b/tests/core/entities/test_CodeletContainerTest.py
@@ -0,0 +1,823 @@
+import unittest
+import time
+
+from cst_python.core.entities import Codelet, CodeletContainer, Mind, MemoryObject, Memory
+
+class CodeletToTestOne(Codelet):
+ def __init__(self, name:str):
+ self.counter = 0
+
+ self.name = name
+
+ def access_memory_objects(self): #NOSONAR
+ pass
+
+ def calculate_activation(self):
+ self.activation = self.counter
+
+ def proc(self):
+ self.counter += 1
+ if (self.outputs is not None and len(self.outputs) != 0):
+ self.outputs[0].set_info("CODELET 1 OUTPUT")
+
+class CodeletToTestTwo(Codelet):
+ def __init__(self, name:str):
+ self.counter = 0
+
+ self.name = name
+
+ def access_memory_objects(self): #NOSONAR
+ pass
+
+ def calculate_activation(self): #NOSONAR
+ pass
+
+ def proc(self):
+ self.counter += 2
+
+class CodeletToTestThree(Codelet):
+ def __init__(self, name:str):
+ self.counter = 0
+
+ self.name = name
+
+ def access_memory_objects(self): #NOSONAR
+ pass
+
+ def calculate_activation(self):
+ self.activation = self.counter
+
+ def proc(self):
+ self.counter += 3
+ if (self.outputs is not None and len(self.outputs) != 0):
+ self.outputs[0].set_info("CODELET 3 OUTPUT")
+
+@unittest.skip("CodeletContainer not implemented")
+class CodeletContainerTest (unittest.TestCase):
+
+ def sleep(self, timestep:int) -> None:
+ time.sleep(timestep/1000)
+
+
+ def test_noMemoryChangeTest(self) -> None:
+ # no codelet runs
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+ self.assertEqual(0, codelet_container.getOutputs().size())
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual(0, codelet_container.getEvaluation(), 0)
+
+
+
+
+ def test_noMemoryChangeButCodeletAddedIsStartedTest(self) -> None:
+ # no codelet runs
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, True)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+ self.assertEqual(0, len(codelet_container.getOutputs()))
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual( [], codelet_container.getOutputs())
+ self.assertEqual(0, codelet_container.getEvaluation(), 0)
+
+
+
+
+ def test_runningCodeletChangingInputTest(self) -> None:
+ # changes the codelet container input
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory_input1 = mind.create_memory_object("MEMORY_INPUT_1", 0.12)
+ memory_input2 = mind.create_memory_object("MEMORY_INPUT_2", 0.32)
+ memory_input3 = mind.create_memory_object("MEMORY_INPUT_3", 0.32)
+ memory_input4 = mind.create_memory_object("MEMORY_INPUT_4", 0.32)
+ memory_output1 = mind.create_memory_object("MEMORY_OUTPUT_1", 0.22)
+ memory_output2 = mind.create_memory_object("MEMORY_OUTPUT_2", 0.22)
+ memory_output3 = mind.create_memory_object("MEMORY_OUTPUT_3", 0.22)
+
+ codelet_one.add_input(memory_input1)
+ codelet_one.add_broadcast(memory_input2)
+ codelet_one.add_output(memory_output1)
+
+ codelet_two.add_broadcast(memory_input3)
+ codelet_two.add_output(memory_output2)
+
+ codelet_three.add_input(memory_input4)
+ codelet_three.add_output(memory_output3)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ codelet_container.set_info(10)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+ for codelet in codelet_container.getAll():
+ for mem in codelet.inputs:
+ self.assertEqual(10, mem.get_info())
+
+
+
+ for codelet in codelet_container.getAll():
+ for mem in codelet.broadcast:
+ self.assertEqual(0.32, mem.get_info())
+
+
+
+ self.assertEqual(3, codelet_container.getOutputs().size())
+ expected_outputs = []
+ expected_outputs.append(memory_output1)
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual(0.22, codelet_container.getOutputs()[1].get_info())
+ self.assertEqual("MEMORY_OUTPUT_3", codelet_container.getOutputs()[2].name)
+ self.assertEqual(0, codelet_container.getEvaluation(), 0)
+
+
+
+
+ def test_runningCodeletChangingInputCodeletStartedWhenAddedTest(self) -> None:
+ # changes the codelet container input
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory_input1 = mind.create_memory_object("MEMORY_INPUT_1", 0.12)
+ memory_input2 = mind.create_memory_object("MEMORY_INPUT_2", 0.32)
+ memory_input3 = mind.create_memory_object("MEMORY_INPUT_3", 0.32)
+ memory_input4 = mind.create_memory_object("MEMORY_INPUT_4", 0.32)
+ memory_output1 = mind.create_memory_object("MEMORY_OUTPUT_1", 0.22)
+ memory_output2 = mind.create_memory_object("MEMORY_OUTPUT_2", 0.22)
+ memory_output3 = mind.create_memory_object("MEMORY_OUTPUT_3", 0.22)
+
+ codelet_one.add_input(memory_input1)
+ codelet_one.add_broadcast(memory_input2)
+ codelet_one.add_output(memory_output1)
+
+ codelet_two.add_broadcast(memory_input3)
+ codelet_two.add_output(memory_output2)
+
+ codelet_three.add_input(memory_input4)
+ codelet_three.add_output(memory_output3)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, True)
+
+ codelet_container.set_info(10)
+ self.sleep(2000)
+
+ for codelet in codelet_container.getAll():
+ for mem in codelet.inputs:
+ self.assertEqual(10, mem.get_info())
+
+
+
+ for codelet in codelet_container.getAll():
+ for mem in codelet.broadcast:
+ self.assertEqual(0.32, mem.get_info())
+
+
+
+ codelet_to_test_one : CodeletToTestOne = codelet_container.getCodelet("Codelet 1")
+ self.assertEqual(7, codelet_to_test_one.counter)
+ self.assertEqual(3, codelet_container.getOutputs().size())
+ expected_outputs : list[Memory] = []
+ expected_outputs.append(memory_output1)
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual(0.22, codelet_container.getOutputs()[1].get_info())
+ self.assertEqual("MEMORY_OUTPUT_3", codelet_container.getOutputs()[2].name)
+ self.assertEqual(0, codelet_container.getEvaluation(), 0)
+
+
+
+
+ def test_addCodeletsToCodeletContainerTest(self) -> None:
+ # changes the codelet container input
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory_input1 = mind.create_memory_object("MEMORY_INPUT_1", 0.12)
+ memory_input2 = mind.create_memory_object("MEMORY_INPUT_2", 0.32)
+ memory_input3 = mind.create_memory_object("MEMORY_INPUT_3", 0.32)
+ memory_input4 = mind.create_memory_object("MEMORY_INPUT_4", 0.32)
+ memory_output1 = mind.create_memory_object("MEMORY_OUTPUT_1", 0.22)
+ memory_output2 = mind.create_memory_object("MEMORY_OUTPUT_2", 0.22)
+ memory_output3 = mind.create_memory_object("MEMORY_OUTPUT_3", 0.22)
+
+ codelet_one.add_input(memory_input1)
+ codelet_one.add_broadcast(memory_input2)
+ codelet_one.add_output(memory_output1)
+
+ codelet_two.add_broadcast(memory_input3)
+ codelet_two.add_output(memory_output2)
+
+ codelet_three.add_input(memory_input4)
+ codelet_three.add_output(memory_output3)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer()
+ codelet_container.addCodelet(codelet_one, False)
+ codelet_container.addCodelet(codelet_two, False)
+ codelet_container.addCodelet(codelet_three, False)
+
+
+ self.assertEqual(3, codelet_container.getOutputs().size())
+ expected_outputs : list[Memory] = []
+ expected_outputs.append(memory_output1)
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+
+ self.assertEqual("MEMORY_OUTPUT_1", codelet_container.getOutputs()[0].name)
+ self.assertEqual("MEMORY_OUTPUT_2", codelet_container.getOutputs()[1].name)
+ self.assertEqual("MEMORY_OUTPUT_3", codelet_container.getOutputs()[2].name)
+ self.assertEqual(3, codelet_container.getCodelet(codelet_one.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_two.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_three.name).outputs.size())
+
+ self.assertEqual(2, codelet_container.getInputs().size())
+ expected_inputs : list[Memory] = []
+ expected_inputs.append(memory_input1)
+ expected_inputs.append(memory_input4)
+ assert expected_inputs == list(codelet_container.getInputs())
+ self.assertEqual("MEMORY_INPUT_1", codelet_container.getInputs()[0].name)
+ self.assertEqual("MEMORY_INPUT_4", codelet_container.getInputs()[1].name)
+ self.assertEqual(2, codelet_container.getCodelet(codelet_one.name).inputs.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_three.name).inputs.size())
+
+ self.assertEqual(2, codelet_container.getBroadcast().size())
+ expected_broadcast : list[Memory] = []
+ expected_broadcast.append(memory_input2)
+ expected_broadcast.append(memory_input3)
+ assert expected_broadcast == list(codelet_container.getBroadcast())
+ self.assertEqual("MEMORY_INPUT_2", codelet_container.getBroadcast()[0].name)
+ self.assertEqual("MEMORY_INPUT_3", codelet_container.getBroadcast()[1].name)
+ self.assertEqual(2, codelet_container.getCodelet(codelet_one.name).broadcast.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_two.name).broadcast.size())
+
+
+
+ def test_addCodeletsToCodeletContainerWhichHasInputsAndOuputsTest(self) -> None:
+ # changes the codelet container input
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory_input1 = mind.create_memory_object("MEMORY_INPUT_1", 0.12)
+ # 2 and 3 is not used
+ memory_input4 = mind.create_memory_object("MEMORY_INPUT_4", 0.32)
+ memory_output1 = mind.create_memory_object("MEMORY_OUTPUT_1", 0.22)
+ memory_output2 = mind.create_memory_object("MEMORY_OUTPUT_2", 0.22)
+ memory_output3 = mind.create_memory_object("MEMORY_OUTPUT_3", 0.22)
+
+ codelet_container = CodeletContainer()
+
+ new_inputs : list[Memory] = []
+ new_inputs.append(memory_input1)
+ new_inputs.append(memory_input4)
+ codelet_container.set_infonputs(new_inputs)
+
+ new_outputs: list[Memory] = []
+ new_outputs.append(memory_output1)
+ new_outputs.append(memory_output2)
+ new_outputs.append(memory_output3)
+ codelet_container.setOutputs(new_outputs)
+
+ codelet_container.addCodelet(codelet_one, False)
+ codelet_container.addCodelet(codelet_two, False)
+ codelet_container.addCodelet(codelet_three, False)
+
+
+ self.assertEqual(3, codelet_container.getOutputs().size())
+ expected_outputs : list[Memory] = []
+ expected_outputs.append(memory_output1)
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual("MEMORY_OUTPUT_1", codelet_container.getOutputs()[0].name)
+ self.assertEqual("MEMORY_OUTPUT_2", codelet_container.getOutputs()[1].name)
+ self.assertEqual("MEMORY_OUTPUT_3", codelet_container.getOutputs()[2].name)
+ self.assertEqual(3, codelet_container.getCodelet(codelet_one.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_two.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_three.name).outputs.size())
+
+ self.assertEqual(2, codelet_container.getInputs().size())
+ expected_inputs : list[Memory] = []
+ expected_inputs.append(memory_input1)
+ expected_inputs.append(memory_input4)
+ assert expected_inputs == list(codelet_container.getInputs())
+ self.assertEqual("MEMORY_INPUT_1", codelet_container.getInputs()[0].name)
+ self.assertEqual("MEMORY_INPUT_4", codelet_container.getInputs()[1].name)
+ self.assertEqual(2, codelet_container.getCodelet(codelet_one.name).inputs.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_three.name).inputs.size())
+
+
+
+
+ def test_removeCodeletsFromCodeletContainerTest(self) -> None:
+ # changes the codelet container input
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory_input1 = mind.create_memory_object("MEMORY_INPUT_1", 0.12)
+ memory_input2 = mind.create_memory_object("MEMORY_INPUT_2", 0.32)
+ memory_input3 = mind.create_memory_object("MEMORY_INPUT_3", 0.32)
+ memory_input4 = mind.create_memory_object("MEMORY_INPUT_4", 0.32)
+ memory_output1 = mind.create_memory_object("MEMORY_OUTPUT_1", 0.22)
+ memory_output2 = mind.create_memory_object("MEMORY_OUTPUT_2", 0.22)
+ memory_output3 = mind.create_memory_object("MEMORY_OUTPUT_3", 0.22)
+
+ codelet_one.add_input(memory_input1)
+ codelet_one.add_broadcast(memory_input2)
+ codelet_one.add_output(memory_output1)
+
+ codelet_two.add_broadcast(memory_input3)
+ codelet_two.add_output(memory_output2)
+
+ codelet_three.add_input(memory_input4)
+ codelet_three.add_output(memory_output3)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+
+ self.assertEqual(3, codelet_container.getOutputs().size())
+ expected_outputs : list[Memory] = []
+ expected_outputs.append(memory_output1)
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual("MEMORY_OUTPUT_1", codelet_container.getOutputs()[0].name)
+ self.assertEqual("MEMORY_OUTPUT_2", codelet_container.getOutputs()[1].name)
+ self.assertEqual("MEMORY_OUTPUT_3", codelet_container.getOutputs()[2].name)
+ self.assertEqual(3, codelet_container.getCodelet(codelet_one.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_two.name).outputs.size())
+ self.assertEqual(3, codelet_container.getCodelet(codelet_three.name).outputs.size())
+
+ self.assertEqual(2, codelet_container.getInputs().size())
+ expected_inputs : list[Memory] = []
+ expected_inputs.append(memory_input1)
+ expected_inputs.append(memory_input4)
+ assert expected_inputs == list(codelet_container.getInputs())
+ self.assertEqual("MEMORY_INPUT_1", codelet_container.getInputs()[0].name)
+ self.assertEqual("MEMORY_INPUT_4", codelet_container.getInputs()[1].name)
+ self.assertEqual(2, codelet_container.getCodelet(codelet_one.name).inputs.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_three.name).inputs.size())
+
+ self.assertEqual(2, codelet_container.getBroadcast().size())
+ expected_broadcast : list[Memory] = []
+ expected_broadcast.append(memory_input2)
+ expected_broadcast.append(memory_input3)
+ assert expected_broadcast == list(codelet_container.getBroadcast())
+ self.assertEqual("MEMORY_INPUT_2", codelet_container.getBroadcast()[0].name)
+ self.assertEqual("MEMORY_INPUT_3", codelet_container.getBroadcast()[1].name)
+ self.assertEqual(2, codelet_container.getCodelet(codelet_one.name).broadcast.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_two.name).broadcast.size())
+
+ codelet_container.removeCodelet(codelet_one)
+
+ self.assertEqual(2, codelet_container.getOutputs().size())
+ expected_outputs = []
+ expected_outputs.append(memory_output2)
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_two.name).outputs.size())
+ self.assertEqual(2, codelet_container.getCodelet(codelet_three.name).outputs.size())
+
+ self.assertEqual(1, codelet_container.getInputs().size())
+ expected_inputs = []
+ expected_inputs.append(memory_input4)
+ assert expected_inputs == list(codelet_container.getInputs())
+ self.assertEqual("MEMORY_INPUT_4", codelet_container.getInputs()[0].name)
+ self.assertEqual(1, codelet_container.getCodelet(codelet_three.name).inputs.size())
+
+ self.assertEqual(1, codelet_container.getBroadcast().size())
+ expected_broadcast = []
+ expected_broadcast.append(memory_input3)
+ assert expected_broadcast == list(codelet_container.getBroadcast())
+ self.assertEqual("MEMORY_INPUT_3", codelet_container.getBroadcast()[0].name)
+ self.assertEqual(1, codelet_container.getCodelet(codelet_two.name).broadcast.size())
+
+ codelet_container.removeCodelet(codelet_two)
+
+ self.assertEqual(1, codelet_container.getOutputs().size())
+ expected_outputs = []
+ expected_outputs.append(memory_output3)
+ assert expected_outputs == list(codelet_container.getOutputs())
+ self.assertEqual(1, codelet_container.getCodelet(codelet_three.name).outputs.size())
+
+ self.assertEqual(1, codelet_container.getInputs().size())
+ expected_inputs = []
+ expected_inputs.append(memory_input4)
+ assert expected_inputs == list(codelet_container.getInputs())
+ self.assertEqual("MEMORY_INPUT_4", codelet_container.getInputs()[0].name)
+ self.assertEqual(1, codelet_container.getCodelet(codelet_three.name).inputs.size())
+
+ self.assertEqual(0, codelet_container.getBroadcast().size())
+ self.assertEqual(0, codelet_container.getCodelet(codelet_three.name).broadcast.size())
+
+
+
+
+
+ def test_getEvaluationTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+ test_value = 100.0
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ memory1.setEvaluation(test_value)
+ codelet_container.set_info(10)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+
+
+ self.assertEqual(test_value, codelet_container.getEvaluation())
+
+
+
+
+
+ def test_getActivationTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+ test_value = 6.0
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ memory1.setEvaluation(test_value)
+ codelet_container.set_info(10)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+
+
+ self.assertEqual(test_value, codelet_container.getActivation(), 0)
+
+
+
+
+ def test_set_infonputsTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+
+ new_inputs : list[Memory] = []
+ new_inputs.append(memory1)
+ codelet_container.set_infonputs(new_inputs)
+
+
+
+ self.assertEqual(new_inputs, codelet_container.getInputs())
+
+
+
+
+ def test_setOutputsTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+
+ new_outputs: list[Memory] = []
+ new_outputs.append(memory1)
+ codelet_container.setOutputs(new_outputs)
+
+
+
+ self.assertEqual(new_outputs, codelet_container.getOutputs())
+
+
+
+
+ def test_setBroadcastTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+
+ new_broadcast : list[Memory] = []
+ new_broadcast.append(memory1)
+ codelet_container.setBroadcast(new_broadcast)
+
+
+
+ self.assertEqual(new_broadcast, codelet_container.getBroadcast())
+
+
+
+
+ def test_setNameTest(self) -> None:
+ codelet_container = CodeletContainer()
+ codelet_container.setName("Container")
+ self.assertEqual("Container", codelet_container.name)
+
+
+
+ def test_setTypeTest(self) -> None:
+ codelet_container = CodeletContainer()
+ codelet_container.setType("Container")
+ self.assertEqual("Container", codelet_container.name)
+
+
+
+ def test_setEvaluationTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ codelet_one.add_input(memory1)
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container = CodeletContainer(codelet_container_array, False)
+ codelet_container.setEvaluation(5.0)
+ self.assertEqual(5.0, codelet_container.getCodelet("Codelet 1").getInputs()[0].getEvaluation(),0)
+
+
+
+ def test_addMemoryObserverTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.set_infosMemoryObserver(True)
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+ codelet_container.addMemoryObserver(codelet_one)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ codelet_container.set_info(10)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+
+ codelet_to_test_one : CodeletToTestOne = codelet_container.getCodelet("Codelet 1")
+ self.assertEqual(6, codelet_to_test_one.counter)
+
+
+
+ def test_getTimestampTest(self) -> None:
+ codelet_one = CodeletToTestOne("Codelet 1")
+ codelet_two = CodeletToTestTwo("Codelet 2")
+ codelet_three = CodeletToTestThree("Codelet 3")
+
+ mind = Mind()
+ memory1 = mind.create_memory_object("MEMORY1", 0.12)
+ memory2 = mind.create_memory_object("MEMORY2", 0.32)
+ memory3 = mind.create_memory_object("MEMORY3", 0.32)
+ memory4 = mind.create_memory_object("MEMORY4", 0.32)
+
+ codelet_one.add_input(memory1)
+ codelet_one.add_broadcast(memory2)
+
+ codelet_two.add_broadcast(memory3)
+
+ codelet_three.add_input(memory4)
+
+ codelet_container_array : list[Codelet] = []
+ codelet_container_array.append(codelet_one)
+ codelet_container_array.append(codelet_two)
+ codelet_container_array.append(codelet_three)
+
+ codelet_container = CodeletContainer(codelet_container_array, False)
+
+ mind.insert_codelet(codelet_one)
+ mind.insert_codelet(codelet_two)
+ mind.insert_codelet(codelet_three)
+ codelet_container.set_info(10)
+ mind.start()
+ self.sleep(2000)
+ mind.shutdown()
+
+ self.assertGreater(codelet_container.getTimestamp().doubleValue(), 1)
+
+
\ No newline at end of file
diff --git a/tests/core/entities/CodeletTest.py b/tests/core/entities/test_CodeletTest.py
similarity index 100%
rename from tests/core/entities/CodeletTest.py
rename to tests/core/entities/test_CodeletTest.py
diff --git a/tests/core/entities/test_DisconnectedCodeletTest.py b/tests/core/entities/test_DisconnectedCodeletTest.py
new file mode 100644
index 0000000..5896a6c
--- /dev/null
+++ b/tests/core/entities/test_DisconnectedCodeletTest.py
@@ -0,0 +1,27 @@
+import unittest
+
+from .utils import CodeletMock
+
+class disconnected_codeletTest (unittest.TestCase):
+ def setUp(self) -> None:
+ self.message = ""
+
+ def tearDown(self) -> None:
+ super().tearDown()
+
+
+ def test_disconnected_codelet(self) -> None:
+
+ disconnected_codelet = CodeletMock()
+
+ disconnected_codelet.name = "Disconnected Codelet"
+ try:
+ disconnected_codelet.start()
+ disconnected_codelet.getInput("TYPE", 0)
+ disconnected_codelet.stop()
+ except Exception as e:
+ message = repr(e)
+ #print("Testing disconnected_codelet:"+e.getMessage())
+
+ disconnected_codelet.stop()
+ #print("Codelet stopped !")
\ No newline at end of file
diff --git a/tests/core/entities/test_MemoryBufferTest.py b/tests/core/entities/test_MemoryBufferTest.py
new file mode 100644
index 0000000..f5d913a
--- /dev/null
+++ b/tests/core/entities/test_MemoryBufferTest.py
@@ -0,0 +1,109 @@
+from contextlib import redirect_stdout
+import io
+import unittest
+
+from cst_python.core.entities import RawMemory, MemoryBuffer, MemoryObject
+
+@unittest.skip("MemoryBuffer not implemented")
+class MemoryBufferTest(unittest.TestCase):
+
+ @unittest.skip("'setType' is not implemented in Python as is deprecated")
+ def test_basic_call(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ testList : list[MemoryObject] = [MemoryObject(), MemoryObject(), MemoryObject()]
+ testList[0].setType("memory_0")
+ testList[1].setType("memory_1")
+ testList[2].setType("memory_2")
+
+ memoryBuffer.putList(testList)
+
+ self.assertEqual(3, len(memoryBuffer))
+ self.assertEqual(memoryBuffer.get(), memoryBuffer.getAll())
+ self.assertEqual(testList[2], memoryBuffer.getMostRecent())
+ self.assertEqual(testList[0], memoryBuffer.getOldest())
+
+
+ @unittest.skip("'setType' is not implemented in Python as is deprecated")
+ def test_puts_more_than_max(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ testList : list[MemoryObject] = [MemoryObject(), MemoryObject(), MemoryObject(), MemoryObject()]
+ testList[0].setType("memory_0")
+ testList[1].setType("memory_1")
+ testList[2].setType("memory_2")
+ testList[3].setType("memory_3")
+ memoryBuffer.putList(testList)
+
+ self.assertEqual(3, len(memoryBuffer))
+ self.assertEqual(memoryBuffer.get(), memoryBuffer.getAll())
+ self.assertEqual(testList[1], memoryBuffer.get()[0])
+
+ memoryBuffer.put(MemoryObject())
+ self.assertEqual(testList[2], memoryBuffer.get()[0])
+
+
+ @unittest.skip("'setType' is not implemented in Python as is deprecated")
+ def test_put_pop(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ testMemory = MemoryObject()
+ testMemory.setType("memory_0")
+ memoryBuffer.put(testMemory)
+
+ self.assertEqual(testMemory, memoryBuffer.pop())
+ self.assertEqual(0, len(memoryBuffer))
+
+
+
+ def test_null_oldest_and_newest(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ self.assertIsNone(memoryBuffer.getOldest())
+ self.assertIsNone(memoryBuffer.getMostRecent())
+
+
+ @unittest.skip("'setType' is not implemented in Python as is deprecated")
+ def test_remove_and_clear(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ testList : list[MemoryObject] = [MemoryObject(), MemoryObject(), MemoryObject()]
+ testList[0].setType("memory_0")
+ testList[1].setType("memory_1")
+ testList[2].setType("memory_2")
+
+ memoryBuffer.putList(testList)
+ memoryBuffer.remove(testList[1])
+
+ self.assertEqual(2, len(memoryBuffer))
+ self.assertEqual(testList[2], memoryBuffer.get()[1])
+
+ memoryBuffer.clear()
+ self.assertEqual(0, len(memoryBuffer))
+
+
+ @unittest.skip("'setType' is not implemented in Python as is deprecated")
+ def test_pint_status(self) -> None:
+ rawMemory = RawMemory()
+ memoryBuffer = MemoryBuffer(3, rawMemory)
+
+ testList : list[MemoryObject] = [MemoryObject()]
+ testList[0].setType("memory_0")
+ memoryBuffer.putList(testList)
+
+ expectedMessage ='''"###### Memory Buffer ########\n# Content: [MemoryObject [idmemoryobject=null, timestamp=null, evaluation=0.0, I=null, name=memory_0]]" +
+ "\n# Size: 1\n###############################'''
+
+ with redirect_stdout(io.StringIO()) as f:
+ memoryBuffer.printStatus()
+
+ printed = f.getvalue().replace("\r\n", "\n")
+ expectedMessage = expectedMessage.replace("\r\n", "\n")
+
+ self.assertTrue(expectedMessage in printed)
+
\ No newline at end of file
diff --git a/tests/core/entities/test_MemoryContainerTest.py b/tests/core/entities/test_MemoryContainerTest.py
new file mode 100644
index 0000000..8128013
--- /dev/null
+++ b/tests/core/entities/test_MemoryContainerTest.py
@@ -0,0 +1,511 @@
+import unittest
+from typing import Callable
+
+from cst_python.core.entities import MemoryContainer, Memory, MemoryObject
+
+@unittest.skip("Memory Container not implemented")
+class MemoryContainerTest (unittest.TestCase):
+
+ def test_memory_container_content(self) -> None:
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(71, 0.1, "TYPE")
+ memoryContainer.set_info(75, 0.2, "TYPE")
+
+ self.assertEqual(75, memoryContainer.get_info())
+
+ def test_memory_container_size(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(71, 0.1, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE3")
+
+ self.assertEqual(2, memoryContainer.getAllMemories().size())
+
+ def test_set_type(self) -> None:
+ # memoryContainer = MemoryContainer()
+ # memoryContainer.setType("TYPE")
+ # self.assertEqual("TYPE", memoryContainer.get_name())
+
+ memoryContainer = MemoryContainer()
+ memoryContainer.set_name("TYPE2")
+ self.assertEqual("TYPE2", memoryContainer.get_name())
+
+ memoryContainer = MemoryContainer("TYPE3")
+ self.assertEqual("TYPE3", memoryContainer.get_name())
+
+ def test_get_type(self) -> None:
+ memoryContainer = MemoryContainer("TYPE-Container")
+ memoryContainer.set_info("value", 1.0, "TYPE")
+ self.assertEqual(memoryContainer.get_info("TYPE"), "value")
+ print("-- This test will raise a warning ...")
+ self.assertIsNone(memoryContainer.get_info("TYPE2"))
+
+ def test_get_i(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(71, 0.1, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+
+ self.assertEqual(70, memoryContainer.get_info())
+ self.assertEqual(75, memoryContainer.get_info(0))
+ print("-- This test will raise a warning ...")
+ # This test will raise a warning for index greater than the number of stored memories
+ self.assertIsNone(memoryContainer.get_info(2))
+ self.assertEqual(70, memoryContainer.get_info("TYPE3"))
+
+ def test_get_i_predicate(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(71, 0.1, "TYPE2")
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+ memoryContainer.set_info(70, 0.25)
+
+ pred: Callable[[Memory], bool] = lambda m: m.get_name() == "TYPE2"
+
+ self.assertEqual(75, memoryContainer.get_info(pred))
+
+ def test_get_i_accumulator(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+ memoryContainer.set_info(80)
+
+ binaryOperator: Callable[[Memory, Memory], Memory] = lambda mem1, mem2: mem1 if mem1.get_evaluation(
+ ) <= mem2.get_evaluation() else mem2
+
+ self.assertEqual(80, memoryContainer.get_info(binaryOperator))
+
+ def test_set_i_specific(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+ memoryContainer.set_info(80)
+
+ memoryContainer.set_info(60, 1)
+ memoryContainer.set_info(90, 0.5, 2)
+
+ self.assertEqual(60, memoryContainer.get_info(1))
+ self.assertEqual(90, memoryContainer.get_info())
+ self.assertEqual(0.5, memoryContainer.get_evaluation(), 0)
+
+ def test_set_evaluation(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+
+ memoryContainer.set_info(90, 0.5, 2)
+
+ self.assertEqual(70, memoryContainer.get_info())
+ memoryContainer.set_evaluation(0.5, 0)
+ self.assertEqual(75, memoryContainer.get_info())
+
+ def test_set_evaluation_last(self) -> None:
+ memoryContainer = MemoryContainer("TYPE")
+ print("-- This test will raise a warning ...")
+ memoryContainer.set_evaluation(2.0)
+ self.assertEqual(memoryContainer.get_evaluation(), None)
+ memoryContainer.set_info("message")
+ memoryContainer.set_evaluation(2.0)
+ self.assertEqual(memoryContainer.get_evaluation(), 2.0)
+
+ def test_get_timestamp_not_valid(self) -> None:
+ memoryContainer = MemoryContainer("TYPE")
+ print("-- This test will raise a warning ...")
+ ts: int = memoryContainer.get_timestamp()
+ self.assertEqual(ts, None)
+ memoryContainer.set_info("message")
+ ts = memoryContainer.get_timestamp()
+ self.assertTrue(ts != None)
+
+ def test_add(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+ memoryContainer.add(MemoryObject())
+
+ self.assertEqual(3, memoryContainer.getAllMemories().size())
+
+ def test_get_internal(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+
+ self.assertEqual(
+ 75, memoryContainer.getInternalMemory("TYPE2").get_info())
+ self.assertIsNone(memoryContainer.getInternalMemory("TYPE4"))
+
+ def test_get_timestamp(self) -> None:
+
+ memoryContainer = MemoryContainer("TYPE")
+
+ memoryContainer.set_info(75, 0.2, "TYPE2")
+ memoryContainer.set_info(70, 0.3, "TYPE3")
+
+ self.assertEqual(memoryContainer.getInternalMemory("TYPE3").get_timestamp(),
+ memoryContainer.get_timestamp())
+
+ def test_max_policy(self) -> None:
+ memoryContainer = MemoryContainer("MAX")
+ memoryContainer.setPolicy(Policy.MAX)
+ m1 = memoryContainer.set_info(1, 0.2)
+ m2 = memoryContainer.set_info(2, 0.4)
+ m3 = memoryContainer.set_info(3, 0.8)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 3)
+ memoryContainer.set_evaluation(0.1)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 2)
+ memoryContainer.set_evaluation(0.1)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 1)
+ memoryContainer.set_evaluation(0.1, m1)
+ memoryContainer.set_evaluation(0.1, m2)
+ memoryContainer.set_evaluation(0.1, m3)
+
+ for j in range(20):
+ m: int = memoryContainer.get_info()
+ ver: bool = (m == 1 or m == 2 or m == 3)
+ self.assertEqual(ver, True)
+ # print("max: "+m)
+
+ memoryContainer.set_evaluation(0.05, m1)
+ for j in range(20):
+ m: int = memoryContainer.get_info()
+ ver: bool = (m == 2 or m == 3)
+ self.assertEqual(ver, True)
+ # print("max2: "+m)
+
+ def test_max_policy_with_same_eval(self) -> None:
+ memoryContainer = MemoryContainer("MAX")
+ memoryContainer.setPolicy(Policy.MAX)
+ m1 = memoryContainer.set_info(1, 0.2)
+ m2 = memoryContainer.set_info(2, 0.2)
+ m3 = memoryContainer.set_info(3, 0.2)
+ i = -1
+ oldi = 0
+ for j in range(10):
+ oldi = i
+ # Despite the choice is random, if no chance in I happens, it stays the same
+ i: int = memoryContainer.get_info()
+ if (j > 0):
+ self.assertEqual(oldi, i)
+
+ i2: int = 0
+ k = 0
+
+ while True:
+ memoryContainer.set_info(1, m1)
+ memoryContainer.set_info(2, m2)
+ memoryContainer.set_info(3, m3)
+ i2: int = memoryContainer.get_info()
+
+ k += 1
+
+ if not (i2 == i and k < 100):
+ break
+
+ self.assertTrue(k != 100)
+
+ def test_min_policy_with_same_eval(self) -> None:
+ memoryContainer = MemoryContainer("MIN")
+ memoryContainer.setPolicy(Policy.MIN)
+ m1: int = memoryContainer.set_info(1, 0.2)
+ m2: int = memoryContainer.set_info(2, 0.2)
+ m3: int = memoryContainer.set_info(3, 0.2)
+ i = -1
+ oldi = 0
+ for j in range(10):
+ oldi = i
+ # Despite the choice is random, if no chance in I happens, it stays the same
+ i: int = memoryContainer.get_info()
+ if (j > 0):
+ self.assertEqual(oldi, i)
+
+ i2 = 0
+ k = 0
+ while True:
+ # Changing I will trigger a different choice, though !
+ memoryContainer.set_info(1, m1)
+ memoryContainer.set_info(2, m2)
+ memoryContainer.set_info(3, m3)
+ i2: int = memoryContainer.get_info()
+ k += 1
+ if not (i2 == i and k < 100):
+ break
+ self.assertTrue(k != 100)
+
+ def test_max_unique_policy(self) -> None:
+ memoryContainer = MemoryContainer("MAX")
+ memoryContainer.setPolicy(Policy.MAX)
+ memoryContainer.set_info(1)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 1)
+
+ def test_min_policy(self) -> None:
+ memoryContainer = MemoryContainer("MIN")
+ memoryContainer.setPolicy(Policy.MIN)
+ m1: int = memoryContainer.set_info(1, 0.2)
+ m2: int = memoryContainer.set_info(2, 0.4)
+ m3: int = memoryContainer.set_info(3, 0.8)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 1)
+ memoryContainer.set_evaluation(0.9)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 2)
+ memoryContainer.set_evaluation(0.9)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 3)
+ memoryContainer.set_evaluation(0.1, m1)
+ memoryContainer.set_evaluation(0.1, m2)
+ memoryContainer.set_evaluation(0.1, m3)
+ for k in range(20):
+ m: int = memoryContainer.get_info()
+ ver: bool = (m == 1 or m == 2 or m == 3)
+ self.assertEqual(ver, True)
+ # print("min: "+m)
+
+ memoryContainer.set_evaluation(0.2, m1)
+ for k in range(20):
+ m: int = memoryContainer.get_info()
+ ver: bool = (m == 2 or m == 3)
+ self.assertEqual(ver, True)
+ # print("min2: "+m)
+
+ def test_random_proportional_policy(self) -> None:
+ memoryContainer = MemoryContainer("RANDOMPROPORTIONAL")
+ memoryContainer.setPolicy(Policy.RANDOM_PROPORTIONA)
+ memoryContainer.set_info(1, 0.2) # 14 %
+ memoryContainer.set_info(2, 0.4) # 28 %
+ memoryContainer.set_info(3, 0.8) # 57 %
+ count = [0, 0, 0]
+ for i in range(1000):
+ j: int = memoryContainer.get_info()
+ count[j-1] += 1
+
+ # print("[0]: "+count[0]+" [1]: "+count[1]+" [2]: "+count[2])
+ self.assertEqual(count[0] < count[1], True)
+ self.assertEqual(count[1] < count[2], True)
+ memoryContainer.set_evaluation(0.8, 0)
+ memoryContainer.set_evaluation(0.4, 1)
+ memoryContainer.set_evaluation(0.2, 2)
+ count = int[3]
+ for i in range(1000):
+ j: int = memoryContainer.get_info()
+ count[j-1] += 1
+
+ # print("[0]: "+count[0]+" [1]: "+count[1]+" [2]: "+count[2])
+ self.assertEqual(count[0] > count[1], True)
+ self.assertEqual(count[1] > count[2], True)
+ memoryContainer.set_info(1, 0.5, 0)
+ memoryContainer.set_info(2, 0.0, 1)
+ memoryContainer.set_info(3, 0.0, 2)
+ for i in range(5):
+ j: int = memoryContainer.get_info()
+ self.assertEqual(j, 1)
+
+ memoryContainer.set_info(1, 0.0, 0)
+ memoryContainer.set_info(2, 0.5, 1)
+ memoryContainer.set_info(3, 0.0, 2)
+ for i in range(5):
+ j: int = memoryContainer.get_info()
+ self.assertEqual(j, 2)
+
+ memoryContainer.set_info(1, 0.0, 0)
+ memoryContainer.set_info(2, 0.0, 1)
+ memoryContainer.set_info(3, 0.5, 2)
+ for i in range(5):
+ j: int = memoryContainer.get_info()
+ self.assertEqual(j, 3)
+
+ memoryContainer.set_info(1, 0.0, 0)
+ memoryContainer.set_info(2, 0.0, 1)
+ memoryContainer.set_info(3, 0.0, 2)
+ count = int[3]
+ for i in range(30):
+ j: int = memoryContainer.get_info()
+ count[j-1] += 1
+
+ # print("[0]: "+count[0]+" [1]: "+count[1]+" [2]: "+count[2])
+ self.assertEqual(count[0] > 0, True)
+ self.assertEqual(count[1] > 0, True)
+ self.assertEqual(count[2] > 0, True)
+
+ def test_random_proportional_stable_policy(self) -> None:
+ memoryContainer = MemoryContainer("RANDOMPROPORTIONALSTABLE")
+ memoryContainer.setPolicy(Policy.RANDOM_PROPORTIONAL_STABLE)
+ n = memoryContainer.set_info(1, 0.2) # 14 %
+ memoryContainer.set_info(2, 0.4) # 28 %
+ memoryContainer.set_info(3, 0.8) # 57 %
+ count = [0, 0, 0]
+ first = 0
+ for i in range(1000):
+ j: int = memoryContainer.get_info()
+ if (i == 0):
+ first = j-1
+ count[j-1] += 1
+
+ # print("[0]: "+count[0]+" [1]: "+count[1]+" [2]: "+count[2]+" first:"+first)
+ for i in range(3):
+ if (i == first):
+ self.assertEqual(count[i] > 0, True)
+ else:
+ self.assertEqual(count[i] > 0, False)
+
+ count[0] = 0
+ count[1] = 0
+ count[2] = 0
+ for i in range(1000):
+ memoryContainer.set_info(1, 0.2, n)
+ j: int = memoryContainer.get_info()
+ count[j-1] += 1
+
+ # print("[0]: "+count[0]+" [1]: "+count[1]+" [2]: "+count[2])
+ self.assertEqual(count[0] < count[1], True)
+ self.assertEqual(count[1] < count[2], True)
+
+ def test_random_flat(self) -> None:
+ memoryContainer = MemoryContainer("RANDOMFLAT")
+ memoryContainer.setPolicy(Policy.RANDOM_FLAT)
+ memoryContainer.set_info(1, 0.2) # 14 %
+ memoryContainer.set_info(2, 0.4) # 28 %
+ memoryContainer.set_info(3, 0.8) # 57 %
+ count = [0, 0, 0]
+ for i in range(1000):
+ j: int = memoryContainer.get_info()
+ count[j-1] += 1
+
+ self.assertEqual(count[0] > 0, True)
+ self.assertEqual(count[1] > 0, True)
+ self.assertEqual(count[2] > 0, True)
+
+ def test_random_flat_stable(self) -> None:
+ memoryContainer = MemoryContainer("RANDOMFLATSTABLE")
+ memoryContainer.setPolicy(Policy.RANDOM_FLAT_STABLE)
+ n1 = memoryContainer.set_info(1, 0.2) # 14 %
+ memoryContainer.set_info(2, 0.4) # 28 %
+ memoryContainer.set_info(3, 0.8) # 57 %
+ count = [0, 0, 0]
+ first = 0
+ for i in range(1000):
+ j: int = memoryContainer.get_info()
+ if (i == 0):
+ first = j-1
+ count[j-1] += 1
+
+ for i in range(3):
+ if (i == first):
+ self.assertEqual(count[i] > 0, True)
+ else:
+ self.assertEqual(count[i] > 0, False)
+
+ count[0] = 0
+ count[1] = 0
+ count[2] = 0
+ for i in range(1000):
+ memoryContainer.set_info(1, 0.2, n1)
+ j: int = memoryContainer.get_info()
+ if (i == 0):
+ first = j-1
+ count[j-1] += 1
+
+ self.assertEqual(count[0] > 0, True)
+ self.assertEqual(count[1] > 0, True)
+ self.assertEqual(count[2] > 0, True)
+
+ def test_iterate_policy(self) -> None:
+ memoryContainer = MemoryContainer("ITERATE")
+ memoryContainer.setPolicy(Policy.ITERATE)
+ print("-- This test will raise a warning ...")
+ k: int = memoryContainer.get_info()
+ self.assertIsNone(k)
+ memoryContainer.set_info(1)
+ memoryContainer.set_info(2)
+ memoryContainer.set_info(3)
+ for i in range(9):
+ j: int = memoryContainer.get_info()
+ self.assertEqual(j, i % 3+1)
+
+ def test_get_evaluation(self) -> None:
+ memoryContainer = MemoryContainer("TEST")
+ self.assertEqual(memoryContainer.get(-1), None)
+ self.assertEqual(memoryContainer.get(0), None)
+ self.assertEqual(memoryContainer.get(10), None)
+ self.assertEqual(memoryContainer.get_name(), "TEST")
+ memoryContainer.set_name("TEST-NEW")
+ self.assertEqual(memoryContainer.get_name(), "TEST-NEW")
+ memoryContainer.setType("TEST-NEW")
+ self.assertEqual(memoryContainer.get_name(), "TEST-NEW")
+ # Testing the getEvaluation without any included MemoryObject
+ self.assertEqual(memoryContainer.get_evaluation(), None)
+ self.assertEqual(memoryContainer.get_evaluation(0), None)
+ self.assertEqual(memoryContainer.get_evaluation(1), None)
+ self.assertEqual(memoryContainer.getPolicy(), Policy.MAX)
+ res: float = memoryContainer.get_evaluation()
+ self.assertEqual(res, None)
+ memoryContainer.set_info(1)
+ memoryContainer.set_evaluation(0.5)
+ self.assertEqual(memoryContainer.get_evaluation(), 0.5)
+ self.assertEqual(memoryContainer.get_evaluation(0), 0.5)
+ memoryContainer.setPolicy(Policy.ITERATE)
+ self.assertEqual(memoryContainer.getPolicy(), Policy.ITERATE)
+ i: int = memoryContainer.get_info()
+ self.assertEqual(i, 1)
+ i: int = memoryContainer.getLastI()
+ self.assertEqual(i, 1)
+ mo: MemoryObject = memoryContainer.getLast()
+ i: int = mo.get_info()
+ self.assertEqual(i, 1)
+ memoryContainer.set_evaluation(0.6, 0)
+ self.assertEqual(memoryContainer.get_evaluation(), 0.6)
+ self.assertEqual(memoryContainer.get_evaluation(0), 0.6)
+
+ def test_get_timestamp(self) -> None:
+ memoryContainer = MemoryContainer("TEST")
+ # Without any initialization, the timestamp must be None
+ self.assertEqual(memoryContainer.get_timestamp(), None)
+ print("This test will raise a warning...")
+ self.assertEqual(memoryContainer.get_timestamp(0), None)
+ print("This test will raise a warning...")
+ self.assertEqual(memoryContainer.get_timestamp(1), None)
+ # after we initialize the container, the timestamp must be something different from None
+ memoryContainer.set_info(1)
+ self.assertEqual(memoryContainer.get_timestamp() != None, True)
+ self.assertEqual(memoryContainer.get_timestamp(0) != None, True)
+ # nevertheless, if we go further, it should remain None
+ print("This test will raise a warning...")
+ self.assertEqual(memoryContainer.get_timestamp(1), None)
+ self.assertEqual(memoryContainer.get(
+ 0).get_info(), memoryContainer.get_info())
+
+ def test_double_indirection(self) -> None:
+ mc1: MemoryContainer = MemoryContainer("TEST1")
+ mc2: MemoryContainer = MemoryContainer("TEST2")
+ mc2.set_info(0)
+ mc1.add(mc2)
+ self.assertEqual(mc1.get_info(), 0)
+ mc1.set_info(1, 0.5, 0)
+ self.assertEqual(mc1.get_info(), 1)
+ mc1.set_evaluation(0.6, 0)
+ self.assertEqual(mc1.get_evaluation(), 0.6)
diff --git a/tests/core/entities/MemoryObjectTest.py b/tests/core/entities/test_MemoryObjectTest.py
similarity index 100%
rename from tests/core/entities/MemoryObjectTest.py
rename to tests/core/entities/test_MemoryObjectTest.py
diff --git a/tests/core/entities/MemoryTest.py b/tests/core/entities/test_MemoryTest.py
similarity index 100%
rename from tests/core/entities/MemoryTest.py
rename to tests/core/entities/test_MemoryTest.py
diff --git a/tests/core/entities/RawMemoryTest.py b/tests/core/entities/test_RawMemoryTest.py
similarity index 100%
rename from tests/core/entities/RawMemoryTest.py
rename to tests/core/entities/test_RawMemoryTest.py
diff --git a/tests/core/entities/MindTest.py b/tests/core/entities/test_mind.py
similarity index 98%
rename from tests/core/entities/MindTest.py
rename to tests/core/entities/test_mind.py
index d23628d..3a44d81 100644
--- a/tests/core/entities/MindTest.py
+++ b/tests/core/entities/test_mind.py
@@ -4,7 +4,7 @@
from .utils import CodeletMock
-class MindTest(unittest.TestCase):
+class TestMind(unittest.TestCase):
def setUp(self) -> None:
self.test_codelet = CodeletMock()
self.mind = Mind()
From a61f87e8a0282bb2e0d8050ba6b699bec89693e7 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 11 Oct 2024 15:02:15 -0300
Subject: [PATCH 06/59] Test pipeline configuration
---
.github/workflows/pipeline-windows.yml | 33 -------------------
.../{pipeline-ubuntu.yml => test.yml} | 13 ++++----
2 files changed, 6 insertions(+), 40 deletions(-)
delete mode 100644 .github/workflows/pipeline-windows.yml
rename .github/workflows/{pipeline-ubuntu.yml => test.yml} (72%)
diff --git a/.github/workflows/pipeline-windows.yml b/.github/workflows/pipeline-windows.yml
deleted file mode 100644
index 253feaa..0000000
--- a/.github/workflows/pipeline-windows.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-name: evolvepy CI/CD
-on:
- push:
- branches: [ develop, main ]
- pull_request:
- branches: [ develop, main ]
-
-jobs:
- build:
-
- runs-on: windows-latest
- strategy:
- fail-fast: false
- matrix:
- python-version: ["3.7","3.8", "3.9", "3.10"]
-
- steps:
- - uses: actions/checkout@v2
- - name: Set up Python ${{ matrix.python-version }}
- uses: actions/setup-python@v2
- with:
- python-version: ${{ matrix.python-version }}
- - name: Install dependencies
- run: |
- python3 -m pip install --upgrade pip
- python3 -m pip install pytest
- if [ -f setup.cfg ]; then python3 -m pip install . ; fi
-
- - name: Test with pytest
- run: |
- cd ./test
- pytest
- shell: bash
\ No newline at end of file
diff --git a/.github/workflows/pipeline-ubuntu.yml b/.github/workflows/test.yml
similarity index 72%
rename from .github/workflows/pipeline-ubuntu.yml
rename to .github/workflows/test.yml
index c353c6a..6821505 100644
--- a/.github/workflows/pipeline-ubuntu.yml
+++ b/.github/workflows/test.yml
@@ -1,4 +1,4 @@
-name: evolvepy CI/CD
+name: Test
on:
push:
branches: [ develop, main ]
@@ -8,27 +8,26 @@ on:
jobs:
build:
- runs-on: ubuntu-latest
+ runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
- python-version: ["3.7","3.8", "3.9"]
+ os: [ubuntu-latest, windows-latest]
+ python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
steps:
- uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python-version }}
-
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python-version }}
-
- name: Install dependencies
run: |
python3 -m pip install --upgrade pip
python3 -m pip install pytest
- if [ -f setup.cfg ]; then python3 -m pip install . ; fi
+ python3 -m pip install .[tests]
- - name: Test with pytest
+ - name: Tests
run: |
pytest
shell: bash
\ No newline at end of file
From 6de63473836cfca63c7441fdff6bb244902b5721 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 11 Oct 2024 15:09:56 -0300
Subject: [PATCH 07/59] Update .gitignore
---
.gitignore | 164 +++++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 159 insertions(+), 5 deletions(-)
diff --git a/.gitignore b/.gitignore
index 895864c..efa407c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,162 @@
+# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
-*.pyc
-*.whl
-*.gz
-*.egg-info/
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
dist/
-build/
\ No newline at end of file
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+# For a library or package, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+# This is especially recommended for binary packages to ensure reproducibility, and is more
+# commonly ignored for libraries.
+# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+# in version control.
+# https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+# and can be added to the global gitignore or merged into this file. For a more nuclear
+# option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
\ No newline at end of file
From 01d714e88bf5ee68a1ea81e642dad43d650628a3 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 11 Oct 2024 15:30:06 -0300
Subject: [PATCH 08/59] Coverage check
---
.github/workflows/test.yml | 13 +++++++++----
.gitignore | 2 ++
tests/check_coverage.py | 8 ++++++++
3 files changed, 19 insertions(+), 4 deletions(-)
create mode 100644 tests/check_coverage.py
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 6821505..b497ad2 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -1,9 +1,9 @@
name: Test
on:
push:
- branches: [ develop, main ]
+ branches: [ dev, main ]
pull_request:
- branches: [ develop, main ]
+ branches: [ dev, main ]
jobs:
build:
@@ -25,9 +25,14 @@ jobs:
run: |
python3 -m pip install --upgrade pip
python3 -m pip install pytest
+ python3 -m pip install pytest-cov
python3 -m pip install .[tests]
- name: Tests
run: |
- pytest
- shell: bash
\ No newline at end of file
+ pytest --cov=cst_python --cov-report json
+ shell: bash
+
+ - name: Coverage Check
+ run: |
+ python3 tests/check_coverage.py
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index efa407c..d5e6f4c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+coverage.json
+
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
diff --git a/tests/check_coverage.py b/tests/check_coverage.py
new file mode 100644
index 0000000..044a576
--- /dev/null
+++ b/tests/check_coverage.py
@@ -0,0 +1,8 @@
+import json
+
+if __name__ == "__main__":
+
+ with open("coverage.json") as file:
+ coverage_info = json.load(file)
+
+ assert coverage_info["totals"]["percent_covered"] > 78
\ No newline at end of file
From 3e6c803e6978ac9af0e742b98eaf2aa235b74b3c Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 11 Oct 2024 15:36:28 -0300
Subject: [PATCH 09/59] Set coverage minimum to 75%
---
tests/check_coverage.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tests/check_coverage.py b/tests/check_coverage.py
index 044a576..7b59da5 100644
--- a/tests/check_coverage.py
+++ b/tests/check_coverage.py
@@ -5,4 +5,4 @@
with open("coverage.json") as file:
coverage_info = json.load(file)
- assert coverage_info["totals"]["percent_covered"] > 78
\ No newline at end of file
+ assert coverage_info["totals"]["percent_covered"] > 75
\ No newline at end of file
From d73f62b0cabe6fd464c1b67e57f21528ad9198d6 Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 18 Oct 2024 13:39:14 -0300
Subject: [PATCH 10/59] Introduction to CST
---
examples/Introduction to CST-Python.ipynb | 571 ++++++++++++++++++
setup.cfg | 3 +
tests/{core => cst_python}/__init__.py | 0
.../entities => cst_python/core}/__init__.py | 0
tests/cst_python/core/entities/__init__.py | 0
.../core/entities/test_CoalitionTest.py | 0
.../core/entities/test_CodeRackTest.py | 0
.../entities/test_CodeletContainerTest.py | 0
.../core/entities/test_CodeletTest.py | 0
.../entities/test_DisconnectedCodeletTest.py | 0
.../core/entities/test_MemoryBufferTest.py | 0
.../core/entities/test_MemoryContainerTest.py | 0
.../core/entities/test_MemoryObjectTest.py | 0
.../core/entities/test_MemoryTest.py | 0
.../core/entities/test_RawMemoryTest.py | 0
.../core/entities/test_mind.py | 0
tests/{ => cst_python}/core/entities/utils.py | 0
tests/examples/__init__.py | 0
.../test_introduction_to_cst_python.py | 38 ++
tests/utils.py | 11 +
20 files changed, 623 insertions(+)
create mode 100644 examples/Introduction to CST-Python.ipynb
rename tests/{core => cst_python}/__init__.py (100%)
rename tests/{core/entities => cst_python/core}/__init__.py (100%)
create mode 100644 tests/cst_python/core/entities/__init__.py
rename tests/{ => cst_python}/core/entities/test_CoalitionTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_CodeRackTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_CodeletContainerTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_CodeletTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_DisconnectedCodeletTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_MemoryBufferTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_MemoryContainerTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_MemoryObjectTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_MemoryTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_RawMemoryTest.py (100%)
rename tests/{ => cst_python}/core/entities/test_mind.py (100%)
rename tests/{ => cst_python}/core/entities/utils.py (100%)
create mode 100644 tests/examples/__init__.py
create mode 100644 tests/examples/test_introduction_to_cst_python.py
create mode 100644 tests/utils.py
diff --git a/examples/Introduction to CST-Python.ipynb b/examples/Introduction to CST-Python.ipynb
new file mode 100644
index 0000000..6c7439e
--- /dev/null
+++ b/examples/Introduction to CST-Python.ipynb
@@ -0,0 +1,571 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Introduction to CST-Python\n",
+ "\n",
+ "The CST (Cognitive Systems Toolkit) is a code toolkit for creating agents that implements Cognitive Architectures, that is, computational models of cognitive process in the mind of living beings. The core toolkit is the [Java CST](https://cst.fee.unicamp.br/), and CST-Python is a compatible implementation in Python.\n",
+ "\n",
+ "For building architectures, the CST defines three basic elements: Memory, Codelet and Mind, that will be presented in this tutorial."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Lets start by importing the CST-Python and other required modules:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "\n",
+ "import cst_python as cst"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Memories: storing data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The first element is the `Memory`. Memories are used to store data that are processed by the agent. That are many classes that implements the basic `Memory` class, but the most simple and used is the `MemoryObject`.\n",
+ "\n",
+ "Lets create one, and set it's name:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "memory = cst.MemoryObject()\n",
+ "\n",
+ "memory.set_name(\"My Memory\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can check that the MemoryObject is a type of Memory:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "tags": [
+ "check_interface"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "isinstance(memory, cst.core.entities.Memory)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Each Memory has a integer id, a unique identifier (that are some details about when the 'id' is really unique), and a name:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "tags": [
+ "basic_memory_members"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0, 'My Memory')"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "memory.get_id(), memory.get_name()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And a `info`, the information that memory is actually storing. Because we didn't set any info, the current is `None`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "tags": [
+ "check_empty_memory"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "memory.get_info() is None"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's set a info. They can be any variable of any type:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "tags": [
+ "set_info"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "memory.set_info(\"My Memory's data\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can now see that the stored info changed. Also, each Memory has a `timestamp`, they store the time when the memory's info have changed:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "tags": [
+ "check_info_change"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(\"My Memory's data\", 1729269027698)"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "memory.get_info(), memory.get_timestamp()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Codelets: cognitive processes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "But, a agent can't do nothing with only data. `Codelets` are elements of the architecture that process data, executing the agent's cognitive processes.\n",
+ "\n",
+ "Each Codelet can have some input and output memories. They can also be local or global, we will only use local inputs/outputs in this example."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For creating a codelet, we need to define the methods:\n",
+ "- `access_memory_objects`: gets all the memories the codelet is going to use, localizable by name.\n",
+ "- `calculate_activation`: computes the codelet's activation. We are not going to use this now.\n",
+ "- `proc`: the actual function that the codelet performs, reading from the inputs, processing and setting the outputs."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Our first codelet is going to read a input value, adding one and sending this value to other memory:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class MyFirstCodelet(cst.Codelet):\n",
+ "\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " self._input_mo : cst.MemoryObject | None = None\n",
+ " self._output_mo : cst.MemoryObject | None = None\n",
+ "\n",
+ "\n",
+ " def access_memory_objects(self):\n",
+ " self._input_mo = self.get_input(name=\"InputMemory\")\n",
+ " self._output_mo = self.get_output(name=\"OutputMemory\")\n",
+ "\n",
+ " def calculate_activation(self):\n",
+ " pass\n",
+ "\n",
+ " def proc(self):\n",
+ " read_value : float = self._input_mo.get_info()\n",
+ " \n",
+ " output_value = read_value + 1\n",
+ "\n",
+ " self._output_mo.set_info(output_value)\n",
+ "\n",
+ "my_first_codelet = MyFirstCodelet()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Before we can use the codelet, we need to create and add it's input and output, and execute `access_memory_objects`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "input_memory = cst.MemoryObject()\n",
+ "input_memory.set_name(\"InputMemory\")\n",
+ "\n",
+ "output_memory = cst.MemoryObject()\n",
+ "output_memory.set_name(\"OutputMemory\")\n",
+ "\n",
+ "my_first_codelet.add_input(input_memory)\n",
+ "my_first_codelet.add_output(output_memory)\n",
+ "\n",
+ "my_first_codelet.access_memory_objects()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Lets test it by setting the info, running the `proc` and checking if the output value is correct:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "tags": [
+ "check_codelet_working"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "input_memory.set_info(0)\n",
+ "\n",
+ "my_first_codelet.proc()\n",
+ "\n",
+ "output_memory.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Mind: organizing everything"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can create all the data and cognitive process of the agent, but they need to be manually managed.\n",
+ "\n",
+ "The `Mind` element contains all the memories in its `RawMemory` and all the codelets in its `Coderack`. It also manage the execution of all the codelets and is the expected way to create an agent with CST."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Lets create a Mind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mind = cst.Mind()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Using a Mind, all the MemoryObjects need to be create by it (now each memory is guaranteed to have a unique id). We can also pass a default value, in this case `0` to the \"InputMemory\":"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "input_memory = mind.create_memory_object(\"InputMemory\", 0)\n",
+ "output_memory = mind.create_memory_object(\"OutputMemory\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We create the codelet and add it's inputs and outputs as before:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "my_first_codelet = MyFirstCodelet()\n",
+ "my_first_codelet.add_input(input_memory)\n",
+ "my_first_codelet.add_output(output_memory)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "But now insert it into the Mind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<__main__.MyFirstCodelet at 0x1a3cef18f10>"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mind.insert_codelet(my_first_codelet)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When running using a Mind, it will run each codelet in a separated thread at a fixed rate. The default `time step` is 300 ms. Lets change it to 100 ms for a faster execution:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "my_first_codelet.time_step = 100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `start` method start the Mind and the execution of all the codelets:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mind.start()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "After waiting our codelet run by 110 ms, we can check the added value in the ouput memory: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "tags": [
+ "check_mind_scheduling"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "time.sleep(0.110)\n",
+ "\n",
+ "output_memory.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can also change the input memory, wait and check the modified value in the output:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "tags": [
+ "example_change_memory"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "124"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "input_memory.set_info(123)\n",
+ "\n",
+ "time.sleep(0.110)\n",
+ "\n",
+ "output_memory.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `shutdown` method stops the execution of the Mind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mind.shutdown()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/setup.cfg b/setup.cfg
index 50a2a2d..c2b9063 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -28,3 +28,6 @@ packages = find:
[options.packages.find]
where = src
+
+[options.extras_require]
+tests = mypy; testbook; ipython; ipykernel
\ No newline at end of file
diff --git a/tests/core/__init__.py b/tests/cst_python/__init__.py
similarity index 100%
rename from tests/core/__init__.py
rename to tests/cst_python/__init__.py
diff --git a/tests/core/entities/__init__.py b/tests/cst_python/core/__init__.py
similarity index 100%
rename from tests/core/entities/__init__.py
rename to tests/cst_python/core/__init__.py
diff --git a/tests/cst_python/core/entities/__init__.py b/tests/cst_python/core/entities/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/core/entities/test_CoalitionTest.py b/tests/cst_python/core/entities/test_CoalitionTest.py
similarity index 100%
rename from tests/core/entities/test_CoalitionTest.py
rename to tests/cst_python/core/entities/test_CoalitionTest.py
diff --git a/tests/core/entities/test_CodeRackTest.py b/tests/cst_python/core/entities/test_CodeRackTest.py
similarity index 100%
rename from tests/core/entities/test_CodeRackTest.py
rename to tests/cst_python/core/entities/test_CodeRackTest.py
diff --git a/tests/core/entities/test_CodeletContainerTest.py b/tests/cst_python/core/entities/test_CodeletContainerTest.py
similarity index 100%
rename from tests/core/entities/test_CodeletContainerTest.py
rename to tests/cst_python/core/entities/test_CodeletContainerTest.py
diff --git a/tests/core/entities/test_CodeletTest.py b/tests/cst_python/core/entities/test_CodeletTest.py
similarity index 100%
rename from tests/core/entities/test_CodeletTest.py
rename to tests/cst_python/core/entities/test_CodeletTest.py
diff --git a/tests/core/entities/test_DisconnectedCodeletTest.py b/tests/cst_python/core/entities/test_DisconnectedCodeletTest.py
similarity index 100%
rename from tests/core/entities/test_DisconnectedCodeletTest.py
rename to tests/cst_python/core/entities/test_DisconnectedCodeletTest.py
diff --git a/tests/core/entities/test_MemoryBufferTest.py b/tests/cst_python/core/entities/test_MemoryBufferTest.py
similarity index 100%
rename from tests/core/entities/test_MemoryBufferTest.py
rename to tests/cst_python/core/entities/test_MemoryBufferTest.py
diff --git a/tests/core/entities/test_MemoryContainerTest.py b/tests/cst_python/core/entities/test_MemoryContainerTest.py
similarity index 100%
rename from tests/core/entities/test_MemoryContainerTest.py
rename to tests/cst_python/core/entities/test_MemoryContainerTest.py
diff --git a/tests/core/entities/test_MemoryObjectTest.py b/tests/cst_python/core/entities/test_MemoryObjectTest.py
similarity index 100%
rename from tests/core/entities/test_MemoryObjectTest.py
rename to tests/cst_python/core/entities/test_MemoryObjectTest.py
diff --git a/tests/core/entities/test_MemoryTest.py b/tests/cst_python/core/entities/test_MemoryTest.py
similarity index 100%
rename from tests/core/entities/test_MemoryTest.py
rename to tests/cst_python/core/entities/test_MemoryTest.py
diff --git a/tests/core/entities/test_RawMemoryTest.py b/tests/cst_python/core/entities/test_RawMemoryTest.py
similarity index 100%
rename from tests/core/entities/test_RawMemoryTest.py
rename to tests/cst_python/core/entities/test_RawMemoryTest.py
diff --git a/tests/core/entities/test_mind.py b/tests/cst_python/core/entities/test_mind.py
similarity index 100%
rename from tests/core/entities/test_mind.py
rename to tests/cst_python/core/entities/test_mind.py
diff --git a/tests/core/entities/utils.py b/tests/cst_python/core/entities/utils.py
similarity index 100%
rename from tests/core/entities/utils.py
rename to tests/cst_python/core/entities/utils.py
diff --git a/tests/examples/__init__.py b/tests/examples/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/examples/test_introduction_to_cst_python.py b/tests/examples/test_introduction_to_cst_python.py
new file mode 100644
index 0000000..782db9c
--- /dev/null
+++ b/tests/examples/test_introduction_to_cst_python.py
@@ -0,0 +1,38 @@
+import os
+import json
+
+from testbook import testbook
+from testbook.client import TestbookNotebookClient
+
+from ..utils import get_examples_path
+
+examples_path = get_examples_path()
+
+@testbook(os.path.join(examples_path, "Introduction to CST-Python.ipynb"), execute=True)
+def test_introduction(tb :TestbookNotebookClient):
+ result = tb.cell_output_text("check_interface")
+ assert result == "True"
+
+ result = tb.cell_output_text("basic_memory_members")
+ assert result == "(0, 'My Memory')"
+
+ result = tb.cell_output_text("check_empty_memory")
+ assert result == "True"
+
+ result = tb.cell_output_text("set_info")
+ assert result == "-1"
+
+ result = tb.cell_output_text("check_info_change")
+ result = eval(result)
+ assert result[0] == "My Memory's data"
+
+ result = tb.cell_output_text("check_codelet_working")
+ assert result == "1"
+
+ result = tb.cell_output_text("check_mind_scheduling")
+ assert result == "1"
+
+ result = tb.cell_output_text("example_change_memory")
+ assert result == "124"
+
+
diff --git a/tests/utils.py b/tests/utils.py
new file mode 100644
index 0000000..600c85f
--- /dev/null
+++ b/tests/utils.py
@@ -0,0 +1,11 @@
+import os
+import pathlib
+
+
+def get_repository_path():
+ repository_path = pathlib.Path(__file__).parent.parent.resolve()
+ return repository_path
+
+def get_examples_path():
+ examples_path = os.path.join(get_repository_path(), "examples")
+ return examples_path
\ No newline at end of file
From dc2b288103b388855aca624f02765cbe2663acad Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 18 Oct 2024 14:47:59 -0300
Subject: [PATCH 11/59] Fix questions about introduction
---
examples/Introduction to CST-Python.ipynb | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/examples/Introduction to CST-Python.ipynb b/examples/Introduction to CST-Python.ipynb
index 6c7439e..857941c 100644
--- a/examples/Introduction to CST-Python.ipynb
+++ b/examples/Introduction to CST-Python.ipynb
@@ -224,7 +224,7 @@
"source": [
"But, a agent can't do nothing with only data. `Codelets` are elements of the architecture that process data, executing the agent's cognitive processes.\n",
"\n",
- "Each Codelet can have some input and output memories. They can also be local or global, we will only use local inputs/outputs in this example."
+ "Each Codelet can have any number of inputs and outputs memories. They can also be local or global, we will only use local inputs/outputs in this example."
]
},
{
@@ -234,7 +234,9 @@
"For creating a codelet, we need to define the methods:\n",
"- `access_memory_objects`: gets all the memories the codelet is going to use, localizable by name.\n",
"- `calculate_activation`: computes the codelet's activation. We are not going to use this now.\n",
- "- `proc`: the actual function that the codelet performs, reading from the inputs, processing and setting the outputs."
+ "- `proc`: the actual function that the codelet performs, reading from the inputs, processing and setting the outputs.\n",
+ "\n",
+ "It is important to note that the codelet should only get inputs in the `access_memory_objects`, not in `proc`. The content of the memories (info) can be accessed everywhere."
]
},
{
From 2065cb3f29931867de37ec39b40839d82c1331fc Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 18 Oct 2024 16:05:03 -0300
Subject: [PATCH 12/59] Add shape library
---
resources/CST-Library.xml | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
create mode 100644 resources/CST-Library.xml
diff --git a/resources/CST-Library.xml b/resources/CST-Library.xml
new file mode 100644
index 0000000..cbcc92b
--- /dev/null
+++ b/resources/CST-Library.xml
@@ -0,0 +1,22 @@
+[
+ {
+ "xml": "<mxGraphModel><root><mxCell id=\"0\"/><mxCell id=\"1\" parent=\"0\"/><mxCell id=\"2\" value=\"\" style=\"group\" vertex=\"1\" connectable=\"0\" parent=\"1\"><mxGeometry width=\"163\" height=\"60\" as=\"geometry\"/></mxCell><mxCell id=\"3\" value=\"<font style="font-size: 12px">Behavioral<br>Codelet</font>\" style=\"rounded=1;whiteSpace=wrap;html=1;strokeWidth=3;fillColor=#ffcc99;strokeColor=#36393d;\" vertex=\"1\" parent=\"2\"><mxGeometry x=\"15.49647887323944\" width=\"132.00704225352115\" height=\"60\" as=\"geometry\"/></mxCell><mxCell id=\"4\" value=\"<font style="font-size: 8px;">O</font>\" style=\"whiteSpace=wrap;html=1;strokeWidth=2;fillColor=#ffcccc;strokeColor=#36393d;fontSize=8;\" vertex=\"1\" parent=\"2\"><mxGeometry x=\"147.50352112676057\" y=\"9.999999999999998\" width=\"15.49647887323944\" height=\"15\" as=\"geometry\"/></mxCell><mxCell id=\"5\" value=\"<font style="font-size: 8px;">A</font>\" style=\"whiteSpace=wrap;html=1;strokeWidth=2;fillColor=#ffcccc;strokeColor=#36393d;fontSize=8;\" vertex=\"1\" parent=\"2\"><mxGeometry x=\"147.50352112676057\" y=\"34.99999999999999\" width=\"15.49647887323944\" height=\"15\" as=\"geometry\"/></mxCell><mxCell id=\"6\" value=\"<font style="font-size: 8px; line-height: 120%;">LI</font>\" style=\"whiteSpace=wrap;html=1;strokeWidth=2;fillColor=#ffcccc;strokeColor=#36393d;verticalAlign=middle;spacing=0;fontSize=8;\" vertex=\"1\" parent=\"2\"><mxGeometry y=\"9.999999999999998\" width=\"15.49647887323944\" height=\"15\" as=\"geometry\"/></mxCell><mxCell id=\"7\" value=\"<font style="font-size: 8px;">GI</font>\" style=\"whiteSpace=wrap;html=1;strokeWidth=2;fillColor=#ffcccc;strokeColor=#36393d;fontSize=8;\" vertex=\"1\" parent=\"2\"><mxGeometry y=\"34.99999999999999\" width=\"15.49647887323944\" height=\"15\" as=\"geometry\"/></mxCell></root></mxGraphModel>",
+ "w": 163,
+ "h": 60
+ },
+ {
+ "xml": "<mxGraphModel><root><mxCell id=\"0\"/><mxCell id=\"1\" parent=\"0\"/><mxCell id=\"2\" value=\"<font style="font-size: 11px">Memory Object<br></font>\" style=\"ellipse;whiteSpace=wrap;html=1;strokeColor=#36393d;strokeWidth=2;fillColor=#ffff88;fontSize=8;align=center;verticalAlign=top;labelPosition=center;verticalLabelPosition=bottom;\" vertex=\"1\" parent=\"1\"><mxGeometry width=\"57\" height=\"60\" as=\"geometry\"/></mxCell></root></mxGraphModel>",
+ "w": 57,
+ "h": 60
+ },
+ {
+ "xml": "<mxGraphModel><root><mxCell id=\"0\"/><mxCell id=\"1\" parent=\"0\"/><mxCell id=\"2\" value=\"<font style="font-size: 11px">Memory Object</font><br>\" style=\"ellipse;shape=doubleEllipse;whiteSpace=wrap;html=1;strokeColor=#36393d;strokeWidth=2;fillColor=#ffff88;fontSize=10;align=center;verticalAlign=top;labelPosition=center;verticalLabelPosition=bottom;\" vertex=\"1\" parent=\"1\"><mxGeometry width=\"70\" height=\"75\" as=\"geometry\"/></mxCell></root></mxGraphModel>",
+ "w": 70,
+ "h": 75
+ },
+ {
+ "xml": "<mxGraphModel><root><mxCell id=\"0\"/><mxCell id=\"1\" parent=\"0\"/><mxCell id=\"2\" value=\"<div align="center"><font style="font-size: 18px">Working Memory</font><br></div>\" style=\"rounded=1;whiteSpace=wrap;html=1;strokeWidth=2;fillColor=#CFE7F5;dashed=1;strokeColor=#3465A4;verticalAlign=top;align=center;spacingLeft=0;\" vertex=\"1\" parent=\"1\"><mxGeometry width=\"331\" height=\"290\" as=\"geometry\"/></mxCell></root></mxGraphModel>",
+ "w": 331,
+ "h": 290
+ }
+]
\ No newline at end of file
From 321b63b853e75cbf24dd866de277e63ddc500cdd Mon Sep 17 00:00:00 2001
From: Elton Cardoso do Nascimento <43186596+EltonCN@users.noreply.github.com>
Date: Fri, 18 Oct 2024 16:30:58 -0300
Subject: [PATCH 13/59] Example: Implementing a Architecture
---
examples/Implementing a Architecture.ipynb | 513 ++++++++++++++++++
.../.$diagram.drawio.bkp | 10 +
.../Implementing a Architecture/Codelet.png | Bin 0 -> 10321 bytes
.../MemoryGroup.png | Bin 0 -> 55033 bytes
.../MemoryObject.png | Bin 0 -> 12687 bytes
.../SimpleDiagram.png | Bin 0 -> 32581 bytes
.../diagram.drawio | 213 ++++++++
.../Implementing a Architecture/diagram.png | Bin 0 -> 198751 bytes
.../test_implementing_a_architecture.py | 37 ++
9 files changed, 773 insertions(+)
create mode 100644 examples/Implementing a Architecture.ipynb
create mode 100644 examples/Implementing a Architecture/.$diagram.drawio.bkp
create mode 100644 examples/Implementing a Architecture/Codelet.png
create mode 100644 examples/Implementing a Architecture/MemoryGroup.png
create mode 100644 examples/Implementing a Architecture/MemoryObject.png
create mode 100644 examples/Implementing a Architecture/SimpleDiagram.png
create mode 100644 examples/Implementing a Architecture/diagram.drawio
create mode 100644 examples/Implementing a Architecture/diagram.png
create mode 100644 tests/examples/test_implementing_a_architecture.py
diff --git a/examples/Implementing a Architecture.ipynb b/examples/Implementing a Architecture.ipynb
new file mode 100644
index 0000000..6767f18
--- /dev/null
+++ b/examples/Implementing a Architecture.ipynb
@@ -0,0 +1,513 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Implementing a Architecture\n",
+ "\n",
+ "A cognitive architecture in the CST is implemented using a combination of Codelets and Memories inside a Mind. Each Codelet will communicate with the others using only the Memories."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Diagrams\n",
+ "\n",
+ "Before implementing the code, it is common to prepare a diagram describing all the elements of the architecture.\n",
+ "\n",
+ "For that, it is defined a visual language:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The **Codelet** symbol:\n",
+ "\n",
+ "\n",
+ "\n",
+ "The string inside the symbol is the Codelet name. The left ports are its inputs, the _local input (LI)_ and the _global input (GI)_, and the right ports its outputs, the _standard output (O)_ and the _activation level (A)_. The LI and A ports will be discussed in later examples."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The Memory Object symbol:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So, if we have a Codelet \"My Codelet\", that reads from \"Input Memory\" and writes to \"Output Memory\", the diagram is going to be:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Its also possible to group memories in a _Memory Group_:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For creating a diagram, a [draw.io](https://www.drawio.com/) shape library is provided: [shape library](https://github.com/H-IAAC/CST-Python/blob/2065cb3f29931867de37ec39b40839d82c1331fc/resources/CST-Library.xml)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Example architecture"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Our example architecture is going to solve a simple quadratic equation in the form $ax^2+bx+c=0$.\n",
+ "\n",
+ "For that, the equation parameters $a$, $b$ and $c$ will be stored in Memory Objects, two \"SolveEquation\" will solve the equation computing the two different solutions, and a final \"JoinResults\" codelet will join each result to a final memory:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For that, we start importing the necessary modules:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math # Math operations\n",
+ "import time # Sleep\n",
+ "\n",
+ "import cst_python as cst # CST-Python module"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And we can implement the `SolveEquationCodelet` using the quadratic formula. Note that the codelet can receive two parameters: if should compute the second solution (`negative`), and the output memory name `output_name`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class SolveEquationCodelet(cst.Codelet):\n",
+ "\n",
+ " def __init__(self, negative:bool=False, output_name:str=\"x\"):\n",
+ " super().__init__()\n",
+ "\n",
+ " self._negative = negative\n",
+ " self._output_name = output_name\n",
+ "\n",
+ " self._a_mo : None | cst.MemoryObject = None\n",
+ " self._b_mo : None | cst.MemoryObject = None\n",
+ " self._c_mo : None | cst.MemoryObject = None\n",
+ " self._x_mo : None | cst.MemoryObject = None\n",
+ "\n",
+ " def access_memory_objects(self):\n",
+ " self._a_mo = self.get_input(name=\"a\")\n",
+ " self._b_mo = self.get_input(name=\"b\")\n",
+ " self._c_mo = self.get_input(name=\"c\")\n",
+ "\n",
+ " self._x_mo = self.get_output(name=self._output_name)\n",
+ "\n",
+ " def calculate_activation(self):\n",
+ " pass\n",
+ "\n",
+ " def proc(self):\n",
+ " a = self._a_mo.get_info()\n",
+ " b = self._b_mo.get_info()\n",
+ " c = self._c_mo.get_info()\n",
+ "\n",
+ " delta = math.pow(b, 2) - (4*a*c)\n",
+ " delta_sqrt = math.sqrt(delta)\n",
+ "\n",
+ " if self._negative:\n",
+ " delta_sqrt *= -1\n",
+ " \n",
+ " if a == 0:\n",
+ " if b == 0:\n",
+ " x = float(\"nan\")\n",
+ " else:\n",
+ " x = -c/b\n",
+ " else: \n",
+ " x = (-b + delta_sqrt)/(2*a)\n",
+ "\n",
+ " self._x_mo.set_info(x)\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `JoinResultsCodelet` is going to get all its inputs and send to a unified result:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class JoinResultsCodelet(cst.Codelet):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self._result_mo : None | cst.MemoryObject = None\n",
+ "\n",
+ " def access_memory_objects(self):\n",
+ " self._result_mo = self.get_output(name=\"result\")\n",
+ "\n",
+ " def calculate_activation(self):\n",
+ " pass\n",
+ "\n",
+ " def proc(self):\n",
+ " result = []\n",
+ "\n",
+ " for input_mo in self.inputs:\n",
+ " result.append(input_mo.get_info())\n",
+ "\n",
+ " self._result_mo.set_info(result)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that we have all the codelets defined, we can start creating the agent mind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mind = cst.Mind()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Starting with the memories, observe that the Memory Groups defined in the diagram is created using a `mind.create_memory_group`, and each memory is assigned to the group using `register_memory`, and that each memory starting info is defined (instead of `None`) to avoid exceptions inside the codelets:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Input\n",
+ "\n",
+ "mind.create_memory_group(\"Input\")\n",
+ "\n",
+ "a_mo = mind.create_memory_object(\"a\", 0)\n",
+ "b_mo = mind.create_memory_object(\"b\", 0)\n",
+ "c_mo = mind.create_memory_object(\"c\", 0)\n",
+ "\n",
+ "mind.register_memory(a_mo, \"Input\")\n",
+ "mind.register_memory(b_mo, \"Input\")\n",
+ "mind.register_memory(c_mo, \"Input\")\n",
+ "\n",
+ "# Working Memory\n",
+ "\n",
+ "mind.create_memory_group(\"Working Memory\")\n",
+ "\n",
+ "x1_mo = mind.create_memory_object(\"x1\", 0)\n",
+ "x2_mo = mind.create_memory_object(\"x2\", 0)\n",
+ "\n",
+ "mind.register_memory(x1_mo, \"Working Memory\")\n",
+ "mind.register_memory(x2_mo, \"Working Memory\")\n",
+ "\n",
+ "# Output\n",
+ "\n",
+ "mind.create_memory_group(\"Output\")\n",
+ "\n",
+ "result_mo = mind.create_memory_object(\"result\")\n",
+ "\n",
+ "mind.register_memory(result_mo, \"Output\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We than create the SolveEquationCodelets:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solve_equation1 = SolveEquationCodelet(output_name=\"x1\")\n",
+ "solve_equation2 = SolveEquationCodelet(output_name=\"x2\", negative=True)\n",
+ "\n",
+ "solve_equation1.add_inputs([a_mo, b_mo, c_mo])\n",
+ "solve_equation2.add_inputs([a_mo, b_mo, c_mo])\n",
+ "\n",
+ "solve_equation1.add_output(x1_mo)\n",
+ "solve_equation2.add_output(x2_mo)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And the JoinResultsCodelet:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "join_results = JoinResultsCodelet()\n",
+ "\n",
+ "join_results.add_inputs([x1_mo, x2_mo])\n",
+ "join_results.add_output(result_mo)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, we can add the codelets to the mind and start it. Before that, we change the time step of each codelet to 10 ms:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solve_equation1.time_step = 10\n",
+ "solve_equation2.time_step = 10\n",
+ "join_results.time_step = 10\n",
+ "\n",
+ "mind.insert_codelet(solve_equation1)\n",
+ "mind.insert_codelet(solve_equation2)\n",
+ "mind.insert_codelet(join_results)\n",
+ "\n",
+ "mind.start()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can check the initial result for the equation $0x^2+0x+c = 0$, that is unsovable equation: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "tags": [
+ "equation1"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[nan, nan]"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "result_mo.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can than change the input values to solve different equations:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "$1x^2 = 0$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "tags": [
+ "equation2"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0.0, 0.0]"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a_mo.set_info(1)\n",
+ "\n",
+ "time.sleep(0.020)\n",
+ "\n",
+ "result_mo.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "$-4x^2+8x+0=0$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "tags": [
+ "equation3"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[-0.0, 2.0]"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a_mo.set_info(-4)\n",
+ "b_mo.set_info(8)\n",
+ "c_mo.set_info(0)\n",
+ "\n",
+ "time.sleep(0.020)\n",
+ "\n",
+ "result_mo.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "$5x^2-6x+9=0$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "tags": [
+ "equation4"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[3.0, 3.0]"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a_mo.set_info(1)\n",
+ "b_mo.set_info(-6)\n",
+ "c_mo.set_info(9)\n",
+ "\n",
+ "time.sleep(0.020)\n",
+ "\n",
+ "result_mo.get_info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In the end, we stop the agent mind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mind.shutdown()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/Implementing a Architecture/.$diagram.drawio.bkp b/examples/Implementing a Architecture/.$diagram.drawio.bkp
new file mode 100644
index 0000000..d5b56be
--- /dev/null
+++ b/examples/Implementing a Architecture/.$diagram.drawio.bkp
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/examples/Implementing a Architecture/Codelet.png b/examples/Implementing a Architecture/Codelet.png
new file mode 100644
index 0000000000000000000000000000000000000000..58e8abada5532afac5ae7a55e7ec9d25d3009216
GIT binary patch
literal 10321
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