can execute simulation with 3min candle data

integration_tests/__init__.py

@@ -4,10 +4,16 @@
 from .analyzer_ITG_test import AnalyzerIntegrationTests
 from .bithumb_data_provider_ITG_test import BithumbDataProviderIntegrationTests
 from .operator_ITG_test import OperatorIntegrationTests
-from .simulation_operator_ITG_test import SimulationOperatorIntegrationTests
+from .simulation_operator_ITG_test import (
+    SimulationOperatorIntegrationTests,
+    SimulationOperator3mIntervalIntegrationTests,
+)
 from .simulation_trader_ITG_test import SimulationTraderIntegrationTests
 from .strategy_bnh_ITG_test import StrategyBuyAndHoldIntegrationTests
 from .upbit_data_provider_ITG_test import UpbitDataProviderIntegrationTests
 from .simulator_ITG_test import SimulatorIntegrationTests
 from .data_repository_ITG_test import DataRepositoryIntegrationTests
-from .mass_simulator_ITG_test import MassSimulatorIntegrationTests
+from .mass_simulator_ITG_test import (
+    MassSimulatorIntegrationTests,
+    MassSimulator3mIntervalIntegrationTests,
+)

integration_tests/data/mass_simulation_3m_config.json

@@ -0,0 +1,18 @@
+{
+    "title": "SMA-1Hour-3min-interval",
+    "budget": 500000,
+    "strategy": "BNH",
+    "interval": 0.5,
+    "currency": "BTC",
+    "description": "mass-simulation-integration-test",
+    "period_list": [
+        {
+            "start": "2020-04-30T17:00:00",
+            "end": "2020-04-30T18:00:00"
+        },
+        {
+            "start": "2020-04-30T17:30:00",
+            "end": "2020-04-30T18:30:00"
+        }
+    ]
+}

integration_tests/data/simulation_data.py

@@ -1,10 +1,100 @@
 def get_data(name):
     if name == "bnh_snapshot":
         return bnh_snapshot
+    elif name == "bnh_3m_snapshot":
+        return bnh_3m_snapshot
     elif name == "sma0_snapshot":
         return sma0_snapshot
 
 
+bnh_3m_snapshot = [
+    {
+        "request": {
+            "id": "1691237535945.211215",
+            "type": "buy",
+            "price": 11288000.0,
+            "amount": 0.0017,
+            "date_time": "2020-04-30T14:48:00",
+        },
+        "type": "buy",
+        "price": 11288000.0,
+        "amount": 0.0017,
+        "msg": "success",
+        "balance": 80801,
+        "state": "done",
+        "date_time": "2020-04-30T15:56:00",
+        "kind": 2,
+    },
+    {
+        "request": {
+            "id": "1691237535948.211215",
+            "type": "buy",
+            "price": 11313000.0,
+            "amount": 0.0017,
+            "date_time": "2020-04-30T14:51:00",
+        },
+        "type": "buy",
+        "price": 11313000.0,
+        "amount": 0.0017,
+        "msg": "success",
+        "balance": 61559,
+        "state": "done",
+        "date_time": "2020-04-30T15:57:00",
+        "kind": 2,
+    },
+    {
+        "request": {
+            "id": "1691237535952.211215",
+            "type": "buy",
+            "price": 11351000.0,
+            "amount": 0.0017,
+            "date_time": "2020-04-30T14:54:00",
+        },
+        "type": "buy",
+        "price": 11351000.0,
+        "amount": 0.0017,
+        "msg": "success",
+        "balance": 42253,
+        "state": "done",
+        "date_time": "2020-04-30T15:58:00",
+        "kind": 2,
+    },
+    {
+        "request": {
+            "id": "1691237535956.211215",
+            "type": "buy",
+            "price": 11341000.0,
+            "amount": 0.0017,
+            "date_time": "2020-04-30T14:57:00",
+        },
+        "type": "buy",
+        "price": 11341000.0,
+        "amount": 0.0017,
+        "msg": "success",
+        "balance": 22964,
+        "state": "done",
+        "date_time": "2020-04-30T15:59:00",
+        "kind": 2,
+    },
+    {
+        "request": {
+            "id": "1691237535962.211215",
+            "type": "buy",
+            "price": 11325000.0,
+            "amount": 0.0017,
+            "date_time": "2020-04-30T15:00:00",
+        },
+        "type": "buy",
+        "price": 11325000.0,
+        "amount": 0.0017,
+        "msg": "success",
+        "balance": 3702,
+        "state": "done",
+        "date_time": "2020-04-30T16:00:00",
+        "kind": 2,
+    },
+]
+
 bnh_snapshot = [
     {
         "request": {
@@ -298,4 +388,4 @@ def get_data(name):
         "date_time": "2020-04-30T15:53:00",
         "kind": 2,
     },
-]
+]

integration_tests/mass_simulator_ITG_test.py

@@ -1,6 +1,6 @@
 import time
 import unittest
-from smtm import MassSimulator
+from smtm import MassSimulator, Config
 from unittest.mock import *
 
 
@@ -16,3 +16,12 @@ def test_ITG_run_single_simulation(self, mock_print):
         mass = MassSimulator()
 
         mass.run("integration_tests/data/mass_simulation_config.json")
+
+
+class MassSimulator3mIntervalIntegrationTests(unittest.TestCase):
+    # It should be executed after set Config.candle_interval = 180
+
+    def test_ITG_run_single_simulation(self):
+        mass = MassSimulator()
+
+        mass.run("integration_tests/data/mass_simulation_3m_config.json")

integration_tests/simulation_operator_ITG_test.py

@@ -7,6 +7,7 @@
     StrategyFactory,
     Analyzer,
     LogManager,
+    Config,
 )
 from .data import simulation_data
 from unittest.mock import *
@@ -15,9 +16,11 @@
 class SimulationOperatorIntegrationTests(unittest.TestCase):
     def setUp(self):
         LogManager.set_stream_level(20)
+        self.interval = Config.candle_interval
+        Config.candle_interval = 60
 
     def tearDown(self):
-        pass
+        Config.candle_interval = self.interval
 
     def test_ITG_run_simulation_with_bnh_strategy(self):
         trading_snapshot = simulation_data.get_data("bnh_snapshot")
@@ -30,7 +33,7 @@ def test_ITG_run_simulation_with_bnh_strategy(self):
         time_limit = 15
         end_str = "2020-04-30T16:30:00"
 
-        data_provider = SimulationDataProvider()
+        data_provider = SimulationDataProvider(interval=Config.candle_interval)
         data_provider.initialize_simulation(end=end_str, count=count)
         trader = SimulationTrader()
         trader.initialize_simulation(end=end_str, count=count, budget=budget)
@@ -265,3 +268,92 @@ def callback(return_report):
 
         self.assertIsNotNone(report)
         self.assertEqual(report[0], 100000)
+
+
+class SimulationOperator3mIntervalIntegrationTests(unittest.TestCase):
+    def setUp(self):
+        LogManager.set_stream_level(20)
+        self.interval = Config.candle_interval
+        Config.candle_interval = 180
+
+    def tearDown(self):
+        Config.candle_interval = self.interval
+
+    def test_ITG_run_simulation_with_bnh_strategy(self):
+        trading_snapshot = simulation_data.get_data("bnh_3m_snapshot")
+        operator = SimulationOperator()
+        strategy = StrategyFactory.create("BNH")
+        strategy.is_simulation = True
+        count = 100
+        budget = 100000
+        interval = 0.0001
+        time_limit = 15
+        end_str = "2020-04-30T16:30:00"
+
+        data_provider = SimulationDataProvider(interval=Config.candle_interval)
+        data_provider.initialize_simulation(end=end_str, count=count)
+        trader = SimulationTrader()
+        trader.initialize_simulation(end=end_str, count=count, budget=budget)
+        analyzer = Analyzer()
+        analyzer.is_simulation = True
+
+        operator.initialize(
+            data_provider,
+            strategy,
+            trader,
+            analyzer,
+            budget=budget,
+        )
+
+        operator.set_interval(interval)
+        operator.start()
+        start_time = time.time()
+        while operator.state == "running":
+            time.sleep(0.5)
+            if time.time() - start_time > time_limit:
+                self.assertTrue(False, "Time out")
+                break
+
+        trading_results = operator.get_trading_results()
+
+        self.check_equal_results_list(trading_results, trading_snapshot)
+        waiting = True
+        start_time = time.time()
+        report = None
+
+        def callback(return_report):
+            nonlocal report
+            nonlocal waiting
+            report = return_report
+            waiting = False
+            self.assertFalse(waiting)
+
+        operator.get_score(callback)
+
+        while waiting:
+            time.sleep(0.5)
+            if time.time() - start_time > time_limit:
+                self.assertTrue(False, "Time out")
+                break
+
+        self.assertIsNotNone(report)
+        self.assertEqual(report[0], 100000)
+        self.assertEqual(report[1], 97066)
+        self.assertEqual(report[2], -2.934)
+        self.assertEqual(report[3]["KRW-BTC"], -2.693)
+
+    def check_equal_results_list(self, a, b):
+        self.assertEqual(len(a), len(b))
+        for i in range(len(a)):
+            self.assertEqual(a[i]["request"]["type"], b[i]["request"]["type"])
+            self.assertEqual(a[i]["request"]["price"], b[i]["request"]["price"])
+            self.assertEqual(a[i]["request"]["amount"], b[i]["request"]["amount"])
+            self.assertEqual(a[i]["request"]["date_time"], b[i]["request"]["date_time"])
+
+            self.assertEqual(a[i]["type"], b[i]["type"])
+            self.assertEqual(a[i]["price"], b[i]["price"])
+            self.assertEqual(a[i]["amount"], b[i]["amount"])
+            self.assertEqual(a[i]["msg"], b[i]["msg"])
+            self.assertEqual(a[i]["balance"], b[i]["balance"])
+            self.assertEqual(a[i]["date_time"], b[i]["date_time"])
+            self.assertEqual(a[i]["kind"], b[i]["kind"])

integration_tests/simulation_trader_ITG_test.py

@@ -1,14 +1,15 @@
 import unittest
-from smtm import SimulationTrader
+from smtm import SimulationTrader, Config
 from unittest.mock import *
 
 
 class SimulationTraderIntegrationTests(unittest.TestCase):
     def setUp(self):
-        pass
+        self.interval = Config.candle_interval
+        Config.candle_interval = 60
 
     def tearDown(self):
-        pass
+        Config.candle_interval = self.interval
 
     def test_ITG_simulation_trader_full(self):
         trader = SimulationTrader()

integration_tests/simulator_ITG_test.py

@@ -1,16 +1,17 @@
 import time
 import unittest
-from smtm import Simulator
+from smtm import Simulator, Config
 from .data import simulation_data
 from unittest.mock import *
 
 
 class SimulatorIntegrationTests(unittest.TestCase):
     def setUp(self):
-        pass
+        self.interval = Config.candle_interval
+        Config.candle_interval = 60
 
     def tearDown(self):
-        pass
+        Config.candle_interval = self.interval
 
     @patch("builtins.print")
     def test_ITG_run_single_simulation(self, mock_print):

smtm/__init__.py

@@ -1,6 +1,7 @@
 """
 Description for Package
 """
+from .config import Config
 from .date_converter import DateConverter
 from .operator import Operator
 from .log_manager import LogManager

smtm/config.py

@@ -0,0 +1,2 @@
+class Config:
+    candle_interval = 60

smtm/mass_simulator.py

@@ -14,6 +14,7 @@
 import pandas as pd
 import matplotlib.pyplot as plt
 
+from .config import Config
 from .log_manager import LogManager
 from .analyzer import Analyzer
 from .strategy_factory import StrategyFactory
@@ -52,7 +53,7 @@ def memory_usage():
         """현재 프로세스의 이름과 메모리 사용양을 화면에 출력"""
         # current process RAM usage
         process = psutil.Process()
-        rss = process.memory_info().rss / 2 ** 20  # Bytes to MB
+        rss = process.memory_info().rss / 2**20  # Bytes to MB
         print(f"[{current_process().name}] memory usage: {rss: 10.5f} MB")
         # print(f"[{current_process().name}] memory usage: {p.memory_info().rss} MB")
 
@@ -118,19 +119,20 @@ def get_score_callback(report):
     @staticmethod
     def get_initialized_operator(budget, strategy_code, interval, currency, start, end, tag):
         """시뮬레이션 오퍼레이션 생성 후 주어진 설정 값으로 초기화 하여 반환"""
-        dt = DateConverter.to_end_min(start_iso=start, end_iso=end)
+        dt = DateConverter.to_end_min(
+            start_iso=start, end_iso=end, interval_min=Config.candle_interval / 60
+        )
         end = dt[0][1]
         count = dt[0][2]
-
-        data_provider = SimulationDataProvider(currency=currency)
+        data_provider = SimulationDataProvider(currency=currency, interval=Config.candle_interval)
         data_provider.initialize_simulation(end=end, count=count)
 
         strategy = StrategyFactory.create(strategy_code)
         if strategy is None:
             raise UserWarning(f"Invalid Strategy! {strategy_code}")
 
         strategy.is_simulation = True
-        trader = SimulationTrader(currency=currency)
+        trader = SimulationTrader(currency=currency, interval=Config.candle_interval)
         trader.initialize_simulation(end=end, count=count, budget=budget)
 
         analyzer = Analyzer()