code/methods/_chattime_engine.py

"""In-process ChatTime engine for `llm_ts` family.

The authors' `ChatTime` class (`baselines/_vendor/chattime/model/model.py`)
runs as a Hugging Face `pipeline("text-generation", ...)` over `LlamaForCausalLM`
and applies a custom 10K-bin numeric tokenisation (`utils.tools.Discretizer`,
`Serializer`) plus their own prompt template (`utils.prompt.getPrompt`).
That pipeline is fundamentally not an OpenAI-compatible chat API and cannot
be served via `vllm serve`; the runner must load it in-process and inject it
as the method's ``engine`` so `methods/llm_ts_reason.py:ChatTime._call_t1_batch`
takes the numeric path (`engine.predict(history)`).

This wrapper:
1. Adds the vendor dir to ``sys.path`` (vendor uses ``from utils.prompt ...``
   imports relative to its own root).
2. Instantiates the vendor `ChatTime(model_path=...)` once.
3. Exposes a `.predict(history, pred_len=...)` API compatible with the
   methods-side `engine.predict(hist)` call site.

Memory note: per ``feedback_use_official_code``, this uses the vendored
authors' code unmodified rather than reimplementing the discretizer or
prompt protocol from the paper text.
"""

from __future__ import annotations

import sys
from pathlib import Path
from typing import Any

import numpy as np


_VENDOR_ROOT = (
    Path(__file__).resolve().parent.parent
    / "baselines" / "_vendor" / "chattime"
)


def _load_vendor_chattime_class():
    """Import ``baselines/_vendor/chattime/model/model.py:ChatTime``."""
    vendor_str = str(_VENDOR_ROOT)
    if vendor_str not in sys.path:
        sys.path.insert(0, vendor_str)
    # The vendor `model/model.py` does `from utils.prompt import getPrompt`,
    # which only resolves when the vendor root is on sys.path.
    from model.model import ChatTime as _VendorChatTime  # type: ignore
    return _VendorChatTime


class ChatTimeEngine:
    """Engine adapter for the vendored ChatTime author code.

    Construct once per run (model load is expensive). The vendor
    `ChatTime(...)` constructor requires ``hist_len`` and ``pred_len``
    up-front; we pass dummy values at construction and override them per
    `predict()` call from the actual lookback / horizon implied by the
    history array and an explicit ``pred_len`` kwarg.
    """

    def __init__(
        self,
        model_path: str = "ChengsenWang/ChatTime-1-7B-Chat",
        *,
        max_pred_len: int = 16,
        num_samples: int = 8,
    ) -> None:
        VendorChatTime = _load_vendor_chattime_class()
        # The vendor class hard-requires non-None hist_len/pred_len at init
        # only for the validation guard in `predict`; the constructor itself
        # accepts any positive ints. Provide dummies; predict() overrides.
        self._impl = VendorChatTime(
            model_path=model_path,
            hist_len=1,
            pred_len=1,
            max_pred_len=int(max_pred_len),
            num_samples=int(num_samples),
        )
        self.model_id = model_path

    def predict(
        self,
        history: np.ndarray,
        *,
        pred_len: int | None = None,
        context: Any = None,
    ) -> np.ndarray:
        """Forecast the next ``pred_len`` steps after ``history``.

        Parameters
        ----------
        history
            1-D ``np.ndarray`` of length ``lookback`` (close-price series).
        pred_len
            Forecast horizon. Defaults to 21 if not set (the
            ``methods/llm_ts_reason.py`` `_LLMTSBase` default for T1).
        context
            Optional natural-language context string (forwarded to the
            authors' ``getPrompt(flag='prediction', context=...)``).
        """
        hist_arr = np.asarray(history, dtype=np.float64).ravel()
        H = int(pred_len if pred_len is not None else 21)
        self._impl.hist_len = int(hist_arr.shape[0])
        self._impl.pred_len = H
        try:
            out = self._impl.predict(hist_arr, context=context)
        except Exception:
            # Authors' pipeline raised on this row (e.g. tokenization /
            # generation edge case). Per the "use upstream code unmodified"
            # discipline we don't retry-via-chat; emit an all-NaN row so the
            # methods-side parser records this cell as unparseable and the
            # eval fillna-then-mean rule handles it.
            return np.full((H,), np.nan, dtype=np.float32)
        arr = np.asarray(out, dtype=np.float32)
        if arr.shape[0] < H:
            arr = np.concatenate([arr, np.full(H - arr.shape[0], np.nan, dtype=np.float32)])
        return arr[:H]

    # Stub for the methods-side chat-completion fallback path. The fallback
    # is irrelevant for ChatTime (we always have the numeric predict path);
    # returning an empty string makes `_parse_horizon_list` yield None, which
    # the runner converts to a NaN row consistent with `predict`'s contract.
    def chat_complete(self, *args, **kwargs) -> str:  # noqa: D401, ARG002
        return ""

    def chat_complete_batch(self, prompts: list[str], **kwargs):  # noqa: ARG002
        return ["" for _ in prompts]