investing-algorithm-framework 9.0.0a2__tar.gz → 9.0.0a4__tar.gz

{investing_algorithm_framework-9.0.0a2 → investing_algorithm_framework-9.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 9.0.0a2
+Version: 9.0.0a4
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10,<4.0
@@ -10,25 +10,27 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
 Provides-Extra: alpha-vantage
+Provides-Extra: aws
+Provides-Extra: azure
+Provides-Extra: notebook
 Provides-Extra: polygon
 Provides-Extra: yahoo
 Requires-Dist: Flask (>=3.1.0)
 Requires-Dist: Flask-Cors (>=3.0.9,<7.0.0)
-Requires-Dist: Flask-Migrate (>=2.6.0)
 Requires-Dist: SQLAlchemy (>=2.0.18)
 Requires-Dist: alpha_vantage (>=3.0.0,<4.0.0) ; extra == "alpha-vantage" or extra == "all"
-Requires-Dist: azure-identity (>=1.19.0,<2.0.0)
-Requires-Dist: azure-mgmt-resource (>=23.2.0,<24.0.0)
-Requires-Dist: azure-mgmt-storage (>=21.2.1,<22.0.0)
-Requires-Dist: azure-mgmt-web (>=7.3.1,<8.0.0)
-Requires-Dist: azure-storage-blob (>=12.24.0,<13.0.0)
-Requires-Dist: boto3 (>=1.38.41,<2.0.0)
+Requires-Dist: azure-identity (>=1.19.0,<2.0.0) ; extra == "azure" or extra == "all"
+Requires-Dist: azure-mgmt-resource (>=23.2.0,<24.0.0) ; extra == "azure" or extra == "all"
+Requires-Dist: azure-mgmt-storage (>=21.2.1,<22.0.0) ; extra == "azure" or extra == "all"
+Requires-Dist: azure-mgmt-web (>=7.3.1,<8.0.0) ; extra == "azure" or extra == "all"
+Requires-Dist: azure-storage-blob (>=12.24.0,<13.0.0) ; extra == "azure" or extra == "all"
+Requires-Dist: boto3 (>=1.38.41,<2.0.0) ; extra == "aws" or extra == "all"
 Requires-Dist: ccxt (>=4.2.48)
 Requires-Dist: dependency-injector (>=4.40.0)
-Requires-Dist: jupyter (>=1.0.0)
+Requires-Dist: finterion-charts (==1.4.0)
+Requires-Dist: ipython (>=8.0.0) ; extra == "notebook" or extra == "all"
 Requires-Dist: marshmallow (>=3.5.0)
 Requires-Dist: msgpack (>=1.0.0)
-Requires-Dist: plotly (>=6.1.2,<7.0.0)
 Requires-Dist: polars[numpy,pandas] (>=0.20.10)
 Requires-Dist: polygon-api-client (>=1.14.0,<2.0.0) ; extra == "polygon" or extra == "all"
 Requires-Dist: pyarrow (>=14.0.0)
@@ -318,16 +320,33 @@ Every backtest produces a **self-contained HTML dashboard** — open it in any b
 Every backtest API — vector or event-driven — returns the same `Backtest` object, which the `BacktestReport` consumes directly. So whether you're iterating over an in-memory list or a folder of persisted `.obtf` bundles, the path to the dashboard is the same:
 
 ```python
-from investing_algorithm_framework import BacktestReport
+from investing_algorithm_framework import (
+    BacktestReport, Study, Universe, BacktestWindow, BacktestEngine,
+)
 
 # --- Single event-driven backtest ---
-backtest = app.run_backtest(backtest_date_range=date_range)
-BacktestReport(backtests=[backtest]).save("event_report.html")
+event_study = Study(
+    universe=Universe(market="BITVAVO", trading_symbol="EUR"),
+    initial_capital=1000,
+    backtest_windows=[BacktestWindow(train_range=date_range)],
+    engines=[BacktestEngine.EVENT_DRIVEN],
+)
+backtests = app.run_backtest(strategy=strategy, study=event_study)
+BacktestReport(backtests=backtests).save("event_report.html")
 
 # --- A sweep of vector backtests (parameter grid / multi-window) ---
-backtests = app.run_vector_backtests(
+sweep_study = Study(
+    universe=Universe(market="BITVAVO", trading_symbol="EUR"),
+    initial_capital=1000,
+    backtest_windows=[
+        BacktestWindow(train_range=dr)
+        for dr in [range_2022, range_2023, range_2024]
+    ],
+    engines=[BacktestEngine.VECTOR],
+)
+backtests = app.run_backtests(
     strategies=[StrategyA(), StrategyB(), StrategyC()],
-    backtest_date_ranges=[range_2022, range_2023, range_2024],
+    study=sweep_study,
     n_workers=-1,
     backtest_storage_directory="./my-backtests/",  # persists .obtf bundles
     show_progress=True,

{investing_algorithm_framework-9.0.0a2 → investing_algorithm_framework-9.0.0a4}/README.md

@@ -274,16 +274,33 @@ Every backtest produces a **self-contained HTML dashboard** — open it in any b
 Every backtest API — vector or event-driven — returns the same `Backtest` object, which the `BacktestReport` consumes directly. So whether you're iterating over an in-memory list or a folder of persisted `.obtf` bundles, the path to the dashboard is the same:
 
 ```python
-from investing_algorithm_framework import BacktestReport
+from investing_algorithm_framework import (
+    BacktestReport, Study, Universe, BacktestWindow, BacktestEngine,
+)
 
 # --- Single event-driven backtest ---
-backtest = app.run_backtest(backtest_date_range=date_range)
-BacktestReport(backtests=[backtest]).save("event_report.html")
+event_study = Study(
+    universe=Universe(market="BITVAVO", trading_symbol="EUR"),
+    initial_capital=1000,
+    backtest_windows=[BacktestWindow(train_range=date_range)],
+    engines=[BacktestEngine.EVENT_DRIVEN],
+)
+backtests = app.run_backtest(strategy=strategy, study=event_study)
+BacktestReport(backtests=backtests).save("event_report.html")
 
 # --- A sweep of vector backtests (parameter grid / multi-window) ---
-backtests = app.run_vector_backtests(
+sweep_study = Study(
+    universe=Universe(market="BITVAVO", trading_symbol="EUR"),
+    initial_capital=1000,
+    backtest_windows=[
+        BacktestWindow(train_range=dr)
+        for dr in [range_2022, range_2023, range_2024]
+    ],
+    engines=[BacktestEngine.VECTOR],
+)
+backtests = app.run_backtests(
     strategies=[StrategyA(), StrategyB(), StrategyC()],
-    backtest_date_ranges=[range_2022, range_2023, range_2024],
+    study=sweep_study,
     n_workers=-1,
     backtest_storage_directory="./my-backtests/",  # persists .obtf bundles
     show_progress=True,

{investing_algorithm_framework-9.0.0a2 → investing_algorithm_framework-9.0.0a4}/investing_algorithm_framework/__init__.py

@@ -142,7 +142,18 @@ from .services import (
     TradeTakeProfitService,
     TradeStopLossService,
 )
-from .notebook.magic import load_ipython_extension  # noqa: F401
+try:
+    from .notebook.magic import load_ipython_extension  # noqa: F401
+except ImportError:
+    # IPython is an optional dependency (install with
+    # `pip install investing-algorithm-framework[notebook]`) — don't
+    # let its absence break importing the framework itself.
+    def load_ipython_extension(ipython):  # pragma: no cover
+        raise ImportError(
+            "IPython is required to use the %backtest magic. Install "
+            "it with `pip install investing-algorithm-framework"
+            "[notebook]`."
+        )
 
 
 __all__ = [

investing_algorithm_framework-9.0.0a4/investing_algorithm_framework/app/algorithm_runner.py

@@ -0,0 +1,236 @@
+import json
+import logging
+import os
+import threading
+from datetime import datetime, timezone
+from typing import Optional
+
+from investing_algorithm_framework.domain import OperationalException
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+NOT_STARTED = "NOT_STARTED"
+RUNNING = "RUNNING"
+STOPPING = "STOPPING"
+STOPPED = "STOPPED"
+
+CONTROL_FILE_NAME = "algorithm_control.json"
+
+
+class AlgorithmRunner:
+    """
+    Thread-safe controller that runs an ``EventLoopService`` in a
+    background thread so the trading algorithm can be started and
+    stopped on demand (e.g. from the web API) without killing the
+    process that hosts it.
+    """
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._thread: Optional[threading.Thread] = None
+        self._event_loop_service = None
+        self._run_kwargs = {}
+        self._status = NOT_STARTED
+        self._started_at = None
+        self._stopped_at = None
+        self._error = None
+        self._resource_directory = None
+        self._state_handler = None
+
+    def bind_persistence(self, resource_directory, state_handler=None) -> None:
+        """
+        Wires where the enabled/disabled control flag is persisted.
+
+        This is what makes ``enable()``/``disable()`` meaningful for
+        *stateless* deployments (AWS Lambda, Azure Functions): the
+        flag file lives inside ``resource_directory``, the same
+        directory a configured ``state_handler`` already uploads/
+        downloads on every run. Passing the state handler here makes a
+        toggle take effect immediately (pushed on the spot) instead of
+        waiting for the next natural save.
+        """
+        with self._lock:
+            self._resource_directory = resource_directory
+            self._state_handler = state_handler
+
+    def _control_file_path(self) -> Optional[str]:
+        if self._resource_directory is None:
+            return None
+        os.makedirs(self._resource_directory, exist_ok=True)
+        return os.path.join(self._resource_directory, CONTROL_FILE_NAME)
+
+    def get_control_state(self) -> dict:
+        """Returns the persisted enabled/disabled control state."""
+        default = {"enabled": True, "reason": None, "updated_at": None}
+        path = self._control_file_path()
+
+        if path is None or not os.path.exists(path):
+            return default
+
+        try:
+            with open(path, "r") as f:
+                return {**default, **json.load(f)}
+        except (OSError, ValueError) as e:
+            logger.warning(f"Could not read algorithm control file: {e}")
+            return default
+
+    def is_enabled(self) -> bool:
+        """Enabled by default when no control file has been written yet."""
+        return self.get_control_state().get("enabled", True)
+
+    def _persist_enabled(
+        self, enabled: bool, reason: Optional[str] = None
+    ) -> None:
+        path = self._control_file_path()
+
+        if path is None:
+            return
+
+        state = {
+            "enabled": enabled,
+            "reason": reason,
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+        with open(path, "w") as f:
+            json.dump(state, f)
+
+        if self._state_handler is not None:
+            try:
+                self._state_handler.save(self._resource_directory)
+            except Exception as e:
+                logger.warning(
+                    "Could not push algorithm control state via the "
+                    f"configured state handler: {e}"
+                )
+
+    def enable(self, reason: Optional[str] = None) -> None:
+        """Persists 'enabled', independent of any in-process thread."""
+        self._persist_enabled(True, reason=reason)
+
+    def disable(self, reason: Optional[str] = None) -> None:
+        """Persists 'disabled', independent of any in-process thread."""
+        self._persist_enabled(False, reason=reason)
+
+    def configure(self, event_loop_service, **run_kwargs) -> None:
+        """
+        Wires the event loop service (and any kwargs for its
+        ``start()`` method) that ``start``/``stop`` will control.
+        Safe to call again after a ``stop()`` to reconfigure before
+        the next ``start()``.
+        """
+        with self._lock:
+            self._event_loop_service = event_loop_service
+            self._run_kwargs = run_kwargs
+
+    @property
+    def status(self) -> str:
+        with self._lock:
+            return self._status
+
+    @property
+    def is_running(self) -> bool:
+        return self.status == RUNNING
+
+    def get_status_report(self) -> dict:
+        with self._lock:
+            return {
+                "status": self._status,
+                "started_at": self._started_at.isoformat()
+                if self._started_at else None,
+                "stopped_at": self._stopped_at.isoformat()
+                if self._stopped_at else None,
+                "error": self._error,
+            }
+
+    def start(self) -> bool:
+        """
+        Starts (or resumes) the algorithm loop in a background thread.
+
+        Returns:
+            bool: True if a new run was started, False if the
+                algorithm was already running.
+
+        Raises:
+            OperationalException: If the runner has not been
+                configured with an event loop service yet (i.e. the
+                app has never been run).
+        """
+        with self._lock:
+            if self._event_loop_service is None:
+                raise OperationalException(
+                    "The algorithm has not been initialized yet. Run "
+                    "the app at least once before starting it "
+                    "through the API."
+                )
+
+            if self._status == RUNNING:
+                self.enable()
+                return False
+
+            self._event_loop_service.reset_stop()
+            self._error = None
+            self._started_at = datetime.now(timezone.utc)
+            self._stopped_at = None
+            self._status = RUNNING
+            event_loop_service = self._event_loop_service
+            run_kwargs = self._run_kwargs
+
+        def _run():
+            try:
+                event_loop_service.start(**run_kwargs)
+            except Exception as e:
+                logger.error(f"Algorithm loop stopped with an error: {e}")
+                with self._lock:
+                    self._error = str(e)
+            finally:
+                with self._lock:
+                    self._status = STOPPED
+                    self._stopped_at = datetime.now(timezone.utc)
+
+        self._thread = threading.Thread(
+            name="Algorithm Loop", target=_run, daemon=True
+        )
+        self._thread.start()
+        self.enable()
+        return True
+
+    def stop(
+        self,
+        wait: bool = False,
+        timeout: float = 10,
+        reason: Optional[str] = None,
+    ) -> bool:
+        """
+        Signals the running algorithm loop to stop after its current
+        iteration completes, and persists 'disabled' regardless of
+        whether a loop is currently running in-process (this is what a
+        stateless/serverless deployment, e.g. AWS Lambda or Azure
+        Functions, checks on its next scheduled invocation).
+
+        Args:
+            wait: If True, blocks until the background thread has
+                actually exited (bounded by ``timeout`` seconds).
+            timeout: Max seconds to wait for the thread to exit when
+                ``wait`` is True.
+            reason: Optional human-readable reason, persisted alongside
+                the disabled state.
+
+        Returns:
+            bool: True if a running in-process loop was signaled to
+                stop, False if it was not running (the disabled state
+                is still persisted either way).
+        """
+        self.disable(reason=reason)
+
+        with self._lock:
+            if self._status != RUNNING:
+                return False
+            self._status = STOPPING
+            self._event_loop_service.request_stop()
+            thread = self._thread
+
+        if wait and thread is not None:
+            thread.join(timeout=timeout)
+
+        return True