pfund 0.0.1.dev2__tar.gz → 0.0.1.dev4__tar.gz

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

@@ -1,23 +1,21 @@
 Metadata-Version: 2.1
 Name: pfund
-Version: 0.0.1.dev2
+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
 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,<4.0
+Requires-Python: >=3.10,<3.12
 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
-Provides-Extra: ml
 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.dev1,<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)
@@ -25,9 +23,9 @@ 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: scikit-learn (>=1.4.0,<2.0.0) ; extra == "ml"
+Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
 Requires-Dist: ta (>=0.11.0,<0.12.0)
-Requires-Dist: torch (>=2.1.2,<3.0.0) ; extra == "ml"
+Requires-Dist: torch (>=2.1.2,<3.0.0)
 Requires-Dist: websocket-client (>=1.7.0,<2.0.0)
 Project-URL: Documentation, https://pfund.ai/docs
 Project-URL: Repository, https://github.com/PFund-Software-Ltd/pfund
@@ -35,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)
@@ -108,7 +107,7 @@ This overview already omits some intricate steps, such as data handling and API
 - [x] Supports machine learning models, features, technical analysis indicators
 - [x] Both Strategy() and Model() are treated as first-class citizens
 - [x] Offers LEGO-style strategy and model building, allowing strategies to add other strategies, models to add other models
-- [x] Standardizes the algo-trading flow, from vectorized backtesting for strategy prototyping and event-driven backtesting for strategy development, to live trading for strategy deployment
+- [x] Streamlines the algo-trading flow, from vectorized backtesting for strategy prototyping and event-driven backtesting for strategy development, to live trading for strategy deployment
 - [x] Enables parallel data processing, e.g. Interactive Brokers and Binance each have their own process for receiving data feeds
 - [ ] Allows choosing your preferred data tool, e.g. pandas, polars, pyspark etc.
 - [ ] Features a modern frontend using [Mantine UI](https://ui.mantine.dev/) and TradingView's Charts library
@@ -117,28 +116,16 @@ This overview already omits some intricate steps, such as data handling and API
 
 ## Installation
 ### Using [Poetry](https://python-poetry.org) (Recommended)
-> If you don't have poetry installed, please visit https://python-poetry.org/docs/
 ```bash
 poetry add pfund
 ```
 
-> To include the machine learning dependencies: \
-(Note that pytorch is not available in python 3.12)
-```bash
-poetry add pfund[ml]
-```
 
 ### Using Pip
 ```bash
 pip install pfund
 ```
 
-> To include the machine learning dependencies: \
-(Note that pytorch is not available in python 3.12)
-```bash
-pip install pfund[ml]
-```
-
 
 ## Quick Start
 ### Backtesting

{pfund-0.0.1.dev2 → 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)
@@ -73,7 +74,7 @@ This overview already omits some intricate steps, such as data handling and API
 - [x] Supports machine learning models, features, technical analysis indicators
 - [x] Both Strategy() and Model() are treated as first-class citizens
 - [x] Offers LEGO-style strategy and model building, allowing strategies to add other strategies, models to add other models
-- [x] Standardizes the algo-trading flow, from vectorized backtesting for strategy prototyping and event-driven backtesting for strategy development, to live trading for strategy deployment
+- [x] Streamlines the algo-trading flow, from vectorized backtesting for strategy prototyping and event-driven backtesting for strategy development, to live trading for strategy deployment
 - [x] Enables parallel data processing, e.g. Interactive Brokers and Binance each have their own process for receiving data feeds
 - [ ] Allows choosing your preferred data tool, e.g. pandas, polars, pyspark etc.
 - [ ] Features a modern frontend using [Mantine UI](https://ui.mantine.dev/) and TradingView's Charts library
@@ -82,28 +83,16 @@ This overview already omits some intricate steps, such as data handling and API
 
 ## Installation
 ### Using [Poetry](https://python-poetry.org) (Recommended)
-> If you don't have poetry installed, please visit https://python-poetry.org/docs/
 ```bash
 poetry add pfund
 ```
 
-> To include the machine learning dependencies: \
-(Note that pytorch is not available in python 3.12)
-```bash
-poetry add pfund[ml]
-```
 
 ### Using Pip
 ```bash
 pip install pfund
 ```
 
-> To include the machine learning dependencies: \
-(Note that pytorch is not available in python 3.12)
-```bash
-pip install pfund[ml]
-```
-
 
 ## Quick Start
 ### Backtesting

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

@@ -1,9 +1,18 @@
+from importlib.metadata import version
+
 from pfund.config_handler import configure
 from pfund.engines import BacktestEngine, TrainEngine, TestEngine, TradeEngine
 from pfund.strategies import Strategy
-from pfund.models import Feature, Model, PyTorchModel, SKLearnModel
+from pfund.models import Feature, Model
+try:
+    from pfund.models import PyTorchModel
+except ImportError:
+    pass
+try:
+    from pfund.models import SKLearnModel
+except ImportError:
+    pass
 from pfund.indicators import TAIndicator, TALibIndicator
-from importlib.metadata import version
 
 
 __version__ = version('pfund')
@@ -15,4 +24,4 @@ __all__ = (
     'BacktestEngine', 'TrainEngine', 'TestEngine', 'TradeEngine',
     'Strategy', 'Model', 'PyTorchModel', 'SKLearnModel',
     'Feature', 'TAIndicator', 'TALibIndicator',
-)
+)

pfund-0.0.1.dev4/pfund/cli/__init__.py

@@ -0,0 +1,4 @@
+from pfund.cli.main import pfund_group
+
+
+__all__ = ["pfund_group"]

pfund-0.0.1.dev4/pfund/cli/commands/config.py

@@ -0,0 +1,64 @@
+import os
+import yaml
+from pathlib import Path
+from pprint import pformat
+
+import click
+
+from pfund.const.paths import USER_CONFIG_FILE_PATH
+from pfund.config_handler import ConfigHandler
+
+
+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)
+        
+
+def remove_config(config_file_path: str | Path):
+    config_file_path = Path(config_file_path)
+    if config_file_path.is_file():
+        os.remove(config_file_path)
+
+
+@click.command()
+@click.pass_context
+@click.option('--data-path', type=click.Path(resolve_path=True), help='Set the data path for storing strategies, models, features and indicators')
+@click.option('--log-path', type=click.Path(resolve_path=True), help='Set the log path')
+@click.option('--logging-file', 'logging_config_file_path', type=click.Path(resolve_path=True, exists=True), help='Set the logging config file path')
+@click.option('--logging-config', type=dict, help='Set the logging config')
+@click.option('--use-fork-process', type=bool, help='If True, multiprocessing.set_start_method("fork")')
+@click.option('--use-custom-excepthook', type=bool, help='If True, log uncaught exceptions to file')
+@click.option('--list', '-l', is_flag=True, is_eager=True, help='List all available options')
+@click.option('--reset', is_flag=True, is_eager=True, help='Reset the configuration to defaults') 
+def config(ctx, **kwargs):
+    """Configures pfund settings."""
+    config: ConfigHandler = ctx.obj['config']
+    
+    # Filter out options that were not provided by the user
+    provided_options = {k: v for k, v in kwargs.items() if v is not None and v is not False}
+    
+    if kwargs.get('list'):  # Check if --list was used
+        del provided_options['list']
+        assert not provided_options, "No options should be provided with --list"
+        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.")
+        return
+    
+    # prints out current config if no options are provided
+    if not provided_options:
+        raise click.UsageError("No options provided. Use --list to see all available options.")
+    else:
+        for option, value in provided_options.items():
+            setattr(config, option, value)
+            click.echo(f"{option} set to: {value}")
+        
+        save_config(config, USER_CONFIG_FILE_PATH)
+        click.echo(f"config saved to {USER_CONFIG_FILE_PATH}.")

pfund-0.0.1.dev4/pfund/cli/commands/docker_compose.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+import importlib.resources
+import subprocess
+
+from dotenv import find_dotenv, load_dotenv
+import click
+
+from pfund.const.paths import PROJ_NAME
+
+
+@click.command(context_settings=dict(
+    ignore_unknown_options=True,
+    allow_extra_args=True,
+))
+@click.pass_context
+@click.option('--env-file', 'env_file_path', type=click.Path(exists=True), help='Path to the .env file')
+@click.option('--docker-file', 'docker_file_path', type=click.Path(exists=True), help='Path to the docker-compose.yml file')
+def docker_compose(ctx, env_file_path, docker_file_path):
+    """Forwards commands to docker-compose with the package's docker-compose.yml file if not specified."""
+    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, 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'
+    else:
+        click.echo(f'loaded custom docker-compose.yml file from "{docker_file_path}"')
+    command = ['docker-compose', '-f', str(docker_file_path)] + ctx.args
+    subprocess.run(command)

pfund-0.0.1.dev4/pfund/cli/main.py

@@ -0,0 +1,18 @@
+import click
+
+from pfund.config_handler import ConfigHandler
+from pfund.cli.commands.docker_compose import docker_compose
+from pfund.cli.commands.config import config
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.pass_context
+@click.version_option()
+def pfund_group(ctx):
+    """pfund's CLI"""
+    ctx.ensure_object(dict)
+    ctx.obj['config'] = ConfigHandler.load_config()
+
+
+pfund_group.add_command(docker_compose)
+pfund_group.add_command(config)

{pfund-0.0.1.dev2 → pfund-0.0.1.dev4}/pfund/config/configuration.py

@@ -26,14 +26,14 @@ class Configuration:
     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)
+        # short_file_path = short_path(file_path)
         if not os.path.exists(file_path):
-            print(f'cannot find config {short_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 {short_file_path}')
+                    print(f'loaded config {file_path}')
                 return list(yaml.safe_load_all(f))
 
     def write_config(self, config_name, content):

{pfund-0.0.1.dev2 → 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, STRATEGY_PATH, MODEL_PATH, FEATURE_PATH, INDICATOR_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,18 +51,29 @@ def import_strategies_models_features_or_indicators(path: str):
 
 @dataclass
 class ConfigHandler:
-    strategy_path: str = str(STRATEGY_PATH)
-    model_path: str = str(MODEL_PATH)
-    feature_path: str = str(FEATURE_PATH)
-    indicator_path: str = str(INDICATOR_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):
-        for path in (self.strategy_path, self.model_path, self.feature_path, self.indicator_path):
+        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]:
             if not os.path.exists(path):
                 os.makedirs(path)
                 print(f'created {path}')
@@ -73,13 +85,10 @@ class ConfigHandler:
         
         if self.use_custom_excepthook:
             sys.excepthook = _custom_excepthook
-            
+    
 
 def configure(
-    strategy_path: str = str(STRATEGY_PATH),
-    model_path: str = str(MODEL_PATH),
-    feature_path: str = str(FEATURE_PATH),
-    indicator_path: str = str(INDICATOR_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,
@@ -87,10 +96,7 @@ def configure(
     use_custom_excepthook: bool=True,
 ):
     return ConfigHandler(
-        strategy_path=strategy_path,
-        model_path=model_path,
-        feature_path=feature_path,
-        indicator_path=indicator_path,
+        data_path=data_path,
         log_path=log_path,
         logging_config_file_path=logging_config_file_path,
         logging_config=logging_config,

{pfund-0.0.1.dev2 → pfund-0.0.1.dev4}/pfund/const/paths.py

@@ -13,6 +13,7 @@ PROJ_CONFIG_PATH = PROJ_PATH / 'config'
 # user paths
 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'

{pfund-0.0.1.dev2 → 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.dev2 → 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.dev2 → pfund-0.0.1.dev4}/pfund/exchanges/bybit/exchange.py

@@ -26,7 +26,7 @@ class Exchange(BaseExchange):
         super().__init__(env, 'BYBIT')
 
     @staticmethod
-    def categorize_product(ptype):
+    def categorize_product_type(ptype):
         is_spot = (ptype == 'SPOT')
         is_inverse = (ptype in ['IPERP', 'IFUT'])
         is_linear = not is_inverse and not is_spot

{pfund-0.0.1.dev2 → pfund-0.0.1.dev4}/pfund/exchanges/exchange_base.py

@@ -57,7 +57,7 @@ class BaseExchange:
             self.categories.append(category)
 
     def create_product(self, bccy, qccy, ptype, *args, **kwargs) -> CryptoProduct:
-        if category := self.categorize_product(ptype) if hasattr(self, 'categorize_product') else '':
+        if category := self.categorize_product_type(ptype) if hasattr(self, 'categorize_product_type') else '':
             self.add_category(category)
         product = CryptoProduct(self.exch, bccy, qccy, ptype, *args, category=category, **kwargs)
         product.load_configs(self.configs)

pfund-0.0.1.dev4/pfund/main.py

@@ -0,0 +1,10 @@
+from pfund.cli import pfund_group
+
+
+def run_cli() -> None:
+    """Application Entrypoint."""
+    pfund_group(obj={})
+
+
+if __name__ == '__main__':
+    run_cli()

{pfund-0.0.1.dev2 → 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.dev4/pfund/models/__init__.py

@@ -0,0 +1,6 @@
+from pfund.models.model_base import BaseModel, BaseModel as Model, BaseFeature as Feature
+try:
+    from pfund.models.pytorch_model import PyTorchModel
+    from pfund.models.sklearn_model import SKLearnModel
+except ImportError:
+    pass

{pfund-0.0.1.dev2 → pfund-0.0.1.dev4}/pfund/models/model_base.py

@@ -8,13 +8,16 @@ from collections import defaultdict
 
 from typing import TYPE_CHECKING, Any, Union
 
-import joblib
-import torch
+try:
+    import joblib
+    import torch
+    import torch.nn as nn
+    from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
+    from sklearn.pipeline import Pipeline
+except ImportError:
+    pass
 import numpy as np
 import pandas as pd
-import torch.nn as nn
-from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
-from sklearn.pipeline import Pipeline
 
 if TYPE_CHECKING:
     from pfund.strategies.strategy_base import BaseStrategy

{pfund-0.0.1.dev2 → 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.dev2 → 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',