feat: local mock test

README.md

@@ -1 +1,3 @@
+# python-sdk-patterns
 
+Abstractions on top of the Python SDK for Flame   

flame/star/__init__.py

@@ -1,3 +1,4 @@
 from flame.star.star_model import StarModel
 from flame.star.analyzer_client import Analyzer as StarAnalyzer
 from flame.star.aggregator_client import Aggregator as StarAggregator
+from flame.star.star_model_tester import StarModelTester

flame/star/aggregator_client.py

@@ -1,26 +1,27 @@
 from abc import abstractmethod
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from flamesdk import FlameCoreSDK
 from flame.star.node_base_client import Node
+from flame.utils.mock_flame_core import MockFlameCoreSDK
 
 
 class Aggregator(Node):
 
-    def __init__(self, flame: FlameCoreSDK) -> None:
-        if flame.config.node_role != 'aggregator':
-            raise ValueError(f'Attempted to initialize aggregator node with mismatching configuration '
-                             f'(expected: node_role="aggregator", received="{flame.config.node_role}").')
+    def __init__(self, flame: Union[FlameCoreSDK, MockFlameCoreSDK]) -> None:
         super().__init__(flame)
+        if self.role != 'aggregator':
+            raise ValueError(f'Attempted to initialize aggregator node with mismatching configuration '
+                             f'(expected: node_role="aggregator", received="{self.role}").')
 
     def aggregate(self, node_results: list[Any], simple_analysis: bool = True) -> tuple[Any, bool]:
         result = self.aggregation_method(node_results)
 
         if not simple_analysis:
-            if self.latest_result is None:
-                converged = False
+            if self.num_iterations != 0:
+                converged = self.has_converged(result, self.latest_result)
             else:
-                converged = self.has_converged(result, self.latest_result, self.num_iterations)
+                converged = False
         else:
             converged = True
 
@@ -32,15 +33,15 @@ def aggregate(self, node_results: list[Any], simple_analysis: bool = True) -> tu
     @abstractmethod
     def aggregation_method(self, analysis_results: list[Any]) -> Any:
         """
-        This method will be used to aggregate the data. It has to be overridden.
+        This method will be used to aggregate the data. It has to be overwritten.
         :return: aggregated_result
         """
         pass
 
     @abstractmethod
-    def has_converged(self, result: Any, last_result: Optional[Any], num_iterations: int) -> bool:
+    def has_converged(self, result: Any, last_result: Optional[Any]) -> bool:
         """
-        This method will be used to check if the aggregator has converged. It has to be overridden.
+        This method will be used to check if the aggregator has converged. It has to be overwritten.
         :return: converged
         """
         pass

flame/star/analyzer_client.py

@@ -1,33 +1,31 @@
 from abc import abstractmethod
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from flamesdk import FlameCoreSDK
 from flame.star.node_base_client import Node
+from flame.utils.mock_flame_core import MockFlameCoreSDK
 
 
 class Analyzer(Node):
 
-    def __init__(self, flame: FlameCoreSDK) -> None:
-        if flame.config.node_role != 'default':
-            raise ValueError(f'Attempted to initialize analyzer node with mismatching configuration '
-                             f'(expected: node_mode="default", received="{flame.config.node_role}").')
+    def __init__(self, flame: Union[FlameCoreSDK, MockFlameCoreSDK]) -> None:
         super().__init__(flame)
+        if self.role != 'default':
+            raise ValueError(f'Attempted to initialize analyzer node with mismatching configuration '
+                             f'(expected: node_mode="default", received="{self.role}").')
 
-    def analyze(self,
-                data: list[Any],
-                aggregator_results: Optional[str],
-                simple_analysis: bool = True) -> tuple[Any, bool]:
-        result = self.analysis_method(data, aggregator_results)
+    def analyze(self, data: list[Any]) -> Any:
+        result = self.analysis_method(data, self.latest_result)
 
         self.latest_result = result
         self.num_iterations += 1
 
-        return self.latest_result, simple_analysis
+        return self.latest_result
 
     @abstractmethod
     def analysis_method(self, data: list[Any], aggregator_results: Optional[Any]) -> Any:
         """
-        This method will be used to analyze the data. It has to be overridden.
+        This method will be used to analyze the data. It has to be overwritten.
 
         The parameter data will be formatted like this:
             [list element for every registered data source

flame/star/node_base_client.py

@@ -1,18 +1,12 @@
 from typing import Any, Literal, Optional
-from enum import Enum
 
 from flamesdk import FlameCoreSDK
 
 
-class NodeStatus(Enum):
-    STARTED = "Analysis/Aggregation undergoing"
-    FINISHED = "Results sent"
-
-
 class Node:
     id: str
     role: Literal["default", "aggregator"]
-    status: str
+    finished: bool
     latest_result: Optional[Any]
     partner_node_ids: list[str]
     num_iterations: int
@@ -21,12 +15,26 @@ class Node:
     def __init__(self, flame: FlameCoreSDK):
         self.flame = flame
 
-        self.id = self.flame.config.node_id
-        self.role = self.flame.config.node_role
-        self.status = NodeStatus.STARTED.value
+        self.id = self.flame.get_id()
+        self.role = self.flame.get_role()
+        self.finished = False
         self.latest_result = None
         self.partner_node_ids = self.flame.get_participant_ids()
         self.num_iterations: int = 0
 
     def node_finished(self):
-        self.status = NodeStatus.FINISHED.value
+        self.finished = True
+
+    def set_num_iterations(self, num_iterations: int) -> None:
+        """
+        This method sets the number of iterations completed by the aggregator.
+        :param num_iterations: Number of iterations to set.
+        """
+        self.num_iterations = num_iterations
+
+    def set_latest_result(self, latest_result: Any) -> None:
+        """
+        This method sets the latest result of the aggregator.
+        :param latest_result: Latest result to set.
+        """
+        self.latest_result = latest_result