Merge pull request #2 from PySATL/feature/result-store

Summary: Make Result Store be more abstract

Author: alex98247

stattest/experiment/configuration/configuration.py

@@ -1,6 +1,7 @@
 from stattest.experiment.generator import AbstractRVSGenerator
 from stattest.experiment.hypothesis import AbstractHypothesis
 from stattest.persistence import ICriticalValueStore, IRvsStore
+from stattest.persistence.models import IResultStore
 from stattest.test import AbstractTestStatistic
 
 
@@ -33,17 +34,12 @@ def execute(
     ) -> TestWorkerResult:
         pass
 
-    def save_result(self, result: TestWorkerResult):
+    def build_id(self, test: AbstractTestStatistic, data: [[float]], code, size: int) -> str:
         pass
 
 
 class ReportConfiguration:
-    def __init__(
-        self,
-        report_builder: ReportBuilder,
-        data_reader,
-        listeners: [StepListener] = None,
-    ):
+    def __init__(self, report_builder: ReportBuilder, listeners: [StepListener] = None):
         """
         Report configuration provides configuration for report.
 
@@ -53,7 +49,6 @@ def __init__(
             listeners = []
         self.report_builder = report_builder
         self.listeners = listeners
-        self.data_reader = data_reader
 
 
 class AlternativeConfiguration:
@@ -83,6 +78,8 @@ def __init__(
 
 
 class TestConfiguration:
+    __test__ = False
+
     def __init__(
         self,
         tests: [AbstractTestStatistic],
@@ -109,10 +106,12 @@ def __init__(
         test_configuration: TestConfiguration,
         report_configuration: ReportConfiguration,
         rvs_store: IRvsStore,
+        result_store: IResultStore,
         critical_value_store: ICriticalValueStore,
     ):
         self.alternative_configuration = alternative_configuration
         self.test_configuration = test_configuration
         self.report_configuration = report_configuration
         self.rvs_store = rvs_store
+        self.result_store = result_store
         self.critical_value_store = critical_value_store

stattest/experiment/experiment.py

@@ -16,12 +16,13 @@ def execute(self):
         """
 
         rvs_store = self.__configuration.rvs_store
+        result_store = self.__configuration.result_store
 
         # Generate data for alternatives
         data_generation_step(self.__configuration.alternative_configuration, rvs_store)
 
         # Test hypothesis
-        execute_test_step(self.__configuration.test_configuration, rvs_store)
+        execute_test_step(self.__configuration.test_configuration, rvs_store, result_store)
 
         # Generate reports
-        execute_report_step(self.__configuration.report_configuration)
+        execute_report_step(self.__configuration.report_configuration, result_store)

stattest/experiment/report/model.py

@@ -1,8 +1,8 @@
 from matplotlib import pyplot as plt
 
-from stattest.experiment import ReportBuilder
+from stattest.experiment.configuration.configuration import ReportBuilder
 from stattest.experiment.test.worker import PowerWorkerResult
-from stattest.persistence.models import IBenchmarkResultStore
+from stattest.persistence.models import IResultStore
 
 
 """
@@ -95,9 +95,9 @@ def build(self):
         pass
 
 
-class PowerResultReader:
-    def __init__(self, power_result_store, batch_size=100):
-        self.power_result_store = power_result_store
+class ResultReader:
+    def __init__(self, result_store: IResultStore, batch_size=100):
+        self.result_store = result_store
         self.batch_size = batch_size
         self.offset = 0
         self.items = []
@@ -109,33 +109,7 @@ def __iter__(self):
     def __next__(self):
         self.i += 1
         if self.i >= len(self.items):
-            self.items = self.power_result_store.get_powers(
-                offset=self.offset, limit=self.batch_size
-            )
-            self.i = 0
-            self.offset += self.batch_size
-            if len(self.items) == 0:
-                raise StopIteration
-        return self.items[self.i]
-
-
-class BenchmarkResultReader:
-    def __init__(self, benchmark_result_store: IBenchmarkResultStore, batch_size=100):
-        self.benchmark_result_store = benchmark_result_store
-        self.batch_size = batch_size
-        self.offset = 0
-        self.items = []
-        self.i = 0
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        self.i += 1
-        if self.i >= len(self.items):
-            self.items = self.benchmark_result_store.get_benchmarks(
-                offset=self.offset, limit=self.batch_size
-            )
+            self.items = self.result_store.get_results(offset=self.offset, limit=self.batch_size)
             self.i = 0
             self.offset += self.batch_size
             if len(self.items) == 0:

stattest/experiment/report/report_step.py

@@ -1,5 +1,9 @@
-def execute_report_step(configuration):
-    data_reader = configuration.data_reader
+from stattest.experiment.report.model import ResultReader
+from stattest.persistence.models import IResultStore
+
+
+def execute_report_step(configuration, result_store: IResultStore):
+    data_reader = ResultReader(result_store)
     # Execute before all listeners
     for listener in configuration.listeners:
         listener.before()

stattest/experiment/test/test_step.py

@@ -8,6 +8,7 @@
 
 from stattest.experiment.configuration.configuration import TestConfiguration, TestWorker
 from stattest.persistence import IRvsStore
+from stattest.persistence.models import IResultStore
 from stattest.test import AbstractTestStatistic
 
 
@@ -18,9 +19,11 @@ def execute_tests(
     worker: TestWorker,
     tests: [AbstractTestStatistic],
     rvs_store: IRvsStore,
+    result_store: IResultStore,
     thread_count: int = 0,
 ):
     rvs_store.init()
+    result_store.init()
     worker.init()
 
     stat = rvs_store.get_rvs_stat()
@@ -29,12 +32,17 @@ def execute_tests(
     for code, size, _ in stat:
         data = rvs_store.get_rvs(code, size)
         for test in tests:
-            result = worker.execute(test, data, code, size)
-            worker.save_result(result)
+            result_id = worker.build_id(test, data, code, size)
+            result = result_store.get_result(result_id)
+            if result is None:
+                result = worker.execute(test, data, code, size)
+                result_store.insert_result(result_id, result)
             pbar.update(1)
 
 
-def execute_test_step(configuration: TestConfiguration, rvs_store: IRvsStore):
+def execute_test_step(
+    configuration: TestConfiguration, rvs_store: IRvsStore, result_store: IResultStore
+):
     threads_count = configuration.threads
     worker = configuration.worker
     tests = configuration.tests
@@ -58,10 +66,16 @@ def execute_test_step(configuration: TestConfiguration, rvs_store: IRvsStore):
         with multiprocessing.Pool(threads_count) as pool:
             pool.starmap(
                 execute_tests,
-                zip(repeat(worker), tests_chunks, repeat(rvs_store), threads_counts),
+                zip(
+                    repeat(worker),
+                    tests_chunks,
+                    repeat(rvs_store),
+                    repeat(result_store),
+                    threads_counts,
+                ),
             )
     else:
-        execute_tests(worker, tests, rvs_store)
+        execute_tests(worker, tests, rvs_store, result_store)
 
     # Execute after all listeners
     for listener in configuration.listeners:

stattest/experiment/test/worker.py

@@ -3,7 +3,7 @@
 from stattest.experiment.configuration.configuration import TestWorker, TestWorkerResult
 from stattest.experiment.hypothesis import AbstractHypothesis
 from stattest.experiment.test.power_calculation import calculate_test_power
-from stattest.persistence.models import ICriticalValueStore, IPowerResultStore
+from stattest.persistence.models import ICriticalValueStore
 from stattest.test import AbstractTestStatistic
 
 
@@ -16,50 +16,38 @@ def __init__(self, test_code, alternative_code, size, alpha, power):
         self.alternative_code = alternative_code
 
 
+class BenchmarkWorkerResult(TestWorkerResult):
+    def __init__(self, size: int, test_code: str, benchmark: [float]):
+        self.size = size
+        self.benchmark = benchmark
+        self.test_code = test_code
+
+
 class PowerCalculationWorker(TestWorker):
     def __init__(
         self,
         alpha,
         monte_carlo_count,
-        worker_result_store: IPowerResultStore,
-        critical_value_store: ICriticalValueStore,
+        cv_store: ICriticalValueStore,
         hypothesis: AbstractHypothesis,
     ):
         self.alpha = alpha
         self.monte_carlo_count = monte_carlo_count
-        self.worker_result_store = worker_result_store
-        self.critical_value_store = critical_value_store
+        self.cv_store = cv_store
         self.hypothesis = hypothesis
 
     @override
     def init(self):
-        self.critical_value_store.init()
-        self.worker_result_store.init()
+        self.cv_store.init()
+
+    def build_id(self, test: AbstractTestStatistic, data: [[float]], code: str, size: int) -> str:
+        return "_".join([self.alpha, size, test.code(), code])
 
     @override
     def execute(
         self, test: AbstractTestStatistic, data: [[float]], code: str, size: int
     ) -> PowerWorkerResult:
-        # 1. Check power result
-        power = self.worker_result_store.get_power(self.alpha, size, test.code(), code)
-        if power is not None:
-            return PowerWorkerResult(test.code(), code, size, self.alpha, power)
-
-        # 2. Calculate power
         power = calculate_test_power(
-            test,
-            data,
-            self.hypothesis,
-            self.alpha,
-            self.critical_value_store,
-            self.monte_carlo_count,
+            test, data, self.hypothesis, self.alpha, self.cv_store, self.monte_carlo_count
         )
-
-        # 3. Save result
-        self.worker_result_store.insert_power(self.alpha, size, test.code(), code, power)
-
         return PowerWorkerResult(test.code(), code, size, self.alpha, power)
-
-    @override
-    def save_result(self, result: PowerWorkerResult):
-        pass

stattest/persistence/__init__.py

@@ -1,4 +1,4 @@
-from stattest.persistence.models import ICriticalValueStore, IPowerResultStore, IRvsStore, IStore
+from stattest.persistence.models import ICriticalValueStore, IRvsStore, IStore
 
 
-__all__ = ["ICriticalValueStore", "IPowerResultStore", "IRvsStore", "IStore"]
+__all__ = ["ICriticalValueStore", "IRvsStore", "IStore"]

stattest/persistence/db_store/__init__.py

@@ -1,16 +1,16 @@
 from stattest.persistence.db_store.base import ModelBase, SessionType
-from stattest.persistence.db_store.benchmark_result_store import BenchmarkResultDbStore
 from stattest.persistence.db_store.critical_value_store import CriticalValueDbStore
 from stattest.persistence.db_store.db_init import get_request_or_thread_id, init_db
-from stattest.persistence.db_store.rvs_store import RvsDbLiteStore
+from stattest.persistence.db_store.result_store import ResultDbStore
+from stattest.persistence.db_store.rvs_store import RvsDbStore
 
 
 __all__ = [
-    "RvsDbLiteStore",
+    "RvsDbStore",
     "get_request_or_thread_id",
     "init_db",
     "CriticalValueDbStore",
-    "BenchmarkResultDbStore",
     "ModelBase",
     "SessionType",
+    "ResultDbStore",
 ]