pfund 0.0.1.dev5__tar.gz → 0.0.1.dev6__tar.gz

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/PKG-INFO

@@ -1,28 +1,26 @@
 Metadata-Version: 2.1
 Name: pfund
-Version: 0.0.1.dev5
+Version: 0.0.1.dev6
 Summary: A Complete Algo-Trading Framework for Machine Learning, enabling trading across TradFi, CeFi and DeFi. Supports Vectorized and Event-Driven Backtesting, Paper and Live Trading
 Home-page: https://pfund.ai
 License: Apache-2.0
 Keywords: trading,algo-trading,stocks,cryptos,cryptocurrencies,TradFi,CeFi,DeFi,portfolio management,investment,backtesting,machine learning
 Author: Stephen Yau
 Author-email: softwareentrepreneer+pfund@gmail.com
-Requires-Python: >=3.10,<3.12
+Requires-Python: >=3.10,<3.13
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: orjson (>=3.9.14,<4.0.0)
+Requires-Dist: gitpython (>=3.1.43,<4.0.0)
 Requires-Dist: pfeed (>=0.0.1.dev5,<0.0.2)
 Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
-Requires-Dist: psutil (>=5.9.8,<6.0.0)
 Requires-Dist: python-telegram-bot (>=20.7,<21.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
-Requires-Dist: pyzmq (>=25.1.2,<26.0.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: schedule (>=1.2.1,<2.0.0)
-Requires-Dist: ta (>=0.11.0,<0.12.0)
 Requires-Dist: websocket-client (>=1.7.0,<2.0.0)
 Project-URL: Documentation, https://pfund-docs.pfund.ai
 Project-URL: Repository, https://github.com/PFund-Software-Ltd/pfund
@@ -131,7 +129,6 @@ This overview already omits some intricate steps, such as data handling and API
 
 
 ## Installation
-> Python 3.12 is not supported until [PyTorch]supports it
 
 ### Using [Poetry] (Recommended)
 ```bash

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/README.md

@@ -101,7 +101,6 @@ This overview already omits some intricate steps, such as data handling and API
 
 
 ## Installation
-> Python 3.12 is not supported until [PyTorch]supports it
 
 ### Using [Poetry] (Recommended)
 ```bash

pfund-0.0.1.dev6/pfund/analyzer.py

@@ -0,0 +1,3 @@
+class Analyzer:
+    def __init__(self):
+        pass

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/config/configuration.py

@@ -6,9 +6,6 @@ from pfund.const.paths import PROJ_CONFIG_PATH
 from pfund.utils.utils import short_path
 
 
-has_printed = False
-
-
 class Configuration:
     def __init__(self, config_dir, config_name):
         self.config_dir = config_dir.lower()
@@ -24,16 +21,12 @@ class Configuration:
         return self.config_dir
 
     def read_config(self, config_name):
-        global has_printed
         file_path = f'{self.config_path}/{config_name}.yml'
         # short_file_path = short_path(file_path)
         if not os.path.exists(file_path):
             print(f'cannot find config {file_path}')
         else:
             with open(file_path, 'r') as f:
-                if not has_printed:
-                    has_printed = True
-                    print(f'loaded config {file_path}')
                 return list(yaml.safe_load_all(f))
 
     def write_config(self, config_name, content):

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/config_handler.py

@@ -25,11 +25,12 @@ def _custom_excepthook(exception_class: type[BaseException], exception: BaseExce
         logging.getLogger(PROJ_NAME).exception('Uncaught exception:')
         
         
-def import_strategies_models_features_or_indicators(path: str):
+def dynamic_import(path: str):
     for item in os.listdir(path):
         item_path = os.path.join(path, item)
         if os.path.isdir(item_path) and '__pycache__' not in item_path:
-            for type_ in ['strategies', 'models', 'features', 'indicators']:
+            for type_ in ['strategies', 'models', 'features', 'indicators', 
+                          'backtests', 'notebooks', 'spreadsheets', 'dashboards']:
                 if type_ in path:
                     break
             else:
@@ -65,17 +66,48 @@ class ConfigHandler:
             config = {}
         return cls(**config)
     
+    @property
+    def strategy_path(self):
+        return f'{self.data_path}/hub/strategies'
+    
+    @property
+    def model_path(self):
+        return f'{self.data_path}/hub/models'
+    
+    @property
+    def feature_path(self):
+        return f'{self.data_path}/hub/features'
+    
+    @property
+    def indicator_path(self):
+        return f'{self.data_path}/hub/indicators'
+    
+    @property
+    def backtest_path(self):
+        return f'{self.data_path}/backtests'
+    
+    @property
+    def notebook_path(self):
+        return f'{self.data_path}/templates/notebooks'
+    
+    @property
+    def spreadsheet_path(self):
+        return f'{self.data_path}/templates/spreadsheets'
+    
+    @property
+    def dashboard_path(self):
+        return f'{self.data_path}/templates/dashboards'
+    
     def __post_init__(self):
         self.logging_config = self.logging_config or {}
         
-        strategy_path, model_path = f'{self.data_path}/strategies', f'{self.data_path}/models'
-        feature_path, indicator_path = f'{self.data_path}/features', f'{self.data_path}/indicators'
-        for path in [strategy_path, model_path, feature_path, indicator_path]:
+        for path in [self.strategy_path, self.model_path, self.feature_path, self.indicator_path,
+                     self.backtest_path, self.notebook_path, self.spreadsheet_path, self.dashboard_path]:
             if not os.path.exists(path):
                 os.makedirs(path)
                 print(f'created {path}')
             sys.path.append(path)
-            import_strategies_models_features_or_indicators(path)
+            dynamic_import(path)
         
         if self.use_fork_process and sys.platform != 'win32':
             multiprocessing.set_start_method('fork', force=True)

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/const/commons.py

@@ -18,4 +18,6 @@ SUPPORTED_TIMEFRAMES = [
     'weeks', 'week', 'w',
     'months', 'month', 'M',
 ]
-SUPPORTED_DATA_CHANNELS = ['orderbook', 'tradebook', 'kline']
+SUPPORTED_DATA_CHANNELS = ['orderbook', 'tradebook', 'kline']
+SUPPORTED_BACKTEST_MODES = ['vectorized', 'event_driven']
+SUPPORTED_DATA_TOOLS = ['pandas']

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/const/paths.py

@@ -16,7 +16,11 @@ LOG_PATH = Path(user_log_dir()) / PROJ_NAME
 USER_CONFIG_PATH = Path(user_config_dir()) / PROJ_NAME
 USER_CONFIG_FILE_PATH = USER_CONFIG_PATH / f'{PROJ_NAME}_config.yml'
 DATA_PATH = Path(user_data_dir()) / PROJ_NAME
-STRATEGY_PATH = DATA_PATH / 'strategies'
-MODEL_PATH = DATA_PATH / 'models'
-FEATURE_PATH = DATA_PATH / 'features'
-INDICATOR_PATH = DATA_PATH / 'indicators'
+STRATEGY_PATH = DATA_PATH / 'hub' / 'strategies'
+MODEL_PATH = DATA_PATH / 'hub' / 'models'
+FEATURE_PATH = DATA_PATH / 'hub' / 'features'
+INDICATOR_PATH = DATA_PATH / 'hub' / 'indicators'
+BACKTEST_PATH = DATA_PATH / 'backtests'
+NOTEBOOK_PATH = DATA_PATH / 'templates' / 'notebooks'
+SPREADSHEET_PATH = DATA_PATH / 'templates' / 'spreadsheets'
+DASHBOARD_PATH = DATA_PATH / 'templates' / 'dashboards'

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/data_tools/data_tool_base.py

@@ -1,12 +1,7 @@
-from typing import Literal
-
 from pfund.datas.data_base import BaseData
 from pfund.utils.utils import convert_ts_to_dt
 
 
-DataTool = Literal['pandas']
-
-
 class BaseDataTool:
     def __init__(self):
         self.train_periods = {}  # {product: ('start_date', 'end_date')}

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/data_tools/data_tool_pandas.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
 from decimal import Decimal
+from pathlib import Path
 
 import pandas as pd
 
@@ -150,6 +151,13 @@ class PandasDataTool(BaseDataTool):
             index=pd.MultiIndex(levels=[[]]*len(index_names), codes=[[]]*len(index_names), names=index_names)
         )
     
+    def output_df_to_parquet(self, name: str, df: pd.DataFrame,path: str | Path):
+        if '.parquet' not in name:
+            name = name + '.parquet'
+        if type(path) is str:
+            path = Path(path)
+        df.to_parquet(path / name)
+    
     def _create_multi_index(self, index_data: dict, index_names: list[str]) -> pd.MultiIndex:
         return pd.MultiIndex.from_tuples([tuple(index_data[name] for name in index_names)], names=index_names)
         

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/engines/backtest_engine.py

@@ -1,21 +1,27 @@
-from typing import Literal
+import hashlib
+import os
+import time
+import datetime
+import json
+import uuid
 
-from pfund.data_tools.data_tool_base import DataTool
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.common_literals import tSUPPORTED_BACKTEST_MODES, tSUPPORTED_DATA_TOOLS
+    
+import pfund as pf
+from pfund.types.core import tStrategy, tModel, tFeature, tIndicator
 from pfund.engines.base_engine import BaseEngine
-from pfund.models.model_base import BaseModel, BaseFeature
-from pfund.indicators.indicator_base import BaseIndicator
 from pfund.brokers.broker_backtest import BacktestBroker
 from pfund.strategies.strategy_base import BaseStrategy
 from pfund.strategies.strategy_backtest import BacktestStrategy
-from pfund.const.commons import *
 from pfund.config_handler import ConfigHandler
+from pfund.utils import utils
+from pfund.mixins.backtest import BacktestMixin
 
 
-BacktestMode = Literal['vectorized', 'event_driven']
-        
-
 class BacktestEngine(BaseEngine):
-    def __new__(cls, *, env: str='BACKTEST', data_tool: DataTool='pandas', mode: BacktestMode='vectorized', append_to_strategy_df=False, use_prepared_signals=True, config: ConfigHandler | None=None, **settings):
+    def __new__(cls, *, env: str='BACKTEST', data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', mode: 'tSUPPORTED_BACKTEST_MODES'='vectorized', append_to_strategy_df=False, use_prepared_signals=True, config: ConfigHandler | None=None, **settings):
         if not hasattr(cls, 'mode'):
             cls.mode = mode.lower()
         if not hasattr(cls, 'append_to_strategy_df'):
@@ -26,13 +32,15 @@ class BacktestEngine(BaseEngine):
             cls.use_prepared_signals = use_prepared_signals
         return super().__new__(cls, env, data_tool=data_tool, config=config, **settings)
 
-    def __init__(self, *, env: str='BACKTEST', data_tool: DataTool='pandas', mode: BacktestMode='vectorized', append_to_strategy_df=False, use_prepared_signals=True, config: ConfigHandler | None=None, **settings):
+    def __init__(self, *, env: str='BACKTEST', data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', mode: 'tSUPPORTED_BACKTEST_MODES'='vectorized', append_to_strategy_df=False, use_prepared_signals=True, config: ConfigHandler | None=None, **settings):
         super().__init__(env, data_tool=data_tool)
         # avoid re-initialization to implement singleton class correctly
         # if not hasattr(self, '_initialized'):
         #     pass
     
-    def add_strategy(self, strategy: BaseStrategy, name: str='', is_parallel=False) -> BaseStrategy:
+    # HACK: since python doesn't support dynamic typing, true return type should be subclass of BacktestMixin and tStrategy
+    # write -> BacktestMixin | tStrategy for better intellisense in IDEs
+    def add_strategy(self, strategy: tStrategy, name: str='', is_parallel=False) -> BacktestMixin | tStrategy:
         is_dummy_strategy_exist = '_dummy' in self.strategy_manager.strategies
         assert not is_dummy_strategy_exist, 'dummy strategy is being used for model backtesting, adding another strategy is not allowed'
         if is_parallel:
@@ -42,7 +50,7 @@ class BacktestEngine(BaseEngine):
         strategy = BacktestStrategy(type(strategy), *strategy._args, **strategy._kwargs)
         return super().add_strategy(strategy, name=name, is_parallel=is_parallel)
 
-    def add_model(self, model: BaseModel, name: str='', model_path: str='', is_load: bool=True) -> BaseModel:
+    def add_model(self, model: tModel, name: str='', model_path: str='', is_load: bool=True) -> BacktestMixin | tModel:
         '''Add model without creating a strategy (using dummy strategy)'''
         is_non_dummy_strategy_exist = bool([strat for strat in self.strategy_manager.strategies if strat != '_dummy'])
         assert not is_non_dummy_strategy_exist, 'Please use strategy.add_model(...) instead of engine.add_model(...) when a strategy is already created'
@@ -57,10 +65,10 @@ class BacktestEngine(BaseEngine):
         model = strategy.add_model(model, name=name, model_path=model_path, is_load=is_load)
         return model
     
-    def add_feature(self, feature: BaseFeature, name: str='', feature_path: str='', is_load: bool=True) -> BaseFeature:
+    def add_feature(self, feature: tFeature, name: str='', feature_path: str='', is_load: bool=True) -> BacktestMixin | tFeature:
         return self.add_model(feature, name=name, model_path=feature_path, is_load=is_load)
     
-    def add_indicator(self, indicator: BaseIndicator, name: str='', indicator_path: str='', is_load: bool=True) -> BaseIndicator:
+    def add_indicator(self, indicator: tIndicator, name: str='', indicator_path: str='', is_load: bool=True) -> BacktestMixin | tIndicator:
         return self.add_model(indicator, name=name, model_path=indicator_path, is_load=is_load)
     
     def add_broker(self, bkr: str):
@@ -73,12 +81,108 @@ class BacktestEngine(BaseEngine):
         self.brokers[bkr] = broker
         self.logger.debug(f'added {bkr=}')
         return broker
+    
+    @staticmethod 
+    def _generate_backtest_id() -> str:
+        return uuid.uuid4().hex
+    
+    def _create_backtest_name(self, strat: str):
+        local_tz = utils.get_local_timezone()
+        utcnow = datetime.datetime.now(tz=local_tz).strftime('%Y-%m-%d_%H:%M:%S_UTC%z')
+        backtest_id = self._generate_backtest_id()
+        return '.'.join([strat, utcnow, backtest_id])
+    
+    @staticmethod 
+    def _generate_backtest_hash(strategy: BaseStrategy):
+        '''Generate hash based on strategy for backtest traceability
+        backtest_hash is used to identify if the backtests are generated by the same strategy.
+        Useful for avoiding overfitting the strategy on the same dataset.
+        '''
+        # REVIEW: currently only use strategy to generate hash, may include other settings in the future
+        strategy_dict = strategy.to_dict()
+        # since conceptually backtest_hash should be the same regardless of the 
+        # strategy_signature (params) and data_signatures (e.g. backtest_kwargs, train_kwargs, data_source, resolution etc.)
+        # remove them
+        del strategy_dict['strategy_signature']
+        del strategy_dict['data_signatures']
+        strategy_str = json.dumps(strategy_dict)
+        return hashlib.sha256(strategy_str.encode()).hexdigest()
+    
+    def read_json(self, file_name: str) -> dict:
+        '''Reads json file from backtest_path'''
+        file_path = os.path.join(self.config.backtest_path, file_name)
+        backtest_json = {}
+        try:
+            if os.path.exists(file_path):
+                with open(file_path, 'r') as f:
+                    backtest_json = json.load(f)
+        except:
+            self.logger.exception(f"Error reading from {file_path}:")
+        return backtest_json
+    
+    def _write_json(self, file_name: str, json_file: dict) -> None:
+        '''Writes json file to backtest_path'''
+        file_path = os.path.join(self.config.backtest_path, file_name)
+        try:
+            with open(file_path, 'w') as f:
+                json.dump(json_file, f, indent=4)
+        except:
+            self.logger.exception(f"Error writing to {file_path}:")
+    
+    def _generate_backtest_iteration(self, strategy: BaseStrategy) -> int:
+        '''Generate backtest iteration number for the same backtest_hash.
+        Read the existing backtest.json file to get the iteration number for the same strategy hash
+        If the backtest hash is not found, create a new entry with iteration number 1
+        else increment the iteration number by 1.
+        '''
+        backtest_hash = self._generate_backtest_hash(strategy)
+        file_name = 'backtest.json'
+        backtest_json = self.read_json(file_name)
+        backtest_json[backtest_hash] = backtest_json.get(backtest_hash, 0) + 1
+        self._write_json(file_name, backtest_json)
+        return backtest_json[backtest_hash]
+    
+    def _write_backtest_history(self, backtest_name: str, backtest_name_trimmed: str, start_time: float, end_time: float):
+        splits = backtest_name.split('.')
+        strat, backtest_id = splits[0], splits[-1]
+        strategy = self.get_strategy(strat)
+        local_tz = utils.get_local_timezone()
+        duration = end_time - start_time
+        backtest_history = {
+            'settings': self.settings,
+            'metadata': {
+                'pfund_version': pf.__version__,
+                'backtest_name': backtest_name,
+                'backtest_id': backtest_id,
+                'backtest_iteration': self._generate_backtest_iteration(strategy),
+                'duration': f'{duration:.2f}s' if duration > 1 else f'{duration*1000:.2f}ms',
+                'start_time': datetime.datetime.fromtimestamp(start_time, tz=local_tz).strftime('%Y-%m-%dT%H:%M:%S%z'),
+                'end_time': datetime.datetime.fromtimestamp(end_time, tz=local_tz).strftime('%Y-%m-%dT%H:%M:%S%z'),
+            },
+            'strategy': strategy.to_dict(),
+            'results': {
+                'df_file_path': os.path.join(self.config.backtest_path, f'{backtest_name_trimmed}.parquet'),
+            }
+        }
+        self._write_json(f'{backtest_name_trimmed}.json', backtest_history)
+    
+    def trim_backtest_name(self, backtest_name: str) -> str:
+        splits = backtest_name.split('.')
+        backtest_id_len = 12
+        splits[-1] = splits[-1][:backtest_id_len]
+        return '.'.join(splits)
+    
+    def output_backtest_results(self, strat: str, df, start_time: float, end_time: float):
+        backtest_name = self._create_backtest_name(strat)
+        backtest_name_trimmed = self.trim_backtest_name(backtest_name)
+        self.data_tool.output_df_to_parquet(backtest_name_trimmed, df, self.config.backtest_path)
+        self._write_backtest_history(backtest_name, backtest_name_trimmed, start_time, end_time)
         
     def run(self):
         for broker in self.brokers.values():
             broker.start()
         self.strategy_manager.start()
-    
+
         if self.mode == 'vectorized':
             for strat, strategy in self.strategy_manager.strategies.items():
                 # _dummy strategy is only created for model training, do nothing
@@ -86,7 +190,11 @@ class BacktestEngine(BaseEngine):
                     continue
                 if not hasattr(strategy, 'backtest'):
                     raise Exception(f'Strategy {strat} does not have backtest() method, cannot run vectorized backtesting')
+                start_time = time.time()
                 strategy.backtest()
+                end_time = time.time()
+                df = strategy.get_df()
+                self.output_backtest_results(strat, df, start_time, end_time)
         elif self.mode == 'event_driven':
             for strat, strategy in self.strategy_manager.strategies.items():
                 if strat == '_dummy':

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/engines/base_engine.py

@@ -2,14 +2,18 @@ import os
 import logging
 import importlib
 
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.core import tStrategy
+    from pfund.types.common_literals import tSUPPORTED_DATA_TOOLS
+    
 from rich.console import Console
 
 from pfund.utils.utils import Singleton
-from pfund.data_tools.data_tool_base import DataTool
 from pfund.strategies.strategy_base import BaseStrategy
 from pfund.brokers.broker_base import BaseBroker
 from pfund.managers.strategy_manager import StrategyManager
-from pfund.const.commons import *
+from pfund.const.commons import SUPPORTED_ENVIRONMENTS, SUPPORTED_BROKERS
 from pfund.config_handler import ConfigHandler
 from pfund.plogging import set_up_loggers
 from pfund.plogging.config import LoggingDictConfigurator
@@ -27,9 +31,9 @@ ENV_COLORS = {
 class BaseEngine(Singleton):
     _PROCESS_NO_PONG_TOLERANCE_IN_SECONDS = 30
 
-    def __new__(cls, env, data_tool: DataTool='pandas', config: ConfigHandler | None=None, **settings):
+    def __new__(cls, env, data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', config: ConfigHandler | None=None, **settings):
         if not hasattr(cls, 'env'):
-            cls.env = env.upper() if type(env) is str else str(env).upper()
+            cls.env = env.upper() if isinstance(env, str) else str(env).upper()
             assert cls.env in SUPPORTED_ENVIRONMENTS, f'env={cls.env} is not supported'
 
             # TODO, do NOT allow LIVE env for now
@@ -50,7 +54,7 @@ class BaseEngine(Singleton):
             cls.logging_configurator: LoggingDictConfigurator  = set_up_loggers(log_path, logging_config_file_path, user_logging_config=cls.config.logging_config)
         return super().__new__(cls)
     
-    def __init__(self, env, data_tool: DataTool='pandas', config: ConfigHandler | None=None, **settings):
+    def __init__(self, env, data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', config: ConfigHandler | None=None, **settings):
         # avoid re-initialization to implement singleton class correctly
         if not hasattr(self, '_initialized'):
             self.logger = logging.getLogger('pfund')
@@ -70,7 +74,7 @@ class BaseEngine(Singleton):
     def get_strategy(self, strat: str) -> BaseStrategy | None:
         return self.strategy_manager.get_strategy(strat)
 
-    def add_strategy(self, strategy: BaseStrategy, name: str='', is_parallel=False) -> BaseStrategy:
+    def add_strategy(self, strategy: 'tStrategy', name: str='', is_parallel=False) -> 'tStrategy':
         return self.strategy_manager.add_strategy(strategy, name=name, is_parallel=is_parallel)
 
     def remove_strategy(self, strat: str):
@@ -83,7 +87,7 @@ class BaseEngine(Singleton):
         bkr = bkr.upper()
         assert bkr in SUPPORTED_BROKERS, f'broker {bkr} is not supported'
         if bkr == 'CRYPTO':
-            Broker = getattr(importlib.import_module(f'pfund.brokers.broker_{bkr.lower()}'), f'CryptoBroker')
+            Broker = getattr(importlib.import_module(f'pfund.brokers.broker_{bkr.lower()}'), 'CryptoBroker')
         elif bkr == 'IB':
-            Broker = getattr(importlib.import_module(f'pfund.brokers.ib.broker_{bkr.lower()}'), f'IBBroker')
+            Broker = getattr(importlib.import_module(f'pfund.brokers.ib.broker_{bkr.lower()}'), 'IBBroker')
         return Broker

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/engines/trade_engine.py

@@ -8,19 +8,19 @@ components at the highest level such as:
     strategies (your trading strategies)
 In order to communicate with other processes, it uses ZeroMQ as the core 
 message queue.
-
-Please refer to #TODO for more examples.
 """
 import time
 from threading import Thread
 
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.common_literals import tSUPPORTED_DATA_TOOLS
+
 import schedule
 import psutil
 
-from pfund.data_tools.data_tool_base import DataTool
 from pfund.engines.base_engine import BaseEngine
 from pfund.brokers.broker_base import BaseBroker
-from pfund.const.commons import *
 from pfund.utils.utils import flatten_dict
 from pfund.zeromq import ZeroMQ
 from pfund.config_handler import ConfigHandler
@@ -29,13 +29,13 @@ from pfund.config_handler import ConfigHandler
 class TradeEngine(BaseEngine):
     zmq_ports = {}
 
-    def __new__(cls, *, env: str='PAPER', data_tool: DataTool='pandas', zmq_port=5557, config: ConfigHandler | None=None, **settings):
+    def __new__(cls, *, env: str='PAPER', data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', zmq_port=5557, config: ConfigHandler | None=None, **settings):
         if not hasattr(cls, 'zmq_port'):
-            assert type(zmq_port) is int, f'{zmq_port=} must be an integer'
+            assert isinstance(zmq_port, int), f'{zmq_port=} must be an integer'
             cls._zmq_port = zmq_port
         return super().__new__(cls, env, data_tool=data_tool, config=config, **settings)
 
-    def __init__(self, *, env: str='PAPER', data_tool: DataTool='pandas', zmq_port=5557, config: ConfigHandler | None=None, **settings):
+    def __init__(self, *, env: str='PAPER', data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', zmq_port=5557, config: ConfigHandler | None=None, **settings):
         super().__init__(env, data_tool=data_tool)
         # avoid re-initialization to implement singleton class correctly
         if not hasattr(self, '_initialized'):
@@ -157,7 +157,7 @@ class TradeEngine(BaseEngine):
         schedule.run_all()  # run all tasks at start
         self._background_thread = Thread(target=self._run_background_tasks, daemon=True)
         self._background_thread.start()
-        self.logger.debug(f'background thread started')
+        self.logger.debug('background thread started')
 
         # TEMP, zeromq examples
         # self._zmq.send(
@@ -174,7 +174,6 @@ class TradeEngine(BaseEngine):
         # )
 
         while self._is_running:
-            lats = []
             if msg := self._zmq.recv():
                 channel, topic, info = msg
                 # TODO
@@ -193,7 +192,7 @@ class TradeEngine(BaseEngine):
         schedule.clear()
         self._is_running = False
         while self._background_thread.is_alive():
-            self.logger.debug(f'waiting for background thread to finish')
+            self.logger.debug('waiting for background thread to finish')
             time.sleep(1)
         else:
-            self.logger.debug(f'background thread is finished')
+            self.logger.debug('background thread is finished')

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/engines/train_engine.py

@@ -1,14 +1,16 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.common_literals import tSUPPORTED_BACKTEST_MODES, tSUPPORTED_DATA_TOOLS
+
 from pfund.engines.backtest_engine import BacktestEngine
-from pfund.data_tools.data_tool_base import DataTool
-from pfund.engines.backtest_engine import BacktestMode
 from pfund.config_handler import ConfigHandler
 
 
 class TrainEngine(BacktestEngine):
-    def __new__(cls, *, data_tool: DataTool='pandas', mode: BacktestMode='vectorized', config: ConfigHandler | None=None, **settings):
+    def __new__(cls, *, data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', mode: 'tSUPPORTED_BACKTEST_MODES'='vectorized', config: ConfigHandler | None=None, **settings):
         return super().__new__(cls, env='TRAIN', data_tool=data_tool, mode=mode, config=config, **settings)
     
-    def __init__(self, *, data_tool: DataTool='pandas', mode: BacktestMode='vectorized', config: ConfigHandler | None=None, **settings):
+    def __init__(self, *, data_tool: 'tSUPPORTED_DATA_TOOLS'='pandas', mode: 'tSUPPORTED_BACKTEST_MODES'='vectorized', config: ConfigHandler | None=None, **settings):
         super().__init__(env='TRAIN', data_tool=data_tool)
         # avoid re-initialization to implement singleton class correctly
         # if not hasattr(self, '_initialized'):

{pfund-0.0.1.dev5 → pfund-0.0.1.dev6}/pfund/exchanges/bybit/exchange.py

@@ -236,7 +236,7 @@ class Exchange(BaseExchange):
         """
         def _convert_to_date(time_):
             if type(time_) is float:
-                date = datetime.datetime.fromtimestamp(tz=datetime.timezone.utc)
+                date = datetime.datetime.fromtimestamp(time_, tz=datetime.timezone.utc)
             elif type(time_) is str:
                 date = datetime.datetime.strptime(time_, date_format)
                 date = date.replace(tzinfo=datetime.timezone.utc)

pfund-0.0.1.dev6/pfund/investment_profile.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.common_literals import tSUPPORTED_PRODUCT_TYPES, tSUPPORTED_CRYPTO_PRODUCT_TYPES
+
+
+# TODO
+@dataclass
+class InvestmentProfile:
+    investment_objectives: list[str]
+    risk_tolerance: str
+    investment_horizon: str
+    asset_classes: list[tSUPPORTED_PRODUCT_TYPES | tSUPPORTED_CRYPTO_PRODUCT_TYPES]
+    diversification: str
+    rebalancing_period: str