opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/core/plugin/cli.py

@@ -0,0 +1,96 @@
+from typing import TYPE_CHECKING, Any
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+from . import Plugin, ConfigT
+
+if TYPE_CHECKING:
+    import typer
+
+
+@dataclass(slots=True)
+class CLIOption:
+    """
+    Declarative description of a CLI option injected into a built-in command.
+
+    Deliberately backend-agnostic: the plugin describes the option, PyneCore
+    builds the concrete parser object. Plugins must not construct parser
+    objects themselves — Click is not a PyneCore dependency, and since Typer
+    0.26 it is not a Typer dependency either (Typer vendors a reduced fork of
+    it), so an externally built ``click.Option`` is not even parseable by the
+    CLI anymore.
+
+    :ivar decls: Option string, or a tuple of them (``"--live"``,
+        ``("--output", "-o")``). The parameter name is derived from the first
+        long option, as usual.
+    :ivar help: Help text shown in ``--help``.
+    :ivar default: Value used when the option is not given on the command line.
+    :ivar is_flag: Boolean switch that takes no value.
+    :ivar type: Converter applied to the raw string value (``int``, ``float``,
+        ``pathlib.Path``, or any single-argument callable). Ignored when
+        ``choices`` is set.
+    :ivar choices: Restrict the value to this set.
+    :ivar metavar: Value placeholder in the help output.
+    :ivar required: Fail when the option is missing.
+    :ivar multiple: Allow the option to be repeated, collecting a tuple.
+    :ivar hidden: Keep the option out of the help output.
+    :ivar envvar: Environment variable to read the value from.
+    :ivar rich_help_panel: Help panel to group the option under.
+    """
+
+    decls: str | tuple[str, ...]
+    help: str = ""
+    default: Any = None
+    is_flag: bool = False
+    type: Callable[[str], Any] | None = None
+    choices: Sequence[str] | None = None
+    metavar: str | None = None
+    required: bool = False
+    multiple: bool = False
+    hidden: bool = False
+    envvar: str | None = None
+    rich_help_panel: str | None = None
+
+    def __post_init__(self) -> None:
+        if isinstance(self.decls, str):
+            self.decls = (self.decls,)
+        else:
+            self.decls = tuple(self.decls)
+        if not self.decls:
+            raise ValueError("CLIOption needs at least one option string")
+
+
+class CLIPlugin(Plugin[ConfigT]):
+    """
+    Plugin that provides CLI commands and/or parameter hooks.
+
+    Override :meth:`cli` to add subcommands (``pyne <name> ...``).
+    Override :meth:`cli_params` to inject flags into existing commands.
+    """
+
+    @staticmethod
+    def cli() -> 'typer.Typer | None':
+        """
+        Return a Typer app for plugin subcommands.
+
+        Override to add commands like ``pyne <plugin_name> <subcommand>``.
+
+        :return: A Typer app, or ``None`` if the plugin has no CLI commands.
+        """
+        return None
+
+    # noinspection PyUnusedLocal
+    @staticmethod
+    def cli_params(command_name: str) -> list[CLIOption]:
+        """
+        Return extra parameters for an existing command.
+
+        Override to inject flags/options into commands like ``pyne run``.
+        Nested subcommands are addressed by their space-separated path, so
+        ``pyne data download`` is matched as ``"data download"``.
+
+        :param command_name: The command to extend (e.g. ``"run"`` or
+            ``"data download"``).
+        :return: List of option specs, or ``[]`` if no hooks for this command.
+        """
+        return []

pynecore/core/plugin/live_provider.py

@@ -0,0 +1,208 @@
+from abc import abstractmethod, ABCMeta
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, TypeVar
+
+from pynecore.types.ohlcv import OHLCV
+
+from .provider import ProviderPlugin
+
+if TYPE_CHECKING:
+    from ..syminfo import SymInfo
+
+
+@dataclass
+class LiveProviderConfig:
+    """Common base for all live-provider plugin configs.
+
+    Provides the symbol-translation map every live plugin shares so a Pine
+    script can keep using TradingView-style symbols (e.g. ``"FX:EURUSD"``)
+    even when the running provider exposes a different native identifier
+    (e.g. Capital.com's ``"EURUSD"`` epic). Subclasses inherit this field
+    via dataclass inheritance and add their own credentials/tunables on top.
+
+    Generated TOML example (a commented default appears in every live
+    plugin's config file)::
+
+        # Optional translation map. Keys are TradingView-style symbols as
+        # written in your Pine script (``request.security("FX:EURUSD", ...)``);
+        # values are the native identifier the plugin sends to the
+        # exchange API. Example for Capital.com::
+        #
+        #     [symbol_map]
+        #     "FX:EURUSD" = "EURUSD"
+        #     "OANDA:XAUUSD" = "GOLD"
+        #
+        # When a Pine symbol is not in the map the plugin falls back to
+        # ``normalize_symbol()`` (provider-specific prefix-strip etc.).
+        #symbol_map = {}
+    """
+
+    symbol_map: dict[str, str] = field(default_factory=dict)
+    """Optional translation map. Keys are TradingView-style symbols as
+    written in Pine scripts (e.g. ``"FX:EURUSD"``); values are the native
+    identifier the plugin sends to the exchange API (e.g. ``"EURUSD"``).
+    Missing keys fall back to ``ProviderPlugin.normalize_symbol``."""
+
+
+LiveProviderConfigT = TypeVar('LiveProviderConfigT', bound=LiveProviderConfig)
+
+
+@dataclass(frozen=True)
+class PluginSymbol:
+    """Live-mode descriptor for a :func:`request.security` data source.
+
+    Replaces the historical ``.ohlcv`` file path in live runs: the security
+    subprocess instantiates ``provider_name``'s :class:`LiveProviderPlugin`
+    itself, downloads warmup history in-memory, then streams live bars.
+    No intermediate ``.ohlcv`` file is written.
+
+    :ivar provider_name: Entry-point name for :func:`load_plugin`
+                         (e.g. ``"capitalcom"``).
+    :ivar symbol: Plugin-native symbol (e.g. ``"EURUSD"``); already passed
+                  through :meth:`ProviderPlugin.resolve_symbol`.
+    :ivar timeframe: Timeframe in TradingView format (e.g. ``"1D"``).
+    :ivar config: Pre-loaded plugin config dataclass instance. The chart
+                  process runs :func:`ensure_config` once and hands the
+                  resulting instance to every subprocess via spawn args —
+                  subprocesses must not touch the TOML file themselves
+                  because :func:`ensure_config` is not process-safe.
+    :ivar time_from: Optional warmup-window start. Defaults to ``None``,
+                  which lets the subprocess fall back to its built-in
+                  ``_DEFAULT_WARMUP_BARS`` heuristic; the chart passes
+                  its own ``--from`` here so security contexts inherit
+                  the same look-back range.
+    :ivar syminfo: Optional pre-fetched :class:`SymInfo`. The chart
+                  process can call ``provider.update_symbol_info()`` once
+                  and pass the result here, so the subprocess does not
+                  have to repeat the REST round-trip on startup. ``None``
+                  means the subprocess will fetch syminfo itself.
+    :ivar is_rate_source: When ``True`` the subprocess runs in a stripped
+                  "close-only" loop instead of importing and executing the
+                  Pine script. Used by the auto-spawned rate-source
+                  contexts created from a ``request.security(..., currency=X)``
+                  request when no explicit context already covers the
+                  required currency pair.
+    :ivar ohlcv_dir: Optional path to the chart process's OHLCV data dir.
+                  Forwarded to the subprocess so the provider can locate
+                  workdir-side resources that live next to the data dir —
+                  most notably per-exchange config overrides in
+                  ``<workdir>/config/plugins/<provider>.toml`` (e.g. the
+                  ``[binance]`` section of ``ccxt.toml``). Without it the
+                  subprocess provider runs with default config while the
+                  chart side runs with the override, breaking auth and
+                  market-type selection for cross-symbol security feeds.
+                  ``None`` means the subprocess provider is constructed
+                  without an OHLCV directory (no file is written either way).
+    """
+
+    provider_name: str
+    symbol: str
+    timeframe: str
+    config: LiveProviderConfig | None = None
+    time_from: datetime | None = None
+    syminfo: 'SymInfo | None' = None
+    is_rate_source: bool = False
+    ohlcv_dir: Path | None = None
+
+
+class LiveProviderPlugin(ProviderPlugin[LiveProviderConfigT], metaclass=ABCMeta):
+    """
+    WebSocket/streaming data provider extending :class:`ProviderPlugin`.
+
+    Adds real-time data streaming to the offline OHLCV download capability.
+    Subclasses must implement connection lifecycle and data streaming methods
+    in addition to the :class:`ProviderPlugin` abstract methods.
+
+    The async methods run in a background thread; the framework bridges them
+    to the synchronous :class:`ScriptRunner` via a :class:`queue.Queue`.
+    """
+
+    reconnect_delay: float = 1.0
+    """Initial delay in seconds before a reconnection attempt. Doubles per
+    consecutive failure (exponential backoff) up to :attr:`max_reconnect_delay`."""
+
+    max_reconnect_delay: float = 60.0
+    """Ceiling in seconds for the exponential reconnect backoff.
+
+    Reconnection is retried indefinitely — a live session must survive
+    arbitrarily long network / provider outages and resume on its own once
+    connectivity returns — so there is no attempt limit; the backoff simply
+    saturates at this delay.
+    """
+
+    feed_timeout_bars: int | None = 3
+    """Feed-liveness watchdog threshold, in timeframe periods.
+
+    When the provider reports a healthy connection but :meth:`watch_ohlcv`
+    has produced no update (closed bar or intra-bar) for this many timeframe
+    periods (floored at 90 s) during an open trading session, the framework
+    assumes the data feed is dead even though the transport looks alive
+    (half-open socket, lost server-side subscription) and drives a full
+    ``disconnect()`` → ``connect()`` cycle. ``None`` disables the watchdog —
+    only justified for providers whose feed legitimately stays silent for
+    long in-session stretches AND whose own liveness machinery already
+    covers the dead-feed case.
+    """
+
+    # --- Connection lifecycle ---
+
+    @abstractmethod
+    async def connect(self) -> None:
+        """Establish connection to the data source.
+
+        Called for the initial connection AND again on every reconnect (the
+        framework drives ``disconnect()`` → ``connect()`` after a connection
+        error or a stale feed). Implementations must therefore fully
+        re-initialize every piece of connection-scoped state here —
+        authentication, server-side subscriptions, partially accumulated
+        quote state — rather than assuming a first-call-only environment.
+        """
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Close connection cleanly."""
+
+    @property
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Whether the connection is currently active."""
+
+    # --- Data streaming ---
+
+    @abstractmethod
+    async def watch_ohlcv(self, symbol: str, timeframe: str) -> OHLCV:
+        """
+        Wait for and return the next OHLCV update.
+
+        Called in a loop by the framework.  Each call blocks (awaits)
+        until new data arrives from the data source.
+
+        :param symbol: The symbol in provider-specific format.
+        :param timeframe: Timeframe in TradingView format (e.g. ``"1D"``, ``"1"``, ``"4H"``).
+        :return: An :class:`OHLCV` with ``is_closed=True`` for a final bar, ``False`` for intra-bar updates.
+        """
+
+    # --- Reconnection hooks (override for custom behavior) ---
+
+    async def on_disconnect(self) -> None:
+        """Called when the connection is unexpectedly lost."""
+
+    async def on_reconnect(self) -> None:
+        """Called after a successful reconnection."""
+
+    # --- Shutdown hooks ---
+
+    # noinspection PyMethodMayBeStatic
+    async def can_shutdown(self) -> bool:
+        """
+        Whether the provider is ready to shut down.
+
+        Override to delay shutdown while cleanup is in progress
+        (e.g. waiting for open orders to fill or positions to close).
+        Called every second during the graceful shutdown phase.
+
+        :return: True if ready to shut down, False to keep waiting.
+        """
+        return True

pynecore/core/plugin/provider.py

@@ -0,0 +1,331 @@
+import logging
+from typing import Callable, NamedTuple, TYPE_CHECKING
+from abc import abstractmethod, ABCMeta
+from pathlib import Path
+from datetime import datetime
+
+from pynecore.types.ohlcv import OHLCV
+from pynecore.core.syminfo import SymInfo, default_mincontract
+from pynecore.core.ohlcv_file import OHLCVWriter, OHLCVReader
+
+from . import Plugin, ConfigT
+
+if TYPE_CHECKING:
+    from pynecore.core.symbol_map import SymbolMap
+
+logger = logging.getLogger(__name__)
+
+
+class Broker(NamedTuple):
+    """A selectable broker / exchange of a :attr:`~ProviderPlugin.multi_broker` provider.
+
+    :ivar id: The canonical selector used in the provider string and the saved
+        filename (e.g. ``"pepperstoneuk"``, ``"binance"``). Must be space-free.
+    :ivar name: A human-readable display name (e.g. ``"Pepperstone - Europe"``,
+        ``"Binance"``), or ``""`` when the provider exposes none.
+    """
+    id: str
+    name: str = ""
+
+
+class ProviderPlugin(Plugin[ConfigT], metaclass=ABCMeta):
+    """
+    Base class for all data providers.
+
+    Subclasses must implement the abstract methods and define a ``Config``
+    dataclass for configuration (used by :func:`pynecore.core.config.ensure_config`).
+    """
+
+    timezone: str = 'UTC'
+    """Default timezone of the provider."""
+
+    symbol: str | None = None
+    """Symbol of the provider."""
+
+    timeframe: str | None = None
+    """Timeframe of the provider."""
+
+    xchg_timeframe: str | None = None
+    """Exchange-specific timeframe format."""
+
+    ohlcv_path: Path | None = None
+    """Path to the OHLCV data file."""
+
+    syminfo: SymInfo | None = None
+    """Symbol info pre-fetched by the chart side (security subprocesses store
+    it here instead of issuing a second REST round-trip)."""
+
+    global_symbol_map: 'SymbolMap | None' = None
+    """Global workdir symbol map (``config/symbol_map.toml``), consulted by
+    :meth:`resolve_symbol` AFTER the plugin's own ``config.symbol_map``. Set by
+    the framework on the chart provider instance; ``None`` disables the fallback."""
+
+    provider_name: str | None = None
+    """This provider's entry-point name, used to gate global-map entries to the
+    running provider (an entry naming a different provider is warned + skipped,
+    pending multi-provider support)."""
+
+    fetch_all_by_default: bool = False
+    """If True, fetch all available data when no start date is given (instead of 1 year)."""
+
+    multi_broker: bool = False
+    """If True, this provider serves many brokers/exchanges and the first segment
+    of the provider string after the provider name selects the broker
+    (e.g. ``ccxt:BYBIT:BTC/USDT:USDT`` → broker ``BYBIT``). Single-broker
+    providers leave this ``False`` and treat the whole string as the symbol."""
+
+    mincontract_estimated: bool = False
+    """True when the last :meth:`get_symbol_info` fetch had to estimate
+    ``mincontract`` because the provider returned no exchange value. The
+    download flow then refines the estimate from the downloaded volume data."""
+
+    @classmethod
+    @abstractmethod
+    def to_tradingview_timeframe(cls, timeframe: str) -> str:
+        """
+        Convert timeframe to TradingView format.
+
+        :param timeframe: Timeframe in exchange format.
+        :return: Timeframe in TradingView format.
+        """
+
+    @classmethod
+    @abstractmethod
+    def to_exchange_timeframe(cls, timeframe: str) -> str:
+        """
+        Convert timeframe to exchange format.
+
+        :param timeframe: Timeframe in TradingView format.
+        :return: Timeframe in exchange format.
+        """
+
+    @classmethod
+    def get_ohlcv_path(cls, symbol: str, timeframe: str, ohlcv_dir: Path,
+                       provider_name: str | None = None) -> Path:
+        """
+        Get the output path of the OHLCV data file.
+
+        :param symbol: Symbol name.
+        :param timeframe: Timeframe in TradingView format.
+        :param ohlcv_dir: Directory to save OHLCV data.
+        :param provider_name: Override provider name in filename.
+        :return: Path to the OHLCV file.
+        """
+        return ohlcv_dir / (f"{provider_name or cls.__name__.lower().replace('provider', '').replace('plugin', '')}"
+                            f"_{symbol.replace('/', '_').replace(':', '_').upper()}"
+                            f"_{timeframe}.ohlcv")
+
+    def __init__(self, *, symbol: str | None = None, timeframe: str | None = None,
+                 ohlcv_dir: Path | None = None, config: ConfigT | None = None):
+        """
+        :param symbol: The symbol to get data for.
+        :param timeframe: The timeframe to get data for in TradingView format.
+        :param ohlcv_dir: The directory to save OHLCV data.
+        :param config: Pre-loaded config dataclass instance.
+        """
+        self.symbol = symbol
+        self.timeframe = timeframe
+        self.xchg_timeframe = self.to_exchange_timeframe(timeframe) if timeframe else None
+        if ohlcv_dir:
+            assert symbol and timeframe
+            self.ohlcv_path = self.get_ohlcv_path(symbol, timeframe, ohlcv_dir)
+        else:
+            self.ohlcv_path = None
+        self.ohlcv_file = OHLCVWriter(self.ohlcv_path) if self.ohlcv_path else None
+        self.config: ConfigT | None = config
+
+    def normalize_symbol(self, symbol: str) -> str:
+        """
+        Normalize a provider-format symbol to the exchange API format.
+
+        Called by the framework before passing ``symbol`` to :meth:`watch_ohlcv`
+        in the live runner. For historical methods (:meth:`download_ohlcv`,
+        :meth:`update_symbol_info`), providers use ``self.symbol`` directly —
+        handle any needed format conversion in ``__init__`` instead.
+
+        Override when the user-configured symbol includes prefixes or formatting
+        that the exchange API cannot accept
+        (e.g. stripping ``"binance:"`` from ``"binance:BTC/USDT"``).
+
+        :param symbol: Symbol as configured by the user.
+        :return: Symbol in the format the exchange API expects.
+        """
+        return symbol
+
+    def resolve_symbol(self, pine_key: str) -> str:
+        """
+        Translate a Pine-style symbol key to the plugin-native form.
+
+        Live ``request.security()`` calls hand the framework a TradingView-style
+        symbol (e.g. ``"FX:EURUSD"``). This method consults
+        ``config.symbol_map`` first (the per-plugin TOML translation table),
+        then the global workdir ``symbol_map.toml`` (:attr:`global_symbol_map`,
+        only for entries whose provider matches :attr:`provider_name` — an entry
+        naming a different provider is warned + skipped); if the key is not
+        mapped the default fallback is the identity, i.e. the Pine key is
+        forwarded unchanged on the assumption that the user already wrote a
+        plugin-native symbol.
+
+        ``normalize_symbol`` is deliberately **not** used as the fallback:
+        provider instances bind ``normalize_symbol`` to the chart's own
+        symbol (e.g. CCXT's returns ``self.symbol`` regardless of the
+        argument), so consulting it for a cross-symbol key would silently
+        resolve to the chart symbol and download wrong data.
+
+        Plugins that need real cross-symbol translation should override
+        :meth:`resolve_symbol` directly.
+
+        :param pine_key: Symbol as written in the Pine script.
+        :return: Symbol in the format the plugin's exchange API expects.
+        """
+        sm = getattr(self.config, 'symbol_map', None)
+        if sm and pine_key in sm:
+            return sm[pine_key]
+        gm = self.global_symbol_map
+        if gm:
+            mapped = gm.resolve(pine_key)
+            if mapped is not None:
+                if self.provider_name is not None and mapped.provider != self.provider_name:
+                    logger.warning(
+                        "Skipping global symbol_map entry %r -> %r: it targets "
+                        "provider %r but the running provider is %r "
+                        "(multi-provider resolution is not supported yet).",
+                        pine_key, f"{mapped.provider}:{mapped.native_symbol}",
+                        mapped.provider, self.provider_name)
+                else:
+                    return mapped.native_symbol
+        return pine_key
+
+    @classmethod
+    def construct_pair_symbol(cls, from_cur: str, to_cur: str) -> str:
+        """
+        Build a Pine-style symbol for a currency pair.
+
+        Used by the auto-spawn rate-source path when a Pine script needs a
+        ``(from_cur, to_cur)`` rate that is not already exposed by the chart
+        or by an explicit ``request.security()`` context. The default
+        concatenation (``"EUR" + "USD" -> "EURUSD"``) matches the most common
+        FX symbol convention; plugins whose API expects a different shape
+        (e.g. ``"EUR-USD"`` or ``"EUR/USD"``) can override.
+
+        The returned key is fed through :meth:`resolve_symbol`, so users can
+        still keep TradingView prefixes (``"FX:EURUSD"``) in their
+        ``symbol_map`` instead of relying on the raw concatenation.
+        """
+        return f"{from_cur}{to_cur}"
+
+    def __enter__(self) -> OHLCVWriter:
+        assert self.ohlcv_file is not None
+        return self.ohlcv_file.open()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        assert self.ohlcv_file is not None
+        self.ohlcv_file.close()
+
+    @classmethod
+    def get_list_of_brokers(cls) -> list[Broker]:
+        """
+        Get the list of brokers/exchanges this provider can serve.
+
+        Only meaningful for :attr:`multi_broker` providers. Optional — the
+        default raises :class:`NotImplementedError`, which the ``pyne data``
+        CLI catches and reports gracefully. Implemented as a classmethod so it
+        can answer ``--list-brokers`` without a symbol-bound instance.
+
+        :return: List of :class:`Broker` records (``id`` selector + optional
+            human-readable ``name``).
+        :raises NotImplementedError: If the provider does not enumerate brokers.
+        """
+        raise NotImplementedError(
+            f"{cls.__name__} does not support listing brokers"
+        )
+
+    @abstractmethod
+    def get_list_of_symbols(self, *args, **kwargs) -> list[str]:
+        """
+        Get list of available symbols.
+
+        :return: List of symbol names.
+        """
+
+    @abstractmethod
+    def update_symbol_info(self) -> SymInfo:
+        """
+        Fetch and return symbol info from the exchange.
+
+        This should include opening hours and session data.
+
+        :return: Symbol information.
+        """
+
+    def is_symbol_info_exists(self) -> bool:
+        """
+        Check if the symbol info TOML file exists.
+
+        :return: True if the file exists.
+        """
+        assert self.ohlcv_path is not None
+        return self.ohlcv_path.with_suffix('.toml').exists()
+
+    def get_symbol_info(self, force_update=False) -> SymInfo:
+        """
+        Get symbol info, loading from cache or fetching from exchange.
+
+        :param force_update: Force update from exchange even if cached.
+        :return: Symbol information.
+        """
+        assert self.ohlcv_path is not None
+        toml_path = self.ohlcv_path.with_suffix('.toml')
+        if self.is_symbol_info_exists() and not force_update:
+            return SymInfo.load_toml(toml_path)
+
+        sym_info = self.update_symbol_info()
+        if sym_info.mincontract <= 0.0:
+            # No exchange value (providers signal that with 0.0): estimate it.
+            # The download flow refines the estimate from the downloaded
+            # volume data, see ``mincontract_estimated``.
+            sym_info.mincontract = default_mincontract(sym_info.type, sym_info.basecurrency)
+            self.mincontract_estimated = True
+        sym_info.save_toml(toml_path)
+        return sym_info
+
+    def save_ohlcv_data(self, data: OHLCV | list[OHLCV]):
+        """
+        Save OHLCV data to the file.
+
+        :param data: Single OHLCV record or list of records.
+        """
+        assert self.ohlcv_file is not None
+        if isinstance(data, OHLCV):
+            self.ohlcv_file.write(data)
+        else:
+            for candle in data:
+                self.ohlcv_file.write(candle)
+
+    @abstractmethod
+    def download_ohlcv(self, time_from: datetime, time_to: datetime,
+                       on_progress: Callable[[datetime], None] | None = None,
+                       limit: int | None = None, with_extra: bool = False):
+        """
+        Download OHLCV data from the exchange.
+
+        Use :meth:`save_ohlcv_data` to write records to the data file.
+
+        :param time_from: The start time. Use ``datetime.fromtimestamp(0)`` to fetch all available data.
+        :param time_to: The end time.
+        :param on_progress: Optional progress callback.
+        :param limit: Override the automatic chunk size (number of bars per API request).
+        :param with_extra: When ``True``, also fetch and persist the provider's
+            extra per-bar fields (e.g. ask/bid/spread) to the ``.extra.csv``
+            sidecar. Off by default: the extra fields cost extra requests to
+            fetch and slow every later backtest that loads the sidecar, so they
+            are only produced on request. Providers without extra fields ignore it.
+        """
+
+    def load_ohlcv_data(self) -> OHLCVReader:
+        """
+        Load OHLCV data from the file.
+
+        :return: An OHLCVReader instance.
+        """
+        return OHLCVReader(str(self.ohlcv_path))