pfund 0.0.1.dev3__tar.gz → 0.0.1.dev4__tar.gz

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pfund
-Version: 0.0.1.dev3
+Version: 0.0.1.dev4
 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,9 +13,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: orjson (>=3.9.12,<4.0.0)
+Requires-Dist: orjson (>=3.9.14,<4.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: pfeed (>=0.0.1.dev3,<0.0.2)
+Requires-Dist: pfeed (>=0.0.1.dev4,<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)
@@ -33,6 +33,7 @@ Description-Content-Type: text/markdown
 
 # PFund: Algo-Trading Framework for Machine Learning, TradFi, CeFi and DeFi ready.
 
+[![Jupyter Book Badge](docs/images/jupyterbook.svg)](https://jupyterbook.org)
 [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
 [![PyPI](https://img.shields.io/pypi/v/pfund.svg)](https://pypi.org/project/pfund)
 ![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/pfund)

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/README.md

@@ -1,5 +1,6 @@
 # PFund: Algo-Trading Framework for Machine Learning, TradFi, CeFi and DeFi ready.
 
+[![Jupyter Book Badge](docs/images/jupyterbook.svg)](https://jupyterbook.org)
 [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
 [![PyPI](https://img.shields.io/pypi/v/pfund.svg)](https://pypi.org/project/pfund)
 ![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/pfund)

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/__init__.py

@@ -1,3 +1,5 @@
+from importlib.metadata import version
+
 from pfund.config_handler import configure
 from pfund.engines import BacktestEngine, TrainEngine, TestEngine, TradeEngine
 from pfund.strategies import Strategy
@@ -11,7 +13,6 @@ try:
 except ImportError:
     pass
 from pfund.indicators import TAIndicator, TALibIndicator
-from importlib.metadata import version
 
 
 __version__ = version('pfund')
@@ -23,4 +24,4 @@ __all__ = (
     'BacktestEngine', 'TrainEngine', 'TestEngine', 'TradeEngine',
     'Strategy', 'Model', 'PyTorchModel', 'SKLearnModel',
     'Feature', 'TAIndicator', 'TALibIndicator',
-)
+)

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/cli/commands/config.py

@@ -9,14 +9,6 @@ from pfund.const.paths import USER_CONFIG_FILE_PATH
 from pfund.config_handler import ConfigHandler
 
 
-def load_config(config_file_path: str | Path):
-    config_file_path = Path(config_file_path)
-    if config_file_path.is_file():
-        with open(config_file_path, 'r') as f:
-            return yaml.safe_load(f) or {}
-    return {}
-
-
 def save_config(config: ConfigHandler, config_file_path: str | Path):
     with open(config_file_path, 'w') as f:
         yaml.dump(config.__dict__, f, default_flow_style=False)
@@ -48,14 +40,16 @@ def config(ctx, **kwargs):
     if kwargs.get('list'):  # Check if --list was used
         del provided_options['list']
         assert not provided_options, "No options should be provided with --list"
-        click.echo(f"PFund's config:\n{pformat(config.__dict__)}")
+        config_dict = config.__dict__
+        config_dict.update({'config_file_path': USER_CONFIG_FILE_PATH})
+        click.echo(f"PFund's config:\n{pformat(config_dict)}")
         return
 
     if kwargs.get('reset'): # Check if --reset was used
         del provided_options['reset']
         assert not provided_options, "No options should be provided with --reset"
         remove_config(USER_CONFIG_FILE_PATH)
-        click.echo("PFund;s config successfully reset.")
+        click.echo("PFund's config successfully reset.")
         return
     
     # prints out current config if no options are provided

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/cli/commands/docker_compose.py

@@ -20,7 +20,7 @@ def docker_compose(ctx, env_file_path, docker_file_path):
     if not env_file_path:
         env_file_path = find_dotenv(usecwd=True, raise_error_if_not_found=True)
         click.echo(f'.env file path is not specified, using env file in "{env_file_path}"')
-    load_dotenv(env_file_path)
+    load_dotenv(env_file_path, override=True)
     if not docker_file_path:
         package_dir = Path(importlib.resources.files(PROJ_NAME)).resolve().parents[0]
         docker_file_path = package_dir / 'docker-compose.yml'

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/cli/main.py

@@ -1,9 +1,8 @@
 import click
 
 from pfund.config_handler import ConfigHandler
-from pfund.const.paths import USER_CONFIG_FILE_PATH
 from pfund.cli.commands.docker_compose import docker_compose
-from pfund.cli.commands.config import config, load_config
+from pfund.cli.commands.config import config
 
 
 @click.group(context_settings={"help_option_names": ["-h", "--help"]})
@@ -12,8 +11,7 @@ from pfund.cli.commands.config import config, load_config
 def pfund_group(ctx):
     """pfund's CLI"""
     ctx.ensure_object(dict)
-    config: dict = load_config(USER_CONFIG_FILE_PATH)
-    ctx.obj['config'] = ConfigHandler(**config)
+    ctx.obj['config'] = ConfigHandler.load_config()
 
 
 pfund_group.add_command(docker_compose)

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/config_handler.py

@@ -6,13 +6,14 @@ import logging
 from types import TracebackType
 from dataclasses import dataclass
 
+import yaml
 # from rich.traceback import install
 
-from pfund.const.paths import PROJ_NAME, PROJ_PATH, LOG_PATH, PROJ_CONFIG_PATH, DATA_PATH
+from pfund.const.paths import PROJ_NAME, PROJ_PATH, LOG_PATH, PROJ_CONFIG_PATH, DATA_PATH, USER_CONFIG_FILE_PATH
+
 # add python path so that for files like "ibapi" (official python code from IB)
 # can find their modules
 sys.path.append(f'{PROJ_PATH}/externals')
-
 # install(show_locals=False)  # rich will set its own sys.excepthook
 # rich_excepthook = sys.excepthook  # get rich's excepthook
 
@@ -50,19 +51,29 @@ def import_strategies_models_features_or_indicators(path: str):
 
 @dataclass
 class ConfigHandler:
-    data_path: str = str(DATA_PATH),
+    data_path: str = str(DATA_PATH)
     log_path: str = str(LOG_PATH)
     logging_config_file_path: str = f'{PROJ_CONFIG_PATH}/logging.yml'
     logging_config: dict | None = None
     use_fork_process: bool = True
     use_custom_excepthook: bool = True
     
+    @classmethod
+    def load_config(cls):
+        config_file_path = USER_CONFIG_FILE_PATH
+        if config_file_path.is_file():
+            with open(config_file_path, 'r') as f:
+                config = yaml.safe_load(f) or {}
+        else:
+            config = {}
+        return cls(**config)
+    
     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 [strategy_path, model_path, feature_path, indicator_path]:
             if not os.path.exists(path):
                 os.makedirs(path)
                 print(f'created {path}')
@@ -74,7 +85,7 @@ class ConfigHandler:
         
         if self.use_custom_excepthook:
             sys.excepthook = _custom_excepthook
-            
+    
 
 def configure(
     data_path: str = str(DATA_PATH),

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/engines/backtest_engine.py

@@ -79,8 +79,7 @@ class BacktestEngine(BaseEngine):
                     continue
                 if not hasattr(strategy, 'backtest'):
                     raise Exception(f'Strategy {strat} does not have backtest() method, cannot run vectorized backtesting')
-                df = strategy.get_df()
-                strategy.backtest(df.copy(deep=True))
+                strategy.backtest()
         elif self.mode == 'event_driven':
             for strat, strategy in self.strategy_manager.strategies.items():
                 if strat == '_dummy':

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/engines/base_engine.py

@@ -12,6 +12,7 @@ from pfund.managers.strategy_manager import StrategyManager
 from pfund.const.commons import *
 from pfund.config_handler import ConfigHandler
 from pfund.plogging import set_up_loggers
+from pfund.plogging.config import LoggingDictConfigurator
 
 
 ENV_COLORS = {
@@ -43,10 +44,10 @@ class BaseEngine(Singleton):
         if not hasattr(cls, 'settings'):
             cls.settings = settings
         if not hasattr(cls, 'config'):
-            cls.config = config if config else ConfigHandler()
+            cls.config = config if config else ConfigHandler.load_config()
             log_path = f'{cls.config.log_path}/{cls.env}'
             logging_config_file_path = cls.config.logging_config_file_path
-            set_up_loggers(log_path, logging_config_file_path, user_logging_config=cls.config.logging_config)
+            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):

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/mixins/backtest.py

@@ -12,7 +12,6 @@ if TYPE_CHECKING:
 
 from pfund.managers.data_manager import get_resolutions_from_kwargs
 from pfund.models.model_backtest import BacktestModel
-from pfund.strategies.strategy_base import BaseStrategy
 from pfund.models.model_base import BaseModel
 
 
@@ -25,7 +24,7 @@ class BacktestMixin:
         backtest_kwargs, train_kwargs = backtest or {}, train or {}
         
         if backtest_kwargs:
-            data_source = self._get_data_source(backtest_kwargs)
+            data_source = self._get_data_source(trading_venue, backtest_kwargs)
             feed = self.get_feed(data_source)
             kwargs = self._prepare_kwargs(feed, kwargs)
         
@@ -45,11 +44,15 @@ class BacktestMixin:
         model = BacktestModel(type(model), model.ml_model, *model._args, **model._kwargs)
         return super().add_model(model, name=name, model_path=model_path, is_load=is_load)
         
-    def _get_data_source(self, backtest_kwargs: dict):
+    def _get_data_source(self, trading_venue: str, backtest_kwargs: dict):
         from pfeed.const.commons import SUPPORTED_DATA_FEEDS
+        trading_venue = trading_venue.upper()
+        # if data_source is not defined, use trading_venue as data_source
+        if trading_venue in SUPPORTED_DATA_FEEDS and 'data_source' not in backtest_kwargs:
+            backtest_kwargs['data_source'] = trading_venue
         assert 'data_source' in backtest_kwargs, f"data_source must be defined"
         data_source = backtest_kwargs['data_source'].upper()
-        assert backtest_kwargs['data_source'] in SUPPORTED_DATA_FEEDS, f"{data_source=} not in {SUPPORTED_DATA_FEEDS}"
+        assert data_source in SUPPORTED_DATA_FEEDS, f"{data_source=} not in {SUPPORTED_DATA_FEEDS}"
         return data_source
     
     def _prepare_kwargs(self, feed: BaseFeed, kwargs: dict):
@@ -99,10 +102,12 @@ class BacktestMixin:
 
     @staticmethod
     def get_feed(data_source: str) -> BaseFeed:
-        import pfeed as dd
+        from pfeed.feeds import YahooFinanceFeed, BybitFeed
         data_source = data_source.upper()
         if data_source == 'YAHOO_FINANCE':
-            feed = dd.YahooFinanceFeed()
+            feed = YahooFinanceFeed()
+        elif data_source == 'BYBIT':
+            feed = BybitFeed()
         # TODO: other feeds
         else:
             raise NotImplementedError
@@ -123,9 +128,9 @@ class BacktestMixin:
                     continue
             product = data.product
             resolution = data.resolution
-            symbol = product.symbol
-            df = feed.get_historical_data(symbol, rollback_period=rollback_period, start_date=start_date, end_date=end_date, resolution=repr(resolution), **backtest_kwargs)
-            assert not df.empty, f"dataframe is empty for {symbol=}"
+            pdt_or_symbol = product.symbol if feed.name == 'YAHOO_FINANCE' else product.pdt
+            df = feed.get_historical_data(pdt_or_symbol, rollback_period=rollback_period, start_date=start_date, end_date=end_date, resolution=repr(resolution), **backtest_kwargs)
+            assert not df.empty, f"dataframe is empty for {pdt_or_symbol=}"
             df.reset_index(inplace=True)
             latest_date = str(df['ts'][0])
             if feed.name == 'YAHOO_FINANCE' and latest_date == utcnow_date:

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/plogging/__init__.py

@@ -1,11 +1,10 @@
 import os
 import logging
-from pathlib import Path
 
 from typing import Literal
 
 from pfund.plogging.config import LoggingDictConfigurator
-from pfund.utils.utils import load_yaml_file
+from pfund.utils.utils import load_yaml_file, get_engine_class
 
 
 def print_all_loggers():
@@ -14,7 +13,7 @@ def print_all_loggers():
             print(name, logger, logger.handlers)
 
 
-def set_up_loggers(log_path, logging_config_file_path, user_logging_config: dict | None=None):
+def set_up_loggers(log_path, logging_config_file_path, user_logging_config: dict | None=None) -> LoggingDictConfigurator:
     def deep_update(default_dict, override_dict, raise_if_key_not_exist=False):
         '''Updates a default dictionary with an override dictionary, supports nested dictionaries.'''
         for key, value in override_dict.items():
@@ -33,9 +32,8 @@ def set_up_loggers(log_path, logging_config_file_path, user_logging_config: dict
             else:
                 # Update the key with the override value
                 default_dict[key] = value
-    print('Setting up loggers...')
-    log_path, logging_config_file_path = Path(log_path), Path(logging_config_file_path)
-    if not log_path.exists():
+    # print('Setting up loggers...')
+    if not os.path.exists(log_path):
         os.makedirs(log_path)
         print(f'created {str(log_path)}')
     logging_config: dict = load_yaml_file(logging_config_file_path)
@@ -43,8 +41,10 @@ def set_up_loggers(log_path, logging_config_file_path, user_logging_config: dict
         deep_update(logging_config, user_logging_config)
     logging_config['log_path'] = log_path
     # ≈ logging.config.dictConfig(logging_config) with a custom configurator
-    LoggingDictConfigurator(logging_config).configure()
-    
+    logging_configurator = LoggingDictConfigurator(logging_config)
+    logging_configurator.configure()
+    return logging_configurator
+
 
 # TODO: support 'feature', 'indicator'
 def create_dynamic_logger(name: str, type_: Literal['strategy', 'model', 'manager']):
@@ -57,8 +57,8 @@ def create_dynamic_logger(name: str, type_: Literal['strategy', 'model', 'manage
     assert name, "logger name cannot be empty/None"
     assert type_ in ['strategy', 'model', 'manager'], f"Unsupported {type_=}"
     
-    # NOTE: LoggingDictConfigurator is a singleton, since it has already configured in set_up_loggers(), no need to pass in config to it
-    config = LoggingDictConfigurator(config=None)
+    Engine = get_engine_class()
+    config = Engine.logging_configurator
     
     logging_config = config.config_orig
     loggers_config = logging_config['loggers']

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pfund/plogging/config.py

@@ -4,7 +4,6 @@ import copy
 import logging
 from logging.config import DictConfigurator
 
-from pfund.utils.utils import Singleton
 from pfund.plogging.filters import FullPathFilter
 from pfund.plogging.formatter import ColoredFormatter
 
@@ -19,7 +18,7 @@ LEVELS = {
 
 
 # override logging's DictConfigurator as it doesn't pass in logger names to file handlers to create filenames
-class LoggingDictConfigurator(Singleton, DictConfigurator):
+class LoggingDictConfigurator(DictConfigurator):
     _MANUALLY_CONFIGURED_HANDLERS = [
         'file_handler', 
         'compressed_timed_rotating_file_handler',

{pfund-0.0.1.dev3 → pfund-0.0.1.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pfund"
-version = "0.0.1.dev3"
+version = "0.0.1.dev4"
 description = "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"
 license = "Apache-2.0"
 authors = ["Stephen Yau <softwareentrepreneer+pfund@gmail.com>"]
@@ -12,11 +12,11 @@ keywords = ["trading", "algo-trading", "stocks", "cryptos", "cryptocurrencies",
 
 [tool.poetry.dependencies]
 python = "^3.10 <3.12"
-pfeed = "^0.0.1.dev3"
+pfeed = "^0.0.1.dev4"
 pyzmq = "^25.1.2"
 pyyaml = "^6.0.1"
 psutil = "^5.9.8"
-orjson = "^3.9.12"
+orjson = "^3.9.14"
 rich = "^13.7.0"
 schedule = "^1.2.1"
 websocket-client = "^1.7.0"
@@ -39,14 +39,18 @@ pfeed = {path = "../pfeed", develop = true}
 pybit = "^5.6.2"
 ta-lib = "^0.4.28"
 pytest = "^8.0.0"
-sphinx = "^7.2.6"
-autodocsumm = {git = "https://github.com/Chilipp/autodocsumm.git"}
-sphinxcontrib-napoleon = "^0.7"
-pre-commit = "^3.6.0"
+pre-commit = "^3.6.1"
 bandit = "^1.7.7"
 ruff = "^0.1.15"
 pyright = "^1.1.349"
 
+[tool.poetry.group.doc]
+optional = true
+
+[tool.poetry.group.doc.dependencies]
+jupyter-book = "^1.0.0"
+notebook = "^7.1.0"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"