pfund 0.0.1.dev10__tar.gz → 0.0.1.dev12__tar.gz

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pfund
-Version: 0.0.1.dev10
+Version: 0.0.1.dev12
 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
@@ -13,13 +13,16 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: analytics
 Provides-Extra: data
 Provides-Extra: ml
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: gitpython (>=3.1.43,<4.0.0)
 Requires-Dist: mlflow (>=2.11.3,<3.0.0) ; extra == "ml"
 Requires-Dist: orjson (>=3.9.14,<4.0.0) ; extra == "data"
+Requires-Dist: papermill (>=2.5.0,<3.0.0) ; extra == "analytics"
 Requires-Dist: pfeed[boost,data,df] (>=0.0.1.dev10,<0.0.2) ; extra == "data"
+Requires-Dist: pfolio[bayesian,data,portfolio,temporary] (>=0.0.1.dev4,<0.0.2) ; extra == "analytics"
 Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-telegram-bot (>=20.7,<21.0)
@@ -32,6 +35,7 @@ Requires-Dist: scikit-learn (>=1.4.0,<2.0.0) ; extra == "ml"
 Requires-Dist: ta (>=0.11.0,<0.12.0) ; extra == "ml"
 Requires-Dist: torch (>=2.1.2,<3.0.0) ; extra == "ml"
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Requires-Dist: voila (>=0.5.6,<0.6.0) ; extra == "analytics"
 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

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/CONTRIBUTING.md

@@ -16,4 +16,7 @@ git pull --recurse-submodules  # = git pull + git submodule update --recursive
 ```bash
 # at the root directory, run:
 jb build docs/ [--all]
+
+# check if external links are broken:
+jb build docs/ --builder linkcheck
 ```

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/adapter.py

@@ -1,12 +1,10 @@
 import yaml
 import os
 
-from pfund.const.paths import PROJ_CONFIG_PATH
-
 
 class Adapter:
-    def __init__(self, trading_venue, adapter_dict):
-        self._trading_venue = trading_venue
+    def __init__(self, config_path, adapter_dict):
+        self.config_path = config_path
         self._adapter_dict = adapter_dict
         self._adapter = {}
         self._ref_keys = []
@@ -25,9 +23,8 @@ class Adapter:
         return pdt
 
     def load_pdt_matchings(self):
-        file_path = f'{PROJ_CONFIG_PATH}/{self._trading_venue.lower()}'
         config_name = 'pdt_matchings'
-        for file_name in os.listdir(file_path):
+        for file_name in os.listdir(self.config_path):
             if not file_name.startswith(config_name):
                 continue
             file_splits = file_name.split('_')
@@ -35,7 +32,7 @@ class Adapter:
                 category = file_splits[-1].split('.')[0]
             else:
                 category = ''
-            with open(file_path + '/' + file_name, 'r') as f:
+            with open(self.config_path + '/' + file_name, 'r') as f:
                 if pdt_macthings := yaml.safe_load(f):
                     for pdt, epdt in pdt_macthings.items():
                         self.update(pdt, epdt, ref_key=category)

pfund-0.0.1.dev12/pfund/analyzer.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pfund.types.common_literals import tSUPPORTED_CODE_EDITORS, tSUPPORTED_TEMPLATE_TYPES
+
+from pfund.utils import utils
+from pfund.config_handler import ConfigHandler
+from pfund.const.paths import PROJ_PATH
+
+
+class Analyzer:    
+    try:
+        Engine = utils.get_engine_class()
+        config = Engine.config
+    except:
+        config = ConfigHandler.load_config()
+    
+    notebook_path = Path(config.notebook_path)
+    spreadsheet_path = Path(config.spreadsheet_path)
+    dashboard_path = Path(config.dashboard_path)
+    
+    def __init__(self, data: dict | None=None):
+        self.data = data or {}
+        
+    @staticmethod
+    def _is_file(template: str) -> bool:
+        if '\\' in template or '/' in template:
+            assert Path(template).resolve().is_file(), f"File {template} does not exist"
+            return True
+        return False
+    
+    @staticmethod
+    def _derive_template_type(template: str) -> tSUPPORTED_TEMPLATE_TYPES:
+        if '.ipynb' in template:
+            template_type = 'notebook'
+        elif '.grid' in template:
+            template_type = 'spreadsheet'
+        elif '.py' in template:
+            template_type = 'dashboard'
+        else:
+            raise ValueError(f"Template {template} is not a valid template, only .ipynb, .grid, .py are supported.")
+        return template_type
+    
+    def _find_template(self, template: str) -> str:
+        '''Check if the template exists in pfund's templates or user's templates
+        e.g. template = 'notebook.ipynb' or 'spreadsheet.grid' or 'dashboard.py'
+        '''
+        template_type = self._derive_template_type(template)
+        pfund_templates_dir = PROJ_PATH / 'templates' / (template_type+'s')
+        user_templates_dir = getattr(self, f'{template_type}_path')
+        for templates_dir in [pfund_templates_dir, user_templates_dir]:
+            for file_name in os.listdir(templates_dir):
+                if template == file_name:
+                    template_file_path = templates_dir / template
+                    return str(template_file_path)
+        else:
+            raise FileNotFoundError(f"Template {template} not found in pfund's templates or user's templates")
+    
+    def _get_editor_cmd(self, editor: tSUPPORTED_CODE_EDITORS) -> str:
+        if editor == 'vscode':
+            cmd = 'code'
+            if utils.is_command_available(cmd):
+                return cmd
+            else:
+                print("VSCode command 'code' is not available, cannot open the output notebook")
+        elif editor == 'pycharm':
+            for cmd in ['charm', 'pycharm']:
+                if utils.is_command_available(cmd):
+                    return cmd
+            else:
+                print("PyCharm commands 'charm'/'pycharm' are both not available, cannot open the output notebook")
+        else:
+            print(f"Editor '{editor}' is not supported, cannot open the output notebook")
+    
+    def run_notebooks(
+        self, 
+        notebooks: list[str] | str,
+        *voila_args,
+        data: dict | None=None,
+        display: bool=True,
+        port: int=8866,
+        show_results_only: bool=True,
+        open_outputs: bool=False,
+        outputs_path: str | None=None,
+        editor: tSUPPORTED_CODE_EDITORS='vscode'
+    ) -> None:
+        '''
+        Args:
+            notebook:
+                - notebook_template's name
+                - notebook's full path in str or Path
+            voila_args: additional arguments to pass to voila
+            data: data to be analyzed, if None, use the data passed to the Analyzer instance during initialization
+            display: if True, display the notebook in voila
+            show_results_only: if True, display only the results (no source code) in voila
+            open_outputs: if True, open the output notebook in the editor
+            outputs_path: path to save the output notebooks, if None, do not save the output notebooks
+        '''
+        import subprocess
+        import papermill as pm
+        
+        def _find_available_port(_port):
+            retry_num = 100
+            while retry_num:
+                if not utils.is_port_in_use(_port):
+                    return _port
+                retry_num -= 1
+                _port += 1
+            else:
+                raise Exception(f"No available ports found starting from {_port - 100}, cannot display the notebook")
+        
+        def _assert_voila_args_are_valid():
+            for arg in voila_args:
+                if not arg.startswith('--'):
+                    raise ValueError(f"Voila argument '{arg}' should start with '--'")
+                if arg.startswith('--port='):
+                    raise ValueError(f"Voila argument '{arg}' should not be passed in, use the 'port' argument instead")
+                if arg.startswith('--strip_sources='):
+                    raise ValueError(f"Voila argument '{arg}' should not be passed in, use the 'show_results_only' argument instead")
+            
+        voila_processes = []
+        nb_output_file_paths = []
+        if isinstance(notebooks, str):
+            notebooks = [notebooks]
+        data = data or self.data
+        if not data:
+            raise ValueError("No data passed in or stored in the Analyzer instance, please pass in the data to be analyzed.")
+        
+        if open_outputs:
+            assert outputs_path is not None, f"{outputs_path=}, cannot open the output notebook without saving it."
+            editor_cmd = self._get_editor_cmd(editor)
+        
+        _assert_voila_args_are_valid()
+        is_theme_provided = any(arg.startswith('--theme=') for arg in voila_args)
+        if not is_theme_provided:
+            default_theme = 'dark'
+            voila_args = [f'--theme={default_theme}', *voila_args]
+            
+        try:
+            for notebook in notebooks:
+                if self._is_file(notebook):
+                    nb_input_file_path: str = notebook
+                    notebook = Path(notebook).name  # e.g. 'notebook.ipynb'
+                else:
+                    nb_input_file_path: str = self._find_template(notebook)
+                nb_output_file_path = Path(outputs_path or '.').resolve() / f'{notebook.replace(".ipynb", "")}_output.ipynb'
+                nb_output_file_path = str(nb_output_file_path)
+                nb_output_file_paths.append(nb_output_file_path)
+                
+                print(f"Executing notebook: {notebook}")
+                pm.execute_notebook(
+                    nb_input_file_path,
+                    nb_output_file_path,
+                    parameters=data
+                )
+                
+                if open_outputs:
+                    # e.g. code notebook_output.ipynb if using vscode
+                    if editor_cmd:
+                        subprocess.run([editor_cmd, nb_output_file_path])
+                
+                if display:
+                    port = _find_available_port(port)
+                    is_last_notebook = (notebook == notebooks[-1])
+                    subprocess_func = subprocess.run if is_last_notebook else subprocess.Popen
+                    process = subprocess_func([
+                        'voila',
+                        f'--port={port}',
+                        f'--strip_sources={show_results_only}',
+                        *voila_args,
+                        nb_output_file_path
+                    ])
+                    voila_processes.append(process)
+        except KeyboardInterrupt:
+            print("KeyboardInterrupt: Stopping the execution of the notebooks")
+        except Exception:
+            raise
+        finally:
+            if outputs_path is None:
+                for nb_output_file_path in nb_output_file_paths:
+                    print(f"{outputs_path=}, removing output notebook: {nb_output_file_path}")
+                    os.remove(nb_output_file_path)
+            for process in voila_processes:
+                process.terminate()
+                process.wait()
+    
+    # TODO:
+    def run_spreadsheets(
+        self, 
+        spreadsheets: list[str] | str
+    ):
+        pass
+    
+    # TODO:
+    def run_dashboards(
+        self, 
+        dashboards: list[str] | str
+    ):
+        pass

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/brokers/ib/broker_ib.py

@@ -5,6 +5,7 @@ from collections import defaultdict
 
 from pfund.adapter import Adapter
 from pfund.config.configuration import Configuration
+from pfund.const.paths import PROJ_CONFIG_PATH
 from pfund.const.commons import SUPPORTED_PRODUCT_TYPES
 from pfund.products import IBProduct
 from pfund.accounts import IBAccount
@@ -19,8 +20,9 @@ from pfund.brokers.ib.ib_api import IBApi
 class IBBroker(LiveBroker):
     def __init__(self, env, **configs):
         super().__init__(env, 'IB', **configs)
-        self.configs = Configuration(self.bkr, 'config')
-        self.adapter = Adapter(self.bkr, self.configs.load_config_section('adapter'))
+        config_path = f'{PROJ_CONFIG_PATH}/{self.bkr.lower()}'
+        self.configs = Configuration(config_path, 'config')
+        self.adapter = Adapter(config_path, self.configs.load_config_section('adapter'))
         self.account = None
         
         # API

pfund-0.0.1.dev12/pfund/config/binance/linear/config.yml

@@ -0,0 +1,7 @@
+---
+settings:
+  private_channels: []
+...
+---
+adapter:
+  pdts: {}

pfund-0.0.1.dev12/pfund/config/binance/linear/lot_sizes_linear.yml

@@ -0,0 +1,2 @@
+# FIXME: fake
+BTC_USDT_PERP: 0.001

pfund-0.0.1.dev12/pfund/config/binance/linear/pdt_matchings_linear.yml

@@ -0,0 +1,2 @@
+BTC_USDT_PERP: BTCUSDT
+ETH_USDT_PERP: ETHUSDT

pfund-0.0.1.dev12/pfund/config/binance/linear/tick_sizes_linear.yml

@@ -0,0 +1,2 @@
+# FIXME: fake
+BTC_USDT_PERP: 0.01

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/config/configuration.py

@@ -2,23 +2,21 @@ import os
 
 import yaml
 
-from pfund.const.paths import PROJ_CONFIG_PATH
 from pfund.utils.utils import short_path
 
 
 class Configuration:
-    def __init__(self, config_dir, config_name):
-        self.config_dir = config_dir.lower()
+    def __init__(self, config_path, config_name):
+        self.config_path = config_path
         self.config_name = config_name
-        self.config_path = f'{PROJ_CONFIG_PATH}/{self.config_dir}'
         self.configs = None
         self.reload()
 
     def reload(self):
         self.configs = self.read_config(self.config_name)
     
-    def get_config_dir(self):
-        return self.config_dir
+    def get_config_path(self):
+        return self.config_path
 
     def read_config(self, config_name):
         file_path = f'{self.config_path}/{config_name}.yml'
@@ -40,7 +38,7 @@ class Configuration:
             raise Exception(f'could not find section {section} for config {self.config_name}')
 
     def check_if_config_exists_and_not_empty(self, config_name):
-        file_path = f'{PROJ_CONFIG_PATH}/{self.config_dir}/{config_name}.yml'
+        file_path = f'{self.config_path}/{config_name}.yml'
         if os.path.exists(file_path) and os.stat(file_path).st_size != 0:
             return True
         else:

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/config_handler.py

@@ -98,6 +98,10 @@ class ConfigHandler:
     def dashboard_path(self):
         return f'{self.data_path}/templates/dashboards'
     
+    @property
+    def artifact_path(self):
+        return f'{self.data_path}/.artifacts'
+    
     def __post_init__(self):
         self.logging_config = self.logging_config or {}
         

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/const/commons.py

@@ -20,4 +20,6 @@ SUPPORTED_TIMEFRAMES = [
 ]
 SUPPORTED_DATA_CHANNELS = ['orderbook', 'tradebook', 'kline']
 SUPPORTED_BACKTEST_MODES = ['vectorized', 'event_driven']
-SUPPORTED_DATA_TOOLS = ['pandas']
+SUPPORTED_DATA_TOOLS = ['pandas']
+SUPPORTED_CODE_EDITORS = ['vscode', 'pycharm']
+SUPPORTED_TEMPLATE_TYPES = ['notebook', 'spreadsheet', 'dashboard']

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/const/paths.py

@@ -24,3 +24,4 @@ BACKTEST_PATH = DATA_PATH / 'backtests'
 NOTEBOOK_PATH = DATA_PATH / 'templates' / 'notebooks'
 SPREADSHEET_PATH = DATA_PATH / 'templates' / 'spreadsheets'
 DASHBOARD_PATH = DATA_PATH / 'templates' / 'dashboards'
+ARTIFACT_PATH = DATA_PATH / '.artifacts'

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/data_tools/data_tool_pandas.py

@@ -151,12 +151,8 @@ 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 output_df_to_parquet(self, df: pd.DataFrame, file_path: str):
+        df.to_parquet(file_path)
     
     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.dev10 → pfund-0.0.1.dev12}/pfund/engines/backtest_engine.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import hashlib
+import inspect
 import os
 import time
 import datetime
@@ -13,6 +14,7 @@ if TYPE_CHECKING:
     from pfund.types.core import tStrategy, tModel, tFeature, tIndicator
     
 import pfund as pf
+from pfund.git_controller import GitController
 from pfund.engines.base_engine import BaseEngine
 from pfund.brokers.broker_backtest import BacktestBroker
 from pfund.strategies.strategy_base import BaseStrategy
@@ -23,7 +25,7 @@ from pfund.mixins.backtest import BacktestMixin
 
 
 class BacktestEngine(BaseEngine):
-    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):
+    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, auto_git_commit=False, **settings):
         if not hasattr(cls, 'mode'):
             cls.mode = mode.lower()
         if not hasattr(cls, 'append_to_strategy_df'):
@@ -32,13 +34,18 @@ class BacktestEngine(BaseEngine):
         # instead of recalculating the signals. This will make event-driven backtesting faster but less consistent with live trading
         if not hasattr(cls, 'use_prepared_signals'):
             cls.use_prepared_signals = use_prepared_signals
+        if not hasattr(cls, 'auto_git_commit'):
+            cls.auto_git_commit = auto_git_commit
         return super().__new__(cls, env, data_tool=data_tool, config=config, **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)
+    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, auto_git_commit=False, **settings):
         # avoid re-initialization to implement singleton class correctly
-        # if not hasattr(self, '_initialized'):
-        #     pass
+        if not hasattr(self, '_initialized'):
+            # Get the current frame and then the outer frame (where the engine instance is created)
+            caller_frame = inspect.currentframe().f_back
+            file_path = caller_frame.f_code.co_filename  # Extract the file path from the frame
+            self._git = GitController(os.path.abspath(file_path))
+            super().__init__(env, data_tool=data_tool)
     
     # 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
@@ -88,11 +95,11 @@ class BacktestEngine(BaseEngine):
     def _generate_backtest_id() -> str:
         return uuid.uuid4().hex
     
-    def _create_backtest_name(self, strat: str):
+    def _create_backtest_name(self, strat: str, backtest_id: str, backtest_id_length: int=12):
         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])
+        trimmed_backtest_id = backtest_id[:backtest_id_length]
+        return '.'.join([strat, utcnow, trimmed_backtest_id])
     
     @staticmethod 
     def _generate_backtest_hash(strategy: BaseStrategy):
@@ -131,60 +138,64 @@ class BacktestEngine(BaseEngine):
         except:
             self.logger.exception(f"Error writing to {file_path}:")
     
-    def _generate_backtest_iteration(self, strategy: BaseStrategy) -> int:
+    def _generate_backtest_iteration(self, backtest_hash: str) -> 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]
+    def _commit_strategy(self, strategy: BaseStrategy) -> str | None:
+        engine_name = self.__class__.__name__
+        strat = strategy.name
+        commit_hash: str | None = self._git.commit(strategy._file_path, f'[PFund] {engine_name}: auto-commit strategy "{strat}"')
+        if commit_hash:
+            self.logger.debug(f"Strategy {strat} committed. {commit_hash=}")
+        else:
+            commit_hash = self._git.get_last_n_commit(n=1)[0]
+            self.logger.debug(f"Strategy {strat} has no changes to commit, return the last {commit_hash=}")
+        return commit_hash
+    
+    def _output_backtest_results(self, strat: str, df, start_time: float, end_time: float, commit_hash: str | None):
         strategy = self.get_strategy(strat)
+        backtest_id = self._generate_backtest_id()
+        backtest_hash = self._generate_backtest_hash(strategy)
+        backtest_name = self._create_backtest_name(strat, backtest_id)
+        backtest_iter = self._generate_backtest_iteration(backtest_hash)
         local_tz = utils.get_local_timezone()
         duration = end_time - start_time
+        df_file_path = os.path.join(self.config.backtest_path, f'{backtest_name}.parquet')
         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),
+                'backtest_hash': backtest_hash,
+                'backtest_name': backtest_name,
+                'backtest_iteration': backtest_iter,
+                'commit_hash': commit_hash,
                 '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'),
+                'settings': self.settings,
             },
             'strategy': strategy.to_dict(),
-            'results': {
-                'df_file_path': os.path.join(self.config.backtest_path, f'{backtest_name_trimmed}.parquet'),
-            }
+            'result': df_file_path
         }
-        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)
+        self.data_tool.output_df_to_parquet(df, df_file_path)
+        self._write_json(f'{backtest_name}.json', backtest_history)
+        return backtest_history
         
     def run(self):
         for broker in self.brokers.values():
             broker.start()
         self.strategy_manager.start()
 
+        backtests = {}
         if self.mode == 'vectorized':
             for strat, strategy in self.strategy_manager.strategies.items():
                 # _dummy strategy is only created for model training, do nothing
@@ -192,11 +203,16 @@ class BacktestEngine(BaseEngine):
                     continue
                 if not hasattr(strategy, 'backtest'):
                     raise Exception(f'Strategy {strat} does not have backtest() method, cannot run vectorized backtesting')
+                if self.auto_git_commit and self._git.is_git_repo():
+                    commit_hash = self._commit_strategy(strategy)
+                else:
+                    commit_hash = None
                 start_time = time.time()
                 strategy.backtest()
                 end_time = time.time()
                 df = strategy.get_df()
-                self.output_backtest_results(strat, df, start_time, end_time)
+                backtest_history: dict = self._output_backtest_results(strat, df, start_time, end_time, commit_hash)
+                backtests[strat] = backtest_history
         elif self.mode == 'event_driven':
             for strat, strategy in self.strategy_manager.strategies.items():
                 if strat == '_dummy':
@@ -248,6 +264,7 @@ class BacktestEngine(BaseEngine):
         else:
             raise NotImplementedError(f'Backtesting mode {self.mode} is not supported')
         self.strategy_manager.stop(reason='finished backtesting')
+        return backtests
 
     def end(self):
         self.strategy_manager.stop(reason='finished backtesting')

{pfund-0.0.1.dev10 → pfund-0.0.1.dev12}/pfund/engines/trade_engine.py

@@ -22,7 +22,7 @@ import schedule
 
 from pfund.engines.base_engine import BaseEngine
 from pfund.brokers.broker_base import BaseBroker
-from pfund.utils.utils import flatten_dict
+from pfund.utils.utils import flatten_dict, is_port_in_use
 from pfund.zeromq import ZeroMQ
 from pfund.config_handler import ConfigHandler
 
@@ -57,15 +57,12 @@ class TradeEngine(BaseEngine):
     def _assign_zmq_ports(self) -> dict:
         _assigned_ports = []
         def _is_port_available(_port):
-            import socket
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                _is_port_in_use = (s.connect_ex(('localhost', _port)) == 0)
-                _is_port_assigned = (_port in _assigned_ports)
-                if _is_port_in_use or _is_port_assigned:
-                    return False
-                else:
-                    _assigned_ports.append(_port)
-                    return True
+            _is_port_assigned = (_port in _assigned_ports)
+            if is_port_in_use(_port) or _is_port_assigned:
+                return False
+            else:
+                _assigned_ports.append(_port)
+                return True
         def _get_port(start_port=None):
             _port = start_port or self._zmq_port
             if _is_port_available(_port):

pfund-0.0.1.dev12/pfund/exchanges/binance/__init__.py

@@ -0,0 +1,3 @@
+from pfund.exchanges.binance.exchange import Exchange as Binance
+from pfund.exchanges.binance.rest_api import RestApi as BinanceRestApi
+from pfund.exchanges.binance.ws_api import WebsocketApi as BinanceWebsocketApi

pfund-0.0.1.dev12/pfund/exchanges/binance/exchange.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from pfund.exchanges.exchange_base import BaseExchange
+        
+        
+class Exchange(BaseExchange):
+    SUPPORTED_CATEGORIES = ['linear', 'inverse', 'spot', 'option']
+    PTYPE_TO_CATEGORY = {
+        'PERP': 'linear',
+        'FUT': 'linear',
+        'IPERP': 'inverse',
+        'IFUT': 'inverse',
+        'SPOT': 'spot',
+        'OPT': 'option',
+    }
+    def __new__(cls, env: str, ptype: str):
+        from pfund.exchanges.binance.linear.exchange import ExchangeLinear
+        
+        ptype = ptype.upper()
+        category = cls.PTYPE_TO_CATEGORY[ptype]
+        
+        if category == 'linear':
+            instance = super().__new__(ExchangeLinear)
+            instance.category = category
+            return instance
+        # EXTEND: Add other categories
+        else:
+            raise ValueError(f"Invalid {category=}")
+    
+    def __init__(self, env: str, ptype: str):
+        exch = Path(__file__).parent.name
+        super().__init__(env, exch)
+        
+    # FIXME: temporarily override the method, remove it later
+    def _setup_configs(self):
+        pass
+    

pfund-0.0.1.dev12/pfund/exchanges/binance/linear/exchange.py

@@ -0,0 +1,6 @@
+from pfund.exchanges.binance.exchange import Exchange
+
+
+class ExchangeLinear(Exchange):
+    def __init__(self, env: str, ptype: str):
+        super().__init__(env, ptype)