Upload folder using huggingface_hub (part 2)

.gitattributes

@@ -60,3 +60,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/_libs/expanding.cpython-313-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/_libs/rolling.cpython-313-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/_libs/expanding.cpython-39-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/_libs/rolling.cpython-39-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/dataset/utils.py

@@ -0,0 +1,142 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+import pandas as pd
+from typing import Union, List, TYPE_CHECKING
+from qlib.utils import init_instance_by_config
+
+if TYPE_CHECKING:
+    from qlib.data.dataset import DataHandler
+
+
+def get_level_index(df: pd.DataFrame, level: Union[str, int]) -> int:
+    """
+
+    get the level index of `df` given `level`
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        data
+    level : Union[str, int]
+        index level
+
+    Returns
+    -------
+    int:
+        The level index in the multiple index
+    """
+    if isinstance(level, str):
+        try:
+            return df.index.names.index(level)
+        except (AttributeError, ValueError):
+            # NOTE: If level index is not given in the data, the default level index will be ('datetime', 'instrument')
+            return ("datetime", "instrument").index(level)
+    elif isinstance(level, int):
+        return level
+    else:
+        raise NotImplementedError(f"This type of input is not supported")
+
+
+def fetch_df_by_index(
+    df: pd.DataFrame,
+    selector: Union[pd.Timestamp, slice, str, list, pd.Index],
+    level: Union[str, int],
+    fetch_orig=True,
+) -> pd.DataFrame:
+    """
+    fetch data from `data` with `selector` and `level`
+
+    selector are assumed to be well processed.
+    `fetch_df_by_index` is only responsible for get the right level
+
+    Parameters
+    ----------
+    selector : Union[pd.Timestamp, slice, str, list]
+        selector
+    level : Union[int, str]
+        the level to use the selector
+
+    Returns
+    -------
+    Data of the given index.
+    """
+    # level = None -> use selector directly
+    if level is None or isinstance(selector, pd.MultiIndex):
+        return df.loc(axis=0)[selector]
+    # Try to get the right index
+    idx_slc = (selector, slice(None, None))
+    if get_level_index(df, level) == 1:
+        idx_slc = idx_slc[1], idx_slc[0]
+    if fetch_orig:
+        for slc in idx_slc:
+            if slc != slice(None, None):
+                return df.loc[pd.IndexSlice[idx_slc],]  # noqa: E231
+        else:  # pylint: disable=W0120
+            return df
+    else:
+        return df.loc[pd.IndexSlice[idx_slc],]  # noqa: E231
+
+
+def fetch_df_by_col(df: pd.DataFrame, col_set: Union[str, List[str]]) -> pd.DataFrame:
+    from .handler import DataHandler  # pylint: disable=C0415
+
+    if not isinstance(df.columns, pd.MultiIndex) or col_set == DataHandler.CS_RAW:
+        return df
+    elif col_set == DataHandler.CS_ALL:
+        return df.droplevel(axis=1, level=0)
+    else:
+        return df.loc(axis=1)[col_set]
+
+
+def convert_index_format(df: Union[pd.DataFrame, pd.Series], level: str = "datetime") -> Union[pd.DataFrame, pd.Series]:
+    """
+    Convert the format of df.MultiIndex according to the following rules:
+        - If `level` is the first level of df.MultiIndex, do nothing
+        - If `level` is the second level of df.MultiIndex, swap the level of index.
+
+    NOTE:
+        the number of levels of df.MultiIndex should be 2
+
+    Parameters
+    ----------
+    df : Union[pd.DataFrame, pd.Series]
+        raw DataFrame/Series
+    level : str, optional
+        the level that will be converted to the first one, by default "datetime"
+
+    Returns
+    -------
+    Union[pd.DataFrame, pd.Series]
+        converted DataFrame/Series
+    """
+
+    if get_level_index(df, level=level) == 1:
+        df = df.swaplevel().sort_index()
+    return df
+
+
+def init_task_handler(task: dict) -> DataHandler:
+    """
+    initialize the handler part of the task **inplace**
+
+    Parameters
+    ----------
+    task : dict
+        the task to be handled
+
+    Returns
+    -------
+    Union[DataHandler, None]:
+        returns
+    """
+    # avoid recursive import
+    from .handler import DataHandler  # pylint: disable=C0415
+
+    h_conf = task["dataset"]["kwargs"].get("handler")
+    if h_conf is not None:
+        handler = init_instance_by_config(h_conf, accept_types=DataHandler)
+        task["dataset"]["kwargs"]["handler"] = handler
+        return handler
+    else:
+        raise ValueError("The task does not contains a handler part.")

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/dataset/weight.py

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+class Reweighter:
+    def __init__(self, *args, **kwargs):
+        """
+        To initialize the Reweighter, users should provide specific methods to let reweighter do the reweighting (such as sample-wise, rule-based).
+        """
+        raise NotImplementedError()
+
+    def reweight(self, data: object) -> object:
+        """
+        Get weights for data
+
+        Parameters
+        ----------
+        data : object
+            The input data.
+            The first dimension is the index of samples
+
+        Returns
+        -------
+        object:
+            the weights info for the data
+        """
+        raise NotImplementedError(f"This type of input is not supported")

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/filter.py

@@ -0,0 +1,375 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import print_function
+from abc import abstractmethod
+
+import re
+import pandas as pd
+import numpy as np
+import abc
+
+from .data import Cal, DatasetD
+
+
+class BaseDFilter(abc.ABC):
+    """Dynamic Instruments Filter Abstract class
+
+    Users can override this class to construct their own filter
+
+    Override __init__ to input filter regulations
+
+    Override filter_main to use the regulations to filter instruments
+    """
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def from_config(config):
+        """Construct an instance from config dict.
+
+        Parameters
+        ----------
+        config : dict
+            dict of config parameters.
+        """
+        raise NotImplementedError("Subclass of BaseDFilter must reimplement `from_config` method")
+
+    @abstractmethod
+    def to_config(self):
+        """Construct an instance from config dict.
+
+        Returns
+        ----------
+        dict
+            return the dict of config parameters.
+        """
+        raise NotImplementedError("Subclass of BaseDFilter must reimplement `to_config` method")
+
+
+class SeriesDFilter(BaseDFilter):
+    """Dynamic Instruments Filter Abstract class to filter a series of certain features
+
+    Filters should provide parameters:
+
+    - filter start time
+    - filter end time
+    - filter rule
+
+    Override __init__ to assign a certain rule to filter the series.
+
+    Override _getFilterSeries to use the rule to filter the series and get a dict of {inst => series}, or override filter_main for more advanced series filter rule
+    """
+
+    def __init__(self, fstart_time=None, fend_time=None, keep=False):
+        """Init function for filter base class.
+            Filter a set of instruments based on a certain rule within a certain period assigned by fstart_time and fend_time.
+
+        Parameters
+        ----------
+        fstart_time: str
+            the time for the filter rule to start filter the instruments.
+        fend_time: str
+            the time for the filter rule to stop filter the instruments.
+        keep: bool
+            whether to keep the instruments of which features don't exist in the filter time span.
+        """
+        super(SeriesDFilter, self).__init__()
+        self.filter_start_time = pd.Timestamp(fstart_time) if fstart_time else None
+        self.filter_end_time = pd.Timestamp(fend_time) if fend_time else None
+        self.keep = keep
+
+    def _getTimeBound(self, instruments):
+        """Get time bound for all instruments.
+
+        Parameters
+        ----------
+        instruments: dict
+            the dict of instruments in the form {instrument_name => list of timestamp tuple}.
+
+        Returns
+        ----------
+        pd.Timestamp, pd.Timestamp
+            the lower time bound and upper time bound of all the instruments.
+        """
+        trange = Cal.calendar(freq=self.filter_freq)
+        ubound, lbound = trange[0], trange[-1]
+        for _, timestamp in instruments.items():
+            if timestamp:
+                lbound = timestamp[0][0] if timestamp[0][0] < lbound else lbound
+                ubound = timestamp[-1][-1] if timestamp[-1][-1] > ubound else ubound
+        return lbound, ubound
+
+    def _toSeries(self, time_range, target_timestamp):
+        """Convert the target timestamp to a pandas series of bool value within a time range.
+            Make the time inside the target_timestamp range TRUE, others FALSE.
+
+        Parameters
+        ----------
+        time_range : D.calendar
+            the time range of the instruments.
+        target_timestamp : list
+            the list of tuple (timestamp, timestamp).
+
+        Returns
+        ----------
+        pd.Series
+            the series of bool value for an instrument.
+        """
+        # Construct a whole dict of {date => bool}
+        timestamp_series = {timestamp: False for timestamp in time_range}
+        # Convert to pd.Series
+        timestamp_series = pd.Series(timestamp_series)
+        # Fill the date within target_timestamp with TRUE
+        for start, end in target_timestamp:
+            timestamp_series[Cal.calendar(start_time=start, end_time=end, freq=self.filter_freq)] = True
+        return timestamp_series
+
+    def _filterSeries(self, timestamp_series, filter_series):
+        """Filter the timestamp series with filter series by using element-wise AND operation of the two series.
+
+        Parameters
+        ----------
+        timestamp_series : pd.Series
+            the series of bool value indicating existing time.
+        filter_series : pd.Series
+            the series of bool value indicating filter feature.
+
+        Returns
+        ----------
+        pd.Series
+            the series of bool value indicating whether the date satisfies the filter condition and exists in target timestamp.
+        """
+        fstart, fend = list(filter_series.keys())[0], list(filter_series.keys())[-1]
+        filter_series = filter_series.astype("bool")  # Make sure the filter_series is boolean
+        timestamp_series[fstart:fend] = timestamp_series[fstart:fend] & filter_series
+        return timestamp_series
+
+    def _toTimestamp(self, timestamp_series):
+        """Convert the timestamp series to a list of tuple (timestamp, timestamp) indicating a continuous range of TRUE.
+
+        Parameters
+        ----------
+        timestamp_series: pd.Series
+            the series of bool value after being filtered.
+
+        Returns
+        ----------
+        list
+            the list of tuple (timestamp, timestamp).
+        """
+        # sort the timestamp_series according to the timestamps
+        timestamp_series.sort_index()
+        timestamp = []
+        _lbool = None
+        _ltime = None
+        _cur_start = None
+        for _ts, _bool in timestamp_series.items():
+            # there is likely to be NAN when the filter series don't have the
+            # bool value, so we just change the NAN into False
+            if np.isnan(_bool):
+                _bool = False
+            if _lbool is None:
+                _cur_start = _ts
+                _lbool = _bool
+                _ltime = _ts
+                continue
+            if (_lbool, _bool) == (True, False):
+                if _cur_start:
+                    timestamp.append((_cur_start, _ltime))
+            elif (_lbool, _bool) == (False, True):
+                _cur_start = _ts
+            _lbool = _bool
+            _ltime = _ts
+        if _lbool:
+            timestamp.append((_cur_start, _ltime))
+        return timestamp
+
+    def __call__(self, instruments, start_time=None, end_time=None, freq="day"):
+        """Call this filter to get filtered instruments list"""
+        self.filter_freq = freq
+        return self.filter_main(instruments, start_time, end_time)
+
+    @abstractmethod
+    def _getFilterSeries(self, instruments, fstart, fend):
+        """Get filter series based on the rules assigned during the initialization and the input time range.
+
+        Parameters
+        ----------
+        instruments : dict
+            the dict of instruments to be filtered.
+        fstart : pd.Timestamp
+            start time of filter.
+        fend : pd.Timestamp
+            end time of filter.
+
+        .. note:: fstart/fend indicates the intersection of instruments start/end time and filter start/end time.
+
+        Returns
+        ----------
+        pd.Dataframe
+            a series of {pd.Timestamp => bool}.
+        """
+        raise NotImplementedError("Subclass of SeriesDFilter must reimplement `getFilterSeries` method")
+
+    def filter_main(self, instruments, start_time=None, end_time=None):
+        """Implement this method to filter the instruments.
+
+        Parameters
+        ----------
+        instruments: dict
+            input instruments to be filtered.
+        start_time: str
+            start of the time range.
+        end_time: str
+            end of the time range.
+
+        Returns
+        ----------
+        dict
+            filtered instruments, same structure as input instruments.
+        """
+        lbound, ubound = self._getTimeBound(instruments)
+        start_time = pd.Timestamp(start_time or lbound)
+        end_time = pd.Timestamp(end_time or ubound)
+        _instruments_filtered = {}
+        _all_calendar = Cal.calendar(start_time=start_time, end_time=end_time, freq=self.filter_freq)
+        _filter_calendar = Cal.calendar(
+            start_time=self.filter_start_time and max(self.filter_start_time, _all_calendar[0]) or _all_calendar[0],
+            end_time=self.filter_end_time and min(self.filter_end_time, _all_calendar[-1]) or _all_calendar[-1],
+            freq=self.filter_freq,
+        )
+        _all_filter_series = self._getFilterSeries(instruments, _filter_calendar[0], _filter_calendar[-1])
+        for inst, timestamp in instruments.items():
+            # Construct a whole map of date
+            _timestamp_series = self._toSeries(_all_calendar, timestamp)
+            # Get filter series
+            if inst in _all_filter_series:
+                _filter_series = _all_filter_series[inst]
+            else:
+                if self.keep:
+                    _filter_series = pd.Series({timestamp: True for timestamp in _filter_calendar})
+                else:
+                    _filter_series = pd.Series({timestamp: False for timestamp in _filter_calendar})
+            # Calculate bool value within the range of filter
+            _timestamp_series = self._filterSeries(_timestamp_series, _filter_series)
+            # Reform the map to (start_timestamp, end_timestamp) format
+            _timestamp = self._toTimestamp(_timestamp_series)
+            # Remove empty timestamp
+            if _timestamp:
+                _instruments_filtered[inst] = _timestamp
+        return _instruments_filtered
+
+
+class NameDFilter(SeriesDFilter):
+    """Name dynamic instrument filter
+
+    Filter the instruments based on a regulated name format.
+
+    A name rule regular expression is required.
+    """
+
+    def __init__(self, name_rule_re, fstart_time=None, fend_time=None):
+        """Init function for name filter class
+
+        Parameters
+        ----------
+        name_rule_re: str
+            regular expression for the name rule.
+        """
+        super(NameDFilter, self).__init__(fstart_time, fend_time)
+        self.name_rule_re = name_rule_re
+
+    def _getFilterSeries(self, instruments, fstart, fend):
+        all_filter_series = {}
+        filter_calendar = Cal.calendar(start_time=fstart, end_time=fend, freq=self.filter_freq)
+        for inst, timestamp in instruments.items():
+            if re.match(self.name_rule_re, inst):
+                _filter_series = pd.Series({timestamp: True for timestamp in filter_calendar})
+            else:
+                _filter_series = pd.Series({timestamp: False for timestamp in filter_calendar})
+            all_filter_series[inst] = _filter_series
+        return all_filter_series
+
+    @staticmethod
+    def from_config(config):
+        return NameDFilter(
+            name_rule_re=config["name_rule_re"],
+            fstart_time=config["filter_start_time"],
+            fend_time=config["filter_end_time"],
+        )
+
+    def to_config(self):
+        return {
+            "filter_type": "NameDFilter",
+            "name_rule_re": self.name_rule_re,
+            "filter_start_time": str(self.filter_start_time) if self.filter_start_time else self.filter_start_time,
+            "filter_end_time": str(self.filter_end_time) if self.filter_end_time else self.filter_end_time,
+        }
+
+
+class ExpressionDFilter(SeriesDFilter):
+    """Expression dynamic instrument filter
+
+    Filter the instruments based on a certain expression.
+
+    An expression rule indicating a certain feature field is required.
+
+    Examples
+    ----------
+    - *basic features filter* : rule_expression = '$close/$open>5'
+    - *cross-sectional features filter* : rule_expression = '$rank($close)<10'
+    - *time-sequence features filter* : rule_expression = '$Ref($close, 3)>100'
+    """
+
+    def __init__(self, rule_expression, fstart_time=None, fend_time=None, keep=False):
+        """Init function for expression filter class
+
+        Parameters
+        ----------
+        fstart_time: str
+            filter the feature starting from this time.
+        fend_time: str
+            filter the feature ending by this time.
+        rule_expression: str
+            an input expression for the rule.
+        """
+        super(ExpressionDFilter, self).__init__(fstart_time, fend_time, keep=keep)
+        self.rule_expression = rule_expression
+
+    def _getFilterSeries(self, instruments, fstart, fend):
+        # do not use dataset cache
+        try:
+            _features = DatasetD.dataset(
+                instruments,
+                [self.rule_expression],
+                fstart,
+                fend,
+                freq=self.filter_freq,
+                disk_cache=0,
+            )
+        except TypeError:
+            # use LocalDatasetProvider
+            _features = DatasetD.dataset(instruments, [self.rule_expression], fstart, fend, freq=self.filter_freq)
+        rule_expression_field_name = list(_features.keys())[0]
+        all_filter_series = _features[rule_expression_field_name]
+        return all_filter_series
+
+    @staticmethod
+    def from_config(config):
+        return ExpressionDFilter(
+            rule_expression=config["rule_expression"],
+            fstart_time=config["filter_start_time"],
+            fend_time=config["filter_end_time"],
+            keep=config["keep"],
+        )
+
+    def to_config(self):
+        return {
+            "filter_type": "ExpressionDFilter",
+            "rule_expression": self.rule_expression,
+            "filter_start_time": str(self.filter_start_time) if self.filter_start_time else self.filter_start_time,
+            "filter_end_time": str(self.filter_end_time) if self.filter_end_time else self.filter_end_time,
+            "keep": self.keep,
+        }

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/inst_processor.py

@@ -0,0 +1,22 @@
+import abc
+import json
+import pandas as pd
+
+
+class InstProcessor:
+    @abc.abstractmethod
+    def __call__(self, df: pd.DataFrame, instrument, *args, **kwargs):
+        """
+        process the data
+
+        NOTE: **The processor could change the content of `df` inplace !!!!! **
+        User should keep a copy of data outside
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The raw_df of handler or result from previous processor.
+        """
+
+    def __str__(self):
+        return f"{self.__class__.__name__}:{json.dumps(self.__dict__, sort_keys=True, default=str)}"

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/ops.py

@@ -0,0 +1,1681 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import pandas as pd
+
+from typing import Union, List, Type
+from scipy.stats import percentileofscore
+from .base import Expression, ExpressionOps, Feature, PFeature
+from ..log import get_module_logger
+from ..utils import get_callable_kwargs
+
+try:
+    from ._libs.rolling import rolling_slope, rolling_rsquare, rolling_resi
+    from ._libs.expanding import expanding_slope, expanding_rsquare, expanding_resi
+except ImportError:
+    print(
+        "#### Do not import qlib package in the repository directory in case of importing qlib from . without compiling #####"
+    )
+    raise
+except ValueError:
+    print("!!!!!!!! A error occurs when importing operators implemented based on Cython.!!!!!!!!")
+    print("!!!!!!!! They will be disabled. Please Upgrade your numpy to enable them     !!!!!!!!")
+    # We catch this error because some platform can't upgrade there package (e.g. Kaggle)
+    # https://www.kaggle.com/general/293387
+    # https://www.kaggle.com/product-feedback/98562
+
+
+np.seterr(invalid="ignore")
+
+
+#################### Element-Wise Operator ####################
+class ElemOperator(ExpressionOps):
+    """Element-wise Operator
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+
+    Returns
+    ----------
+    Expression
+        feature operation output
+    """
+
+    def __init__(self, feature):
+        self.feature = feature
+
+    def __str__(self):
+        return "{}({})".format(type(self).__name__, self.feature)
+
+    def get_longest_back_rolling(self):
+        return self.feature.get_longest_back_rolling()
+
+    def get_extended_window_size(self):
+        return self.feature.get_extended_window_size()
+
+
+class ChangeInstrument(ElemOperator):
+    """Change Instrument Operator
+    In some case, one may want to change to another instrument when calculating, for example, to
+    calculate beta of a stock with respect to a market index.
+    This would require changing the calculation of features from the stock (original instrument) to
+    the index (reference instrument)
+    Parameters
+    ----------
+    instrument: new instrument for which the downstream operations should be performed upon.
+                i.e., SH000300 (CSI300 index), or ^GPSC (SP500 index).
+
+    feature: the feature to be calculated for the new instrument.
+    Returns
+    ----------
+    Expression
+        feature operation output
+    """
+
+    def __init__(self, instrument, feature):
+        self.instrument = instrument
+        self.feature = feature
+
+    def __str__(self):
+        return "{}('{}',{})".format(type(self).__name__, self.instrument, self.feature)
+
+    def load(self, instrument, start_index, end_index, *args):
+        # the first `instrument` is ignored
+        return super().load(self.instrument, start_index, end_index, *args)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        return self.feature.load(instrument, start_index, end_index, *args)
+
+
+class NpElemOperator(ElemOperator):
+    """Numpy Element-wise Operator
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    func : str
+        numpy feature operation method
+
+    Returns
+    ----------
+    Expression
+        feature operation output
+    """
+
+    def __init__(self, feature, func):
+        self.func = func
+        super(NpElemOperator, self).__init__(feature)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        return getattr(np, self.func)(series)
+
+
+class Abs(NpElemOperator):
+    """Feature Absolute Value
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+
+    Returns
+    ----------
+    Expression
+        a feature instance with absolute output
+    """
+
+    def __init__(self, feature):
+        super(Abs, self).__init__(feature, "abs")
+
+
+class Sign(NpElemOperator):
+    """Feature Sign
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+
+    Returns
+    ----------
+    Expression
+        a feature instance with sign
+    """
+
+    def __init__(self, feature):
+        super(Sign, self).__init__(feature, "sign")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        """
+        To avoid error raised by bool type input, we transform the data into float32.
+        """
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        # TODO:  More precision types should be configurable
+        series = series.astype(np.float32)
+        return getattr(np, self.func)(series)
+
+
+class Log(NpElemOperator):
+    """Feature Log
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+
+    Returns
+    ----------
+    Expression
+        a feature instance with log
+    """
+
+    def __init__(self, feature):
+        super(Log, self).__init__(feature, "log")
+
+
+class Mask(NpElemOperator):
+    """Feature Mask
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    instrument : str
+        instrument mask
+
+    Returns
+    ----------
+    Expression
+        a feature instance with masked instrument
+    """
+
+    def __init__(self, feature, instrument):
+        super(Mask, self).__init__(feature, "mask")
+        self.instrument = instrument
+
+    def __str__(self):
+        return "{}({},{})".format(type(self).__name__, self.feature, self.instrument.lower())
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        return self.feature.load(self.instrument, start_index, end_index, *args)
+
+
+class Not(NpElemOperator):
+    """Not Operator
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        feature elementwise not output
+    """
+
+    def __init__(self, feature):
+        super(Not, self).__init__(feature, "bitwise_not")
+
+
+#################### Pair-Wise Operator ####################
+class PairOperator(ExpressionOps):
+    """Pair-wise operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance or numeric value
+    feature_right : Expression
+        feature instance or numeric value
+
+    Returns
+    ----------
+    Feature:
+        two features' operation output
+    """
+
+    def __init__(self, feature_left, feature_right):
+        self.feature_left = feature_left
+        self.feature_right = feature_right
+
+    def __str__(self):
+        return "{}({},{})".format(type(self).__name__, self.feature_left, self.feature_right)
+
+    def get_longest_back_rolling(self):
+        if isinstance(self.feature_left, (Expression,)):
+            left_br = self.feature_left.get_longest_back_rolling()
+        else:
+            left_br = 0
+
+        if isinstance(self.feature_right, (Expression,)):
+            right_br = self.feature_right.get_longest_back_rolling()
+        else:
+            right_br = 0
+        return max(left_br, right_br)
+
+    def get_extended_window_size(self):
+        if isinstance(self.feature_left, (Expression,)):
+            ll, lr = self.feature_left.get_extended_window_size()
+        else:
+            ll, lr = 0, 0
+
+        if isinstance(self.feature_right, (Expression,)):
+            rl, rr = self.feature_right.get_extended_window_size()
+        else:
+            rl, rr = 0, 0
+        return max(ll, rl), max(lr, rr)
+
+
+class NpPairOperator(PairOperator):
+    """Numpy Pair-wise operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance or numeric value
+    feature_right : Expression
+        feature instance or numeric value
+    func : str
+        operator function
+
+    Returns
+    ----------
+    Feature:
+        two features' operation output
+    """
+
+    def __init__(self, feature_left, feature_right, func):
+        self.func = func
+        super(NpPairOperator, self).__init__(feature_left, feature_right)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        assert any(
+            [isinstance(self.feature_left, (Expression,)), self.feature_right, Expression]
+        ), "at least one of two inputs is Expression instance"
+        if isinstance(self.feature_left, (Expression,)):
+            series_left = self.feature_left.load(instrument, start_index, end_index, *args)
+        else:
+            series_left = self.feature_left  # numeric value
+        if isinstance(self.feature_right, (Expression,)):
+            series_right = self.feature_right.load(instrument, start_index, end_index, *args)
+        else:
+            series_right = self.feature_right
+        check_length = isinstance(series_left, (np.ndarray, pd.Series)) and isinstance(
+            series_right, (np.ndarray, pd.Series)
+        )
+        if check_length:
+            warning_info = (
+                f"Loading {instrument}: {str(self)}; np.{self.func}(series_left, series_right), "
+                f"The length of series_left and series_right is different: ({len(series_left)}, {len(series_right)}), "
+                f"series_left is {str(self.feature_left)}, series_right is {str(self.feature_right)}. Please check the data"
+            )
+        else:
+            warning_info = (
+                f"Loading {instrument}: {str(self)}; np.{self.func}(series_left, series_right), "
+                f"series_left is {str(self.feature_left)}, series_right is {str(self.feature_right)}. Please check the data"
+            )
+        try:
+            res = getattr(np, self.func)(series_left, series_right)
+        except ValueError as e:
+            get_module_logger("ops").debug(warning_info)
+            raise ValueError(f"{str(e)}. \n\t{warning_info}") from e
+        else:
+            if check_length and len(series_left) != len(series_right):
+                get_module_logger("ops").debug(warning_info)
+        return res
+
+
+class Power(NpPairOperator):
+    """Power Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        The bases in feature_left raised to the exponents in feature_right
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Power, self).__init__(feature_left, feature_right, "power")
+
+
+class Add(NpPairOperator):
+    """Add Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' sum
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Add, self).__init__(feature_left, feature_right, "add")
+
+
+class Sub(NpPairOperator):
+    """Subtract Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' subtraction
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Sub, self).__init__(feature_left, feature_right, "subtract")
+
+
+class Mul(NpPairOperator):
+    """Multiply Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' product
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Mul, self).__init__(feature_left, feature_right, "multiply")
+
+
+class Div(NpPairOperator):
+    """Division Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' division
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Div, self).__init__(feature_left, feature_right, "divide")
+
+
+class Greater(NpPairOperator):
+    """Greater Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        greater elements taken from the input two features
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Greater, self).__init__(feature_left, feature_right, "maximum")
+
+
+class Less(NpPairOperator):
+    """Less Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        smaller elements taken from the input two features
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Less, self).__init__(feature_left, feature_right, "minimum")
+
+
+class Gt(NpPairOperator):
+    """Greater Than Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left > right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Gt, self).__init__(feature_left, feature_right, "greater")
+
+
+class Ge(NpPairOperator):
+    """Greater Equal Than Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left >= right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Ge, self).__init__(feature_left, feature_right, "greater_equal")
+
+
+class Lt(NpPairOperator):
+    """Less Than Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left < right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Lt, self).__init__(feature_left, feature_right, "less")
+
+
+class Le(NpPairOperator):
+    """Less Equal Than Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left <= right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Le, self).__init__(feature_left, feature_right, "less_equal")
+
+
+class Eq(NpPairOperator):
+    """Equal Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left == right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Eq, self).__init__(feature_left, feature_right, "equal")
+
+
+class Ne(NpPairOperator):
+    """Not Equal Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        bool series indicate `left != right`
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Ne, self).__init__(feature_left, feature_right, "not_equal")
+
+
+class And(NpPairOperator):
+    """And Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' row by row & output
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(And, self).__init__(feature_left, feature_right, "bitwise_and")
+
+
+class Or(NpPairOperator):
+    """Or Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+
+    Returns
+    ----------
+    Feature:
+        two features' row by row | outputs
+    """
+
+    def __init__(self, feature_left, feature_right):
+        super(Or, self).__init__(feature_left, feature_right, "bitwise_or")
+
+
+#################### Triple-wise Operator ####################
+class If(ExpressionOps):
+    """If Operator
+
+    Parameters
+    ----------
+    condition : Expression
+        feature instance with bool values as condition
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+    """
+
+    def __init__(self, condition, feature_left, feature_right):
+        self.condition = condition
+        self.feature_left = feature_left
+        self.feature_right = feature_right
+
+    def __str__(self):
+        return "If({},{},{})".format(self.condition, self.feature_left, self.feature_right)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series_cond = self.condition.load(instrument, start_index, end_index, *args)
+        if isinstance(self.feature_left, (Expression,)):
+            series_left = self.feature_left.load(instrument, start_index, end_index, *args)
+        else:
+            series_left = self.feature_left
+        if isinstance(self.feature_right, (Expression,)):
+            series_right = self.feature_right.load(instrument, start_index, end_index, *args)
+        else:
+            series_right = self.feature_right
+        series = pd.Series(np.where(series_cond, series_left, series_right), index=series_cond.index)
+        return series
+
+    def get_longest_back_rolling(self):
+        if isinstance(self.feature_left, (Expression,)):
+            left_br = self.feature_left.get_longest_back_rolling()
+        else:
+            left_br = 0
+
+        if isinstance(self.feature_right, (Expression,)):
+            right_br = self.feature_right.get_longest_back_rolling()
+        else:
+            right_br = 0
+
+        if isinstance(self.condition, (Expression,)):
+            c_br = self.condition.get_longest_back_rolling()
+        else:
+            c_br = 0
+        return max(left_br, right_br, c_br)
+
+    def get_extended_window_size(self):
+        if isinstance(self.feature_left, (Expression,)):
+            ll, lr = self.feature_left.get_extended_window_size()
+        else:
+            ll, lr = 0, 0
+
+        if isinstance(self.feature_right, (Expression,)):
+            rl, rr = self.feature_right.get_extended_window_size()
+        else:
+            rl, rr = 0, 0
+
+        if isinstance(self.condition, (Expression,)):
+            cl, cr = self.condition.get_extended_window_size()
+        else:
+            cl, cr = 0, 0
+        return max(ll, rl, cl), max(lr, rr, cr)
+
+
+#################### Rolling ####################
+# NOTE: methods like `rolling.mean` are optimized with cython,
+# and are super faster than `rolling.apply(np.mean)`
+
+
+class Rolling(ExpressionOps):
+    """Rolling Operator
+    The meaning of rolling and expanding is the same in pandas.
+    When the window is set to 0, the behaviour of the operator should follow `expanding`
+    Otherwise, it follows `rolling`
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+    func : str
+        rolling method
+
+    Returns
+    ----------
+    Expression
+        rolling outputs
+    """
+
+    def __init__(self, feature, N, func):
+        self.feature = feature
+        self.N = N
+        self.func = func
+
+    def __str__(self):
+        return "{}({},{})".format(type(self).__name__, self.feature, self.N)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        # NOTE: remove all null check,
+        # now it's user's responsibility to decide whether use features in null days
+        # isnull = series.isnull() # NOTE: isnull = NaN, inf is not null
+        if isinstance(self.N, int) and self.N == 0:
+            series = getattr(series.expanding(min_periods=1), self.func)()
+        elif isinstance(self.N, float) and 0 < self.N < 1:
+            series = series.ewm(alpha=self.N, min_periods=1).mean()
+        else:
+            series = getattr(series.rolling(self.N, min_periods=1), self.func)()
+            # series.iloc[:self.N-1] = np.nan
+        # series[isnull] = np.nan
+        return series
+
+    def get_longest_back_rolling(self):
+        if self.N == 0:
+            return np.inf
+        if 0 < self.N < 1:
+            return int(np.log(1e-6) / np.log(1 - self.N))  # (1 - N)**window == 1e-6
+        return self.feature.get_longest_back_rolling() + self.N - 1
+
+    def get_extended_window_size(self):
+        if self.N == 0:
+            # FIXME: How to make this accurate and efficiently? Or  should we
+            # remove such support for N == 0?
+            get_module_logger(self.__class__.__name__).warning("The Rolling(ATTR, 0) will not be accurately calculated")
+            return self.feature.get_extended_window_size()
+        elif 0 < self.N < 1:
+            lft_etd, rght_etd = self.feature.get_extended_window_size()
+            size = int(np.log(1e-6) / np.log(1 - self.N))
+            lft_etd = max(lft_etd + size - 1, lft_etd)
+            return lft_etd, rght_etd
+        else:
+            lft_etd, rght_etd = self.feature.get_extended_window_size()
+            lft_etd = max(lft_etd + self.N - 1, lft_etd)
+            return lft_etd, rght_etd
+
+
+class Ref(Rolling):
+    """Feature Reference
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        N = 0, retrieve the first data; N > 0, retrieve data of N periods ago; N < 0, future data
+
+    Returns
+    ----------
+    Expression
+        a feature instance with target reference
+    """
+
+    def __init__(self, feature, N):
+        super(Ref, self).__init__(feature, N, "ref")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        # N = 0, return first day
+        if series.empty:
+            return series  # Pandas bug, see: https://github.com/pandas-dev/pandas/issues/21049
+        elif self.N == 0:
+            series = pd.Series(series.iloc[0], index=series.index)
+        else:
+            series = series.shift(self.N)  # copy
+        return series
+
+    def get_longest_back_rolling(self):
+        if self.N == 0:
+            return np.inf
+        return self.feature.get_longest_back_rolling() + self.N
+
+    def get_extended_window_size(self):
+        if self.N == 0:
+            get_module_logger(self.__class__.__name__).warning("The Ref(ATTR, 0) will not be accurately calculated")
+            return self.feature.get_extended_window_size()
+        else:
+            lft_etd, rght_etd = self.feature.get_extended_window_size()
+            lft_etd = max(lft_etd + self.N, lft_etd)
+            rght_etd = max(rght_etd - self.N, rght_etd)
+            return lft_etd, rght_etd
+
+
+class Mean(Rolling):
+    """Rolling Mean (MA)
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling average
+    """
+
+    def __init__(self, feature, N):
+        super(Mean, self).__init__(feature, N, "mean")
+
+
+class Sum(Rolling):
+    """Rolling Sum
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling sum
+    """
+
+    def __init__(self, feature, N):
+        super(Sum, self).__init__(feature, N, "sum")
+
+
+class Std(Rolling):
+    """Rolling Std
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling std
+    """
+
+    def __init__(self, feature, N):
+        super(Std, self).__init__(feature, N, "std")
+
+
+class Var(Rolling):
+    """Rolling Variance
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling variance
+    """
+
+    def __init__(self, feature, N):
+        super(Var, self).__init__(feature, N, "var")
+
+
+class Skew(Rolling):
+    """Rolling Skewness
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling skewness
+    """
+
+    def __init__(self, feature, N):
+        if N != 0 and N < 3:
+            raise ValueError("The rolling window size of Skewness operation should >= 3")
+        super(Skew, self).__init__(feature, N, "skew")
+
+
+class Kurt(Rolling):
+    """Rolling Kurtosis
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling kurtosis
+    """
+
+    def __init__(self, feature, N):
+        if N != 0 and N < 4:
+            raise ValueError("The rolling window size of Kurtosis operation should >= 5")
+        super(Kurt, self).__init__(feature, N, "kurt")
+
+
+class Max(Rolling):
+    """Rolling Max
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling max
+    """
+
+    def __init__(self, feature, N):
+        super(Max, self).__init__(feature, N, "max")
+
+
+class IdxMax(Rolling):
+    """Rolling Max Index
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling max index
+    """
+
+    def __init__(self, feature, N):
+        super(IdxMax, self).__init__(feature, N, "idxmax")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = series.expanding(min_periods=1).apply(lambda x: x.argmax() + 1, raw=True)
+        else:
+            series = series.rolling(self.N, min_periods=1).apply(lambda x: x.argmax() + 1, raw=True)
+        return series
+
+
+class Min(Rolling):
+    """Rolling Min
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling min
+    """
+
+    def __init__(self, feature, N):
+        super(Min, self).__init__(feature, N, "min")
+
+
+class IdxMin(Rolling):
+    """Rolling Min Index
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling min index
+    """
+
+    def __init__(self, feature, N):
+        super(IdxMin, self).__init__(feature, N, "idxmin")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = series.expanding(min_periods=1).apply(lambda x: x.argmin() + 1, raw=True)
+        else:
+            series = series.rolling(self.N, min_periods=1).apply(lambda x: x.argmin() + 1, raw=True)
+        return series
+
+
+class Quantile(Rolling):
+    """Rolling Quantile
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling quantile
+    """
+
+    def __init__(self, feature, N, qscore):
+        super(Quantile, self).__init__(feature, N, "quantile")
+        self.qscore = qscore
+
+    def __str__(self):
+        return "{}({},{},{})".format(type(self).__name__, self.feature, self.N, self.qscore)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = series.expanding(min_periods=1).quantile(self.qscore)
+        else:
+            series = series.rolling(self.N, min_periods=1).quantile(self.qscore)
+        return series
+
+
+class Med(Rolling):
+    """Rolling Median
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling median
+    """
+
+    def __init__(self, feature, N):
+        super(Med, self).__init__(feature, N, "median")
+
+
+class Mad(Rolling):
+    """Rolling Mean Absolute Deviation
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling mean absolute deviation
+    """
+
+    def __init__(self, feature, N):
+        super(Mad, self).__init__(feature, N, "mad")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        # TODO: implement in Cython
+
+        def mad(x):
+            x1 = x[~np.isnan(x)]
+            return np.mean(np.abs(x1 - x1.mean()))
+
+        if self.N == 0:
+            series = series.expanding(min_periods=1).apply(mad, raw=True)
+        else:
+            series = series.rolling(self.N, min_periods=1).apply(mad, raw=True)
+        return series
+
+
+class Rank(Rolling):
+    """Rolling Rank (Percentile)
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling rank
+    """
+
+    def __init__(self, feature, N):
+        super(Rank, self).__init__(feature, N, "rank")
+
+    # for compatiblity of python 3.7, which doesn't support pandas 1.4.0+ which implements Rolling.rank
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+
+        rolling_or_expending = series.expanding(min_periods=1) if self.N == 0 else series.rolling(self.N, min_periods=1)
+        if hasattr(rolling_or_expending, "rank"):
+            return rolling_or_expending.rank(pct=True)
+
+        def rank(x):
+            if np.isnan(x[-1]):
+                return np.nan
+            x1 = x[~np.isnan(x)]
+            if x1.shape[0] == 0:
+                return np.nan
+            return percentileofscore(x1, x1[-1]) / 100
+
+        return rolling_or_expending.apply(rank, raw=True)
+
+
+class Count(Rolling):
+    """Rolling Count
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling count of number of non-NaN elements
+    """
+
+    def __init__(self, feature, N):
+        super(Count, self).__init__(feature, N, "count")
+
+
+class Delta(Rolling):
+    """Rolling Delta
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with end minus start in rolling window
+    """
+
+    def __init__(self, feature, N):
+        super(Delta, self).__init__(feature, N, "delta")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = series - series.iloc[0]
+        else:
+            series = series - series.shift(self.N)
+        return series
+
+
+# TODO:
+# support pair-wise rolling like `Slope(A, B, N)`
+class Slope(Rolling):
+    """Rolling Slope
+    This operator calculate the slope between `idx` and `feature`.
+    (e.g. [<feature_t1>, <feature_t2>, <feature_t3>] and [1, 2, 3])
+
+    Usage Example:
+    - "Slope($close, %d)/$close"
+
+    # TODO:
+    # Some users may want pair-wise rolling like `Slope(A, B, N)`
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with linear regression slope of given window
+    """
+
+    def __init__(self, feature, N):
+        super(Slope, self).__init__(feature, N, "slope")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = pd.Series(expanding_slope(series.values), index=series.index)
+        else:
+            series = pd.Series(rolling_slope(series.values, self.N), index=series.index)
+        return series
+
+
+class Rsquare(Rolling):
+    """Rolling R-value Square
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with linear regression r-value square of given window
+    """
+
+    def __init__(self, feature, N):
+        super(Rsquare, self).__init__(feature, N, "rsquare")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        _series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = pd.Series(expanding_rsquare(_series.values), index=_series.index)
+        else:
+            series = pd.Series(rolling_rsquare(_series.values, self.N), index=_series.index)
+            series.loc[np.isclose(_series.rolling(self.N, min_periods=1).std(), 0, atol=2e-05)] = np.nan
+        return series
+
+
+class Resi(Rolling):
+    """Rolling Regression Residuals
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with regression residuals of given window
+    """
+
+    def __init__(self, feature, N):
+        super(Resi, self).__init__(feature, N, "resi")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        if self.N == 0:
+            series = pd.Series(expanding_resi(series.values), index=series.index)
+        else:
+            series = pd.Series(rolling_resi(series.values, self.N), index=series.index)
+        return series
+
+
+class WMA(Rolling):
+    """Rolling WMA
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with weighted moving average output
+    """
+
+    def __init__(self, feature, N):
+        super(WMA, self).__init__(feature, N, "wma")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+        # TODO: implement in Cython
+
+        def weighted_mean(x):
+            w = np.arange(len(x)) + 1
+            w = w / w.sum()
+            return np.nanmean(w * x)
+
+        if self.N == 0:
+            series = series.expanding(min_periods=1).apply(weighted_mean, raw=True)
+        else:
+            series = series.rolling(self.N, min_periods=1).apply(weighted_mean, raw=True)
+        return series
+
+
+class EMA(Rolling):
+    """Rolling Exponential Mean (EMA)
+
+    Parameters
+    ----------
+    feature : Expression
+        feature instance
+    N : int, float
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with regression r-value square of given window
+    """
+
+    def __init__(self, feature, N):
+        super(EMA, self).__init__(feature, N, "ema")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+
+        def exp_weighted_mean(x):
+            a = 1 - 2 / (1 + len(x))
+            w = a ** np.arange(len(x))[::-1]
+            w /= w.sum()
+            return np.nansum(w * x)
+
+        if self.N == 0:
+            series = series.expanding(min_periods=1).apply(exp_weighted_mean, raw=True)
+        elif 0 < self.N < 1:
+            series = series.ewm(alpha=self.N, min_periods=1).mean()
+        else:
+            series = series.ewm(span=self.N, min_periods=1).mean()
+        return series
+
+
+#################### Pair-Wise Rolling ####################
+class PairRolling(ExpressionOps):
+    """Pair Rolling Operator
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling output of two input features
+    """
+
+    def __init__(self, feature_left, feature_right, N, func):
+        # TODO: in what case will a const be passed into `__init__` as `feature_left` or `feature_right`
+        self.feature_left = feature_left
+        self.feature_right = feature_right
+        self.N = N
+        self.func = func
+
+    def __str__(self):
+        return "{}({},{},{})".format(type(self).__name__, self.feature_left, self.feature_right, self.N)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        assert any(
+            [isinstance(self.feature_left, Expression), self.feature_right, Expression]
+        ), "at least one of two inputs is Expression instance"
+
+        if isinstance(self.feature_left, Expression):
+            series_left = self.feature_left.load(instrument, start_index, end_index, *args)
+        else:
+            series_left = self.feature_left  # numeric value
+        if isinstance(self.feature_right, Expression):
+            series_right = self.feature_right.load(instrument, start_index, end_index, *args)
+        else:
+            series_right = self.feature_right
+
+        if self.N == 0:
+            series = getattr(series_left.expanding(min_periods=1), self.func)(series_right)
+        else:
+            series = getattr(series_left.rolling(self.N, min_periods=1), self.func)(series_right)
+        return series
+
+    def get_longest_back_rolling(self):
+        if self.N == 0:
+            return np.inf
+        if isinstance(self.feature_left, Expression):
+            left_br = self.feature_left.get_longest_back_rolling()
+        else:
+            left_br = 0
+
+        if isinstance(self.feature_right, Expression):
+            right_br = self.feature_right.get_longest_back_rolling()
+        else:
+            right_br = 0
+        return max(left_br, right_br)
+
+    def get_extended_window_size(self):
+        if isinstance(self.feature_left, Expression):
+            ll, lr = self.feature_left.get_extended_window_size()
+        else:
+            ll, lr = 0, 0
+        if isinstance(self.feature_right, Expression):
+            rl, rr = self.feature_right.get_extended_window_size()
+        else:
+            rl, rr = 0, 0
+        if self.N == 0:
+            get_module_logger(self.__class__.__name__).warning(
+                "The PairRolling(ATTR, 0) will not be accurately calculated"
+            )
+            return -np.inf, max(lr, rr)
+        else:
+            return max(ll, rl) + self.N - 1, max(lr, rr)
+
+
+class Corr(PairRolling):
+    """Rolling Correlation
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling correlation of two input features
+    """
+
+    def __init__(self, feature_left, feature_right, N):
+        super(Corr, self).__init__(feature_left, feature_right, N, "corr")
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        res: pd.Series = super(Corr, self)._load_internal(instrument, start_index, end_index, *args)
+
+        # NOTE: Load uses MemCache, so calling load again will not cause performance degradation
+        series_left = self.feature_left.load(instrument, start_index, end_index, *args)
+        series_right = self.feature_right.load(instrument, start_index, end_index, *args)
+        res.loc[
+            np.isclose(series_left.rolling(self.N, min_periods=1).std(), 0, atol=2e-05)
+            | np.isclose(series_right.rolling(self.N, min_periods=1).std(), 0, atol=2e-05)
+        ] = np.nan
+        return res
+
+
+class Cov(PairRolling):
+    """Rolling Covariance
+
+    Parameters
+    ----------
+    feature_left : Expression
+        feature instance
+    feature_right : Expression
+        feature instance
+    N : int
+        rolling window size
+
+    Returns
+    ----------
+    Expression
+        a feature instance with rolling max of two input features
+    """
+
+    def __init__(self, feature_left, feature_right, N):
+        super(Cov, self).__init__(feature_left, feature_right, N, "cov")
+
+
+#################### Operator which only support data with time index ####################
+# Convention
+# - The name of the operators in this section will start with "T"
+
+
+class TResample(ElemOperator):
+    def __init__(self, feature, freq, func):
+        """
+        Resampling the data to target frequency.
+        The resample function of pandas is used.
+
+        - the timestamp will be at the start of the time span after resample.
+
+        Parameters
+        ----------
+        feature : Expression
+            An expression for calculating the feature
+        freq : str
+            It will be passed into the resample method for resampling basedn on given frequency
+        func : method
+            The method to get the resampled values
+            Some expression are high frequently used
+        """
+        self.feature = feature
+        self.freq = freq
+        self.func = func
+
+    def __str__(self):
+        return "{}({},{})".format(type(self).__name__, self.feature, self.freq)
+
+    def _load_internal(self, instrument, start_index, end_index, *args):
+        series = self.feature.load(instrument, start_index, end_index, *args)
+
+        if series.empty:
+            return series
+        else:
+            if self.func == "sum":
+                return getattr(series.resample(self.freq), self.func)(min_count=1)
+            else:
+                return getattr(series.resample(self.freq), self.func)()
+
+
+TOpsList = [TResample]
+OpsList = [
+    ChangeInstrument,
+    Rolling,
+    Ref,
+    Max,
+    Min,
+    Sum,
+    Mean,
+    Std,
+    Var,
+    Skew,
+    Kurt,
+    Med,
+    Mad,
+    Slope,
+    Rsquare,
+    Resi,
+    Rank,
+    Quantile,
+    Count,
+    EMA,
+    WMA,
+    Corr,
+    Cov,
+    Delta,
+    Abs,
+    Sign,
+    Log,
+    Power,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Greater,
+    Less,
+    And,
+    Or,
+    Not,
+    Gt,
+    Ge,
+    Lt,
+    Le,
+    Eq,
+    Ne,
+    Mask,
+    IdxMax,
+    IdxMin,
+    If,
+    Feature,
+    PFeature,
+] + [TResample]
+
+
+class OpsWrapper:
+    """Ops Wrapper"""
+
+    def __init__(self):
+        self._ops = {}
+
+    def reset(self):
+        self._ops = {}
+
+    def register(self, ops_list: List[Union[Type[ExpressionOps], dict]]):
+        """register operator
+
+        Parameters
+        ----------
+        ops_list : List[Union[Type[ExpressionOps], dict]]
+            - if type(ops_list) is List[Type[ExpressionOps]], each element of ops_list represents the operator class, which should be the subclass of `ExpressionOps`.
+            - if type(ops_list) is List[dict], each element of ops_list represents the config of operator, which has the following format:
+
+                .. code-block:: text
+
+                    {
+                        "class": class_name,
+                        "module_path": path,
+                    }
+
+                Note: `class` should be the class name of operator, `module_path` should be a python module or path of file.
+        """
+        for _operator in ops_list:
+            if isinstance(_operator, dict):
+                _ops_class, _ = get_callable_kwargs(_operator)
+            else:
+                _ops_class = _operator
+
+            if not issubclass(_ops_class, (Expression,)):
+                raise TypeError("operator must be subclass of ExpressionOps, not {}".format(_ops_class))
+
+            if _ops_class.__name__ in self._ops:
+                get_module_logger(self.__class__.__name__).warning(
+                    "The custom operator [{}] will override the qlib default definition".format(_ops_class.__name__)
+                )
+            self._ops[_ops_class.__name__] = _ops_class
+
+    def __getattr__(self, key):
+        if key not in self._ops:
+            raise AttributeError("The operator [{0}] is not registered".format(key))
+        return self._ops[key]
+
+
+Operators = OpsWrapper()
+
+
+def register_all_ops(C):
+    """register all operator"""
+    logger = get_module_logger("ops")
+
+    from qlib.data.pit import P, PRef  # pylint: disable=C0415
+
+    Operators.reset()
+    Operators.register(OpsList + [P, PRef])
+
+    if getattr(C, "custom_ops", None) is not None:
+        Operators.register(C.custom_ops)
+        logger.debug("register custom operator {}".format(C.custom_ops))

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/pit.py

@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""
+Qlib follow the logic below to supporting point-in-time database
+
+For each stock, the format of its data is <observe_time, feature>. Expression Engine support calculation on such format of data
+
+To calculate the feature value f_t at a specific observe time t,  data with format <period_time, feature> will be used.
+For example, the average earning of last 4 quarters (period_time) on 20190719 (observe_time)
+
+The calculation of both <period_time, feature> and <observe_time, feature> data rely on expression engine. It consists of 2 phases.
+1) calculation <period_time, feature> at each observation time t and it will collasped into a point (just like a normal feature)
+2) concatenate all th collasped data, we will get data with format <observe_time, feature>.
+Qlib will use the operator `P` to perform the collapse.
+"""
+
+import numpy as np
+import pandas as pd
+from qlib.data.ops import ElemOperator
+from qlib.log import get_module_logger
+from .data import Cal
+
+
+class P(ElemOperator):
+    def _load_internal(self, instrument, start_index, end_index, freq):
+        _calendar = Cal.calendar(freq=freq)
+        resample_data = np.empty(end_index - start_index + 1, dtype="float32")
+
+        for cur_index in range(start_index, end_index + 1):
+            cur_time = _calendar[cur_index]
+            # To load expression accurately, more historical data are required
+            start_ws, end_ws = self.feature.get_extended_window_size()
+            if end_ws > 0:
+                raise ValueError(
+                    "PIT database does not support referring to future period (e.g. expressions like `Ref('$$roewa_q', -1)` are not supported"
+                )
+
+            # The calculated value will always the last element, so the end_offset is zero.
+            try:
+                s = self._load_feature(instrument, -start_ws, 0, cur_time)
+                resample_data[cur_index - start_index] = s.iloc[-1] if len(s) > 0 else np.nan
+            except FileNotFoundError:
+                get_module_logger("base").warning(f"WARN: period data not found for {str(self)}")
+                return pd.Series(dtype="float32", name=str(self))
+
+        resample_series = pd.Series(
+            resample_data, index=pd.RangeIndex(start_index, end_index + 1), dtype="float32", name=str(self)
+        )
+        return resample_series
+
+    def _load_feature(self, instrument, start_index, end_index, cur_time):
+        return self.feature.load(instrument, start_index, end_index, cur_time)
+
+    def get_longest_back_rolling(self):
+        # The period data will collapse as a normal feature. So no extending and looking back
+        return 0
+
+    def get_extended_window_size(self):
+        # The period data will collapse as a normal feature. So no extending and looking back
+        return 0, 0
+
+
+class PRef(P):
+    def __init__(self, feature, period):
+        super().__init__(feature)
+        self.period = period
+
+    def __str__(self):
+        return f"{super().__str__()}[{self.period}]"
+
+    def _load_feature(self, instrument, start_index, end_index, cur_time):
+        return self.feature.load(instrument, start_index, end_index, cur_time, self.period)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/storage/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from .storage import CalendarStorage, InstrumentStorage, FeatureStorage, CalVT, InstVT, InstKT
+
+__all__ = ["CalendarStorage", "InstrumentStorage", "FeatureStorage", "CalVT", "InstVT", "InstKT"]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/storage/file_storage.py

@@ -0,0 +1,379 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import struct
+from pathlib import Path
+from typing import Iterable, Union, Dict, Mapping, Tuple, List
+
+import numpy as np
+import pandas as pd
+
+from qlib.utils.time import Freq
+from qlib.utils.resam import resam_calendar
+from qlib.config import C
+from qlib.data.cache import H
+from qlib.log import get_module_logger
+from qlib.data.storage import CalendarStorage, InstrumentStorage, FeatureStorage, CalVT, InstKT, InstVT
+
+logger = get_module_logger("file_storage")
+
+
+class FileStorageMixin:
+    """FileStorageMixin, applicable to FileXXXStorage
+    Subclasses need to have provider_uri, freq, storage_name, file_name attributes
+
+    """
+
+    # NOTE: provider_uri priority:
+    #   1. self._provider_uri : if provider_uri is provided.
+    #   2. provider_uri in qlib.config.C
+
+    @property
+    def provider_uri(self):
+        return C["provider_uri"] if getattr(self, "_provider_uri", None) is None else self._provider_uri
+
+    @property
+    def dpm(self):
+        return (
+            C.dpm
+            if getattr(self, "_provider_uri", None) is None
+            else C.DataPathManager(self._provider_uri, C.mount_path)
+        )
+
+    @property
+    def support_freq(self) -> List[str]:
+        _v = "_support_freq"
+        if hasattr(self, _v):
+            return getattr(self, _v)
+        if len(self.provider_uri) == 1 and C.DEFAULT_FREQ in self.provider_uri:
+            freq_l = filter(
+                lambda _freq: not _freq.endswith("_future"),
+                map(lambda x: x.stem, self.dpm.get_data_uri(C.DEFAULT_FREQ).joinpath("calendars").glob("*.txt")),
+            )
+        else:
+            freq_l = self.provider_uri.keys()
+        freq_l = [Freq(freq) for freq in freq_l]
+        setattr(self, _v, freq_l)
+        return freq_l
+
+    @property
+    def uri(self) -> Path:
+        if self.freq not in self.support_freq:
+            raise ValueError(f"{self.storage_name}: {self.provider_uri} does not contain data for {self.freq}")
+        return self.dpm.get_data_uri(self.freq).joinpath(f"{self.storage_name}s", self.file_name)
+
+    def check(self):
+        """check self.uri
+
+        Raises
+        -------
+        ValueError
+        """
+        if not self.uri.exists():
+            raise ValueError(f"{self.storage_name} not exists: {self.uri}")
+
+
+class FileCalendarStorage(FileStorageMixin, CalendarStorage):
+    def __init__(self, freq: str, future: bool, provider_uri: dict = None, **kwargs):
+        super(FileCalendarStorage, self).__init__(freq, future, **kwargs)
+        self.future = future
+        self._provider_uri = None if provider_uri is None else C.DataPathManager.format_provider_uri(provider_uri)
+        self.enable_read_cache = True  # TODO: make it configurable
+        self.region = C["region"]
+
+    @property
+    def file_name(self) -> str:
+        return f"{self._freq_file}_future.txt" if self.future else f"{self._freq_file}.txt".lower()
+
+    @property
+    def _freq_file(self) -> str:
+        """the freq to read from file"""
+        if not hasattr(self, "_freq_file_cache"):
+            freq = Freq(self.freq)
+            if freq not in self.support_freq:
+                # NOTE: uri
+                #   1. If `uri` does not exist
+                #       - Get the `min_uri` of the closest `freq` under the same "directory" as the `uri`
+                #       - Read data from `min_uri` and resample to `freq`
+
+                freq = Freq.get_recent_freq(freq, self.support_freq)
+                if freq is None:
+                    raise ValueError(f"can't find a freq from {self.support_freq} that can resample to {self.freq}!")
+            self._freq_file_cache = freq
+        return self._freq_file_cache
+
+    def _read_calendar(self) -> List[CalVT]:
+        # NOTE:
+        # if we want to accelerate partial reading calendar
+        # we can add parameters like `skip_rows: int = 0, n_rows: int = None` to the interface.
+        # Currently, it is not supported for the txt-based calendar
+
+        if not self.uri.exists():
+            self._write_calendar(values=[])
+
+        with self.uri.open("r") as fp:
+            res = []
+            for line in fp.readlines():
+                line = line.strip()
+                if len(line) > 0:
+                    res.append(line)
+            return res
+
+    def _write_calendar(self, values: Iterable[CalVT], mode: str = "wb"):
+        with self.uri.open(mode=mode) as fp:
+            np.savetxt(fp, values, fmt="%s", encoding="utf-8")
+
+    @property
+    def uri(self) -> Path:
+        return self.dpm.get_data_uri(self._freq_file).joinpath(f"{self.storage_name}s", self.file_name)
+
+    @property
+    def data(self) -> List[CalVT]:
+        self.check()
+        # If cache is enabled, then return cache directly
+        if self.enable_read_cache:
+            key = "orig_file" + str(self.uri)
+            if key not in H["c"]:
+                H["c"][key] = self._read_calendar()
+            _calendar = H["c"][key]
+        else:
+            _calendar = self._read_calendar()
+        if Freq(self._freq_file) != Freq(self.freq):
+            _calendar = resam_calendar(
+                np.array(list(map(pd.Timestamp, _calendar))), self._freq_file, self.freq, self.region
+            )
+        return _calendar
+
+    def _get_storage_freq(self) -> List[str]:
+        return sorted(set(map(lambda x: x.stem.split("_")[0], self.uri.parent.glob("*.txt"))))
+
+    def extend(self, values: Iterable[CalVT]) -> None:
+        self._write_calendar(values, mode="ab")
+
+    def clear(self) -> None:
+        self._write_calendar(values=[])
+
+    def index(self, value: CalVT) -> int:
+        self.check()
+        calendar = self._read_calendar()
+        return int(np.argwhere(calendar == value)[0])
+
+    def insert(self, index: int, value: CalVT):
+        calendar = self._read_calendar()
+        calendar = np.insert(calendar, index, value)
+        self._write_calendar(values=calendar)
+
+    def remove(self, value: CalVT) -> None:
+        self.check()
+        index = self.index(value)
+        calendar = self._read_calendar()
+        calendar = np.delete(calendar, index)
+        self._write_calendar(values=calendar)
+
+    def __setitem__(self, i: Union[int, slice], values: Union[CalVT, Iterable[CalVT]]) -> None:
+        calendar = self._read_calendar()
+        calendar[i] = values
+        self._write_calendar(values=calendar)
+
+    def __delitem__(self, i: Union[int, slice]) -> None:
+        self.check()
+        calendar = self._read_calendar()
+        calendar = np.delete(calendar, i)
+        self._write_calendar(values=calendar)
+
+    def __getitem__(self, i: Union[int, slice]) -> Union[CalVT, List[CalVT]]:
+        self.check()
+        return self._read_calendar()[i]
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+
+class FileInstrumentStorage(FileStorageMixin, InstrumentStorage):
+    INSTRUMENT_SEP = "\t"
+    INSTRUMENT_START_FIELD = "start_datetime"
+    INSTRUMENT_END_FIELD = "end_datetime"
+    SYMBOL_FIELD_NAME = "instrument"
+
+    def __init__(self, market: str, freq: str, provider_uri: dict = None, **kwargs):
+        super(FileInstrumentStorage, self).__init__(market, freq, **kwargs)
+        self._provider_uri = None if provider_uri is None else C.DataPathManager.format_provider_uri(provider_uri)
+        self.file_name = f"{market.lower()}.txt"
+
+    def _read_instrument(self) -> Dict[InstKT, InstVT]:
+        if not self.uri.exists():
+            self._write_instrument()
+
+        _instruments = dict()
+        df = pd.read_csv(
+            self.uri,
+            sep="\t",
+            usecols=[0, 1, 2],
+            names=[self.SYMBOL_FIELD_NAME, self.INSTRUMENT_START_FIELD, self.INSTRUMENT_END_FIELD],
+            dtype={self.SYMBOL_FIELD_NAME: str},
+            parse_dates=[self.INSTRUMENT_START_FIELD, self.INSTRUMENT_END_FIELD],
+        )
+        for row in df.itertuples(index=False):
+            _instruments.setdefault(row[0], []).append((row[1], row[2]))
+        return _instruments
+
+    def _write_instrument(self, data: Dict[InstKT, InstVT] = None) -> None:
+        if not data:
+            with self.uri.open("w") as _:
+                pass
+            return
+
+        res = []
+        for inst, v_list in data.items():
+            _df = pd.DataFrame(v_list, columns=[self.INSTRUMENT_START_FIELD, self.INSTRUMENT_END_FIELD])
+            _df[self.SYMBOL_FIELD_NAME] = inst
+            res.append(_df)
+
+        df = pd.concat(res, sort=False)
+        df.loc[:, [self.SYMBOL_FIELD_NAME, self.INSTRUMENT_START_FIELD, self.INSTRUMENT_END_FIELD]].to_csv(
+            self.uri, header=False, sep=self.INSTRUMENT_SEP, index=False
+        )
+        df.to_csv(self.uri, sep="\t", encoding="utf-8", header=False, index=False)
+
+    def clear(self) -> None:
+        self._write_instrument(data={})
+
+    @property
+    def data(self) -> Dict[InstKT, InstVT]:
+        self.check()
+        return self._read_instrument()
+
+    def __setitem__(self, k: InstKT, v: InstVT) -> None:
+        inst = self._read_instrument()
+        inst[k] = v
+        self._write_instrument(inst)
+
+    def __delitem__(self, k: InstKT) -> None:
+        self.check()
+        inst = self._read_instrument()
+        del inst[k]
+        self._write_instrument(inst)
+
+    def __getitem__(self, k: InstKT) -> InstVT:
+        self.check()
+        return self._read_instrument()[k]
+
+    def update(self, *args, **kwargs) -> None:
+        if len(args) > 1:
+            raise TypeError(f"update expected at most 1 arguments, got {len(args)}")
+        inst = self._read_instrument()
+        if args:
+            other = args[0]  # type: dict
+            if isinstance(other, Mapping):
+                for key in other:
+                    inst[key] = other[key]
+            elif hasattr(other, "keys"):
+                for key in other.keys():
+                    inst[key] = other[key]
+            else:
+                for key, value in other:
+                    inst[key] = value
+        for key, value in kwargs.items():
+            inst[key] = value
+
+        self._write_instrument(inst)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+
+class FileFeatureStorage(FileStorageMixin, FeatureStorage):
+    def __init__(self, instrument: str, field: str, freq: str, provider_uri: dict = None, **kwargs):
+        super(FileFeatureStorage, self).__init__(instrument, field, freq, **kwargs)
+        self._provider_uri = None if provider_uri is None else C.DataPathManager.format_provider_uri(provider_uri)
+        self.file_name = f"{instrument.lower()}/{field.lower()}.{freq.lower()}.bin"
+
+    def clear(self):
+        with self.uri.open("wb") as _:
+            pass
+
+    @property
+    def data(self) -> pd.Series:
+        return self[:]
+
+    def write(self, data_array: Union[List, np.ndarray], index: int = None) -> None:
+        if len(data_array) == 0:
+            logger.info(
+                "len(data_array) == 0, write"
+                "if you need to clear the FeatureStorage, please execute: FeatureStorage.clear"
+            )
+            return
+        if not self.uri.exists():
+            # write
+            index = 0 if index is None else index
+            with self.uri.open("wb") as fp:
+                np.hstack([index, data_array]).astype("<f").tofile(fp)
+        else:
+            if index is None or index > self.end_index:
+                # append
+                index = 0 if index is None else index
+                with self.uri.open("ab+") as fp:
+                    np.hstack([[np.nan] * (index - self.end_index - 1), data_array]).astype("<f").tofile(fp)
+            else:
+                # rewrite
+                with self.uri.open("rb+") as fp:
+                    _old_data = np.fromfile(fp, dtype="<f")
+                    _old_index = _old_data[0]
+                    _old_df = pd.DataFrame(
+                        _old_data[1:], index=range(_old_index, _old_index + len(_old_data) - 1), columns=["old"]
+                    )
+                    fp.seek(0)
+                    _new_df = pd.DataFrame(data_array, index=range(index, index + len(data_array)), columns=["new"])
+                    _df = pd.concat([_old_df, _new_df], sort=False, axis=1)
+                    _df = _df.reindex(range(_df.index.min(), _df.index.max() + 1))
+                    _df["new"].fillna(_df["old"]).values.astype("<f").tofile(fp)
+
+    @property
+    def start_index(self) -> Union[int, None]:
+        if not self.uri.exists():
+            return None
+        with self.uri.open("rb") as fp:
+            index = int(np.frombuffer(fp.read(4), dtype="<f")[0])
+        return index
+
+    @property
+    def end_index(self) -> Union[int, None]:
+        if not self.uri.exists():
+            return None
+        # The next  data appending index point will be  `end_index + 1`
+        return self.start_index + len(self) - 1
+
+    def __getitem__(self, i: Union[int, slice]) -> Union[Tuple[int, float], pd.Series]:
+        if not self.uri.exists():
+            if isinstance(i, int):
+                return None, None
+            elif isinstance(i, slice):
+                return pd.Series(dtype=np.float32)
+            else:
+                raise TypeError(f"type(i) = {type(i)}")
+
+        storage_start_index = self.start_index
+        storage_end_index = self.end_index
+        with self.uri.open("rb") as fp:
+            if isinstance(i, int):
+                if storage_start_index > i:
+                    raise IndexError(f"{i}: start index is {storage_start_index}")
+                fp.seek(4 * (i - storage_start_index) + 4)
+                return i, struct.unpack("f", fp.read(4))[0]
+            elif isinstance(i, slice):
+                start_index = storage_start_index if i.start is None else i.start
+                end_index = storage_end_index if i.stop is None else i.stop - 1
+                si = max(start_index, storage_start_index)
+                if si > end_index:
+                    return pd.Series(dtype=np.float32)
+                fp.seek(4 * (si - storage_start_index) + 4)
+                # read n bytes
+                count = end_index - si + 1
+                data = np.frombuffer(fp.read(4 * count), dtype="<f")
+                return pd.Series(data, index=pd.RangeIndex(si, si + len(data)))
+            else:
+                raise TypeError(f"type(i) = {type(i)}")
+
+    def __len__(self) -> int:
+        self.check()
+        return self.uri.stat().st_size // 4 - 1

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/storage/storage.py

@@ -0,0 +1,494 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import re
+from typing import Iterable, overload, Tuple, List, Text, Union, Dict
+
+import numpy as np
+import pandas as pd
+from qlib.log import get_module_logger
+
+# calendar value type
+CalVT = str
+
+# instrument value
+InstVT = List[Tuple[CalVT, CalVT]]
+# instrument key
+InstKT = Text
+
+logger = get_module_logger("storage")
+
+"""
+If the user is only using it in `qlib`, you can customize Storage to implement only the following methods:
+
+class UserCalendarStorage(CalendarStorage):
+
+    @property
+    def data(self) -> Iterable[CalVT]:
+        '''get all data
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        '''
+        raise NotImplementedError("Subclass of CalendarStorage must implement `data` method")
+
+
+class UserInstrumentStorage(InstrumentStorage):
+
+    @property
+    def data(self) -> Dict[InstKT, InstVT]:
+        '''get all data
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        '''
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `data` method")
+
+
+class UserFeatureStorage(FeatureStorage):
+
+    def __getitem__(self, s: slice) -> pd.Series:
+        '''x.__getitem__(slice(start: int, stop: int, step: int)) <==> x[start:stop:step]
+
+        Returns
+        -------
+            pd.Series(values, index=pd.RangeIndex(start, len(values))
+
+        Notes
+        -------
+        if data(storage) does not exist:
+            if isinstance(i, int):
+                return (None, None)
+            if isinstance(i,  slice):
+                # return empty pd.Series
+                return pd.Series(dtype=np.float32)
+        '''
+        raise NotImplementedError(
+            "Subclass of FeatureStorage must implement `__getitem__(s: slice)` method"
+        )
+
+
+"""
+
+
+class BaseStorage:
+    @property
+    def storage_name(self) -> str:
+        return re.findall("[A-Z][^A-Z]*", self.__class__.__name__)[-2].lower()
+
+
+class CalendarStorage(BaseStorage):
+    """
+    The behavior of CalendarStorage's methods and List's methods of the same name remain consistent
+    """
+
+    def __init__(self, freq: str, future: bool, **kwargs):
+        self.freq = freq
+        self.future = future
+        self.kwargs = kwargs
+
+    @property
+    def data(self) -> Iterable[CalVT]:
+        """get all data
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        """
+        raise NotImplementedError("Subclass of CalendarStorage must implement `data` method")
+
+    def clear(self) -> None:
+        raise NotImplementedError("Subclass of CalendarStorage must implement `clear` method")
+
+    def extend(self, iterable: Iterable[CalVT]) -> None:
+        raise NotImplementedError("Subclass of CalendarStorage must implement `extend` method")
+
+    def index(self, value: CalVT) -> int:
+        """
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        """
+        raise NotImplementedError("Subclass of CalendarStorage must implement `index` method")
+
+    def insert(self, index: int, value: CalVT) -> None:
+        raise NotImplementedError("Subclass of CalendarStorage must implement `insert` method")
+
+    def remove(self, value: CalVT) -> None:
+        raise NotImplementedError("Subclass of CalendarStorage must implement `remove` method")
+
+    @overload
+    def __setitem__(self, i: int, value: CalVT) -> None:
+        """x.__setitem__(i, o) <==> (x[i] = o)"""
+
+    @overload
+    def __setitem__(self, s: slice, value: Iterable[CalVT]) -> None:
+        """x.__setitem__(s, o) <==> (x[s] = o)"""
+
+    def __setitem__(self, i, value) -> None:
+        raise NotImplementedError(
+            "Subclass of CalendarStorage must implement `__setitem__(i: int, o: CalVT)`/`__setitem__(s: slice, o: Iterable[CalVT])`  method"
+        )
+
+    @overload
+    def __delitem__(self, i: int) -> None:
+        """x.__delitem__(i) <==> del x[i]"""
+
+    @overload
+    def __delitem__(self, i: slice) -> None:
+        """x.__delitem__(slice(start: int, stop: int, step: int)) <==> del x[start:stop:step]"""
+
+    def __delitem__(self, i) -> None:
+        """
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        """
+        raise NotImplementedError(
+            "Subclass of CalendarStorage must implement `__delitem__(i: int)`/`__delitem__(s: slice)`  method"
+        )
+
+    @overload
+    def __getitem__(self, s: slice) -> Iterable[CalVT]:
+        """x.__getitem__(slice(start: int, stop: int, step: int)) <==> x[start:stop:step]"""
+
+    @overload
+    def __getitem__(self, i: int) -> CalVT:
+        """x.__getitem__(i) <==> x[i]"""
+
+    def __getitem__(self, i) -> CalVT:
+        """
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+
+        """
+        raise NotImplementedError(
+            "Subclass of CalendarStorage must implement `__getitem__(i: int)`/`__getitem__(s: slice)`  method"
+        )
+
+    def __len__(self) -> int:
+        """
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+
+        """
+        raise NotImplementedError("Subclass of CalendarStorage must implement `__len__`  method")
+
+
+class InstrumentStorage(BaseStorage):
+    def __init__(self, market: str, freq: str, **kwargs):
+        self.market = market
+        self.freq = freq
+        self.kwargs = kwargs
+
+    @property
+    def data(self) -> Dict[InstKT, InstVT]:
+        """get all data
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        """
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `data` method")
+
+    def clear(self) -> None:
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `clear` method")
+
+    def update(self, *args, **kwargs) -> None:
+        """D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
+
+        Notes
+        ------
+            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
+
+            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
+
+            In either case, this is followed by: for k, v in F.items(): D[k] = v
+
+        """
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `update` method")
+
+    def __setitem__(self, k: InstKT, v: InstVT) -> None:
+        """Set self[key] to value."""
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `__setitem__` method")
+
+    def __delitem__(self, k: InstKT) -> None:
+        """Delete self[key].
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+        """
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `__delitem__` method")
+
+    def __getitem__(self, k: InstKT) -> InstVT:
+        """x.__getitem__(k) <==> x[k]"""
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `__getitem__` method")
+
+    def __len__(self) -> int:
+        """
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+
+        """
+        raise NotImplementedError("Subclass of InstrumentStorage must implement `__len__`  method")
+
+
+class FeatureStorage(BaseStorage):
+    def __init__(self, instrument: str, field: str, freq: str, **kwargs):
+        self.instrument = instrument
+        self.field = field
+        self.freq = freq
+        self.kwargs = kwargs
+
+    @property
+    def data(self) -> pd.Series:
+        """get all data
+
+        Notes
+        ------
+        if data(storage) does not exist, return empty pd.Series: `return pd.Series(dtype=np.float32)`
+        """
+        raise NotImplementedError("Subclass of FeatureStorage must implement `data` method")
+
+    @property
+    def start_index(self) -> Union[int, None]:
+        """get FeatureStorage start index
+
+        Notes
+        -----
+        If the data(storage) does not exist, return None
+        """
+        raise NotImplementedError("Subclass of FeatureStorage must implement `start_index` method")
+
+    @property
+    def end_index(self) -> Union[int, None]:
+        """get FeatureStorage end index
+
+        Notes
+        -----
+        The  right index of the data range (both sides are closed)
+
+            The next  data appending point will be  `end_index + 1`
+
+        If the data(storage) does not exist, return None
+        """
+        raise NotImplementedError("Subclass of FeatureStorage must implement `end_index` method")
+
+    def clear(self) -> None:
+        raise NotImplementedError("Subclass of FeatureStorage must implement `clear` method")
+
+    def write(self, data_array: Union[List, np.ndarray, Tuple], index: int = None):
+        """Write data_array to FeatureStorage starting from index.
+
+        Notes
+        ------
+            If index is None, append data_array to feature.
+
+            If len(data_array) == 0; return
+
+            If (index - self.end_index) >= 1, self[end_index+1: index] will be filled with np.nan
+
+        Examples
+        ---------
+            .. code-block::
+
+                feature:
+                    3   4
+                    4   5
+                    5   6
+
+
+            >>> self.write([6, 7], index=6)
+
+                feature:
+                    3   4
+                    4   5
+                    5   6
+                    6   6
+                    7   7
+
+            >>> self.write([8], index=9)
+
+                feature:
+                    3   4
+                    4   5
+                    5   6
+                    6   6
+                    7   7
+                    8   np.nan
+                    9   8
+
+            >>> self.write([1, np.nan], index=3)
+
+                feature:
+                    3   1
+                    4   np.nan
+                    5   6
+                    6   6
+                    7   7
+                    8   np.nan
+                    9   8
+
+        """
+        raise NotImplementedError("Subclass of FeatureStorage must implement `write` method")
+
+    def rebase(self, start_index: int = None, end_index: int = None):
+        """Rebase the start_index and end_index of the FeatureStorage.
+
+        start_index and end_index are closed intervals: [start_index, end_index]
+
+        Examples
+        ---------
+
+            .. code-block::
+
+                    feature:
+                        3   4
+                        4   5
+                        5   6
+
+
+                >>> self.rebase(start_index=4)
+
+                    feature:
+                        4   5
+                        5   6
+
+                >>> self.rebase(start_index=3)
+
+                    feature:
+                        3   np.nan
+                        4   5
+                        5   6
+
+                >>> self.write([3], index=3)
+
+                    feature:
+                        3   3
+                        4   5
+                        5   6
+
+                >>> self.rebase(end_index=4)
+
+                    feature:
+                        3   3
+                        4   5
+
+                >>> self.write([6, 7, 8], index=4)
+
+                    feature:
+                        3   3
+                        4   6
+                        5   7
+                        6   8
+
+                >>> self.rebase(start_index=4, end_index=5)
+
+                    feature:
+                        4   6
+                        5   7
+
+        """
+        storage_si = self.start_index
+        storage_ei = self.end_index
+        if storage_si is None or storage_ei is None:
+            raise ValueError("storage.start_index or storage.end_index is None, storage may not exist")
+
+        start_index = storage_si if start_index is None else start_index
+        end_index = storage_ei if end_index is None else end_index
+
+        if start_index is None or end_index is None:
+            logger.warning("both start_index and end_index are None, or storage does not exist; rebase is ignored")
+            return
+
+        if start_index < 0 or end_index < 0:
+            logger.warning("start_index or end_index cannot be less than 0")
+            return
+        if start_index > end_index:
+            logger.warning(
+                f"start_index({start_index}) > end_index({end_index}), rebase is ignored; "
+                f"if you need to clear the FeatureStorage, please execute: FeatureStorage.clear"
+            )
+            return
+
+        if start_index <= storage_si:
+            self.write([np.nan] * (storage_si - start_index), start_index)
+        else:
+            self.rewrite(self[start_index:].values, start_index)
+
+        if end_index >= self.end_index:
+            self.write([np.nan] * (end_index - self.end_index))
+        else:
+            self.rewrite(self[: end_index + 1].values, start_index)
+
+    def rewrite(self, data: Union[List, np.ndarray, Tuple], index: int):
+        """overwrite all data in FeatureStorage with data
+
+        Parameters
+        ----------
+        data: Union[List, np.ndarray, Tuple]
+            data
+        index: int
+            data start index
+        """
+        self.clear()
+        self.write(data, index)
+
+    @overload
+    def __getitem__(self, s: slice) -> pd.Series:
+        """x.__getitem__(slice(start: int, stop: int, step: int)) <==> x[start:stop:step]
+
+        Returns
+        -------
+            pd.Series(values, index=pd.RangeIndex(start, len(values))
+        """
+
+    @overload
+    def __getitem__(self, i: int) -> Tuple[int, float]:
+        """x.__getitem__(y) <==> x[y]"""
+
+    def __getitem__(self, i) -> Union[Tuple[int, float], pd.Series]:
+        """x.__getitem__(y) <==> x[y]
+
+        Notes
+        -------
+        if data(storage) does not exist:
+            if isinstance(i, int):
+                return (None, None)
+            if isinstance(i,  slice):
+                # return empty pd.Series
+                return pd.Series(dtype=np.float32)
+        """
+        raise NotImplementedError(
+            "Subclass of FeatureStorage must implement `__getitem__(i: int)`/`__getitem__(s: slice)` method"
+        )
+
+    def __len__(self) -> int:
+        """
+
+        Raises
+        ------
+        ValueError
+            If the data(storage) does not exist, raise ValueError
+
+        """
+        raise NotImplementedError("Subclass of FeatureStorage must implement `__len__`  method")

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/log.py

@@ -0,0 +1,262 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+import logging
+from typing import Optional, Text, Dict, Any
+import re
+from logging import config as logging_config
+from time import time
+from contextlib import contextmanager
+
+from .config import C
+
+
+class MetaLogger(type):
+    def __new__(mcs, name, bases, attrs):  # pylint: disable=C0204
+        wrapper_dict = logging.Logger.__dict__.copy()
+        for key, val in wrapper_dict.items():
+            if key not in attrs and key != "__reduce__":
+                attrs[key] = val
+        return type.__new__(mcs, name, bases, attrs)
+
+
+class QlibLogger(metaclass=MetaLogger):
+    """
+    Customized logger for Qlib.
+    """
+
+    def __init__(self, module_name):
+        self.module_name = module_name
+        # this feature name conflicts with the attribute with Logger
+        # rename it to avoid some corner cases that result in comparing `str` and `int`
+        self.__level = 0
+
+    @property
+    def logger(self):
+        logger = logging.getLogger(self.module_name)
+        logger.setLevel(self.__level)
+        return logger
+
+    def setLevel(self, level):
+        self.__level = level
+
+    def __getattr__(self, name):
+        # During unpickling, python will call __getattr__. Use this line to avoid maximum recursion error.
+        if name in {"__setstate__"}:
+            raise AttributeError
+        return self.logger.__getattribute__(name)
+
+
+class _QLibLoggerManager:
+    def __init__(self):
+        self._loggers = {}
+
+    def setLevel(self, level):
+        for logger in self._loggers.values():
+            logger.setLevel(level)
+
+    def __call__(self, module_name, level: Optional[int] = None) -> QlibLogger:
+        """
+        Get a logger for a specific module.
+
+        :param module_name: str
+            Logic module name.
+        :param level: int
+        :return: Logger
+            Logger object.
+        """
+        if level is None:
+            level = C.logging_level
+
+        if not module_name.startswith("qlib."):
+            # Add a prefix of qlib. when the requested ``module_name`` doesn't start with ``qlib.``.
+            # If the module_name is already qlib.xxx, we do not format here. Otherwise, it will become qlib.qlib.xxx.
+            module_name = "qlib.{}".format(module_name)
+
+        # Get logger.
+        module_logger = self._loggers.setdefault(module_name, QlibLogger(module_name))
+        module_logger.setLevel(level)
+        return module_logger
+
+
+get_module_logger = _QLibLoggerManager()
+
+
+class TimeInspector:
+    timer_logger = get_module_logger("timer")
+
+    time_marks = []
+
+    @classmethod
+    def set_time_mark(cls):
+        """
+        Set a time mark with current time, and this time mark will push into a stack.
+        :return: float
+            A timestamp for current time.
+        """
+        _time = time()
+        cls.time_marks.append(_time)
+        return _time
+
+    @classmethod
+    def pop_time_mark(cls):
+        """
+        Pop last time mark from stack.
+        """
+        return cls.time_marks.pop()
+
+    @classmethod
+    def get_cost_time(cls):
+        """
+        Get last time mark from stack, calculate time diff with current time.
+        :return: float
+            Time diff calculated by last time mark with current time.
+        """
+        cost_time = time() - cls.time_marks.pop()
+        return cost_time
+
+    @classmethod
+    def log_cost_time(cls, info="Done"):
+        """
+        Get last time mark from stack, calculate time diff with current time, and log time diff and info.
+        :param info: str
+            Info that will be logged into stdout.
+        """
+        cost_time = time() - cls.time_marks.pop()
+        cls.timer_logger.info("Time cost: {0:.3f}s | {1}".format(cost_time, info))
+
+    @classmethod
+    @contextmanager
+    def logt(cls, name="", show_start=False):
+        """logt.
+        Log the time of the inside code
+
+        Parameters
+        ----------
+        name :
+            name
+        show_start :
+            show_start
+        """
+        if show_start:
+            cls.timer_logger.info(f"{name} Begin")
+        cls.set_time_mark()
+        try:
+            yield None
+        finally:
+            pass
+        cls.log_cost_time(info=f"{name} Done")
+
+
+def set_log_with_config(log_config: Dict[Text, Any]):
+    """set log with config
+
+    :param log_config:
+    :return:
+    """
+    logging_config.dictConfig(log_config)
+
+
+class LogFilter(logging.Filter):
+    def __init__(self, param=None):
+        super().__init__()
+        self.param = param
+
+    @staticmethod
+    def match_msg(filter_str, msg):
+        match = False
+        try:
+            if re.match(filter_str, msg):
+                match = True
+        except Exception:
+            pass
+        return match
+
+    def filter(self, record):
+        allow = True
+        if isinstance(self.param, str):
+            allow = not self.match_msg(self.param, record.msg)
+        elif isinstance(self.param, list):
+            allow = not any(self.match_msg(p, record.msg) for p in self.param)
+        return allow
+
+
+def set_global_logger_level(level: int, return_orig_handler_level: bool = False):
+    """set qlib.xxx logger handlers level
+
+    Parameters
+    ----------
+    level: int
+        logger level
+
+    return_orig_handler_level: bool
+        return origin handler level map
+
+    Examples
+    ---------
+
+        .. code-block:: python
+
+            import qlib
+            import logging
+            from qlib.log import get_module_logger, set_global_logger_level
+            qlib.init()
+
+            tmp_logger_01 = get_module_logger("tmp_logger_01", level=logging.INFO)
+            tmp_logger_01.info("1. tmp_logger_01 info show")
+
+            global_level = logging.WARNING + 1
+            set_global_logger_level(global_level)
+            tmp_logger_02 = get_module_logger("tmp_logger_02", level=logging.INFO)
+            tmp_logger_02.log(msg="2. tmp_logger_02 log show", level=global_level)
+
+            tmp_logger_01.info("3. tmp_logger_01 info do not show")
+
+    """
+    _handler_level_map = {}
+    qlib_logger = logging.root.manager.loggerDict.get("qlib", None)  # pylint: disable=E1101
+    if qlib_logger is not None:
+        for _handler in qlib_logger.handlers:
+            _handler_level_map[_handler] = _handler.level
+            _handler.level = level
+    return _handler_level_map if return_orig_handler_level else None
+
+
+@contextmanager
+def set_global_logger_level_cm(level: int):
+    """set qlib.xxx logger handlers level to use contextmanager
+
+    Parameters
+    ----------
+    level: int
+        logger level
+
+    Examples
+    ---------
+
+        .. code-block:: python
+
+            import qlib
+            import logging
+            from qlib.log import get_module_logger, set_global_logger_level_cm
+            qlib.init()
+
+            tmp_logger_01 = get_module_logger("tmp_logger_01", level=logging.INFO)
+            tmp_logger_01.info("1. tmp_logger_01 info show")
+
+            global_level = logging.WARNING + 1
+            with set_global_logger_level_cm(global_level):
+                tmp_logger_02 = get_module_logger("tmp_logger_02", level=logging.INFO)
+                tmp_logger_02.log(msg="2. tmp_logger_02 log show", level=global_level)
+                tmp_logger_01.info("3. tmp_logger_01 info do not show")
+
+            tmp_logger_01.info("4. tmp_logger_01 info show")
+
+    """
+    _handler_level_map = set_global_logger_level(level, return_orig_handler_level=True)
+    try:
+        yield
+    finally:
+        for _handler, _level in _handler_level_map.items():
+            _handler.level = _level

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import warnings
+
+from .base import Model
+
+__all__ = ["Model", "warnings"]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/base.py

@@ -0,0 +1,110 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+import abc
+from typing import Text, Union
+from ..utils.serial import Serializable
+from ..data.dataset import Dataset
+from ..data.dataset.weight import Reweighter
+
+
+class BaseModel(Serializable, metaclass=abc.ABCMeta):
+    """Modeling things"""
+
+    @abc.abstractmethod
+    def predict(self, *args, **kwargs) -> object:
+        """Make predictions after modeling things"""
+
+    def __call__(self, *args, **kwargs) -> object:
+        """leverage Python syntactic sugar to make the models' behaviors like functions"""
+        return self.predict(*args, **kwargs)
+
+
+class Model(BaseModel):
+    """Learnable Models"""
+
+    def fit(self, dataset: Dataset, reweighter: Reweighter):
+        """
+        Learn model from the base model
+
+        .. note::
+
+            The attribute names of learned model should `not` start with '_'. So that the model could be
+            dumped to disk.
+
+        The following code example shows how to retrieve `x_train`, `y_train` and `w_train` from the `dataset`:
+
+            .. code-block:: Python
+
+                # get features and labels
+                df_train, df_valid = dataset.prepare(
+                    ["train", "valid"], col_set=["feature", "label"], data_key=DataHandlerLP.DK_L
+                )
+                x_train, y_train = df_train["feature"], df_train["label"]
+                x_valid, y_valid = df_valid["feature"], df_valid["label"]
+
+                # get weights
+                try:
+                    wdf_train, wdf_valid = dataset.prepare(["train", "valid"], col_set=["weight"],
+                                                           data_key=DataHandlerLP.DK_L)
+                    w_train, w_valid = wdf_train["weight"], wdf_valid["weight"]
+                except KeyError as e:
+                    w_train = pd.DataFrame(np.ones_like(y_train.values), index=y_train.index)
+                    w_valid = pd.DataFrame(np.ones_like(y_valid.values), index=y_valid.index)
+
+        Parameters
+        ----------
+        dataset : Dataset
+            dataset will generate the processed data from model training.
+
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def predict(self, dataset: Dataset, segment: Union[Text, slice] = "test") -> object:
+        """give prediction given Dataset
+
+        Parameters
+        ----------
+        dataset : Dataset
+            dataset will generate the processed dataset from model training.
+
+        segment : Text or slice
+            dataset will use this segment to prepare data. (default=test)
+
+        Returns
+        -------
+        Prediction results with certain type such as `pandas.Series`.
+        """
+        raise NotImplementedError()
+
+
+class ModelFT(Model):
+    """Model (F)ine(t)unable"""
+
+    @abc.abstractmethod
+    def finetune(self, dataset: Dataset):
+        """finetune model based given dataset
+
+        A typical use case of finetuning model with qlib.workflow.R
+
+        .. code-block:: python
+
+            # start exp to train init model
+            with R.start(experiment_name="init models"):
+                model.fit(dataset)
+                R.save_objects(init_model=model)
+                rid = R.get_recorder().id
+
+            # Finetune model based on previous trained model
+            with R.start(experiment_name="finetune model"):
+                recorder = R.get_recorder(recorder_id=rid, experiment_name="init models")
+                model = recorder.load_object("init_model")
+                model.finetune(dataset, num_boost_round=10)
+
+
+        Parameters
+        ----------
+        dataset : Dataset
+            dataset will generate the processed dataset from model training.
+        """
+        raise NotImplementedError()

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/ens/ensemble.py

@@ -0,0 +1,132 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+Ensemble module can merge the objects in an Ensemble. For example, if there are many submodels predictions, we may need to merge them into an ensemble prediction.
+"""
+
+from typing import Union
+import pandas as pd
+from qlib.utils import FLATTEN_TUPLE, flatten_dict
+from qlib.log import get_module_logger
+
+
+class Ensemble:
+    """Merge the ensemble_dict into an ensemble object.
+
+    For example: {Rollinga_b: object, Rollingb_c: object} -> object
+
+    When calling this class:
+
+        Args:
+            ensemble_dict (dict): the ensemble dict like {name: things} waiting for merging
+
+        Returns:
+            object: the ensemble object
+    """
+
+    def __call__(self, ensemble_dict: dict, *args, **kwargs):
+        raise NotImplementedError(f"Please implement the `__call__` method.")
+
+
+class SingleKeyEnsemble(Ensemble):
+    """
+    Extract the object if there is only one key and value in the dict. Make the result more readable.
+    {Only key: Only value} -> Only value
+
+    If there is more than 1 key or less than 1 key, then do nothing.
+    Even you can run this recursively to make dict more readable.
+
+    NOTE: Default runs recursively.
+
+    When calling this class:
+
+        Args:
+            ensemble_dict (dict): the dict. The key of the dict will be ignored.
+
+        Returns:
+            dict: the readable dict.
+    """
+
+    def __call__(self, ensemble_dict: Union[dict, object], recursion: bool = True) -> object:
+        if not isinstance(ensemble_dict, dict):
+            return ensemble_dict
+        if recursion:
+            tmp_dict = {}
+            for k, v in ensemble_dict.items():
+                tmp_dict[k] = self(v, recursion)
+            ensemble_dict = tmp_dict
+        keys = list(ensemble_dict.keys())
+        if len(keys) == 1:
+            ensemble_dict = ensemble_dict[keys[0]]
+        return ensemble_dict
+
+
+class RollingEnsemble(Ensemble):
+    """Merge a dict of rolling dataframe like `prediction` or `IC` into an ensemble.
+
+    NOTE: The values of dict must be pd.DataFrame, and have the index "datetime".
+
+    When calling this class:
+
+        Args:
+            ensemble_dict (dict): a dict like {"A": pd.DataFrame, "B": pd.DataFrame}.
+            The key of the dict will be ignored.
+
+        Returns:
+            pd.DataFrame: the complete result of rolling.
+    """
+
+    def __call__(self, ensemble_dict: dict) -> pd.DataFrame:
+        get_module_logger("RollingEnsemble").info(f"keys in group: {list(ensemble_dict.keys())}")
+        artifact_list = list(ensemble_dict.values())
+        artifact_list.sort(key=lambda x: x.index.get_level_values("datetime").min())
+        artifact = pd.concat(artifact_list)
+        # If there are duplicated predition, use the latest perdiction
+        artifact = artifact[~artifact.index.duplicated(keep="last")]
+        artifact = artifact.sort_index()
+        return artifact
+
+
+class AverageEnsemble(Ensemble):
+    """
+    Average and standardize a dict of same shape dataframe like `prediction` or `IC` into an ensemble.
+
+    NOTE: The values of dict must be pd.DataFrame, and have the index "datetime". If it is a nested dict, then flat it.
+
+    When calling this class:
+
+        Args:
+            ensemble_dict (dict): a dict like {"A": pd.DataFrame, "B": pd.DataFrame}.
+            The key of the dict will be ignored.
+
+        Returns:
+            pd.DataFrame: the complete result of averaging and standardizing.
+    """
+
+    def __call__(self, ensemble_dict: dict) -> pd.DataFrame:
+        """using sample:
+        from qlib.model.ens.ensemble import AverageEnsemble
+        pred_res['new_key_name'] = AverageEnsemble()(predict_dict)
+
+        Parameters
+        ----------
+        ensemble_dict : dict
+            Dictionary you want to ensemble
+
+        Returns
+        -------
+        pd.DataFrame
+            The dictionary including ensenbling result
+        """
+        # need to flatten the nested dict
+        ensemble_dict = flatten_dict(ensemble_dict, sep=FLATTEN_TUPLE)
+        get_module_logger("AverageEnsemble").info(f"keys in group: {list(ensemble_dict.keys())}")
+        values = list(ensemble_dict.values())
+        # NOTE: this may change the style underlying data!!!!
+        # from pd.DataFrame to pd.Series
+        results = pd.concat(values, axis=1)
+        results = results.groupby("datetime", group_keys=False).apply(lambda df: (df - df.mean()) / df.std())
+        results = results.mean(axis=1)
+        results = results.sort_index()
+        return results

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/ens/group.py

@@ -0,0 +1,115 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+Group can group a set of objects based on `group_func` and change them to a dict.
+After group, we provide a method to reduce them.
+
+For example:
+
+group: {(A,B,C1): object, (A,B,C2): object} -> {(A,B): {C1: object, C2: object}}
+reduce: {(A,B): {C1: object, C2: object}} -> {(A,B): object}
+
+"""
+
+from qlib.model.ens.ensemble import Ensemble, RollingEnsemble
+from typing import Callable
+from joblib import Parallel, delayed
+
+
+class Group:
+    """Group the objects based on dict"""
+
+    def __init__(self, group_func=None, ens: Ensemble = None):
+        """
+        Init Group.
+
+        Args:
+            group_func (Callable, optional): Given a dict and return the group key and one of the group elements.
+
+                For example: {(A,B,C1): object, (A,B,C2): object} -> {(A,B): {C1: object, C2: object}}
+
+            Defaults to None.
+
+            ens (Ensemble, optional): If not None, do ensemble for grouped value after grouping.
+        """
+        self._group_func = group_func
+        self._ens_func = ens
+
+    def group(self, *args, **kwargs) -> dict:
+        """
+        Group a set of objects and change them to a dict.
+
+        For example: {(A,B,C1): object, (A,B,C2): object} -> {(A,B): {C1: object, C2: object}}
+
+        Returns:
+            dict: grouped dict
+        """
+        if isinstance(getattr(self, "_group_func", None), Callable):
+            return self._group_func(*args, **kwargs)
+        else:
+            raise NotImplementedError(f"Please specify valid `group_func`.")
+
+    def reduce(self, *args, **kwargs) -> dict:
+        """
+        Reduce grouped dict.
+
+        For example: {(A,B): {C1: object, C2: object}} -> {(A,B): object}
+
+        Returns:
+            dict: reduced dict
+        """
+        if isinstance(getattr(self, "_ens_func", None), Callable):
+            return self._ens_func(*args, **kwargs)
+        else:
+            raise NotImplementedError(f"Please specify valid `_ens_func`.")
+
+    def __call__(self, ungrouped_dict: dict, n_jobs: int = 1, verbose: int = 0, *args, **kwargs) -> dict:
+        """
+        Group the ungrouped_dict into different groups.
+
+        Args:
+            ungrouped_dict (dict): the ungrouped dict waiting for grouping like {name: things}
+
+        Returns:
+            dict: grouped_dict like {G1: object, G2: object}
+            n_jobs: how many progress you need.
+            verbose: the print mode for Parallel.
+        """
+
+        # NOTE: The multiprocessing will raise error if you use `Serializable`
+        # Because the `Serializable` will affect the behaviors of pickle
+        grouped_dict = self.group(ungrouped_dict, *args, **kwargs)
+
+        key_l = []
+        job_l = []
+        for key, value in grouped_dict.items():
+            key_l.append(key)
+            job_l.append(delayed(Group.reduce)(self, value))
+        return dict(zip(key_l, Parallel(n_jobs=n_jobs, verbose=verbose)(job_l)))
+
+
+class RollingGroup(Group):
+    """Group the rolling dict"""
+
+    def group(self, rolling_dict: dict) -> dict:
+        """Given an rolling dict likes {(A,B,R): things}, return the grouped dict likes {(A,B): {R:things}}
+
+        NOTE: There is an assumption which is the rolling key is at the end of the key tuple, because the rolling results always need to be ensemble firstly.
+
+        Args:
+            rolling_dict (dict): an rolling dict. If the key is not a tuple, then do nothing.
+
+        Returns:
+            dict: grouped dict
+        """
+        grouped_dict = {}
+        for key, values in rolling_dict.items():
+            if isinstance(key, tuple):
+                grouped_dict.setdefault(key[:-1], {})[key[-1]] = values
+            else:
+                raise TypeError(f"Expected `tuple` type, but got a value `{key}`")
+        return grouped_dict
+
+    def __init__(self, ens=RollingEnsemble()):
+        super().__init__(ens=ens)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/interpret/base.py

@@ -0,0 +1,45 @@
+#  Copyright (c) Microsoft Corporation.
+#  Licensed under the MIT License.
+
+"""
+Interfaces to interpret models
+"""
+
+import pandas as pd
+from abc import abstractmethod
+
+
+class FeatureInt:
+    """Feature (Int)erpreter"""
+
+    @abstractmethod
+    def get_feature_importance(self) -> pd.Series:
+        """get feature importance
+
+        Returns
+        -------
+            The index is the feature name.
+
+            The greater the value, the higher importance.
+        """
+
+
+class LightGBMFInt(FeatureInt):
+    """LightGBM (F)eature (Int)erpreter"""
+
+    def __init__(self):
+        self.model = None
+
+    def get_feature_importance(self, *args, **kwargs) -> pd.Series:
+        """get feature importance
+
+        Notes
+        -----
+            parameters reference:
+            https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.Booster.html?highlight=feature_importance#lightgbm.Booster.feature_importance
+        """
+        return pd.Series(
+            self.model.feature_importance(*args, **kwargs), index=self.model.feature_name()
+        ).sort_values(  # pylint: disable=E1101
+            ascending=False
+        )

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/meta/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from .task import MetaTask
+from .dataset import MetaTaskDataset
+
+__all__ = ["MetaTask", "MetaTaskDataset"]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/meta/dataset.py

@@ -0,0 +1,77 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import abc
+from qlib.model.meta.task import MetaTask
+from typing import Dict, Union, List, Tuple, Text
+from ...utils.serial import Serializable
+
+
+class MetaTaskDataset(Serializable, metaclass=abc.ABCMeta):
+    """
+    A dataset fetching the data in a meta-level.
+
+    A Meta Dataset is responsible for
+
+    - input tasks(e.g. Qlib tasks) and prepare meta tasks
+
+        - meta task contains more information than normal tasks (e.g. input data for meta model)
+
+    The learnt pattern could transfer to other meta dataset. The following cases should be supported
+
+    - A meta-model trained on meta-dataset A and then applied to meta-dataset B
+
+        - Some pattern are shared between meta-dataset A and B, so meta-input on meta-dataset A are used when meta model are applied on meta-dataset-B
+    """
+
+    def __init__(self, segments: Union[Dict[Text, Tuple], float], *args, **kwargs):
+        """
+        The meta-dataset maintains a list of meta-tasks when it is initialized.
+
+        The segments indicates the way to divide the data
+
+        The duty of the `__init__` function of MetaTaskDataset
+        - initialize the tasks
+        """
+        super().__init__(*args, **kwargs)
+        self.segments = segments
+
+    def prepare_tasks(self, segments: Union[List[Text], Text], *args, **kwargs) -> List[MetaTask]:
+        """
+        Prepare the data in each meta-task and ready for training.
+
+        The following code example shows how to retrieve a list of meta-tasks from the `meta_dataset`:
+
+            .. code-block:: Python
+
+                # get the train segment and the test segment, both of them are lists
+                train_meta_tasks, test_meta_tasks = meta_dataset.prepare_tasks(["train", "test"])
+
+        Parameters
+        ----------
+        segments: Union[List[Text], Tuple[Text], Text]
+            the info to select data
+
+        Returns
+        -------
+        list:
+            A list of the prepared data of each meta-task for training the meta-model. For multiple segments [seg1, seg2, ... , segN], the returned list will be [[tasks in seg1], [tasks in seg2], ... , [tasks in segN]].
+            Each task is a meta task
+        """
+        if isinstance(segments, (list, tuple)):
+            return [self._prepare_seg(seg) for seg in segments]
+        elif isinstance(segments, str):
+            return self._prepare_seg(segments)
+        else:
+            raise NotImplementedError(f"This type of input is not supported")
+
+    @abc.abstractmethod
+    def _prepare_seg(self, segment: Text):
+        """
+        prepare a single segment of data for training data
+
+        Parameters
+        ----------
+        seg : Text
+            the name of the segment
+        """

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/meta/model.py

@@ -0,0 +1,75 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import abc
+from typing import List
+
+from .dataset import MetaTaskDataset
+
+
+class MetaModel(metaclass=abc.ABCMeta):
+    """
+    The meta-model guiding the model learning.
+
+    The word `Guiding` can be categorized into two types based on the stage of model learning
+    - The definition of learning tasks:  Please refer to docs of `MetaTaskModel`
+    - Controlling the learning process of models: Please refer to the docs of `MetaGuideModel`
+    """
+
+    @abc.abstractmethod
+    def fit(self, *args, **kwargs):
+        """
+        The training process of the meta-model.
+        """
+
+    @abc.abstractmethod
+    def inference(self, *args, **kwargs) -> object:
+        """
+        The inference process of the meta-model.
+
+        Returns
+        -------
+        object:
+            Some information to guide the model learning
+        """
+
+
+class MetaTaskModel(MetaModel):
+    """
+    This type of meta-model deals with base task definitions. The meta-model creates tasks for training new base forecasting models after it is trained. `prepare_tasks` directly modifies the task definitions.
+    """
+
+    def fit(self, meta_dataset: MetaTaskDataset):
+        """
+        The MetaTaskModel is expected to get prepared MetaTask from meta_dataset.
+        And then it will learn knowledge from the meta tasks
+        """
+        raise NotImplementedError(f"Please implement the `fit` method")
+
+    def inference(self, meta_dataset: MetaTaskDataset) -> List[dict]:
+        """
+        MetaTaskModel will make inference on the meta_dataset
+        The MetaTaskModel is expected to get prepared MetaTask from meta_dataset.
+        Then it will create modified task with Qlib format which can be executed by Qlib trainer.
+
+        Returns
+        -------
+        List[dict]:
+            A list of modified task definitions.
+
+        """
+        raise NotImplementedError(f"Please implement the `inference` method")
+
+
+class MetaGuideModel(MetaModel):
+    """
+    This type of meta-model aims to guide the training process of the base model. The meta-model interacts with the base forecasting models during their training process.
+    """
+
+    @abc.abstractmethod
+    def fit(self, *args, **kwargs):
+        pass
+
+    @abc.abstractmethod
+    def inference(self, *args, **kwargs):
+        pass

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/meta/task.py

@@ -0,0 +1,56 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from qlib.data.dataset import Dataset
+from ...utils import init_instance_by_config
+
+
+class MetaTask:
+    """
+    A single meta-task, a meta-dataset contains a list of them.
+    It serves as a component as in MetaDatasetDS
+
+    The data processing is different
+
+    - the processed input may be different between training and testing
+
+        - When training, the X, y, X_test, y_test in training tasks are necessary (# PROC_MODE_FULL #)
+          but not necessary in test tasks. (# PROC_MODE_TEST #)
+        - When the meta model can be transferred into other dataset, only meta_info is necessary  (# PROC_MODE_TRANSFER #)
+    """
+
+    PROC_MODE_FULL = "full"
+    PROC_MODE_TEST = "test"
+    PROC_MODE_TRANSFER = "transfer"
+
+    def __init__(self, task: dict, meta_info: object, mode: str = PROC_MODE_FULL):
+        """
+        The `__init__` func is responsible for
+
+        - store the task
+        - store the origin input data for
+        - process the input data for meta data
+
+        Parameters
+        ----------
+        task : dict
+            the task to be enhanced by meta model
+
+        meta_info : object
+            the input for meta model
+        """
+        self.task = task
+        self.meta_info = meta_info  # the original meta input information, it will be processed later
+        self.mode = mode
+
+    def get_dataset(self) -> Dataset:
+        return init_instance_by_config(self.task["dataset"], accept_types=Dataset)
+
+    def get_meta_input(self) -> object:
+        """
+        Return the **processed** meta_info
+        """
+        return self.meta_info
+
+    def __repr__(self):
+        return f"MetaTask(task={self.task}, meta_info={self.meta_info})"

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/riskmodel/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from .base import RiskModel
+from .poet import POETCovEstimator
+from .shrink import ShrinkCovEstimator
+from .structured import StructuredCovEstimator
+
+__all__ = [
+    "RiskModel",
+    "POETCovEstimator",
+    "ShrinkCovEstimator",
+    "StructuredCovEstimator",
+]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/riskmodel/base.py

@@ -0,0 +1,147 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import inspect
+import numpy as np
+import pandas as pd
+from typing import Union
+
+from qlib.model.base import BaseModel
+
+
+class RiskModel(BaseModel):
+    """Risk Model
+
+    A risk model is used to estimate the covariance matrix of stock returns.
+    """
+
+    MASK_NAN = "mask"
+    FILL_NAN = "fill"
+    IGNORE_NAN = "ignore"
+
+    def __init__(self, nan_option: str = "ignore", assume_centered: bool = False, scale_return: bool = True):
+        """
+        Args:
+            nan_option (str): nan handling option (`ignore`/`mask`/`fill`).
+            assume_centered (bool): whether the data is assumed to be centered.
+            scale_return (bool): whether scale returns as percentage.
+        """
+        # nan
+        assert nan_option in [
+            self.MASK_NAN,
+            self.FILL_NAN,
+            self.IGNORE_NAN,
+        ], f"`nan_option={nan_option}` is not supported"
+        self.nan_option = nan_option
+
+        self.assume_centered = assume_centered
+        self.scale_return = scale_return
+
+    def predict(
+        self,
+        X: Union[pd.Series, pd.DataFrame, np.ndarray],
+        return_corr: bool = False,
+        is_price: bool = True,
+        return_decomposed_components=False,
+    ) -> Union[pd.DataFrame, np.ndarray, tuple]:
+        """
+        Args:
+            X (pd.Series, pd.DataFrame or np.ndarray): data from which to estimate the covariance,
+                with variables as columns and observations as rows.
+            return_corr (bool): whether return the correlation matrix.
+            is_price (bool): whether `X` contains price (if not assume stock returns).
+            return_decomposed_components (bool): whether return decomposed components of the covariance matrix.
+
+        Returns:
+            pd.DataFrame or np.ndarray: estimated covariance (or correlation).
+        """
+        assert (
+            not return_corr or not return_decomposed_components
+        ), "Can only return either correlation matrix or decomposed components."
+
+        # transform input into 2D array
+        if not isinstance(X, (pd.Series, pd.DataFrame)):
+            columns = None
+        else:
+            if isinstance(X.index, pd.MultiIndex):
+                if isinstance(X, pd.DataFrame):
+                    X = X.iloc[:, 0].unstack(level="instrument")  # always use the first column
+                else:
+                    X = X.unstack(level="instrument")
+            else:
+                # X is 2D DataFrame
+                pass
+            columns = X.columns  # will be used to restore dataframe
+            X = X.values
+
+        # calculate pct_change
+        if is_price:
+            X = X[1:] / X[:-1] - 1  # NOTE: resulting `n - 1` rows
+
+        # scale return
+        if self.scale_return:
+            X *= 100
+
+        # handle nan and centered
+        X = self._preprocess(X)
+
+        # return decomposed components if needed
+        if return_decomposed_components:
+            assert (
+                "return_decomposed_components" in inspect.getfullargspec(self._predict).args
+            ), "This risk model does not support return decomposed components of the covariance matrix "
+
+            F, cov_b, var_u = self._predict(X, return_decomposed_components=True)  # pylint: disable=E1123
+            return F, cov_b, var_u
+
+        # estimate covariance
+        S = self._predict(X)
+
+        # return correlation if needed
+        if return_corr:
+            vola = np.sqrt(np.diag(S))
+            corr = S / np.outer(vola, vola)
+            if columns is None:
+                return corr
+            return pd.DataFrame(corr, index=columns, columns=columns)
+
+        # return covariance
+        if columns is None:
+            return S
+        return pd.DataFrame(S, index=columns, columns=columns)
+
+    def _predict(self, X: np.ndarray) -> np.ndarray:
+        """covariance estimation implementation
+
+        This method should be overridden by child classes.
+
+        By default, this method implements the empirical covariance estimation.
+
+        Args:
+            X (np.ndarray): data matrix containing multiple variables (columns) and observations (rows).
+
+        Returns:
+            np.ndarray: covariance matrix.
+        """
+        xTx = np.asarray(X.T.dot(X))
+        N = len(X)
+        if isinstance(X, np.ma.MaskedArray):
+            M = 1 - X.mask
+            N = M.T.dot(M)  # each pair has distinct number of samples
+        return xTx / N
+
+    def _preprocess(self, X: np.ndarray) -> Union[np.ndarray, np.ma.MaskedArray]:
+        """handle nan and centerize data
+
+        Note:
+            if `nan_option='mask'` then the returned array will be `np.ma.MaskedArray`.
+        """
+        # handle nan
+        if self.nan_option == self.FILL_NAN:
+            X = np.nan_to_num(X)
+        elif self.nan_option == self.MASK_NAN:
+            X = np.ma.masked_invalid(X)
+        # centralize
+        if not self.assume_centered:
+            X = X - np.nanmean(X, axis=0)
+        return X

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/riskmodel/poet.py

@@ -0,0 +1,83 @@
+import numpy as np
+
+from qlib.model.riskmodel import RiskModel
+
+
+class POETCovEstimator(RiskModel):
+    """Principal Orthogonal Complement Thresholding Estimator (POET)
+
+    Reference:
+        [1] Fan, J., Liao, Y., & Mincheva, M. (2013). Large covariance estimation by thresholding principal orthogonal complements.
+            Journal of the Royal Statistical Society. Series B: Statistical Methodology, 75(4), 603–680. https://doi.org/10.1111/rssb.12016
+        [2] http://econweb.rutgers.edu/yl1114/papers/poet/POET.m
+    """
+
+    THRESH_SOFT = "soft"
+    THRESH_HARD = "hard"
+    THRESH_SCAD = "scad"
+
+    def __init__(self, num_factors: int = 0, thresh: float = 1.0, thresh_method: str = "soft", **kwargs):
+        """
+        Args:
+            num_factors (int): number of factors (if set to zero, no factor model will be used).
+            thresh (float): the positive constant for thresholding.
+            thresh_method (str): thresholding method, which can be
+                - 'soft': soft thresholding.
+                - 'hard': hard thresholding.
+                - 'scad': scad thresholding.
+            kwargs: see `RiskModel` for more information.
+        """
+        super().__init__(**kwargs)
+
+        assert num_factors >= 0, "`num_factors` requires a positive integer"
+        self.num_factors = num_factors
+
+        assert thresh >= 0, "`thresh` requires a positive float number"
+        self.thresh = thresh
+
+        assert thresh_method in [
+            self.THRESH_HARD,
+            self.THRESH_SOFT,
+            self.THRESH_SCAD,
+        ], "`thresh_method` should be `soft`/`hard`/`scad`"
+        self.thresh_method = thresh_method
+
+    def _predict(self, X: np.ndarray) -> np.ndarray:
+        Y = X.T  # NOTE: to match POET's implementation
+        p, n = Y.shape
+
+        if self.num_factors > 0:
+            Dd, V = np.linalg.eig(Y.T.dot(Y))
+            V = V[:, np.argsort(Dd)]
+            F = V[:, -self.num_factors :][:, ::-1] * np.sqrt(n)
+            LamPCA = Y.dot(F) / n
+            uhat = np.asarray(Y - LamPCA.dot(F.T))
+            Lowrank = np.asarray(LamPCA.dot(LamPCA.T))
+            rate = 1 / np.sqrt(p) + np.sqrt(np.log(p) / n)
+        else:
+            uhat = np.asarray(Y)
+            rate = np.sqrt(np.log(p) / n)
+            Lowrank = 0
+
+        lamb = rate * self.thresh
+        SuPCA = uhat.dot(uhat.T) / n
+        SuDiag = np.diag(np.diag(SuPCA))
+        R = np.linalg.inv(SuDiag**0.5).dot(SuPCA).dot(np.linalg.inv(SuDiag**0.5))
+
+        if self.thresh_method == self.THRESH_HARD:
+            M = R * (np.abs(R) > lamb)
+        elif self.thresh_method == self.THRESH_SOFT:
+            res = np.abs(R) - lamb
+            res = (res + np.abs(res)) / 2
+            M = np.sign(R) * res
+        else:
+            M1 = (np.abs(R) < 2 * lamb) * np.sign(R) * (np.abs(R) - lamb) * (np.abs(R) > lamb)
+            M2 = (np.abs(R) < 3.7 * lamb) * (np.abs(R) >= 2 * lamb) * (2.7 * R - 3.7 * np.sign(R) * lamb) / 1.7
+            M3 = (np.abs(R) >= 3.7 * lamb) * R
+            M = M1 + M2 + M3
+
+        Rthresh = M - np.diag(np.diag(M)) + np.eye(p)
+        SigmaU = (SuDiag**0.5).dot(Rthresh).dot(SuDiag**0.5)
+        SigmaY = SigmaU + Lowrank
+
+        return SigmaY

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/riskmodel/shrink.py

@@ -0,0 +1,259 @@
+import numpy as np
+from typing import Union
+
+from qlib.model.riskmodel import RiskModel
+
+
+class ShrinkCovEstimator(RiskModel):
+    """Shrinkage Covariance Estimator
+
+    This estimator will shrink the sample covariance matrix towards
+    an identify matrix:
+        S_hat = (1 - alpha) * S + alpha * F
+    where `alpha` is the shrink parameter and `F` is the shrinking target.
+
+    The following shrinking parameters (`alpha`) are supported:
+        - `lw` [1][2][3]: use Ledoit-Wolf shrinking parameter.
+        - `oas` [4]: use Oracle Approximating Shrinkage shrinking parameter.
+        - float: directly specify the shrink parameter, should be between [0, 1].
+
+    The following shrinking targets (`F`) are supported:
+        - `const_var` [1][4][5]: assume stocks have the same constant variance and zero correlation.
+        - `const_corr` [2][6]: assume stocks have different variance but equal correlation.
+        - `single_factor` [3][7]: assume single factor model as the shrinking target.
+        - np.ndarray: provide the shrinking targets directly.
+
+    Note:
+        - The optimal shrinking parameter depends on the selection of the shrinking target.
+            Currently, `oas` is not supported for `const_corr` and `single_factor`.
+        - Remember to set `nan_option` to `fill` or `mask` if your data has missing values.
+
+    References:
+        [1] Ledoit, O., & Wolf, M. (2004). A well-conditioned estimator for large-dimensional covariance matrices.
+            Journal of Multivariate Analysis, 88(2), 365–411. https://doi.org/10.1016/S0047-259X(03)00096-4
+        [2] Ledoit, O., & Wolf, M. (2004). Honey, I shrunk the sample covariance matrix.
+            Journal of Portfolio Management, 30(4), 1–22. https://doi.org/10.3905/jpm.2004.110
+        [3] Ledoit, O., & Wolf, M. (2003). Improved estimation of the covariance matrix of stock returns
+            with an application to portfolio selection.
+            Journal of Empirical Finance, 10(5), 603–621. https://doi.org/10.1016/S0927-5398(03)00007-0
+        [4] Chen, Y., Wiesel, A., Eldar, Y. C., & Hero, A. O. (2010). Shrinkage algorithms for MMSE covariance
+            estimation. IEEE Transactions on Signal Processing, 58(10), 5016–5029.
+            https://doi.org/10.1109/TSP.2010.2053029
+        [5] https://www.econ.uzh.ch/dam/jcr:ffffffff-935a-b0d6-0000-00007f64e5b9/cov1para.m.zip
+        [6] https://www.econ.uzh.ch/dam/jcr:ffffffff-935a-b0d6-ffff-ffffde5e2d4e/covCor.m.zip
+        [7] https://www.econ.uzh.ch/dam/jcr:ffffffff-935a-b0d6-0000-0000648dfc98/covMarket.m.zip
+    """
+
+    SHR_LW = "lw"
+    SHR_OAS = "oas"
+
+    TGT_CONST_VAR = "const_var"
+    TGT_CONST_CORR = "const_corr"
+    TGT_SINGLE_FACTOR = "single_factor"
+
+    def __init__(self, alpha: Union[str, float] = 0.0, target: Union[str, np.ndarray] = "const_var", **kwargs):
+        """
+        Args:
+            alpha (str or float): shrinking parameter or estimator (`lw`/`oas`)
+            target (str or np.ndarray): shrinking target (`const_var`/`const_corr`/`single_factor`)
+            kwargs: see `RiskModel` for more information
+        """
+        super().__init__(**kwargs)
+
+        # alpha
+        if isinstance(alpha, str):
+            assert alpha in [self.SHR_LW, self.SHR_OAS], f"shrinking method `{alpha}` is not supported"
+        elif isinstance(alpha, (float, np.floating)):
+            assert 0 <= alpha <= 1, "alpha should be between [0, 1]"
+        else:
+            raise TypeError("invalid argument type for `alpha`")
+        self.alpha = alpha
+
+        # target
+        if isinstance(target, str):
+            assert target in [
+                self.TGT_CONST_VAR,
+                self.TGT_CONST_CORR,
+                self.TGT_SINGLE_FACTOR,
+            ], f"shrinking target `{target} is not supported"
+        elif isinstance(target, np.ndarray):
+            pass
+        else:
+            raise TypeError("invalid argument type for `target`")
+        if alpha == self.SHR_OAS and target != self.TGT_CONST_VAR:
+            raise NotImplementedError("currently `oas` can only support `const_var` as target")
+        self.target = target
+
+    def _predict(self, X: np.ndarray) -> np.ndarray:
+        # sample covariance
+        S = super()._predict(X)
+
+        # shrinking target
+        F = self._get_shrink_target(X, S)
+
+        # get shrinking parameter
+        alpha = self._get_shrink_param(X, S, F)
+
+        # shrink covariance
+        if alpha > 0:
+            S *= 1 - alpha
+            F *= alpha
+            S += F
+
+        return S
+
+    def _get_shrink_target(self, X: np.ndarray, S: np.ndarray) -> np.ndarray:
+        """get shrinking target `F`"""
+        if self.target == self.TGT_CONST_VAR:
+            return self._get_shrink_target_const_var(X, S)
+        if self.target == self.TGT_CONST_CORR:
+            return self._get_shrink_target_const_corr(X, S)
+        if self.target == self.TGT_SINGLE_FACTOR:
+            return self._get_shrink_target_single_factor(X, S)
+        return self.target
+
+    def _get_shrink_target_const_var(self, X: np.ndarray, S: np.ndarray) -> np.ndarray:
+        """get shrinking target with constant variance
+
+        This target assumes zero pair-wise correlation and constant variance.
+        The constant variance is estimated by averaging all sample's variances.
+        """
+        n = len(S)
+        F = np.eye(n)
+        np.fill_diagonal(F, np.mean(np.diag(S)))
+        return F
+
+    def _get_shrink_target_const_corr(self, X: np.ndarray, S: np.ndarray) -> np.ndarray:
+        """get shrinking target with constant correlation
+
+        This target assumes constant pair-wise correlation but keep the sample variance.
+        The constant correlation is estimated by averaging all pairwise correlations.
+        """
+        n = len(S)
+        var = np.diag(S)
+        sqrt_var = np.sqrt(var)
+        covar = np.outer(sqrt_var, sqrt_var)
+        r_bar = (np.sum(S / covar) - n) / (n * (n - 1))
+        F = r_bar * covar
+        np.fill_diagonal(F, var)
+        return F
+
+    def _get_shrink_target_single_factor(self, X: np.ndarray, S: np.ndarray) -> np.ndarray:
+        """get shrinking target with single factor model"""
+        X_mkt = np.nanmean(X, axis=1)
+        cov_mkt = np.asarray(X.T.dot(X_mkt) / len(X))
+        var_mkt = np.asarray(X_mkt.dot(X_mkt) / len(X))
+        F = np.outer(cov_mkt, cov_mkt) / var_mkt
+        np.fill_diagonal(F, np.diag(S))
+        return F
+
+    def _get_shrink_param(self, X: np.ndarray, S: np.ndarray, F: np.ndarray) -> float:
+        """get shrinking parameter `alpha`
+
+        Note:
+            The Ledoit-Wolf shrinking parameter estimator consists of three different methods.
+        """
+        if self.alpha == self.SHR_OAS:
+            return self._get_shrink_param_oas(X, S, F)
+        elif self.alpha == self.SHR_LW:
+            if self.target == self.TGT_CONST_VAR:
+                return self._get_shrink_param_lw_const_var(X, S, F)
+            if self.target == self.TGT_CONST_CORR:
+                return self._get_shrink_param_lw_const_corr(X, S, F)
+            if self.target == self.TGT_SINGLE_FACTOR:
+                return self._get_shrink_param_lw_single_factor(X, S, F)
+        return self.alpha
+
+    def _get_shrink_param_oas(self, X: np.ndarray, S: np.ndarray, F: np.ndarray) -> float:
+        """Oracle Approximating Shrinkage Estimator
+
+        This method uses the following formula to estimate the `alpha`
+        parameter for the shrink covariance estimator:
+            A = (1 - 2 / p) * trace(S^2) + trace^2(S)
+            B = (n + 1 - 2 / p) * (trace(S^2) - trace^2(S) / p)
+            alpha = A / B
+        where `n`, `p` are the dim of observations and variables respectively.
+        """
+        trS2 = np.sum(S**2)
+        tr2S = np.trace(S) ** 2
+
+        n, p = X.shape
+
+        A = (1 - 2 / p) * (trS2 + tr2S)
+        B = (n + 1 - 2 / p) * (trS2 + tr2S / p)
+        alpha = A / B
+
+        return alpha
+
+    def _get_shrink_param_lw_const_var(self, X: np.ndarray, S: np.ndarray, F: np.ndarray) -> float:
+        """Ledoit-Wolf Shrinkage Estimator (Constant Variance)
+
+        This method shrinks the covariance matrix towards the constand variance target.
+        """
+        t, n = X.shape
+
+        y = X**2
+        phi = np.sum(y.T.dot(y) / t - S**2)
+
+        gamma = np.linalg.norm(S - F, "fro") ** 2
+
+        kappa = phi / gamma
+        alpha = max(0, min(1, kappa / t))
+
+        return alpha
+
+    def _get_shrink_param_lw_const_corr(self, X: np.ndarray, S: np.ndarray, F: np.ndarray) -> float:
+        """Ledoit-Wolf Shrinkage Estimator (Constant Correlation)
+
+        This method shrinks the covariance matrix towards the constand correlation target.
+        """
+        t, n = X.shape
+
+        var = np.diag(S)
+        sqrt_var = np.sqrt(var)
+        r_bar = (np.sum(S / np.outer(sqrt_var, sqrt_var)) - n) / (n * (n - 1))
+
+        y = X**2
+        phi_mat = y.T.dot(y) / t - S**2
+        phi = np.sum(phi_mat)
+
+        theta_mat = (X**3).T.dot(X) / t - var[:, None] * S
+        np.fill_diagonal(theta_mat, 0)
+        rho = np.sum(np.diag(phi_mat)) + r_bar * np.sum(np.outer(1 / sqrt_var, sqrt_var) * theta_mat)
+
+        gamma = np.linalg.norm(S - F, "fro") ** 2
+
+        kappa = (phi - rho) / gamma
+        alpha = max(0, min(1, kappa / t))
+
+        return alpha
+
+    def _get_shrink_param_lw_single_factor(self, X: np.ndarray, S: np.ndarray, F: np.ndarray) -> float:
+        """Ledoit-Wolf Shrinkage Estimator (Single Factor Model)
+
+        This method shrinks the covariance matrix towards the single factor model target.
+        """
+        t, n = X.shape
+
+        X_mkt = np.nanmean(X, axis=1)
+        cov_mkt = np.asarray(X.T.dot(X_mkt) / len(X))
+        var_mkt = np.asarray(X_mkt.dot(X_mkt) / len(X))
+
+        y = X**2
+        phi = np.sum(y.T.dot(y)) / t - np.sum(S**2)
+
+        rdiag = np.sum(y**2) / t - np.sum(np.diag(S) ** 2)
+        z = X * X_mkt[:, None]
+        v1 = y.T.dot(z) / t - cov_mkt[:, None] * S
+        roff1 = np.sum(v1 * cov_mkt[:, None].T) / var_mkt - np.sum(np.diag(v1) * cov_mkt) / var_mkt
+        v3 = z.T.dot(z) / t - var_mkt * S
+        roff3 = np.sum(v3 * np.outer(cov_mkt, cov_mkt)) / var_mkt**2 - np.sum(np.diag(v3) * cov_mkt**2) / var_mkt**2
+        roff = 2 * roff1 - roff3
+        rho = rdiag + roff
+
+        gamma = np.linalg.norm(S - F, "fro") ** 2
+
+        kappa = (phi - rho) / gamma
+        alpha = max(0, min(1, kappa / t))
+
+        return alpha

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/riskmodel/structured.py

@@ -0,0 +1,94 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import numpy as np
+from typing import Union
+from sklearn.decomposition import PCA, FactorAnalysis
+
+from qlib.model.riskmodel import RiskModel
+
+
+class StructuredCovEstimator(RiskModel):
+    """Structured Covariance Estimator
+
+    This estimator assumes observations can be predicted by multiple factors
+        X = B @ F.T + U
+    where `X` contains observations (row) of multiple variables (column),
+    `F` contains factor exposures (column) for all variables (row),
+    `B` is the regression coefficients matrix for all observations (row) on
+    all factors (columns), and `U` is the residual matrix with shape like `X`.
+
+    Therefore, the structured covariance can be estimated by
+        cov(X.T) = F @ cov(B.T) @ F.T + diag(var(U))
+
+    In finance domain, there are mainly three methods to design `F` [1][2]:
+        - Statistical Risk Model (SRM): latent factor models major components
+        - Fundamental Risk Model (FRM): human designed factors
+        - Deep Risk Model (DRM): neural network designed factors (like a blend of SRM & DRM)
+
+    In this implementation we use latent factor models to specify `F`.
+    Specifically, the following two latent factor models are supported:
+        - `pca`: Principal Component Analysis
+        - `fa`: Factor Analysis
+
+    Reference:
+        [1] Fan, J., Liao, Y., & Liu, H. (2016). An overview of the estimation of large covariance and
+            precision matrices. Econometrics Journal, 19(1), C1–C32. https://doi.org/10.1111/ectj.12061
+        [2] Lin, H., Zhou, D., Liu, W., & Bian, J. (2021). Deep Risk Model: A Deep Learning Solution for
+            Mining Latent Risk Factors to Improve Covariance Matrix Estimation. arXiv preprint arXiv:2107.05201.
+    """
+
+    FACTOR_MODEL_PCA = "pca"
+    FACTOR_MODEL_FA = "fa"
+    DEFAULT_NAN_OPTION = "fill"
+
+    def __init__(self, factor_model: str = "pca", num_factors: int = 10, **kwargs):
+        """
+        Args:
+            factor_model (str): the latent factor models used to estimate the structured covariance (`pca`/`fa`).
+            num_factors (int): number of components to keep.
+            kwargs: see `RiskModel` for more information
+        """
+        if "nan_option" in kwargs:
+            assert kwargs["nan_option"] in [self.DEFAULT_NAN_OPTION], "nan_option={} is not supported".format(
+                kwargs["nan_option"]
+            )
+        else:
+            kwargs["nan_option"] = self.DEFAULT_NAN_OPTION
+
+        super().__init__(**kwargs)
+
+        assert factor_model in [
+            self.FACTOR_MODEL_PCA,
+            self.FACTOR_MODEL_FA,
+        ], "factor_model={} is not supported".format(factor_model)
+        self.solver = PCA if factor_model == self.FACTOR_MODEL_PCA else FactorAnalysis
+
+        self.num_factors = num_factors
+
+    def _predict(self, X: np.ndarray, return_decomposed_components=False) -> Union[np.ndarray, tuple]:
+        """
+        covariance estimation implementation
+
+        Args:
+            X (np.ndarray): data matrix containing multiple variables (columns) and observations (rows).
+            return_decomposed_components (bool): whether return decomposed components of the covariance matrix.
+
+        Returns:
+            tuple or np.ndarray: decomposed covariance matrix or covariance matrix.
+        """
+
+        model = self.solver(self.num_factors, random_state=0).fit(X)
+
+        F = model.components_.T  # variables x factors
+        B = model.transform(X)  # observations x factors
+        U = X - B @ F.T
+        cov_b = np.cov(B.T)  # factors x factors
+        var_u = np.var(U, axis=0)  # diagonal
+
+        if return_decomposed_components:
+            return F, cov_b, var_u
+
+        cov_x = F @ cov_b @ F.T + np.diag(var_u)
+
+        return cov_x

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/trainer.py

@@ -0,0 +1,619 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+The Trainer will train a list of tasks and return a list of model recorders.
+There are two steps in each Trainer including ``train`` (make model recorder) and ``end_train`` (modify model recorder).
+
+This is a concept called ``DelayTrainer``, which can be used in online simulating for parallel training.
+In ``DelayTrainer``, the first step is only to save some necessary info to model recorders, and the second step which will be finished in the end can do some concurrent and time-consuming operations such as model fitting.
+
+``Qlib`` offer two kinds of Trainer, ``TrainerR`` is the simplest way and ``TrainerRM`` is based on TaskManager to help manager tasks lifecycle automatically.
+"""
+
+import socket
+from typing import Callable, List, Optional
+
+from tqdm.auto import tqdm
+
+from qlib.config import C
+from qlib.data.dataset import Dataset
+from qlib.data.dataset.weight import Reweighter
+from qlib.log import get_module_logger
+from qlib.model.base import Model
+from qlib.utils import (
+    auto_filter_kwargs,
+    fill_placeholder,
+    flatten_dict,
+    init_instance_by_config,
+)
+from qlib.utils.paral import call_in_subproc
+from qlib.workflow import R
+from qlib.workflow.recorder import Recorder
+from qlib.workflow.task.manage import TaskManager, run_task
+
+
+def _log_task_info(task_config: dict):
+    R.log_params(**flatten_dict(task_config))
+    R.save_objects(**{"task": task_config})  # keep the original format and datatype
+    R.set_tags(**{"hostname": socket.gethostname()})
+
+
+def _exe_task(task_config: dict):
+    rec = R.get_recorder()
+    # model & dataset initialization
+    model: Model = init_instance_by_config(task_config["model"], accept_types=Model)
+    dataset: Dataset = init_instance_by_config(task_config["dataset"], accept_types=Dataset)
+    reweighter: Reweighter = task_config.get("reweighter", None)
+    # model training
+    auto_filter_kwargs(model.fit)(dataset, reweighter=reweighter)
+    R.save_objects(**{"params.pkl": model})
+    # this dataset is saved for online inference. So the concrete data should not be dumped
+    dataset.config(dump_all=False, recursive=True)
+    R.save_objects(**{"dataset": dataset})
+    # fill placehorder
+    placehorder_value = {"<MODEL>": model, "<DATASET>": dataset}
+    task_config = fill_placeholder(task_config, placehorder_value)
+    # generate records: prediction, backtest, and analysis
+    records = task_config.get("record", [])
+    if isinstance(records, dict):  # prevent only one dict
+        records = [records]
+    for record in records:
+        # Some recorder require the parameter `model` and `dataset`.
+        # try to automatically pass in them to the initialization function
+        # to make defining the tasking easier
+        r = init_instance_by_config(
+            record,
+            recorder=rec,
+            default_module="qlib.workflow.record_temp",
+            try_kwargs={"model": model, "dataset": dataset},
+        )
+        r.generate()
+
+
+def begin_task_train(task_config: dict, experiment_name: str, recorder_name: str = None) -> Recorder:
+    """
+    Begin task training to start a recorder and save the task config.
+
+    Args:
+        task_config (dict): the config of a task
+        experiment_name (str): the name of experiment
+        recorder_name (str): the given name will be the recorder name. None for using rid.
+
+    Returns:
+        Recorder: the model recorder
+    """
+    with R.start(experiment_name=experiment_name, recorder_name=recorder_name):
+        _log_task_info(task_config)
+        return R.get_recorder()
+
+
+def end_task_train(rec: Recorder, experiment_name: str) -> Recorder:
+    """
+    Finish task training with real model fitting and saving.
+
+    Args:
+        rec (Recorder): the recorder will be resumed
+        experiment_name (str): the name of experiment
+
+    Returns:
+        Recorder: the model recorder
+    """
+    with R.start(experiment_name=experiment_name, recorder_id=rec.info["id"], resume=True):
+        task_config = R.load_object("task")
+        _exe_task(task_config)
+    return rec
+
+
+def task_train(task_config: dict, experiment_name: str, recorder_name: str = None) -> Recorder:
+    """
+    Task based training, will be divided into two steps.
+
+    Parameters
+    ----------
+    task_config : dict
+        The config of a task.
+    experiment_name: str
+        The name of experiment
+    recorder_name: str
+        The name of recorder
+
+    Returns
+    ----------
+    Recorder: The instance of the recorder
+    """
+    with R.start(experiment_name=experiment_name, recorder_name=recorder_name):
+        _log_task_info(task_config)
+        _exe_task(task_config)
+        return R.get_recorder()
+
+
+class Trainer:
+    """
+    The trainer can train a list of models.
+    There are Trainer and DelayTrainer, which can be distinguished by when it will finish real training.
+    """
+
+    def __init__(self):
+        self.delay = False
+
+    def train(self, tasks: list, *args, **kwargs) -> list:
+        """
+        Given a list of task definitions, begin training, and return the models.
+
+        For Trainer, it finishes real training in this method.
+        For DelayTrainer, it only does some preparation in this method.
+
+        Args:
+            tasks: a list of tasks
+
+        Returns:
+            list: a list of models
+        """
+        raise NotImplementedError(f"Please implement the `train` method.")
+
+    def end_train(self, models: list, *args, **kwargs) -> list:
+        """
+        Given a list of models, finished something at the end of training if you need.
+        The models may be Recorder, txt file, database, and so on.
+
+        For Trainer, it does some finishing touches in this method.
+        For DelayTrainer, it finishes real training in this method.
+
+        Args:
+            models: a list of models
+
+        Returns:
+            list: a list of models
+        """
+        # do nothing if you finished all work in `train` method
+        return models
+
+    def is_delay(self) -> bool:
+        """
+        If Trainer will delay finishing `end_train`.
+
+        Returns:
+            bool: if DelayTrainer
+        """
+        return self.delay
+
+    def __call__(self, *args, **kwargs) -> list:
+        return self.end_train(self.train(*args, **kwargs))
+
+    def has_worker(self) -> bool:
+        """
+        Some trainer has backend worker to support parallel training
+        This method can tell if the worker is enabled.
+
+        Returns
+        -------
+        bool:
+            if the worker is enabled
+
+        """
+        return False
+
+    def worker(self):
+        """
+        start the worker
+
+        Raises
+        ------
+        NotImplementedError:
+            If the worker is not supported
+        """
+        raise NotImplementedError(f"Please implement the `worker` method")
+
+
+class TrainerR(Trainer):
+    """
+    Trainer based on (R)ecorder.
+    It will train a list of tasks and return a list of model recorders in a linear way.
+
+    Assumption: models were defined by `task` and the results will be saved to `Recorder`.
+    """
+
+    # Those tag will help you distinguish whether the Recorder has finished traning
+    STATUS_KEY = "train_status"
+    STATUS_BEGIN = "begin_task_train"
+    STATUS_END = "end_task_train"
+
+    def __init__(
+        self,
+        experiment_name: Optional[str] = None,
+        train_func: Callable = task_train,
+        call_in_subproc: bool = False,
+        default_rec_name: Optional[str] = None,
+    ):
+        """
+        Init TrainerR.
+
+        Args:
+            experiment_name (str, optional): the default name of experiment.
+            train_func (Callable, optional): default training method. Defaults to `task_train`.
+            call_in_subproc (bool): call the process in subprocess to force memory release
+        """
+        super().__init__()
+        self.experiment_name = experiment_name
+        self.default_rec_name = default_rec_name
+        self.train_func = train_func
+        self._call_in_subproc = call_in_subproc
+
+    def train(
+        self, tasks: list, train_func: Optional[Callable] = None, experiment_name: Optional[str] = None, **kwargs
+    ) -> List[Recorder]:
+        """
+        Given a list of `tasks` and return a list of trained Recorder. The order can be guaranteed.
+
+        Args:
+            tasks (list): a list of definitions based on `task` dict
+            train_func (Callable): the training method which needs at least `tasks` and `experiment_name`. None for the default training method.
+            experiment_name (str): the experiment name, None for use default name.
+            kwargs: the params for train_func.
+
+        Returns:
+            List[Recorder]: a list of Recorders
+        """
+        if isinstance(tasks, dict):
+            tasks = [tasks]
+        if len(tasks) == 0:
+            return []
+        if train_func is None:
+            train_func = self.train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        recs = []
+        for task in tqdm(tasks, desc="train tasks"):
+            if self._call_in_subproc:
+                get_module_logger("TrainerR").info("running models in sub process (for forcing release memroy).")
+                train_func = call_in_subproc(train_func, C)
+            rec = train_func(task, experiment_name, recorder_name=self.default_rec_name, **kwargs)
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_BEGIN})
+            recs.append(rec)
+        return recs
+
+    def end_train(self, models: list, **kwargs) -> List[Recorder]:
+        """
+        Set STATUS_END tag to the recorders.
+
+        Args:
+            models (list): a list of trained recorders.
+
+        Returns:
+            List[Recorder]: the same list as the param.
+        """
+        if isinstance(models, Recorder):
+            models = [models]
+        for rec in models:
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_END})
+        return models
+
+
+class DelayTrainerR(TrainerR):
+    """
+    A delayed implementation based on TrainerR, which means `train` method may only do some preparation and `end_train` method can do the real model fitting.
+    """
+
+    def __init__(
+        self, experiment_name: str = None, train_func=begin_task_train, end_train_func=end_task_train, **kwargs
+    ):
+        """
+        Init TrainerRM.
+
+        Args:
+            experiment_name (str): the default name of experiment.
+            train_func (Callable, optional): default train method. Defaults to `begin_task_train`.
+            end_train_func (Callable, optional): default end_train method. Defaults to `end_task_train`.
+        """
+        super().__init__(experiment_name, train_func, **kwargs)
+        self.end_train_func = end_train_func
+        self.delay = True
+
+    def end_train(self, models, end_train_func=None, experiment_name: str = None, **kwargs) -> List[Recorder]:
+        """
+        Given a list of Recorder and return a list of trained Recorder.
+        This class will finish real data loading and model fitting.
+
+        Args:
+            models (list): a list of Recorder, the tasks have been saved to them
+            end_train_func (Callable, optional): the end_train method which needs at least `recorders` and `experiment_name`. Defaults to None for using self.end_train_func.
+            experiment_name (str): the experiment name, None for use default name.
+            kwargs: the params for end_train_func.
+
+        Returns:
+            List[Recorder]: a list of Recorders
+        """
+        if isinstance(models, Recorder):
+            models = [models]
+        if end_train_func is None:
+            end_train_func = self.end_train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        for rec in models:
+            if rec.list_tags()[self.STATUS_KEY] == self.STATUS_END:
+                continue
+            end_train_func(rec, experiment_name, **kwargs)
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_END})
+        return models
+
+
+class TrainerRM(Trainer):
+    """
+    Trainer based on (R)ecorder and Task(M)anager.
+    It can train a list of tasks and return a list of model recorders in a multiprocessing way.
+
+    Assumption: `task` will be saved to TaskManager and `task` will be fetched and trained from TaskManager
+    """
+
+    # Those tag will help you distinguish whether the Recorder has finished traning
+    STATUS_KEY = "train_status"
+    STATUS_BEGIN = "begin_task_train"
+    STATUS_END = "end_task_train"
+
+    # This tag is the _id in TaskManager to distinguish tasks.
+    TM_ID = "_id in TaskManager"
+
+    def __init__(
+        self,
+        experiment_name: str = None,
+        task_pool: str = None,
+        train_func=task_train,
+        skip_run_task: bool = False,
+        default_rec_name: Optional[str] = None,
+    ):
+        """
+        Init TrainerR.
+
+        Args:
+            experiment_name (str): the default name of experiment.
+            task_pool (str): task pool name in TaskManager. None for use same name as experiment_name.
+            train_func (Callable, optional): default training method. Defaults to `task_train`.
+            skip_run_task (bool):
+                If skip_run_task == True:
+                Only run_task in the worker. Otherwise skip run_task.
+        """
+
+        super().__init__()
+        self.experiment_name = experiment_name
+        self.task_pool = task_pool
+        self.train_func = train_func
+        self.skip_run_task = skip_run_task
+        self.default_rec_name = default_rec_name
+
+    def train(
+        self,
+        tasks: list,
+        train_func: Callable = None,
+        experiment_name: str = None,
+        before_status: str = TaskManager.STATUS_WAITING,
+        after_status: str = TaskManager.STATUS_DONE,
+        default_rec_name: Optional[str] = None,
+        **kwargs,
+    ) -> List[Recorder]:
+        """
+        Given a list of `tasks` and return a list of trained Recorder. The order can be guaranteed.
+
+        This method defaults to a single process, but TaskManager offered a great way to parallel training.
+        Users can customize their train_func to realize multiple processes or even multiple machines.
+
+        Args:
+            tasks (list): a list of definitions based on `task` dict
+            train_func (Callable): the training method which needs at least `tasks` and `experiment_name`. None for the default training method.
+            experiment_name (str): the experiment name, None for use default name.
+            before_status (str): the tasks in before_status will be fetched and trained. Can be STATUS_WAITING, STATUS_PART_DONE.
+            after_status (str): the tasks after trained will become after_status. Can be STATUS_WAITING, STATUS_PART_DONE.
+            kwargs: the params for train_func.
+
+        Returns:
+            List[Recorder]: a list of Recorders
+        """
+        if isinstance(tasks, dict):
+            tasks = [tasks]
+        if len(tasks) == 0:
+            return []
+        if train_func is None:
+            train_func = self.train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        if default_rec_name is None:
+            default_rec_name = self.default_rec_name
+        task_pool = self.task_pool
+        if task_pool is None:
+            task_pool = experiment_name
+        tm = TaskManager(task_pool=task_pool)
+        _id_list = tm.create_task(tasks)  # all tasks will be saved to MongoDB
+        query = {"_id": {"$in": _id_list}}
+        if not self.skip_run_task:
+            run_task(
+                train_func,
+                task_pool,
+                query=query,  # only train these tasks
+                experiment_name=experiment_name,
+                before_status=before_status,
+                after_status=after_status,
+                recorder_name=default_rec_name,
+                **kwargs,
+            )
+
+        if not self.is_delay():
+            tm.wait(query=query)
+
+        recs = []
+        for _id in _id_list:
+            rec = tm.re_query(_id)["res"]
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_BEGIN})
+            rec.set_tags(**{self.TM_ID: _id})
+            recs.append(rec)
+        return recs
+
+    def end_train(self, recs: list, **kwargs) -> List[Recorder]:
+        """
+        Set STATUS_END tag to the recorders.
+
+        Args:
+            recs (list): a list of trained recorders.
+
+        Returns:
+            List[Recorder]: the same list as the param.
+        """
+        if isinstance(recs, Recorder):
+            recs = [recs]
+        for rec in recs:
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_END})
+        return recs
+
+    def worker(
+        self,
+        train_func: Callable = None,
+        experiment_name: str = None,
+    ):
+        """
+        The multiprocessing method for `train`. It can share a same task_pool with `train` and can run in other progress or other machines.
+
+        Args:
+            train_func (Callable): the training method which needs at least `tasks` and `experiment_name`. None for the default training method.
+            experiment_name (str): the experiment name, None for use default name.
+        """
+        if train_func is None:
+            train_func = self.train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        task_pool = self.task_pool
+        if task_pool is None:
+            task_pool = experiment_name
+        run_task(train_func, task_pool=task_pool, experiment_name=experiment_name)
+
+    def has_worker(self) -> bool:
+        return True
+
+
+class DelayTrainerRM(TrainerRM):
+    """
+    A delayed implementation based on TrainerRM, which means `train` method may only do some preparation and `end_train` method can do the real model fitting.
+
+    """
+
+    def __init__(
+        self,
+        experiment_name: str = None,
+        task_pool: str = None,
+        train_func=begin_task_train,
+        end_train_func=end_task_train,
+        skip_run_task: bool = False,
+        **kwargs,
+    ):
+        """
+        Init DelayTrainerRM.
+
+        Args:
+            experiment_name (str): the default name of experiment.
+            task_pool (str): task pool name in TaskManager. None for use same name as experiment_name.
+            train_func (Callable, optional): default train method. Defaults to `begin_task_train`.
+            end_train_func (Callable, optional): default end_train method. Defaults to `end_task_train`.
+            skip_run_task (bool):
+                If skip_run_task == True:
+                Only run_task in the worker. Otherwise skip run_task.
+                E.g. Starting trainer on a CPU VM and then waiting tasks to be finished on GPU VMs.
+        """
+        super().__init__(experiment_name, task_pool, train_func, **kwargs)
+        self.end_train_func = end_train_func
+        self.delay = True
+        self.skip_run_task = skip_run_task
+
+    def train(self, tasks: list, train_func=None, experiment_name: str = None, **kwargs) -> List[Recorder]:
+        """
+        Same as `train` of TrainerRM, after_status will be STATUS_PART_DONE.
+
+        Args:
+            tasks (list): a list of definition based on `task` dict
+            train_func (Callable): the train method which need at least `tasks` and `experiment_name`. Defaults to None for using self.train_func.
+            experiment_name (str): the experiment name, None for use default name.
+
+        Returns:
+            List[Recorder]: a list of Recorders
+        """
+        if isinstance(tasks, dict):
+            tasks = [tasks]
+        if len(tasks) == 0:
+            return []
+        _skip_run_task = self.skip_run_task
+        self.skip_run_task = False  # The task preparation can't be skipped
+        res = super().train(
+            tasks,
+            train_func=train_func,
+            experiment_name=experiment_name,
+            after_status=TaskManager.STATUS_PART_DONE,
+            **kwargs,
+        )
+        self.skip_run_task = _skip_run_task
+        return res
+
+    def end_train(self, recs, end_train_func=None, experiment_name: str = None, **kwargs) -> List[Recorder]:
+        """
+        Given a list of Recorder and return a list of trained Recorder.
+        This class will finish real data loading and model fitting.
+
+        Args:
+            recs (list): a list of Recorder, the tasks have been saved to them.
+            end_train_func (Callable, optional): the end_train method which need at least `recorders` and `experiment_name`. Defaults to None for using self.end_train_func.
+            experiment_name (str): the experiment name, None for use default name.
+            kwargs: the params for end_train_func.
+
+        Returns:
+            List[Recorder]: a list of Recorders
+        """
+        if isinstance(recs, Recorder):
+            recs = [recs]
+        if end_train_func is None:
+            end_train_func = self.end_train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        task_pool = self.task_pool
+        if task_pool is None:
+            task_pool = experiment_name
+        _id_list = []
+        for rec in recs:
+            _id_list.append(rec.list_tags()[self.TM_ID])
+
+        query = {"_id": {"$in": _id_list}}
+        if not self.skip_run_task:
+            run_task(
+                end_train_func,
+                task_pool,
+                query=query,  # only train these tasks
+                experiment_name=experiment_name,
+                before_status=TaskManager.STATUS_PART_DONE,
+                **kwargs,
+            )
+
+        TaskManager(task_pool=task_pool).wait(query=query)
+
+        for rec in recs:
+            rec.set_tags(**{self.STATUS_KEY: self.STATUS_END})
+        return recs
+
+    def worker(self, end_train_func=None, experiment_name: str = None):
+        """
+        The multiprocessing method for `end_train`. It can share a same task_pool with `end_train` and can run in other progress or other machines.
+
+        Args:
+            end_train_func (Callable, optional): the end_train method which need at least `recorders` and `experiment_name`. Defaults to None for using self.end_train_func.
+            experiment_name (str): the experiment name, None for use default name.
+        """
+        if end_train_func is None:
+            end_train_func = self.end_train_func
+        if experiment_name is None:
+            experiment_name = self.experiment_name
+        task_pool = self.task_pool
+        if task_pool is None:
+            task_pool = experiment_name
+        run_task(
+            end_train_func,
+            task_pool=task_pool,
+            experiment_name=experiment_name,
+            before_status=TaskManager.STATUS_PART_DONE,
+        )
+
+    def has_worker(self) -> bool:
+        return True

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/model/utils.py

@@ -0,0 +1,26 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from torch.utils.data import Dataset
+
+
+class ConcatDataset(Dataset):
+    def __init__(self, *datasets):
+        self.datasets = datasets
+
+    def __getitem__(self, i):
+        return tuple(d[i] for d in self.datasets)
+
+    def __len__(self):
+        return min(len(d) for d in self.datasets)
+
+
+class IndexSampler:
+    def __init__(self, sampler):
+        self.sampler = sampler
+
+    def __getitem__(self, i: int):
+        return self.sampler[i], i
+
+    def __len__(self):
+        return len(self.sampler)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from .interpreter import Interpreter, StateInterpreter, ActionInterpreter
+from .reward import Reward, RewardCombination
+from .simulator import Simulator
+
+__all__ = ["Interpreter", "StateInterpreter", "ActionInterpreter", "Reward", "RewardCombination", "Simulator"]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/aux_info.py

@@ -0,0 +1,43 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+
+from qlib.typehint import final
+
+from .simulator import StateType
+
+if TYPE_CHECKING:
+    from .utils.env_wrapper import EnvWrapper
+
+
+__all__ = ["AuxiliaryInfoCollector"]
+
+AuxInfoType = TypeVar("AuxInfoType")
+
+
+class AuxiliaryInfoCollector(Generic[StateType, AuxInfoType]):
+    """Override this class to collect customized auxiliary information from environment."""
+
+    env: Optional[EnvWrapper] = None
+
+    @final
+    def __call__(self, simulator_state: StateType) -> AuxInfoType:
+        return self.collect(simulator_state)
+
+    def collect(self, simulator_state: StateType) -> AuxInfoType:
+        """Override this for customized auxiliary info.
+        Usually useful in Multi-agent RL.
+
+        Parameters
+        ----------
+        simulator_state
+            Retrieved with ``simulator.get_state()``.
+
+        Returns
+        -------
+        Auxiliary information.
+        """
+        raise NotImplementedError("collect is not implemented!")

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/contrib/backtest.py

@@ -0,0 +1,384 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import argparse
+import copy
+import os
+import pickle
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union, cast
+
+import numpy as np
+import pandas as pd
+import torch
+from joblib import Parallel, delayed
+
+from qlib.backtest import INDICATOR_METRIC, collect_data_loop, get_strategy_executor
+from qlib.backtest.decision import BaseTradeDecision, Order, OrderDir, TradeRangeByTime
+from qlib.backtest.executor import SimulatorExecutor
+from qlib.backtest.high_performance_ds import BaseOrderIndicator
+from qlib.rl.contrib.naive_config_parser import get_backtest_config_fromfile
+from qlib.rl.contrib.utils import read_order_file
+from qlib.rl.data.integration import init_qlib
+from qlib.rl.order_execution.simulator_qlib import SingleAssetOrderExecution
+from qlib.typehint import Literal
+
+
+def _get_multi_level_executor_config(
+    strategy_config: dict,
+    cash_limit: float | None = None,
+    generate_report: bool = False,
+    data_granularity: str = "1min",
+) -> dict:
+    executor_config = {
+        "class": "SimulatorExecutor",
+        "module_path": "qlib.backtest.executor",
+        "kwargs": {
+            "time_per_step": data_granularity,
+            "verbose": False,
+            "trade_type": SimulatorExecutor.TT_PARAL if cash_limit is not None else SimulatorExecutor.TT_SERIAL,
+            "generate_report": generate_report,
+            "track_data": True,
+        },
+    }
+
+    freqs = list(strategy_config.keys())
+    freqs.sort(key=pd.Timedelta)
+    for freq in freqs:
+        executor_config = {
+            "class": "NestedExecutor",
+            "module_path": "qlib.backtest.executor",
+            "kwargs": {
+                "time_per_step": freq,
+                "inner_strategy": strategy_config[freq],
+                "inner_executor": executor_config,
+                "track_data": True,
+            },
+        }
+
+    return executor_config
+
+
+def _convert_indicator_to_dataframe(indicator: dict) -> Optional[pd.DataFrame]:
+    record_list = []
+    for time, value_dict in indicator.items():
+        if isinstance(value_dict, BaseOrderIndicator):
+            # HACK: for qlib v0.8
+            value_dict = value_dict.to_series()
+        try:
+            value_dict = copy.deepcopy(value_dict)
+            if value_dict["ffr"].empty:
+                continue
+        except Exception:
+            value_dict = {k: v for k, v in value_dict.items() if k != "pa"}
+        value_dict = pd.DataFrame(value_dict)
+        value_dict["datetime"] = time
+        record_list.append(value_dict)
+
+    if not record_list:
+        return None
+
+    records: pd.DataFrame = pd.concat(record_list, 0).reset_index().rename(columns={"index": "instrument"})
+    records = records.set_index(["instrument", "datetime"])
+    return records
+
+
+def _generate_report(
+    decisions: List[BaseTradeDecision],
+    report_indicators: List[INDICATOR_METRIC],
+) -> Dict[str, Tuple[pd.DataFrame, pd.DataFrame]]:
+    """Generate backtest reports
+
+    Parameters
+    ----------
+    decisions:
+        List of trade decisions.
+    report_indicators
+        List of indicator reports.
+    Returns
+    -------
+
+    """
+    indicator_dict: Dict[str, List[pd.DataFrame]] = defaultdict(list)
+    indicator_his: Dict[str, List[dict]] = defaultdict(list)
+
+    for report_indicator in report_indicators:
+        for key, (indicator_df, indicator_obj) in report_indicator.items():
+            indicator_dict[key].append(indicator_df)
+            indicator_his[key].append(indicator_obj.order_indicator_his)
+
+    report = {}
+    decision_details = pd.concat([getattr(d, "details") for d in decisions if hasattr(d, "details")])
+    for key in indicator_dict:
+        cur_dict = pd.concat(indicator_dict[key])
+        cur_his = pd.concat([_convert_indicator_to_dataframe(his) for his in indicator_his[key]])
+        cur_details = decision_details[decision_details.freq == key].set_index(["instrument", "datetime"])
+        if len(cur_details) > 0:
+            cur_details.pop("freq")
+            cur_his = cur_his.join(cur_details, how="outer")
+
+        report[key] = (cur_dict, cur_his)
+
+    return report
+
+
+def single_with_simulator(
+    backtest_config: dict,
+    orders: pd.DataFrame,
+    split: Literal["stock", "day"] = "stock",
+    cash_limit: float | None = None,
+    generate_report: bool = False,
+) -> Union[Tuple[pd.DataFrame, dict], pd.DataFrame]:
+    """Run backtest in a single thread with SingleAssetOrderExecution simulator. The orders will be executed day by day.
+    A new simulator will be created and used for every single-day order.
+
+    Parameters
+    ----------
+    backtest_config:
+        Backtest config
+    orders:
+        Orders to be executed. Example format:
+                 datetime instrument  amount  direction
+            0  2020-06-01       INST   600.0          0
+            1  2020-06-02       INST   700.0          1
+            ...
+    split
+        Method to split orders. If it is "stock", split orders by stock. If it is "day", split orders by date.
+    cash_limit
+        Limitation of cash.
+    generate_report
+        Whether to generate reports.
+
+    Returns
+    -------
+        If generate_report is True, return execution records and the generated report. Otherwise, return only records.
+    """
+    init_qlib(backtest_config["qlib"])
+
+    stocks = orders.instrument.unique().tolist()
+
+    reports = []
+    decisions = []
+    for _, row in orders.iterrows():
+        date = pd.Timestamp(row["datetime"])
+        start_time = pd.Timestamp(backtest_config["start_time"]).replace(year=date.year, month=date.month, day=date.day)
+        end_time = pd.Timestamp(backtest_config["end_time"]).replace(year=date.year, month=date.month, day=date.day)
+        order = Order(
+            stock_id=row["instrument"],
+            amount=row["amount"],
+            direction=OrderDir(row["direction"]),
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        executor_config = _get_multi_level_executor_config(
+            strategy_config=backtest_config["strategies"],
+            cash_limit=cash_limit,
+            generate_report=generate_report,
+            data_granularity=backtest_config["data_granularity"],
+        )
+
+        exchange_config = copy.deepcopy(backtest_config["exchange"])
+        exchange_config.update(
+            {
+                "codes": stocks,
+                "freq": backtest_config["data_granularity"],
+            }
+        )
+
+        simulator = SingleAssetOrderExecution(
+            order=order,
+            executor_config=executor_config,
+            exchange_config=exchange_config,
+            qlib_config=None,
+            cash_limit=None,
+        )
+
+        reports.append(simulator.report_dict)
+        decisions += simulator.decisions
+
+    indicator_1day_objs = [report["indicator_dict"]["1day"][1] for report in reports]
+    indicator_info = {k: v for obj in indicator_1day_objs for k, v in obj.order_indicator_his.items()}
+    records = _convert_indicator_to_dataframe(indicator_info)
+    assert records is None or not np.isnan(records["ffr"]).any()
+
+    if generate_report:
+        _report = _generate_report(decisions, [report["indicator"] for report in reports])
+
+        if split == "stock":
+            stock_id = orders.iloc[0].instrument
+            report = {stock_id: _report}
+        else:
+            day = orders.iloc[0].datetime
+            report = {day: _report}
+
+        return records, report
+    else:
+        return records
+
+
+def single_with_collect_data_loop(
+    backtest_config: dict,
+    orders: pd.DataFrame,
+    split: Literal["stock", "day"] = "stock",
+    cash_limit: float | None = None,
+    generate_report: bool = False,
+) -> Union[Tuple[pd.DataFrame, dict], pd.DataFrame]:
+    """Run backtest in a single thread with collect_data_loop.
+
+    Parameters
+    ----------
+    backtest_config:
+        Backtest config
+    orders:
+        Orders to be executed. Example format:
+                 datetime instrument  amount  direction
+            0  2020-06-01       INST   600.0          0
+            1  2020-06-02       INST   700.0          1
+            ...
+    split
+        Method to split orders. If it is "stock", split orders by stock. If it is "day", split orders by date.
+    cash_limit
+        Limitation of cash.
+    generate_report
+        Whether to generate reports.
+
+    Returns
+    -------
+        If generate_report is True, return execution records and the generated report. Otherwise, return only records.
+    """
+
+    init_qlib(backtest_config["qlib"])
+
+    trade_start_time = orders["datetime"].min()
+    trade_end_time = orders["datetime"].max()
+    stocks = orders.instrument.unique().tolist()
+
+    strategy_config = {
+        "class": "FileOrderStrategy",
+        "module_path": "qlib.contrib.strategy.rule_strategy",
+        "kwargs": {
+            "file": orders,
+            "trade_range": TradeRangeByTime(
+                pd.Timestamp(backtest_config["start_time"]).time(),
+                pd.Timestamp(backtest_config["end_time"]).time(),
+            ),
+        },
+    }
+
+    executor_config = _get_multi_level_executor_config(
+        strategy_config=backtest_config["strategies"],
+        cash_limit=cash_limit,
+        generate_report=generate_report,
+        data_granularity=backtest_config["data_granularity"],
+    )
+
+    exchange_config = copy.deepcopy(backtest_config["exchange"])
+    exchange_config.update(
+        {
+            "codes": stocks,
+            "freq": backtest_config["data_granularity"],
+        }
+    )
+
+    strategy, executor = get_strategy_executor(
+        start_time=pd.Timestamp(trade_start_time),
+        end_time=pd.Timestamp(trade_end_time) + pd.DateOffset(1),
+        strategy=strategy_config,
+        executor=executor_config,
+        benchmark=None,
+        account=cash_limit if cash_limit is not None else int(1e12),
+        exchange_kwargs=exchange_config,
+        pos_type="Position" if cash_limit is not None else "InfPosition",
+    )
+
+    report_dict: dict = {}
+    decisions = list(collect_data_loop(trade_start_time, trade_end_time, strategy, executor, report_dict))
+
+    indicator_dict = cast(INDICATOR_METRIC, report_dict.get("indicator_dict"))
+    records = _convert_indicator_to_dataframe(indicator_dict["1day"][1].order_indicator_his)
+    assert records is None or not np.isnan(records["ffr"]).any()
+
+    if generate_report:
+        _report = _generate_report(decisions, [indicator_dict])
+        if split == "stock":
+            stock_id = orders.iloc[0].instrument
+            report = {stock_id: _report}
+        else:
+            day = orders.iloc[0].datetime
+            report = {day: _report}
+        return records, report
+    else:
+        return records
+
+
+def backtest(backtest_config: dict, with_simulator: bool = False) -> pd.DataFrame:
+    order_df = read_order_file(backtest_config["order_file"])
+
+    cash_limit = backtest_config["exchange"].pop("cash_limit")
+    generate_report = backtest_config.pop("generate_report")
+
+    stock_pool = order_df["instrument"].unique().tolist()
+    stock_pool.sort()
+
+    single = single_with_simulator if with_simulator else single_with_collect_data_loop
+    mp_config = {"n_jobs": backtest_config["concurrency"], "verbose": 10, "backend": "multiprocessing"}
+    torch.set_num_threads(1)  # https://github.com/pytorch/pytorch/issues/17199
+    res = Parallel(**mp_config)(
+        delayed(single)(
+            backtest_config=backtest_config,
+            orders=order_df[order_df["instrument"] == stock].copy(),
+            split="stock",
+            cash_limit=cash_limit,
+            generate_report=generate_report,
+        )
+        for stock in stock_pool
+    )
+
+    output_path = Path(backtest_config["output_dir"])
+    if generate_report:
+        with (output_path / "report.pkl").open("wb") as f:
+            report = {}
+            for r in res:
+                report.update(r[1])
+            pickle.dump(report, f)
+        res = pd.concat([r[0] for r in res], 0)
+    else:
+        res = pd.concat(res)
+
+    if not output_path.exists():
+        os.makedirs(output_path)
+
+    if "pa" in res.columns:
+        res["pa"] = res["pa"] * 10000.0  # align with training metrics
+    res.to_csv(output_path / "backtest_result.csv")
+    return res
+
+
+if __name__ == "__main__":
+    import warnings
+
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+    warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config_path", type=str, required=True, help="Path to the config file")
+    parser.add_argument("--use_simulator", action="store_true", help="Whether to use simulator as the backend")
+    parser.add_argument(
+        "--n_jobs",
+        type=int,
+        required=False,
+        help="The number of jobs for running backtest parallely(1 for single process)",
+    )
+    args = parser.parse_args()
+
+    config = get_backtest_config_fromfile(args.config_path)
+    if args.n_jobs is not None:
+        config["concurrency"] = args.n_jobs
+
+    backtest(
+        backtest_config=config,
+        with_simulator=args.use_simulator,
+    )

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/contrib/naive_config_parser.py

@@ -0,0 +1,106 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import os
+import platform
+import shutil
+import sys
+import tempfile
+from importlib import import_module
+from ruamel.yaml import YAML
+
+DELETE_KEY = "_delete_"
+
+
+def merge_a_into_b(a: dict, b: dict) -> dict:
+    b = b.copy()
+    for k, v in a.items():
+        if isinstance(v, dict) and k in b:
+            v.pop(DELETE_KEY, False)
+            b[k] = merge_a_into_b(v, b[k])
+        else:
+            b[k] = v
+    return b
+
+
+def check_file_exist(filename: str, msg_tmpl: str = 'file "{}" does not exist') -> None:
+    if not os.path.isfile(filename):
+        raise FileNotFoundError(msg_tmpl.format(filename))
+
+
+def parse_backtest_config(path: str) -> dict:
+    abs_path = os.path.abspath(path)
+    check_file_exist(abs_path)
+
+    file_ext_name = os.path.splitext(abs_path)[1]
+    if file_ext_name not in (".py", ".json", ".yaml", ".yml"):
+        raise IOError("Only py/yml/yaml/json type are supported now!")
+
+    with tempfile.TemporaryDirectory() as tmp_config_dir:
+        with tempfile.NamedTemporaryFile(dir=tmp_config_dir, suffix=file_ext_name) as tmp_config_file:
+            if platform.system() == "Windows":
+                tmp_config_file.close()
+
+            tmp_config_name = os.path.basename(tmp_config_file.name)
+            shutil.copyfile(abs_path, tmp_config_file.name)
+
+            if abs_path.endswith(".py"):
+                tmp_module_name = os.path.splitext(tmp_config_name)[0]
+                sys.path.insert(0, tmp_config_dir)
+                module = import_module(tmp_module_name)
+                sys.path.pop(0)
+
+                config = {k: v for k, v in module.__dict__.items() if not k.startswith("__")}
+
+                del sys.modules[tmp_module_name]
+            else:
+                with open(tmp_config_file.name) as input_stream:
+                    yaml = YAML(typ="safe", pure=True)
+                    config = yaml.load(input_stream)
+
+    if "_base_" in config:
+        base_file_name = config.pop("_base_")
+        if not isinstance(base_file_name, list):
+            base_file_name = [base_file_name]
+
+        for f in base_file_name:
+            base_config = parse_backtest_config(os.path.join(os.path.dirname(abs_path), f))
+            config = merge_a_into_b(a=config, b=base_config)
+
+    return config
+
+
+def _convert_all_list_to_tuple(config: dict) -> dict:
+    for k, v in config.items():
+        if isinstance(v, list):
+            config[k] = tuple(v)
+        elif isinstance(v, dict):
+            config[k] = _convert_all_list_to_tuple(v)
+    return config
+
+
+def get_backtest_config_fromfile(path: str) -> dict:
+    backtest_config = parse_backtest_config(path)
+
+    exchange_config_default = {
+        "open_cost": 0.0005,
+        "close_cost": 0.0015,
+        "min_cost": 5.0,
+        "trade_unit": 100.0,
+        "cash_limit": None,
+    }
+    backtest_config["exchange"] = merge_a_into_b(a=backtest_config["exchange"], b=exchange_config_default)
+    backtest_config["exchange"] = _convert_all_list_to_tuple(backtest_config["exchange"])
+
+    backtest_config_default = {
+        "debug_single_stock": None,
+        "debug_single_day": None,
+        "concurrency": -1,
+        "multiplier": 1.0,
+        "output_dir": "outputs_backtest/",
+        "generate_report": False,
+        "data_granularity": "1min",
+    }
+    backtest_config = merge_a_into_b(a=backtest_config, b=backtest_config_default)
+
+    return backtest_config

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/contrib/train_onpolicy.py

@@ -0,0 +1,269 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import argparse
+import os
+import random
+import sys
+import warnings
+from pathlib import Path
+from ruamel.yaml import YAML
+from typing import cast, List, Optional
+
+import numpy as np
+import pandas as pd
+import torch
+from qlib.backtest import Order
+from qlib.backtest.decision import OrderDir
+from qlib.constant import ONE_MIN
+from qlib.rl.data.native import load_handler_intraday_processed_data
+from qlib.rl.interpreter import ActionInterpreter, StateInterpreter
+from qlib.rl.order_execution import SingleAssetOrderExecutionSimple
+from qlib.rl.reward import Reward
+from qlib.rl.trainer import Checkpoint, backtest, train
+from qlib.rl.trainer.callbacks import Callback, EarlyStopping, MetricsWriter
+from qlib.rl.utils.log import CsvWriter
+from qlib.utils import init_instance_by_config
+from tianshou.policy import BasePolicy
+from torch.utils.data import Dataset
+
+
+def seed_everything(seed: int) -> None:
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+def _read_orders(order_dir: Path) -> pd.DataFrame:
+    if os.path.isfile(order_dir):
+        return pd.read_pickle(order_dir)
+    else:
+        orders = []
+        for file in order_dir.iterdir():
+            order_data = pd.read_pickle(file)
+            orders.append(order_data)
+        return pd.concat(orders)
+
+
+class LazyLoadDataset(Dataset):
+    def __init__(
+        self,
+        data_dir: str,
+        order_file_path: Path,
+        default_start_time_index: int,
+        default_end_time_index: int,
+    ) -> None:
+        self._default_start_time_index = default_start_time_index
+        self._default_end_time_index = default_end_time_index
+
+        self._order_df = _read_orders(order_file_path).reset_index()
+        self._ticks_index: Optional[pd.DatetimeIndex] = None
+        self._data_dir = Path(data_dir)
+
+    def __len__(self) -> int:
+        return len(self._order_df)
+
+    def __getitem__(self, index: int) -> Order:
+        row = self._order_df.iloc[index]
+        date = pd.Timestamp(str(row["date"]))
+
+        if self._ticks_index is None:
+            # TODO: We only load ticks index once based on the assumption that ticks index of different dates
+            # TODO: in one experiment are all the same. If that assumption is not hold, we need to load ticks index
+            # TODO: of all dates.
+
+            data = load_handler_intraday_processed_data(
+                data_dir=self._data_dir,
+                stock_id=row["instrument"],
+                date=date,
+                feature_columns_today=[],
+                feature_columns_yesterday=[],
+                backtest=True,
+                index_only=True,
+            )
+            self._ticks_index = [t - date for t in data.today.index]
+
+        order = Order(
+            stock_id=row["instrument"],
+            amount=row["amount"],
+            direction=OrderDir(int(row["order_type"])),
+            start_time=date + self._ticks_index[self._default_start_time_index],
+            end_time=date + self._ticks_index[self._default_end_time_index - 1] + ONE_MIN,
+        )
+
+        return order
+
+
+def train_and_test(
+    env_config: dict,
+    simulator_config: dict,
+    trainer_config: dict,
+    data_config: dict,
+    state_interpreter: StateInterpreter,
+    action_interpreter: ActionInterpreter,
+    policy: BasePolicy,
+    reward: Reward,
+    run_training: bool,
+    run_backtest: bool,
+) -> None:
+    order_root_path = Path(data_config["source"]["order_dir"])
+
+    data_granularity = simulator_config.get("data_granularity", 1)
+
+    def _simulator_factory_simple(order: Order) -> SingleAssetOrderExecutionSimple:
+        return SingleAssetOrderExecutionSimple(
+            order=order,
+            data_dir=data_config["source"]["feature_root_dir"],
+            feature_columns_today=data_config["source"]["feature_columns_today"],
+            feature_columns_yesterday=data_config["source"]["feature_columns_yesterday"],
+            data_granularity=data_granularity,
+            ticks_per_step=simulator_config["time_per_step"],
+            vol_threshold=simulator_config["vol_limit"],
+        )
+
+    assert data_config["source"]["default_start_time_index"] % data_granularity == 0
+    assert data_config["source"]["default_end_time_index"] % data_granularity == 0
+
+    if run_training:
+        train_dataset, valid_dataset = [
+            LazyLoadDataset(
+                data_dir=data_config["source"]["feature_root_dir"],
+                order_file_path=order_root_path / tag,
+                default_start_time_index=data_config["source"]["default_start_time_index"] // data_granularity,
+                default_end_time_index=data_config["source"]["default_end_time_index"] // data_granularity,
+            )
+            for tag in ("train", "valid")
+        ]
+
+        callbacks: List[Callback] = []
+        if "checkpoint_path" in trainer_config:
+            callbacks.append(MetricsWriter(dirpath=Path(trainer_config["checkpoint_path"])))
+            callbacks.append(
+                Checkpoint(
+                    dirpath=Path(trainer_config["checkpoint_path"]) / "checkpoints",
+                    every_n_iters=trainer_config.get("checkpoint_every_n_iters", 1),
+                    save_latest="copy",
+                ),
+            )
+        if "earlystop_patience" in trainer_config:
+            callbacks.append(
+                EarlyStopping(
+                    patience=trainer_config["earlystop_patience"],
+                    monitor="val/pa",
+                )
+            )
+
+        train(
+            simulator_fn=_simulator_factory_simple,
+            state_interpreter=state_interpreter,
+            action_interpreter=action_interpreter,
+            policy=policy,
+            reward=reward,
+            initial_states=cast(List[Order], train_dataset),
+            trainer_kwargs={
+                "max_iters": trainer_config["max_epoch"],
+                "finite_env_type": env_config["parallel_mode"],
+                "concurrency": env_config["concurrency"],
+                "val_every_n_iters": trainer_config.get("val_every_n_epoch", None),
+                "callbacks": callbacks,
+            },
+            vessel_kwargs={
+                "episode_per_iter": trainer_config["episode_per_collect"],
+                "update_kwargs": {
+                    "batch_size": trainer_config["batch_size"],
+                    "repeat": trainer_config["repeat_per_collect"],
+                },
+                "val_initial_states": valid_dataset,
+            },
+        )
+
+    if run_backtest:
+        test_dataset = LazyLoadDataset(
+            data_dir=data_config["source"]["feature_root_dir"],
+            order_file_path=order_root_path / "test",
+            default_start_time_index=data_config["source"]["default_start_time_index"] // data_granularity,
+            default_end_time_index=data_config["source"]["default_end_time_index"] // data_granularity,
+        )
+
+        backtest(
+            simulator_fn=_simulator_factory_simple,
+            state_interpreter=state_interpreter,
+            action_interpreter=action_interpreter,
+            initial_states=test_dataset,
+            policy=policy,
+            logger=CsvWriter(Path(trainer_config["checkpoint_path"])),
+            reward=reward,
+            finite_env_type=env_config["parallel_mode"],
+            concurrency=env_config["concurrency"],
+        )
+
+
+def main(config: dict, run_training: bool, run_backtest: bool) -> None:
+    if not run_training and not run_backtest:
+        warnings.warn("Skip the entire job since training and backtest are both skipped.")
+        return
+
+    if "seed" in config["runtime"]:
+        seed_everything(config["runtime"]["seed"])
+
+    for extra_module_path in config["env"].get("extra_module_paths", []):
+        sys.path.append(extra_module_path)
+
+    state_interpreter: StateInterpreter = init_instance_by_config(config["state_interpreter"])
+    action_interpreter: ActionInterpreter = init_instance_by_config(config["action_interpreter"])
+    reward: Reward = init_instance_by_config(config["reward"])
+
+    additional_policy_kwargs = {
+        "obs_space": state_interpreter.observation_space,
+        "action_space": action_interpreter.action_space,
+    }
+
+    # Create torch network
+    if "network" in config:
+        if "kwargs" not in config["network"]:
+            config["network"]["kwargs"] = {}
+        config["network"]["kwargs"].update({"obs_space": state_interpreter.observation_space})
+        additional_policy_kwargs["network"] = init_instance_by_config(config["network"])
+
+    # Create policy
+    if "kwargs" not in config["policy"]:
+        config["policy"]["kwargs"] = {}
+    config["policy"]["kwargs"].update(additional_policy_kwargs)
+    policy: BasePolicy = init_instance_by_config(config["policy"])
+
+    use_cuda = config["runtime"].get("use_cuda", False)
+    if use_cuda:
+        policy.cuda()
+
+    train_and_test(
+        env_config=config["env"],
+        simulator_config=config["simulator"],
+        data_config=config["data"],
+        trainer_config=config["trainer"],
+        action_interpreter=action_interpreter,
+        state_interpreter=state_interpreter,
+        policy=policy,
+        reward=reward,
+        run_training=run_training,
+        run_backtest=run_backtest,
+    )
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+    warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config_path", type=str, required=True, help="Path to the config file")
+    parser.add_argument("--no_training", action="store_true", help="Skip training workflow.")
+    parser.add_argument("--run_backtest", action="store_true", help="Run backtest workflow.")
+    args = parser.parse_args()
+
+    with open(args.config_path, "r") as input_stream:
+        yaml = YAML(typ="safe", pure=True)
+        config = yaml.load(input_stream)
+
+    main(config, run_training=not args.no_training, run_backtest=args.run_backtest)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/contrib/utils.py

@@ -0,0 +1,29 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+
+
+def read_order_file(order_file: Path | pd.DataFrame) -> pd.DataFrame:
+    if isinstance(order_file, pd.DataFrame):
+        return order_file
+
+    order_file = Path(order_file)
+
+    if order_file.suffix == ".pkl":
+        order_df = pd.read_pickle(order_file).reset_index()
+    elif order_file.suffix == ".csv":
+        order_df = pd.read_csv(order_file)
+    else:
+        raise TypeError(f"Unsupported order file type: {order_file}")
+
+    if "date" in order_df.columns:
+        # legacy dataframe columns
+        order_df = order_df.rename(columns={"date": "datetime", "order_type": "direction"})
+    order_df["datetime"] = order_df["datetime"].astype(str)
+
+    return order_df

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/data/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Common utilities to handle ad-hoc-styled data.
+
+Most of these snippets comes from research project (paper code).
+Please take caution when using them in production.
+"""

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/data/base.py

@@ -0,0 +1,65 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+from abc import abstractmethod
+
+import pandas as pd
+
+
+class BaseIntradayBacktestData:
+    """
+    Raw market data that is often used in backtesting (thus called BacktestData).
+
+    Base class for all types of backtest data. Currently, each type of simulator has its corresponding backtest
+    data type.
+    """
+
+    @abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_deal_price(self) -> pd.Series:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_volume(self) -> pd.Series:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_time_index(self) -> pd.DatetimeIndex:
+        raise NotImplementedError
+
+
+class BaseIntradayProcessedData:
+    """Processed market data after data cleanup and feature engineering.
+
+    It contains both processed data for "today" and "yesterday", as some algorithms
+    might use the market information of the previous day to assist decision making.
+    """
+
+    today: pd.DataFrame
+    """Processed data for "today".
+    Number of records must be ``time_length``, and columns must be ``feature_dim``."""
+
+    yesterday: pd.DataFrame
+    """Processed data for "yesterday".
+    Number of records must be ``time_length``, and columns must be ``feature_dim``."""
+
+
+class ProcessedDataProvider:
+    """Provider of processed data"""
+
+    def get_data(
+        self,
+        stock_id: str,
+        date: pd.Timestamp,
+        feature_dim: int,
+        time_index: pd.Index,
+    ) -> BaseIntradayProcessedData:
+        raise NotImplementedError

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/data/integration.py

@@ -0,0 +1,82 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+TODO: This file is used to integrate NeuTrader with Qlib to run the existing projects.
+TODO: The implementation here is kind of adhoc. It is better to design a more uniformed & general implementation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import qlib
+from qlib.constant import REG_CN
+from qlib.contrib.ops.high_freq import BFillNan, Cut, Date, DayCumsum, DayLast, FFillNan, IsInf, IsNull, Select
+
+
+def init_qlib(qlib_config: dict) -> None:
+    """Initialize necessary resource to launch the workflow, including data direction, feature columns, etc..
+
+    Parameters
+    ----------
+    qlib_config:
+        Qlib configuration.
+
+        Example::
+
+            {
+                "provider_uri_day": DATA_ROOT_DIR / "qlib_1d",
+                "provider_uri_1min": DATA_ROOT_DIR / "qlib_1min",
+                "feature_root_dir": DATA_ROOT_DIR / "qlib_handler_stock",
+                "feature_columns_today": [
+                    "$open", "$high", "$low", "$close", "$vwap", "$bid", "$ask", "$volume",
+                    "$bidV", "$bidV1", "$bidV3", "$bidV5", "$askV", "$askV1", "$askV3", "$askV5",
+                ],
+                "feature_columns_yesterday": [
+                    "$open_1", "$high_1", "$low_1", "$close_1", "$vwap_1", "$bid_1", "$ask_1", "$volume_1",
+                    "$bidV_1", "$bidV1_1", "$bidV3_1", "$bidV5_1", "$askV_1", "$askV1_1", "$askV3_1", "$askV5_1",
+                ],
+            }
+    """
+
+    def _convert_to_path(path: str | Path) -> Path:
+        return path if isinstance(path, Path) else Path(path)
+
+    provider_uri_map = {}
+    for granularity in ["1min", "5min", "day"]:
+        if f"provider_uri_{granularity}" in qlib_config:
+            provider_uri_map[f"{granularity}"] = _convert_to_path(qlib_config[f"provider_uri_{granularity}"]).as_posix()
+
+    qlib.init(
+        region=REG_CN,
+        auto_mount=False,
+        custom_ops=[DayLast, FFillNan, BFillNan, Date, Select, IsNull, IsInf, Cut, DayCumsum],
+        expression_cache=None,
+        calendar_provider={
+            "class": "LocalCalendarProvider",
+            "module_path": "qlib.data.data",
+            "kwargs": {
+                "backend": {
+                    "class": "FileCalendarStorage",
+                    "module_path": "qlib.data.storage.file_storage",
+                    "kwargs": {"provider_uri_map": provider_uri_map},
+                },
+            },
+        },
+        feature_provider={
+            "class": "LocalFeatureProvider",
+            "module_path": "qlib.data.data",
+            "kwargs": {
+                "backend": {
+                    "class": "FileFeatureStorage",
+                    "module_path": "qlib.data.storage.file_storage",
+                    "kwargs": {"provider_uri_map": provider_uri_map},
+                },
+            },
+        },
+        provider_uri=provider_uri_map,
+        kernels=1,
+        redis_port=-1,
+        clear_mem_cache=False,  # init_qlib will be called for multiple times. Keep the cache for improving performance
+    )

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/data/native.py

@@ -0,0 +1,234 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List, cast
+
+import cachetools
+import pandas as pd
+
+from qlib.backtest import Exchange, Order
+from qlib.backtest.decision import TradeRange, TradeRangeByTime
+from qlib.constant import EPS_T
+from qlib.utils.pickle_utils import restricted_pickle_load
+
+from .base import BaseIntradayBacktestData, BaseIntradayProcessedData, ProcessedDataProvider
+
+
+def get_ticks_slice(
+    ticks_index: pd.DatetimeIndex,
+    start: pd.Timestamp,
+    end: pd.Timestamp,
+    include_end: bool = False,
+) -> pd.DatetimeIndex:
+    if not include_end:
+        end = end - EPS_T
+    return ticks_index[ticks_index.slice_indexer(start, end)]
+
+
+class IntradayBacktestData(BaseIntradayBacktestData):
+    """Backtest data for Qlib simulator"""
+
+    def __init__(
+        self,
+        order: Order,
+        exchange: Exchange,
+        ticks_index: pd.DatetimeIndex,
+        ticks_for_order: pd.DatetimeIndex,
+    ) -> None:
+        self._order = order
+        self._exchange = exchange
+        self._start_time = ticks_for_order[0]
+        self._end_time = ticks_for_order[-1]
+        self.ticks_index = ticks_index
+        self.ticks_for_order = ticks_for_order
+
+        self._deal_price = cast(
+            pd.Series,
+            self._exchange.get_deal_price(
+                self._order.stock_id,
+                self._start_time,
+                self._end_time,
+                direction=self._order.direction,
+                method=None,
+            ),
+        )
+        self._volume = cast(
+            pd.Series,
+            self._exchange.get_volume(
+                self._order.stock_id,
+                self._start_time,
+                self._end_time,
+                method=None,
+            ),
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"Order: {self._order}, Exchange: {self._exchange}, "
+            f"Start time: {self._start_time}, End time: {self._end_time}"
+        )
+
+    def __len__(self) -> int:
+        return len(self._deal_price)
+
+    def get_deal_price(self) -> pd.Series:
+        return self._deal_price
+
+    def get_volume(self) -> pd.Series:
+        return self._volume
+
+    def get_time_index(self) -> pd.DatetimeIndex:
+        return pd.DatetimeIndex([e[1] for e in list(self._exchange.quote_df.index)])
+
+
+class DataframeIntradayBacktestData(BaseIntradayBacktestData):
+    """Backtest data from dataframe"""
+
+    def __init__(self, df: pd.DataFrame, price_column: str = "$close0", volume_column: str = "$volume0") -> None:
+        self.df = df
+        self.price_column = price_column
+        self.volume_column = volume_column
+
+    def __repr__(self) -> str:
+        with pd.option_context("memory_usage", False, "display.max_info_columns", 1, "display.large_repr", "info"):
+            return f"{self.__class__.__name__}({self.df})"
+
+    def __len__(self) -> int:
+        return len(self.df)
+
+    def get_deal_price(self) -> pd.Series:
+        return self.df[self.price_column]
+
+    def get_volume(self) -> pd.Series:
+        return self.df[self.volume_column]
+
+    def get_time_index(self) -> pd.DatetimeIndex:
+        return cast(pd.DatetimeIndex, self.df.index)
+
+
+@cachetools.cached(  # type: ignore
+    cache=cachetools.LRUCache(100),
+    key=lambda order, _, __: order.key_by_day,
+)
+def load_backtest_data(
+    order: Order,
+    trade_exchange: Exchange,
+    trade_range: TradeRange,
+) -> IntradayBacktestData:
+    ticks_index = pd.DatetimeIndex(trade_exchange.quote_df.reset_index()["datetime"])
+    ticks_index = ticks_index[order.start_time <= ticks_index]
+    ticks_index = ticks_index[ticks_index <= order.end_time]
+
+    if isinstance(trade_range, TradeRangeByTime):
+        ticks_for_order = get_ticks_slice(
+            ticks_index,
+            trade_range.start_time,
+            trade_range.end_time,
+            include_end=True,
+        )
+    else:
+        ticks_for_order = None  # FIXME: implement this logic
+
+    backtest_data = IntradayBacktestData(
+        order=order,
+        exchange=trade_exchange,
+        ticks_index=ticks_index,
+        ticks_for_order=ticks_for_order,
+    )
+    return backtest_data
+
+
+class HandlerIntradayProcessedData(BaseIntradayProcessedData):
+    """Subclass of IntradayProcessedData. Used to handle handler (bin format) style data."""
+
+    def __init__(
+        self,
+        data_dir: Path,
+        stock_id: str,
+        date: pd.Timestamp,
+        feature_columns_today: List[str],
+        feature_columns_yesterday: List[str],
+        backtest: bool = False,
+        index_only: bool = False,
+    ) -> None:
+        def _drop_stock_id(df: pd.DataFrame) -> pd.DataFrame:
+            df = df.reset_index()
+            if "instrument" in df.columns:
+                df = df.drop(columns=["instrument"])
+            return df.set_index(["datetime"])
+
+        path = os.path.join(data_dir, "backtest" if backtest else "feature", f"{stock_id}.pkl")
+        start_time, end_time = date.replace(hour=0, minute=0, second=0), date.replace(hour=23, minute=59, second=59)
+        with open(path, "rb") as fstream:
+            dataset = restricted_pickle_load(fstream)
+        data = dataset.handler.fetch(pd.IndexSlice[stock_id, start_time:end_time], level=None)
+
+        if index_only:
+            self.today = _drop_stock_id(data[[]])
+            self.yesterday = _drop_stock_id(data[[]])
+        else:
+            self.today = _drop_stock_id(data[feature_columns_today])
+            self.yesterday = _drop_stock_id(data[feature_columns_yesterday])
+
+    def __repr__(self) -> str:
+        with pd.option_context("memory_usage", False, "display.max_info_columns", 1, "display.large_repr", "info"):
+            return f"{self.__class__.__name__}({self.today}, {self.yesterday})"
+
+
+@cachetools.cached(  # type: ignore
+    cache=cachetools.LRUCache(100),  # 100 * 50K = 5MB
+    key=lambda data_dir, stock_id, date, feature_columns_today, feature_columns_yesterday, backtest, index_only: (
+        stock_id,
+        date,
+        backtest,
+        index_only,
+    ),
+)
+def load_handler_intraday_processed_data(
+    data_dir: Path,
+    stock_id: str,
+    date: pd.Timestamp,
+    feature_columns_today: List[str],
+    feature_columns_yesterday: List[str],
+    backtest: bool = False,
+    index_only: bool = False,
+) -> HandlerIntradayProcessedData:
+    return HandlerIntradayProcessedData(
+        data_dir, stock_id, date, feature_columns_today, feature_columns_yesterday, backtest, index_only
+    )
+
+
+class HandlerProcessedDataProvider(ProcessedDataProvider):
+    def __init__(
+        self,
+        data_dir: str,
+        feature_columns_today: List[str],
+        feature_columns_yesterday: List[str],
+        backtest: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self.data_dir = Path(data_dir)
+        self.feature_columns_today = feature_columns_today
+        self.feature_columns_yesterday = feature_columns_yesterday
+        self.backtest = backtest
+
+    def get_data(
+        self,
+        stock_id: str,
+        date: pd.Timestamp,
+        feature_dim: int,
+        time_index: pd.Index,
+    ) -> BaseIntradayProcessedData:
+        return load_handler_intraday_processed_data(
+            self.data_dir,
+            stock_id,
+            date,
+            self.feature_columns_today,
+            self.feature_columns_yesterday,
+            backtest=self.backtest,
+            index_only=False,
+        )

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/data/pickle_styled.py

@@ -0,0 +1,296 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""This module contains utilities to read financial data from pickle-styled files.
+
+This is the format used in `OPD paper <https://seqml.github.io/opd/>`__. NOT the standard data format in qlib.
+
+The data here are all wrapped with ``@lru_cache``, which saves the expensive IO cost to repetitively read the data.
+We also encourage users to use ``get_xxx_yyy`` rather than ``XxxYyy`` (although they are the same thing),
+because ``get_xxx_yyy`` is cache-optimized.
+
+Note that these pickle files are dumped with Python 3.8. Python lower than 3.7 might not be able to load them.
+See `PEP 574 <https://peps.python.org/pep-0574/>`__ for details.
+
+This file shows resemblence to qlib.backtest.high_performance_ds. We might merge those two in future.
+"""
+
+# TODO: merge with qlib/backtest/high_performance_ds.py
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+from typing import List, Sequence, cast
+
+import cachetools
+import numpy as np
+import pandas as pd
+from cachetools.keys import hashkey
+
+from qlib.backtest.decision import Order, OrderDir
+from qlib.rl.data.base import BaseIntradayBacktestData, BaseIntradayProcessedData, ProcessedDataProvider
+from qlib.typehint import Literal
+
+DealPriceType = Literal["bid_or_ask", "bid_or_ask_fill", "close"]
+"""Several ad-hoc deal price.
+``bid_or_ask``: If sell, use column ``$bid0``; if buy, use column ``$ask0``.
+``bid_or_ask_fill``: Based on ``bid_or_ask``. If price is 0, use another price (``$ask0`` / ``$bid0``) instead.
+``close``: Use close price (``$close0``) as deal price.
+"""
+
+
+def _infer_processed_data_column_names(shape: int) -> List[str]:
+    if shape == 16:
+        return [
+            "$open",
+            "$high",
+            "$low",
+            "$close",
+            "$vwap",
+            "$bid",
+            "$ask",
+            "$volume",
+            "$bidV",
+            "$bidV1",
+            "$bidV3",
+            "$bidV5",
+            "$askV",
+            "$askV1",
+            "$askV3",
+            "$askV5",
+        ]
+    if shape == 6:
+        return ["$high", "$low", "$open", "$close", "$vwap", "$volume"]
+    elif shape == 5:
+        return ["$high", "$low", "$open", "$close", "$volume"]
+    raise ValueError(f"Unrecognized data shape: {shape}")
+
+
+def _find_pickle(filename_without_suffix: Path) -> Path:
+    suffix_list = [".pkl", ".pkl.backtest"]
+    paths: List[Path] = []
+    for suffix in suffix_list:
+        path = filename_without_suffix.parent / (filename_without_suffix.name + suffix)
+        if path.exists():
+            paths.append(path)
+    if not paths:
+        raise FileNotFoundError(f"No file starting with '{filename_without_suffix}' found")
+    if len(paths) > 1:
+        raise ValueError(f"Multiple paths are found with prefix '{filename_without_suffix}': {paths}")
+    return paths[0]
+
+
+@lru_cache(maxsize=10)  # 10 * 40M = 400MB
+def _read_pickle(filename_without_suffix: Path) -> pd.DataFrame:
+    df = pd.read_pickle(_find_pickle(filename_without_suffix))
+    index_cols = df.index.names
+
+    df = df.reset_index()
+    for date_col_name in ["date", "datetime"]:
+        if date_col_name in df:
+            df[date_col_name] = pd.to_datetime(df[date_col_name])
+    df = df.set_index(index_cols)
+
+    return df
+
+
+class SimpleIntradayBacktestData(BaseIntradayBacktestData):
+    """Backtest data for simple simulator"""
+
+    def __init__(
+        self,
+        data_dir: Path | str,
+        stock_id: str,
+        date: pd.Timestamp,
+        deal_price: DealPriceType = "close",
+        order_dir: int | None = None,
+    ) -> None:
+        super(SimpleIntradayBacktestData, self).__init__()
+
+        backtest = _read_pickle((data_dir if isinstance(data_dir, Path) else Path(data_dir)) / stock_id)
+        backtest = backtest.loc[pd.IndexSlice[stock_id, :, date]]
+
+        # No longer need for pandas >= 1.4
+        # backtest = backtest.droplevel([0, 2])
+
+        self.data: pd.DataFrame = backtest
+        self.deal_price_type: DealPriceType = deal_price
+        self.order_dir = order_dir
+
+    def __repr__(self) -> str:
+        with pd.option_context("memory_usage", False, "display.max_info_columns", 1, "display.large_repr", "info"):
+            return f"{self.__class__.__name__}({self.data})"
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def get_deal_price(self) -> pd.Series:
+        """Return a pandas series that can be indexed with time.
+        See :attribute:`DealPriceType` for details."""
+        if self.deal_price_type in ("bid_or_ask", "bid_or_ask_fill"):
+            if self.order_dir is None:
+                raise ValueError("Order direction cannot be none when deal_price_type is not close.")
+            if self.order_dir == OrderDir.SELL:
+                col = "$bid0"
+            else:  # BUY
+                col = "$ask0"
+        elif self.deal_price_type == "close":
+            col = "$close0"
+        else:
+            raise ValueError(f"Unsupported deal_price_type: {self.deal_price_type}")
+        price = self.data[col]
+
+        if self.deal_price_type == "bid_or_ask_fill":
+            if self.order_dir == OrderDir.SELL:
+                fill_col = "$ask0"
+            else:
+                fill_col = "$bid0"
+            price = price.replace(0, np.nan).fillna(self.data[fill_col])
+
+        return price
+
+    def get_volume(self) -> pd.Series:
+        """Return a volume series that can be indexed with time."""
+        return self.data["$volume0"]
+
+    def get_time_index(self) -> pd.DatetimeIndex:
+        return cast(pd.DatetimeIndex, self.data.index)
+
+
+class PickleIntradayProcessedData(BaseIntradayProcessedData):
+    """Subclass of IntradayProcessedData. Used to handle pickle-styled data."""
+
+    def __init__(
+        self,
+        data_dir: Path | str,
+        stock_id: str,
+        date: pd.Timestamp,
+        feature_dim: int,
+        time_index: pd.Index,
+    ) -> None:
+        proc = _read_pickle((data_dir if isinstance(data_dir, Path) else Path(data_dir)) / stock_id)
+
+        # We have to infer the names here because,
+        # unfortunately they are not included in the original data.
+        cnames = _infer_processed_data_column_names(feature_dim)
+
+        time_length: int = len(time_index)
+
+        try:
+            # new data format
+            proc = proc.loc[pd.IndexSlice[stock_id, :, date]]
+            assert len(proc) == time_length and len(proc.columns) == feature_dim * 2
+            proc_today = proc[cnames]
+            proc_yesterday = proc[[f"{c}_1" for c in cnames]].rename(columns=lambda c: c[:-2])
+        except (IndexError, KeyError):
+            # legacy data
+            proc = proc.loc[pd.IndexSlice[stock_id, date]]
+            assert time_length * feature_dim * 2 == len(proc)
+            proc_today = proc.to_numpy()[: time_length * feature_dim].reshape((time_length, feature_dim))
+            proc_yesterday = proc.to_numpy()[time_length * feature_dim :].reshape((time_length, feature_dim))
+            proc_today = pd.DataFrame(proc_today, index=time_index, columns=cnames)
+            proc_yesterday = pd.DataFrame(proc_yesterday, index=time_index, columns=cnames)
+
+        self.today: pd.DataFrame = proc_today
+        self.yesterday: pd.DataFrame = proc_yesterday
+        assert len(self.today.columns) == len(self.yesterday.columns) == feature_dim
+        assert len(self.today) == len(self.yesterday) == time_length
+
+    def __repr__(self) -> str:
+        with pd.option_context("memory_usage", False, "display.max_info_columns", 1, "display.large_repr", "info"):
+            return f"{self.__class__.__name__}({self.today}, {self.yesterday})"
+
+
+@lru_cache(maxsize=100)  # 100 * 50K = 5MB
+def load_simple_intraday_backtest_data(
+    data_dir: Path,
+    stock_id: str,
+    date: pd.Timestamp,
+    deal_price: DealPriceType = "close",
+    order_dir: int | None = None,
+) -> SimpleIntradayBacktestData:
+    return SimpleIntradayBacktestData(data_dir, stock_id, date, deal_price, order_dir)
+
+
+@cachetools.cached(  # type: ignore
+    cache=cachetools.LRUCache(100),  # 100 * 50K = 5MB
+    key=lambda data_dir, stock_id, date, feature_dim, time_index: hashkey(data_dir, stock_id, date),
+)
+def load_pickle_intraday_processed_data(
+    data_dir: Path,
+    stock_id: str,
+    date: pd.Timestamp,
+    feature_dim: int,
+    time_index: pd.Index,
+) -> BaseIntradayProcessedData:
+    return PickleIntradayProcessedData(data_dir, stock_id, date, feature_dim, time_index)
+
+
+class PickleProcessedDataProvider(ProcessedDataProvider):
+    def __init__(self, data_dir: Path) -> None:
+        super().__init__()
+
+        self._data_dir = data_dir
+
+    def get_data(
+        self,
+        stock_id: str,
+        date: pd.Timestamp,
+        feature_dim: int,
+        time_index: pd.Index,
+    ) -> BaseIntradayProcessedData:
+        return load_pickle_intraday_processed_data(
+            data_dir=self._data_dir,
+            stock_id=stock_id,
+            date=date,
+            feature_dim=feature_dim,
+            time_index=time_index,
+        )
+
+
+def load_orders(
+    order_path: Path,
+    start_time: pd.Timestamp = None,
+    end_time: pd.Timestamp = None,
+) -> Sequence[Order]:
+    """Load orders, and set start time and end time for the orders."""
+
+    start_time = start_time or pd.Timestamp("0:00:00")
+    end_time = end_time or pd.Timestamp("23:59:59")
+
+    if order_path.is_file():
+        order_df = pd.read_pickle(order_path)
+    else:
+        order_df = []
+        for file in order_path.iterdir():
+            order_data = pd.read_pickle(file)
+            order_df.append(order_data)
+        order_df = pd.concat(order_df)
+
+    order_df = order_df.reset_index()
+
+    # Legacy-style orders have "date" instead of "datetime"
+    if "date" in order_df.columns:
+        order_df = order_df.rename(columns={"date": "datetime"})
+
+    # Sometimes "date" are str rather than Timestamp
+    order_df["datetime"] = pd.to_datetime(order_df["datetime"])
+
+    orders: List[Order] = []
+
+    for _, row in order_df.iterrows():
+        # filter out orders with amount == 0
+        if row["amount"] <= 0:
+            continue
+        orders.append(
+            Order(
+                row["instrument"],
+                row["amount"],
+                OrderDir(int(row["order_type"])),
+                row["datetime"].replace(hour=start_time.hour, minute=start_time.minute, second=start_time.second),
+                row["datetime"].replace(hour=end_time.hour, minute=end_time.minute, second=end_time.second),
+            ),
+        )
+
+    return orders

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/interpreter.py

@@ -0,0 +1,141 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar
+
+import gym
+import numpy as np
+from gym import spaces
+
+from qlib.typehint import final
+from .simulator import ActType, StateType
+
+ObsType = TypeVar("ObsType")
+PolicyActType = TypeVar("PolicyActType")
+
+
+class Interpreter:
+    """Interpreter is a media between states produced by simulators and states needed by RL policies.
+    Interpreters are two-way:
+
+    1. From simulator state to policy state (aka observation), see :class:`StateInterpreter`.
+    2. From policy action to action accepted by simulator, see :class:`ActionInterpreter`.
+
+    Inherit one of the two sub-classes to define your own interpreter.
+    This super-class is only used for isinstance check.
+
+    Interpreters are recommended to be stateless, meaning that storing temporary information with ``self.xxx``
+    in interpreter is anti-pattern. In future, we might support register some interpreter-related
+    states by calling ``self.env.register_state()``, but it's not planned for first iteration.
+    """
+
+
+class StateInterpreter(Generic[StateType, ObsType], Interpreter):
+    """State Interpreter that interpret execution result of qlib executor into rl env state"""
+
+    @property
+    def observation_space(self) -> gym.Space:
+        raise NotImplementedError()
+
+    @final  # no overridden
+    def __call__(self, simulator_state: StateType) -> ObsType:
+        obs = self.interpret(simulator_state)
+        self.validate(obs)
+        return obs
+
+    def validate(self, obs: ObsType) -> None:
+        """Validate whether an observation belongs to the pre-defined observation space."""
+        _gym_space_contains(self.observation_space, obs)
+
+    def interpret(self, simulator_state: StateType) -> ObsType:
+        """Interpret the state of simulator.
+
+        Parameters
+        ----------
+        simulator_state
+            Retrieved with ``simulator.get_state()``.
+
+        Returns
+        -------
+        State needed by policy. Should conform with the state space defined in ``observation_space``.
+        """
+        raise NotImplementedError("interpret is not implemented!")
+
+
+class ActionInterpreter(Generic[StateType, PolicyActType, ActType], Interpreter):
+    """Action Interpreter that interpret rl agent action into qlib orders"""
+
+    @property
+    def action_space(self) -> gym.Space:
+        raise NotImplementedError()
+
+    @final  # no overridden
+    def __call__(self, simulator_state: StateType, action: PolicyActType) -> ActType:
+        self.validate(action)
+        obs = self.interpret(simulator_state, action)
+        return obs
+
+    def validate(self, action: PolicyActType) -> None:
+        """Validate whether an action belongs to the pre-defined action space."""
+        _gym_space_contains(self.action_space, action)
+
+    def interpret(self, simulator_state: StateType, action: PolicyActType) -> ActType:
+        """Convert the policy action to simulator action.
+
+        Parameters
+        ----------
+        simulator_state
+            Retrieved with ``simulator.get_state()``.
+        action
+            Raw action given by policy.
+
+        Returns
+        -------
+        The action needed by simulator,
+        """
+        raise NotImplementedError("interpret is not implemented!")
+
+
+def _gym_space_contains(space: gym.Space, x: Any) -> None:
+    """Strengthened version of gym.Space.contains.
+    Giving more diagnostic information on why validation fails.
+
+    Throw exception rather than returning true or false.
+    """
+    if isinstance(space, spaces.Dict):
+        if not isinstance(x, dict) or len(x) != len(space):
+            raise GymSpaceValidationError("Sample must be a dict with same length as space.", space, x)
+        for k, subspace in space.spaces.items():
+            if k not in x:
+                raise GymSpaceValidationError(f"Key {k} not found in sample.", space, x)
+            try:
+                _gym_space_contains(subspace, x[k])
+            except GymSpaceValidationError as e:
+                raise GymSpaceValidationError(f"Subspace of key {k} validation error.", space, x) from e
+
+    elif isinstance(space, spaces.Tuple):
+        if isinstance(x, (list, np.ndarray)):
+            x = tuple(x)  # Promote list and ndarray to tuple for contains check
+        if not isinstance(x, tuple) or len(x) != len(space):
+            raise GymSpaceValidationError("Sample must be a tuple with same length as space.", space, x)
+        for i, (subspace, part) in enumerate(zip(space, x)):
+            try:
+                _gym_space_contains(subspace, part)
+            except GymSpaceValidationError as e:
+                raise GymSpaceValidationError(f"Subspace of index {i} validation error.", space, x) from e
+
+    else:
+        if not space.contains(x):
+            raise GymSpaceValidationError("Validation error reported by gym.", space, x)
+
+
+class GymSpaceValidationError(Exception):
+    def __init__(self, message: str, space: gym.Space, x: Any) -> None:
+        self.message = message
+        self.space = space
+        self.x = x
+
+    def __str__(self) -> str:
+        return f"{self.message}\n  Space: {self.space}\n  Sample: {self.x}"

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/__init__.py

@@ -0,0 +1,38 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+Currently it supports single-asset order execution.
+Multi-asset is on the way.
+"""
+
+from .interpreter import (
+    FullHistoryStateInterpreter,
+    CurrentStepStateInterpreter,
+    CategoricalActionInterpreter,
+    TwapRelativeActionInterpreter,
+)
+from .network import Recurrent
+from .policy import AllOne, PPO
+from .reward import PAPenaltyReward
+from .simulator_simple import SingleAssetOrderExecutionSimple
+from .state import SAOEMetrics, SAOEState
+from .strategy import SAOEStateAdapter, SAOEStrategy, ProxySAOEStrategy, SAOEIntStrategy
+
+__all__ = [
+    "FullHistoryStateInterpreter",
+    "CurrentStepStateInterpreter",
+    "CategoricalActionInterpreter",
+    "TwapRelativeActionInterpreter",
+    "Recurrent",
+    "AllOne",
+    "PPO",
+    "PAPenaltyReward",
+    "SingleAssetOrderExecutionSimple",
+    "SAOEStateAdapter",
+    "SAOEMetrics",
+    "SAOEState",
+    "SAOEStrategy",
+    "ProxySAOEStrategy",
+    "SAOEIntStrategy",
+]

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/interpreter.py

@@ -0,0 +1,257 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+import math
+from typing import Any, List, Optional, cast
+
+import numpy as np
+import pandas as pd
+from gym import spaces
+
+from qlib.constant import EPS
+from qlib.rl.data.base import ProcessedDataProvider
+from qlib.rl.interpreter import ActionInterpreter, StateInterpreter
+from qlib.rl.order_execution.state import SAOEState
+from qlib.typehint import TypedDict
+
+__all__ = [
+    "FullHistoryStateInterpreter",
+    "CurrentStepStateInterpreter",
+    "CategoricalActionInterpreter",
+    "TwapRelativeActionInterpreter",
+    "FullHistoryObs",
+]
+
+from qlib.utils import init_instance_by_config
+
+
+def canonicalize(value: int | float | np.ndarray | pd.DataFrame | dict) -> np.ndarray | dict:
+    """To 32-bit numeric types. Recursively."""
+    if isinstance(value, pd.DataFrame):
+        return value.to_numpy()
+    if isinstance(value, (float, np.floating)) or (isinstance(value, np.ndarray) and value.dtype.kind == "f"):
+        return np.array(value, dtype=np.float32)
+    elif isinstance(value, (int, bool, np.integer)) or (isinstance(value, np.ndarray) and value.dtype.kind == "i"):
+        return np.array(value, dtype=np.int32)
+    elif isinstance(value, dict):
+        return {k: canonicalize(v) for k, v in value.items()}
+    else:
+        return value
+
+
+class FullHistoryObs(TypedDict):
+    data_processed: Any
+    data_processed_prev: Any
+    acquiring: Any
+    cur_tick: Any
+    cur_step: Any
+    num_step: Any
+    target: Any
+    position: Any
+    position_history: Any
+
+
+class DummyStateInterpreter(StateInterpreter[SAOEState, dict]):
+    """Dummy interpreter for policies that do not need inputs (for example, AllOne)."""
+
+    def interpret(self, state: SAOEState) -> dict:
+        # TODO: A fake state, used to pass `check_nan_observation`. Find a better way in the future.
+        return {"DUMMY": _to_int32(1)}
+
+    @property
+    def observation_space(self) -> spaces.Dict:
+        return spaces.Dict({"DUMMY": spaces.Box(-np.inf, np.inf, shape=(), dtype=np.int32)})
+
+
+class FullHistoryStateInterpreter(StateInterpreter[SAOEState, FullHistoryObs]):
+    """The observation of all the history, including today (until this moment), and yesterday.
+
+    Parameters
+    ----------
+    max_step
+        Total number of steps (an upper-bound estimation). For example, 390min / 30min-per-step = 13 steps.
+    data_ticks
+        Equal to the total number of records. For example, in SAOE per minute,
+        the total ticks is the length of day in minutes.
+    data_dim
+        Number of dimensions in data.
+    processed_data_provider
+        Provider of the processed data.
+    """
+
+    def __init__(
+        self,
+        max_step: int,
+        data_ticks: int,
+        data_dim: int,
+        processed_data_provider: dict | ProcessedDataProvider,
+    ) -> None:
+        super().__init__()
+
+        self.max_step = max_step
+        self.data_ticks = data_ticks
+        self.data_dim = data_dim
+        self.processed_data_provider: ProcessedDataProvider = init_instance_by_config(
+            processed_data_provider,
+            accept_types=ProcessedDataProvider,
+        )
+
+    def interpret(self, state: SAOEState) -> FullHistoryObs:
+        processed = self.processed_data_provider.get_data(
+            stock_id=state.order.stock_id,
+            date=pd.Timestamp(state.order.start_time.date()),
+            feature_dim=self.data_dim,
+            time_index=state.ticks_index,
+        )
+
+        position_history = np.full(self.max_step + 1, 0.0, dtype=np.float32)
+        position_history[0] = state.order.amount
+        position_history[1 : len(state.history_steps) + 1] = state.history_steps["position"].to_numpy()
+
+        # The min, slice here are to make sure that indices fit into the range,
+        # even after the final step of the simulator (in the done step),
+        # to make network in policy happy.
+        return cast(
+            FullHistoryObs,
+            canonicalize(
+                {
+                    "data_processed": np.array(self._mask_future_info(processed.today, state.cur_time)),
+                    "data_processed_prev": np.array(processed.yesterday),
+                    "acquiring": _to_int32(state.order.direction == state.order.BUY),
+                    "cur_tick": _to_int32(min(int(np.sum(state.ticks_index < state.cur_time)), self.data_ticks - 1)),
+                    "cur_step": _to_int32(min(state.cur_step, self.max_step - 1)),
+                    "num_step": _to_int32(self.max_step),
+                    "target": _to_float32(state.order.amount),
+                    "position": _to_float32(state.position),
+                    "position_history": _to_float32(position_history[: self.max_step]),
+                },
+            ),
+        )
+
+    @property
+    def observation_space(self) -> spaces.Dict:
+        space = {
+            "data_processed": spaces.Box(-np.inf, np.inf, shape=(self.data_ticks, self.data_dim)),
+            "data_processed_prev": spaces.Box(-np.inf, np.inf, shape=(self.data_ticks, self.data_dim)),
+            "acquiring": spaces.Discrete(2),
+            "cur_tick": spaces.Box(0, self.data_ticks - 1, shape=(), dtype=np.int32),
+            "cur_step": spaces.Box(0, self.max_step - 1, shape=(), dtype=np.int32),
+            # TODO: support arbitrary length index
+            "num_step": spaces.Box(self.max_step, self.max_step, shape=(), dtype=np.int32),
+            "target": spaces.Box(-EPS, np.inf, shape=()),
+            "position": spaces.Box(-EPS, np.inf, shape=()),
+            "position_history": spaces.Box(-EPS, np.inf, shape=(self.max_step,)),
+        }
+        return spaces.Dict(space)
+
+    @staticmethod
+    def _mask_future_info(arr: pd.DataFrame, current: pd.Timestamp) -> pd.DataFrame:
+        arr = arr.copy(deep=True)
+        arr.loc[current:] = 0.0  # mask out data after this moment (inclusive)
+        return arr
+
+
+class CurrentStateObs(TypedDict):
+    acquiring: bool
+    cur_step: int
+    num_step: int
+    target: float
+    position: float
+
+
+class CurrentStepStateInterpreter(StateInterpreter[SAOEState, CurrentStateObs]):
+    """The observation of current step.
+
+    Used when policy only depends on the latest state, but not history.
+    The key list is not full. You can add more if more information is needed by your policy.
+    """
+
+    def __init__(self, max_step: int) -> None:
+        super().__init__()
+
+        self.max_step = max_step
+
+    @property
+    def observation_space(self) -> spaces.Dict:
+        space = {
+            "acquiring": spaces.Discrete(2),
+            "cur_step": spaces.Box(0, self.max_step - 1, shape=(), dtype=np.int32),
+            "num_step": spaces.Box(self.max_step, self.max_step, shape=(), dtype=np.int32),
+            "target": spaces.Box(-EPS, np.inf, shape=()),
+            "position": spaces.Box(-EPS, np.inf, shape=()),
+        }
+        return spaces.Dict(space)
+
+    def interpret(self, state: SAOEState) -> CurrentStateObs:
+        assert state.cur_step <= self.max_step
+        obs = CurrentStateObs(
+            acquiring=state.order.direction == state.order.BUY,
+            cur_step=state.cur_step,
+            num_step=self.max_step,
+            target=state.order.amount,
+            position=state.position,
+        )
+        return obs
+
+
+class CategoricalActionInterpreter(ActionInterpreter[SAOEState, int, float]):
+    """Convert a discrete policy action to a continuous action, then multiplied by ``order.amount``.
+
+    Parameters
+    ----------
+    values
+        It can be a list of length $L$: $[a_1, a_2, \\ldots, a_L]$.
+        Then when policy givens decision $x$, $a_x$ times order amount is the output.
+        It can also be an integer $n$, in which case the list of length $n+1$ is auto-generated,
+        i.e., $[0, 1/n, 2/n, \\ldots, n/n]$.
+    max_step
+        Total number of steps (an upper-bound estimation). For example, 390min / 30min-per-step = 13 steps.
+    """
+
+    def __init__(self, values: int | List[float], max_step: Optional[int] = None) -> None:
+        super().__init__()
+
+        if isinstance(values, int):
+            values = [i / values for i in range(0, values + 1)]
+        self.action_values = values
+        self.max_step = max_step
+
+    @property
+    def action_space(self) -> spaces.Discrete:
+        return spaces.Discrete(len(self.action_values))
+
+    def interpret(self, state: SAOEState, action: int) -> float:
+        assert 0 <= action < len(self.action_values)
+        if self.max_step is not None and state.cur_step >= self.max_step - 1:
+            return state.position
+        else:
+            return min(state.position, state.order.amount * self.action_values[action])
+
+
+class TwapRelativeActionInterpreter(ActionInterpreter[SAOEState, float, float]):
+    """Convert a continuous ratio to deal amount.
+
+    The ratio is relative to TWAP on the remainder of the day.
+    For example, there are 5 steps left, and the left position is 300.
+    With TWAP strategy, in each position, 60 should be traded.
+    When this interpreter receives action $a$, its output is $60 \\cdot a$.
+    """
+
+    @property
+    def action_space(self) -> spaces.Box:
+        return spaces.Box(0, np.inf, shape=(), dtype=np.float32)
+
+    def interpret(self, state: SAOEState, action: float) -> float:
+        estimated_total_steps = math.ceil(len(state.ticks_for_order) / state.ticks_per_step)
+        twap_volume = state.position / (estimated_total_steps - state.cur_step)
+        return min(state.position, twap_volume * action)
+
+
+def _to_int32(val):
+    return np.array(int(val), dtype=np.int32)
+
+
+def _to_float32(val):
+    return np.array(val, dtype=np.float32)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/network.py

@@ -0,0 +1,140 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import List, Tuple, cast
+
+import torch
+import torch.nn as nn
+from tianshou.data import Batch
+
+from qlib.typehint import Literal
+
+from .interpreter import FullHistoryObs
+
+__all__ = ["Recurrent"]
+
+
+class Recurrent(nn.Module):
+    """The network architecture proposed in `OPD <https://seqml.github.io/opd/opd_aaai21_supplement.pdf>`_.
+
+    At every time step the input of policy network is divided into two parts,
+    the public variables and the private variables. which are handled by ``raw_rnn``
+    and ``pri_rnn`` in this network, respectively.
+
+    One minor difference is that, in this implementation, we don't assume the direction to be fixed.
+    Thus, another ``dire_fc`` is added to produce an extra direction-related feature.
+    """
+
+    def __init__(
+        self,
+        obs_space: FullHistoryObs,
+        hidden_dim: int = 64,
+        output_dim: int = 32,
+        rnn_type: Literal["rnn", "lstm", "gru"] = "gru",
+        rnn_num_layers: int = 1,
+    ) -> None:
+        super().__init__()
+
+        self.hidden_dim = hidden_dim
+        self.output_dim = output_dim
+        self.num_sources = 3
+
+        rnn_classes = {"rnn": nn.RNN, "lstm": nn.LSTM, "gru": nn.GRU}
+
+        self.rnn_class = rnn_classes[rnn_type]
+        self.rnn_layers = rnn_num_layers
+
+        self.raw_rnn = self.rnn_class(hidden_dim, hidden_dim, batch_first=True, num_layers=self.rnn_layers)
+        self.prev_rnn = self.rnn_class(hidden_dim, hidden_dim, batch_first=True, num_layers=self.rnn_layers)
+        self.pri_rnn = self.rnn_class(hidden_dim, hidden_dim, batch_first=True, num_layers=self.rnn_layers)
+
+        self.raw_fc = nn.Sequential(nn.Linear(obs_space["data_processed"].shape[-1], hidden_dim), nn.ReLU())
+        self.pri_fc = nn.Sequential(nn.Linear(2, hidden_dim), nn.ReLU())
+        self.dire_fc = nn.Sequential(nn.Linear(2, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU())
+
+        self._init_extra_branches()
+
+        self.fc = nn.Sequential(
+            nn.Linear(hidden_dim * self.num_sources, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, output_dim),
+            nn.ReLU(),
+        )
+
+    def _init_extra_branches(self) -> None:
+        pass
+
+    def _source_features(self, obs: FullHistoryObs, device: torch.device) -> Tuple[List[torch.Tensor], torch.Tensor]:
+        bs, _, data_dim = obs["data_processed"].size()
+        data = torch.cat((torch.zeros(bs, 1, data_dim, device=device), obs["data_processed"]), 1)
+        cur_step = obs["cur_step"].long()
+        cur_tick = obs["cur_tick"].long()
+        bs_indices = torch.arange(bs, device=device)
+
+        position = obs["position_history"] / obs["target"].unsqueeze(-1)  # [bs, num_step]
+        steps = (
+            torch.arange(position.size(-1), device=device).unsqueeze(0).repeat(bs, 1).float()
+            / obs["num_step"].unsqueeze(-1).float()
+        )  # [bs, num_step]
+        priv = torch.stack((position.float(), steps), -1)
+
+        data_in = self.raw_fc(data)
+        data_out, _ = self.raw_rnn(data_in)
+        # as it is padded with zero in front, this should be last minute
+        data_out_slice = data_out[bs_indices, cur_tick]
+
+        priv_in = self.pri_fc(priv)
+        priv_out = self.pri_rnn(priv_in)[0]
+        priv_out = priv_out[bs_indices, cur_step]
+
+        sources = [data_out_slice, priv_out]
+
+        dir_out = self.dire_fc(torch.stack((obs["acquiring"], 1 - obs["acquiring"]), -1).float())
+        sources.append(dir_out)
+
+        return sources, data_out
+
+    def forward(self, batch: Batch) -> torch.Tensor:
+        """
+        Input should be a dict (at least) containing:
+
+        - data_processed: [N, T, C]
+        - cur_step: [N]  (int)
+        - cur_time: [N]  (int)
+        - position_history: [N, S]  (S is number of steps)
+        - target: [N]
+        - num_step: [N]  (int)
+        - acquiring: [N]  (0 or 1)
+        """
+
+        inp = cast(FullHistoryObs, batch)
+        device = inp["data_processed"].device
+
+        sources, _ = self._source_features(inp, device)
+        assert len(sources) == self.num_sources
+
+        out = torch.cat(sources, -1)
+        return self.fc(out)
+
+
+class Attention(nn.Module):
+    def __init__(self, in_dim, out_dim):
+        super().__init__()
+        self.q_net = nn.Linear(in_dim, out_dim)
+        self.k_net = nn.Linear(in_dim, out_dim)
+        self.v_net = nn.Linear(in_dim, out_dim)
+
+    def forward(self, Q, K, V):
+        q = self.q_net(Q)
+        k = self.k_net(K)
+        v = self.v_net(V)
+
+        attn = torch.einsum("ijk,ilk->ijl", q, k)
+        attn = attn.to(Q.device)
+        attn_prob = torch.softmax(attn, dim=-1)
+
+        attn_vec = torch.einsum("ijk,ikl->ijl", attn_prob, v)
+
+        return attn_vec

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/policy.py

@@ -0,0 +1,237 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Generator, Iterable, Optional, OrderedDict, Tuple, cast
+
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+from gym.spaces import Discrete
+from tianshou.data import Batch, ReplayBuffer, to_torch
+from tianshou.policy import BasePolicy, PPOPolicy, DQNPolicy
+
+from qlib.rl.trainer.trainer import Trainer
+
+__all__ = ["AllOne", "PPO", "DQN"]
+
+
+# baselines #
+
+
+class NonLearnablePolicy(BasePolicy):
+    """Tianshou's BasePolicy with empty ``learn`` and ``process_fn``.
+
+    This could be moved outside in future.
+    """
+
+    def __init__(self, obs_space: gym.Space, action_space: gym.Space) -> None:
+        super().__init__()
+
+    def learn(self, batch: Batch, **kwargs: Any) -> Dict[str, Any]:
+        return {}
+
+    def process_fn(
+        self,
+        batch: Batch,
+        buffer: ReplayBuffer,
+        indices: np.ndarray,
+    ) -> Batch:
+        return Batch({})
+
+
+class AllOne(NonLearnablePolicy):
+    """Forward returns a batch full of 1.
+
+    Useful when implementing some baselines (e.g., TWAP).
+    """
+
+    def __init__(self, obs_space: gym.Space, action_space: gym.Space, fill_value: float | int = 1.0) -> None:
+        super().__init__(obs_space, action_space)
+
+        self.fill_value = fill_value
+
+    def forward(
+        self,
+        batch: Batch,
+        state: dict | Batch | np.ndarray = None,
+        **kwargs: Any,
+    ) -> Batch:
+        return Batch(act=np.full(len(batch), self.fill_value), state=state)
+
+
+# ppo #
+
+
+class PPOActor(nn.Module):
+    def __init__(self, extractor: nn.Module, action_dim: int) -> None:
+        super().__init__()
+        self.extractor = extractor
+        self.layer_out = nn.Sequential(nn.Linear(cast(int, extractor.output_dim), action_dim), nn.Softmax(dim=-1))
+
+    def forward(
+        self,
+        obs: torch.Tensor,
+        state: torch.Tensor = None,
+        info: dict = {},
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+        feature = self.extractor(to_torch(obs, device=auto_device(self)))
+        out = self.layer_out(feature)
+        return out, state
+
+
+class PPOCritic(nn.Module):
+    def __init__(self, extractor: nn.Module) -> None:
+        super().__init__()
+        self.extractor = extractor
+        self.value_out = nn.Linear(cast(int, extractor.output_dim), 1)
+
+    def forward(
+        self,
+        obs: torch.Tensor,
+        state: torch.Tensor = None,
+        info: dict = {},
+    ) -> torch.Tensor:
+        feature = self.extractor(to_torch(obs, device=auto_device(self)))
+        return self.value_out(feature).squeeze(dim=-1)
+
+
+class PPO(PPOPolicy):
+    """A wrapper of tianshou PPOPolicy.
+
+    Differences:
+
+    - Auto-create actor and critic network. Supports discrete action space only.
+    - Dedup common parameters between actor network and critic network
+      (not sure whether this is included in latest tianshou or not).
+    - Support a ``weight_file`` that supports loading checkpoint.
+    - Some parameters' default values are different from original.
+    """
+
+    def __init__(
+        self,
+        network: nn.Module,
+        obs_space: gym.Space,
+        action_space: gym.Space,
+        lr: float,
+        weight_decay: float = 0.0,
+        discount_factor: float = 1.0,
+        max_grad_norm: float = 100.0,
+        reward_normalization: bool = True,
+        eps_clip: float = 0.3,
+        value_clip: bool = True,
+        vf_coef: float = 1.0,
+        gae_lambda: float = 1.0,
+        max_batch_size: int = 256,
+        deterministic_eval: bool = True,
+        weight_file: Optional[Path] = None,
+    ) -> None:
+        assert isinstance(action_space, Discrete)
+        actor = PPOActor(network, action_space.n)
+        critic = PPOCritic(network)
+        optimizer = torch.optim.Adam(
+            chain_dedup(actor.parameters(), critic.parameters()),
+            lr=lr,
+            weight_decay=weight_decay,
+        )
+        super().__init__(
+            actor,
+            critic,
+            optimizer,
+            torch.distributions.Categorical,
+            discount_factor=discount_factor,
+            max_grad_norm=max_grad_norm,
+            reward_normalization=reward_normalization,
+            eps_clip=eps_clip,
+            value_clip=value_clip,
+            vf_coef=vf_coef,
+            gae_lambda=gae_lambda,
+            max_batchsize=max_batch_size,
+            deterministic_eval=deterministic_eval,
+            observation_space=obs_space,
+            action_space=action_space,
+        )
+        if weight_file is not None:
+            set_weight(self, Trainer.get_policy_state_dict(weight_file))
+
+
+DQNModel = PPOActor  # Reuse PPOActor.
+
+
+class DQN(DQNPolicy):
+    """A wrapper of tianshou DQNPolicy.
+
+    Differences:
+
+    - Auto-create model network. Supports discrete action space only.
+    - Support a ``weight_file`` that supports loading checkpoint.
+    """
+
+    def __init__(
+        self,
+        network: nn.Module,
+        obs_space: gym.Space,
+        action_space: gym.Space,
+        lr: float,
+        weight_decay: float = 0.0,
+        discount_factor: float = 0.99,
+        estimation_step: int = 1,
+        target_update_freq: int = 0,
+        reward_normalization: bool = False,
+        is_double: bool = True,
+        clip_loss_grad: bool = False,
+        weight_file: Optional[Path] = None,
+    ) -> None:
+        assert isinstance(action_space, Discrete)
+
+        model = DQNModel(network, action_space.n)
+        optimizer = torch.optim.Adam(
+            model.parameters(),
+            lr=lr,
+            weight_decay=weight_decay,
+        )
+
+        super().__init__(
+            model,
+            optimizer,
+            discount_factor=discount_factor,
+            estimation_step=estimation_step,
+            target_update_freq=target_update_freq,
+            reward_normalization=reward_normalization,
+            is_double=is_double,
+            clip_loss_grad=clip_loss_grad,
+        )
+        if weight_file is not None:
+            set_weight(self, Trainer.get_policy_state_dict(weight_file))
+
+
+# utilities: these should be put in a separate (common) file. #
+
+
+def auto_device(module: nn.Module) -> torch.device:
+    for param in module.parameters():
+        return param.device
+    return torch.device("cpu")  # fallback to cpu
+
+
+def set_weight(policy: nn.Module, loaded_weight: OrderedDict) -> None:
+    try:
+        policy.load_state_dict(loaded_weight)
+    except RuntimeError:
+        # try again by loading the converted weight
+        # https://github.com/thu-ml/tianshou/issues/468
+        for k in list(loaded_weight):
+            loaded_weight["_actor_critic." + k] = loaded_weight[k]
+        policy.load_state_dict(loaded_weight)
+
+
+def chain_dedup(*iterables: Iterable) -> Generator[Any, None, None]:
+    seen = set()
+    for iterable in iterables:
+        for i in iterable:
+            if i not in seen:
+                seen.add(i)
+                yield i

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/reward.py

@@ -0,0 +1,99 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import cast
+
+import numpy as np
+
+from qlib.backtest.decision import OrderDir
+from qlib.rl.order_execution.state import SAOEMetrics, SAOEState
+from qlib.rl.reward import Reward
+
+__all__ = ["PAPenaltyReward"]
+
+
+class PAPenaltyReward(Reward[SAOEState]):
+    """Encourage higher PAs, but penalize stacking all the amounts within a very short time.
+    Formally, for each time step, the reward is :math:`(PA_t * vol_t / target - vol_t^2 * penalty)`.
+
+    Parameters
+    ----------
+    penalty
+        The penalty for large volume in a short time.
+    scale
+        The weight used to scale up or down the reward.
+    """
+
+    def __init__(self, penalty: float = 100.0, scale: float = 1.0) -> None:
+        self.penalty = penalty
+        self.scale = scale
+
+    def reward(self, simulator_state: SAOEState) -> float:
+        whole_order = simulator_state.order.amount
+        assert whole_order > 0
+        last_step = cast(SAOEMetrics, simulator_state.history_steps.reset_index().iloc[-1].to_dict())
+        pa = last_step["pa"] * last_step["amount"] / whole_order
+
+        # Inspect the "break-down" of the latest step: trading amount at every tick
+        last_step_breakdown = simulator_state.history_exec.loc[last_step["datetime"] :]
+        penalty = -self.penalty * ((last_step_breakdown["amount"] / whole_order) ** 2).sum()
+
+        reward = pa + penalty
+
+        # Throw error in case of NaN
+        assert not (np.isnan(reward) or np.isinf(reward)), f"Invalid reward for simulator state: {simulator_state}"
+
+        self.log("reward/pa", pa)
+        self.log("reward/penalty", penalty)
+        return reward * self.scale
+
+
+class PPOReward(Reward[SAOEState]):
+    """Reward proposed by paper "An End-to-End Optimal Trade Execution Framework based on Proximal Policy Optimization".
+
+    Parameters
+    ----------
+    max_step
+        Maximum number of steps.
+    start_time_index
+        First time index that allowed to trade.
+    end_time_index
+        Last time index that allowed to trade.
+    """
+
+    def __init__(self, max_step: int, start_time_index: int = 0, end_time_index: int = 239) -> None:
+        self.max_step = max_step
+        self.start_time_index = start_time_index
+        self.end_time_index = end_time_index
+
+    def reward(self, simulator_state: SAOEState) -> float:
+        if simulator_state.cur_step == self.max_step - 1 or simulator_state.position < 1e-6:
+            if simulator_state.history_exec["deal_amount"].sum() == 0.0:
+                vwap_price = cast(
+                    float,
+                    np.average(simulator_state.history_exec["market_price"]),
+                )
+            else:
+                vwap_price = cast(
+                    float,
+                    np.average(
+                        simulator_state.history_exec["market_price"],
+                        weights=simulator_state.history_exec["deal_amount"],
+                    ),
+                )
+            twap_price = simulator_state.backtest_data.get_deal_price().mean()
+
+            if simulator_state.order.direction == OrderDir.SELL:
+                ratio = vwap_price / twap_price if twap_price != 0 else 1.0
+            else:
+                ratio = twap_price / vwap_price if vwap_price != 0 else 1.0
+            if ratio < 1.0:
+                return -1.0
+            elif ratio < 1.1:
+                return 0.0
+            else:
+                return 1.0
+        else:
+            return 0.0

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/simulator_qlib.py

@@ -0,0 +1,141 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import Generator, List, Optional
+
+import pandas as pd
+
+from qlib.backtest import collect_data_loop, get_strategy_executor
+from qlib.backtest.decision import BaseTradeDecision, Order, TradeRangeByTime
+from qlib.backtest.executor import NestedExecutor
+from qlib.rl.data.integration import init_qlib
+from qlib.rl.simulator import Simulator
+from .state import SAOEState
+from .strategy import SAOEStateAdapter, SAOEStrategy
+
+
+class SingleAssetOrderExecution(Simulator[Order, SAOEState, float]):
+    """Single-asset order execution (SAOE) simulator which is implemented based on Qlib backtest tools.
+
+    Parameters
+    ----------
+    order
+        The seed to start an SAOE simulator is an order.
+    executor_config
+        Executor configuration
+    exchange_config
+        Exchange configuration
+    qlib_config
+        Configuration used to initialize Qlib. If it is None, Qlib will not be initialized.
+    cash_limit:
+        Cash limit.
+    """
+
+    def __init__(
+        self,
+        order: Order,
+        executor_config: dict,
+        exchange_config: dict,
+        qlib_config: dict | None = None,
+        cash_limit: float | None = None,
+    ) -> None:
+        super().__init__(initial=order)
+
+        assert order.start_time.date() == order.end_time.date(), "Start date and end date must be the same."
+
+        strategy_config = {
+            "class": "SingleOrderStrategy",
+            "module_path": "qlib.rl.strategy.single_order",
+            "kwargs": {
+                "order": order,
+                "trade_range": TradeRangeByTime(order.start_time.time(), order.end_time.time()),
+            },
+        }
+
+        self._collect_data_loop: Optional[Generator] = None
+        self.reset(order, strategy_config, executor_config, exchange_config, qlib_config, cash_limit)
+
+    def reset(
+        self,
+        order: Order,
+        strategy_config: dict,
+        executor_config: dict,
+        exchange_config: dict,
+        qlib_config: dict | None = None,
+        cash_limit: Optional[float] = None,
+    ) -> None:
+        if qlib_config is not None:
+            init_qlib(qlib_config)
+
+        strategy, self._executor = get_strategy_executor(
+            start_time=order.date,
+            end_time=order.date + pd.DateOffset(1),
+            strategy=strategy_config,
+            executor=executor_config,
+            benchmark=order.stock_id,
+            account=cash_limit if cash_limit is not None else int(1e12),
+            exchange_kwargs=exchange_config,
+            pos_type="Position" if cash_limit is not None else "InfPosition",
+        )
+
+        assert isinstance(self._executor, NestedExecutor)
+
+        self.report_dict: dict = {}
+        self.decisions: List[BaseTradeDecision] = []
+        self._collect_data_loop = collect_data_loop(
+            start_time=order.date,
+            end_time=order.date,
+            trade_strategy=strategy,
+            trade_executor=self._executor,
+            return_value=self.report_dict,
+        )
+        assert isinstance(self._collect_data_loop, Generator)
+
+        self.step(action=None)
+
+        self._order = order
+
+    def _get_adapter(self) -> SAOEStateAdapter:
+        return self._last_yielded_saoe_strategy.adapter_dict[self._order.key_by_day]
+
+    @property
+    def twap_price(self) -> float:
+        return self._get_adapter().twap_price
+
+    def _iter_strategy(self, action: Optional[float] = None) -> SAOEStrategy:
+        """Iterate the _collect_data_loop until we get the next yield SAOEStrategy."""
+        assert self._collect_data_loop is not None
+
+        obj = next(self._collect_data_loop) if action is None else self._collect_data_loop.send(action)
+        while not isinstance(obj, SAOEStrategy):
+            if isinstance(obj, BaseTradeDecision):
+                self.decisions.append(obj)
+            obj = next(self._collect_data_loop) if action is None else self._collect_data_loop.send(action)
+        assert isinstance(obj, SAOEStrategy)
+        return obj
+
+    def step(self, action: Optional[float]) -> None:
+        """Execute one step or SAOE.
+
+        Parameters
+        ----------
+        action (float):
+            The amount you wish to deal. The simulator doesn't guarantee all the amount to be successfully dealt.
+        """
+
+        assert not self.done(), "Simulator has already done!"
+
+        try:
+            self._last_yielded_saoe_strategy = self._iter_strategy(action=action)
+        except StopIteration:
+            pass
+
+        assert self._executor is not None
+
+    def get_state(self) -> SAOEState:
+        return self._get_adapter().saoe_state
+
+    def done(self) -> bool:
+        return self._executor.finished()

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/simulator_simple.py

@@ -0,0 +1,362 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import Any, cast, List, Optional
+
+import numpy as np
+import pandas as pd
+
+from pathlib import Path
+from qlib.backtest.decision import Order, OrderDir
+from qlib.constant import EPS, EPS_T, float_or_ndarray
+from qlib.rl.data.base import BaseIntradayBacktestData
+from qlib.rl.data.native import DataframeIntradayBacktestData, load_handler_intraday_processed_data
+from qlib.rl.data.pickle_styled import load_simple_intraday_backtest_data
+from qlib.rl.simulator import Simulator
+from qlib.rl.utils import LogLevel
+from .state import SAOEMetrics, SAOEState
+
+__all__ = ["SingleAssetOrderExecutionSimple"]
+
+
+class SingleAssetOrderExecutionSimple(Simulator[Order, SAOEState, float]):
+    """Single-asset order execution (SAOE) simulator.
+
+    As there's no "calendar" in the simple simulator, ticks are used to trade.
+    A tick is a record (a line) in the pickle-styled data file.
+    Each tick is considered as a individual trading opportunity.
+    If such fine granularity is not needed, use ``ticks_per_step`` to
+    lengthen the ticks for each step.
+
+    In each step, the traded amount are "equally" separated to each tick,
+    then bounded by volume maximum execution volume (i.e., ``vol_threshold``),
+    and if it's the last step, try to ensure all the amount to be executed.
+
+    Parameters
+    ----------
+    order
+        The seed to start an SAOE simulator is an order.
+    data_dir
+        Path to load backtest data.
+    feature_columns_today
+        Columns of today's feature.
+    feature_columns_yesterday
+        Columns of yesterday's feature.
+    data_granularity
+        Number of ticks between consecutive data entries.
+    ticks_per_step
+        How many ticks per step.
+    vol_threshold
+        Maximum execution volume (divided by market execution volume).
+    """
+
+    history_exec: pd.DataFrame
+    """All execution history at every possible time ticks. See :class:`SAOEMetrics` for available columns.
+    Index is ``datetime``.
+    """
+
+    history_steps: pd.DataFrame
+    """Positions at each step. The position before first step is also recorded.
+    See :class:`SAOEMetrics` for available columns.
+    Index is ``datetime``, which is the **starting** time of each step."""
+
+    metrics: Optional[SAOEMetrics]
+    """Metrics. Only available when done."""
+
+    twap_price: float
+    """This price is used to compute price advantage.
+    It"s defined as the average price in the period from order"s start time to end time."""
+
+    ticks_index: pd.DatetimeIndex
+    """All available ticks for the day (not restricted to order)."""
+
+    ticks_for_order: pd.DatetimeIndex
+    """Ticks that is available for trading (sliced by order)."""
+
+    def __init__(
+        self,
+        order: Order,
+        data_dir: Path,
+        feature_columns_today: List[str] = [],
+        feature_columns_yesterday: List[str] = [],
+        data_granularity: int = 1,
+        ticks_per_step: int = 30,
+        vol_threshold: Optional[float] = None,
+    ) -> None:
+        super().__init__(initial=order)
+
+        assert ticks_per_step % data_granularity == 0
+
+        self.order = order
+        self.data_dir = data_dir
+        self.feature_columns_today = feature_columns_today
+        self.feature_columns_yesterday = feature_columns_yesterday
+        self.ticks_per_step: int = ticks_per_step // data_granularity
+        self.vol_threshold = vol_threshold
+
+        self.backtest_data = self.get_backtest_data()
+        self.ticks_index = self.backtest_data.get_time_index()
+
+        # Get time index available for trading
+        self.ticks_for_order = self._get_ticks_slice(self.order.start_time, self.order.end_time)
+
+        self.cur_time = self.ticks_for_order[0]
+        self.cur_step = 0
+        # NOTE: astype(float) is necessary in some systems.
+        # this will align the precision with `.to_numpy()` in `_split_exec_vol`
+        self.twap_price = float(self.backtest_data.get_deal_price().loc[self.ticks_for_order].astype(float).mean())
+
+        self.position = order.amount
+
+        metric_keys = list(SAOEMetrics.__annotations__.keys())  # pylint: disable=no-member
+        # NOTE: can empty dataframe contain index?
+        self.history_exec = pd.DataFrame(columns=metric_keys).set_index("datetime")
+        self.history_steps = pd.DataFrame(columns=metric_keys).set_index("datetime")
+        self.metrics = None
+
+        self.market_price: Optional[np.ndarray] = None
+        self.market_vol: Optional[np.ndarray] = None
+        self.market_vol_limit: Optional[np.ndarray] = None
+
+    def get_backtest_data(self) -> BaseIntradayBacktestData:
+        try:
+            data = load_handler_intraday_processed_data(
+                data_dir=self.data_dir,
+                stock_id=self.order.stock_id,
+                date=pd.Timestamp(self.order.start_time.date()),
+                feature_columns_today=self.feature_columns_today,
+                feature_columns_yesterday=self.feature_columns_yesterday,
+                backtest=True,
+                index_only=False,
+            )
+            return DataframeIntradayBacktestData(data.today)
+        except (AttributeError, FileNotFoundError):
+            # TODO: For compatibility with older versions of test scripts (tests/rl/test_saoe_simple.py)
+            # TODO: In the future, we should modify the data format used by the test script,
+            # TODO: and then delete this branch.
+            return load_simple_intraday_backtest_data(
+                self.data_dir / "backtest",
+                self.order.stock_id,
+                pd.Timestamp(self.order.start_time.date()),
+                "close",
+                self.order.direction,
+            )
+
+    def step(self, amount: float) -> None:
+        """Execute one step or SAOE.
+
+        Parameters
+        ----------
+        amount
+            The amount you wish to deal. The simulator doesn't guarantee all the amount to be successfully dealt.
+        """
+
+        assert not self.done()
+
+        self.market_price = self.market_vol = None  # avoid misuse
+        exec_vol = self._split_exec_vol(amount)
+        assert self.market_price is not None
+        assert self.market_vol is not None
+
+        ticks_position = self.position - np.cumsum(exec_vol)
+
+        self.position -= exec_vol.sum()
+        if abs(self.position) < 1e-6:
+            self.position = 0.0
+        if self.position < -EPS or (exec_vol < -EPS).any():
+            raise ValueError(f"Execution volume is invalid: {exec_vol} (position = {self.position})")
+
+        # Get time index available for this step
+        time_index = self._get_ticks_slice(self.cur_time, self._next_time())
+
+        self.history_exec = self._dataframe_append(
+            self.history_exec,
+            SAOEMetrics(
+                # It should have the same keys with SAOEMetrics,
+                # but the values do not necessarily have the annotated type.
+                # Some values could be vectorized (e.g., exec_vol).
+                stock_id=self.order.stock_id,
+                datetime=time_index,
+                direction=self.order.direction,
+                market_volume=self.market_vol,
+                market_price=self.market_price,
+                amount=exec_vol,
+                inner_amount=exec_vol,
+                deal_amount=exec_vol,
+                trade_price=self.market_price,
+                trade_value=self.market_price * exec_vol,
+                position=ticks_position,
+                ffr=exec_vol / self.order.amount,
+                pa=price_advantage(self.market_price, self.twap_price, self.order.direction),
+            ),
+        )
+
+        self.history_steps = self._dataframe_append(
+            self.history_steps,
+            [self._metrics_collect(self.cur_time, self.market_vol, self.market_price, amount, exec_vol)],
+        )
+
+        if self.done():
+            if self.env is not None:
+                self.env.logger.add_any("history_steps", self.history_steps, loglevel=LogLevel.DEBUG)
+                self.env.logger.add_any("history_exec", self.history_exec, loglevel=LogLevel.DEBUG)
+
+            self.metrics = self._metrics_collect(
+                self.ticks_index[0],  # start time
+                self.history_exec["market_volume"],
+                self.history_exec["market_price"],
+                self.history_steps["amount"].sum(),
+                self.history_exec["deal_amount"],
+            )
+
+            # NOTE (yuge): It looks to me that it's the "correct" decision to
+            # put all the logs here, because only components like simulators themselves
+            # have the knowledge about what could appear in the logs, and what's the format.
+            # But I admit it's not necessarily the most convenient way.
+            # I'll rethink about it when we have the second environment
+            # Maybe some APIs like self.logger.enable_auto_log() ?
+
+            if self.env is not None:
+                for key, value in self.metrics.items():
+                    if isinstance(value, float):
+                        self.env.logger.add_scalar(key, value)
+                    else:
+                        self.env.logger.add_any(key, value)
+
+        self.cur_time = self._next_time()
+        self.cur_step += 1
+
+    def get_state(self) -> SAOEState:
+        return SAOEState(
+            order=self.order,
+            cur_time=self.cur_time,
+            cur_step=self.cur_step,
+            position=self.position,
+            history_exec=self.history_exec,
+            history_steps=self.history_steps,
+            metrics=self.metrics,
+            backtest_data=self.backtest_data,
+            ticks_per_step=self.ticks_per_step,
+            ticks_index=self.ticks_index,
+            ticks_for_order=self.ticks_for_order,
+        )
+
+    def done(self) -> bool:
+        return self.position < EPS or self.cur_time >= self.order.end_time
+
+    def _next_time(self) -> pd.Timestamp:
+        """The "current time" (``cur_time``) for next step."""
+        # Look for next time on time index
+        current_loc = self.ticks_index.get_loc(self.cur_time)
+        next_loc = current_loc + self.ticks_per_step
+
+        # Calibrate the next location to multiple of ticks_per_step.
+        # This is to make sure that:
+        # as long as ticks_per_step is a multiple of something, each step won't cross morning and afternoon.
+        next_loc = next_loc - next_loc % self.ticks_per_step
+
+        if next_loc < len(self.ticks_index) and self.ticks_index[next_loc] < self.order.end_time:
+            return self.ticks_index[next_loc]
+        else:
+            return self.order.end_time
+
+    def _cur_duration(self) -> pd.Timedelta:
+        """The "duration" of this step (step that is about to happen)."""
+        return self._next_time() - self.cur_time
+
+    def _split_exec_vol(self, exec_vol_sum: float) -> np.ndarray:
+        """
+        Split the volume in each step into minutes, considering possible constraints.
+        This follows TWAP strategy.
+        """
+        next_time = self._next_time()
+
+        # get the backtest data for next interval
+        self.market_vol = self.backtest_data.get_volume().loc[self.cur_time : next_time - EPS_T].to_numpy()
+        self.market_price = self.backtest_data.get_deal_price().loc[self.cur_time : next_time - EPS_T].to_numpy()
+
+        assert self.market_vol is not None and self.market_price is not None
+
+        # split the volume equally into each minute
+        exec_vol = np.repeat(exec_vol_sum / len(self.market_price), len(self.market_price))
+
+        # apply the volume threshold
+        market_vol_limit = self.vol_threshold * self.market_vol if self.vol_threshold is not None else np.inf
+        exec_vol = np.minimum(exec_vol, market_vol_limit)  # type: ignore
+
+        # Complete all the order amount at the last moment.
+        if next_time >= self.order.end_time:
+            exec_vol[-1] += self.position - exec_vol.sum()
+            exec_vol = np.minimum(exec_vol, market_vol_limit)  # type: ignore
+
+        return exec_vol
+
+    def _metrics_collect(
+        self,
+        datetime: pd.Timestamp,
+        market_vol: np.ndarray,
+        market_price: np.ndarray,
+        amount: float,  # intended to trade such amount
+        exec_vol: np.ndarray,
+    ) -> SAOEMetrics:
+        assert len(market_vol) == len(market_price) == len(exec_vol)
+
+        if np.abs(np.sum(exec_vol)) < EPS:
+            exec_avg_price = 0.0
+        else:
+            exec_avg_price = cast(float, np.average(market_price, weights=exec_vol))  # could be nan
+            if hasattr(exec_avg_price, "item"):  # could be numpy scalar
+                exec_avg_price = exec_avg_price.item()  # type: ignore
+
+        return SAOEMetrics(
+            stock_id=self.order.stock_id,
+            datetime=datetime,
+            direction=self.order.direction,
+            market_volume=market_vol.sum(),
+            market_price=market_price.mean(),
+            amount=amount,
+            inner_amount=exec_vol.sum(),
+            deal_amount=exec_vol.sum(),  # in this simulator, there's no other restrictions
+            trade_price=exec_avg_price,
+            trade_value=float(np.sum(market_price * exec_vol)),
+            position=self.position,
+            ffr=float(exec_vol.sum() / self.order.amount),
+            pa=price_advantage(exec_avg_price, self.twap_price, self.order.direction),
+        )
+
+    def _get_ticks_slice(self, start: pd.Timestamp, end: pd.Timestamp, include_end: bool = False) -> pd.DatetimeIndex:
+        if not include_end:
+            end = end - EPS_T
+        return self.ticks_index[self.ticks_index.slice_indexer(start, end)]
+
+    @staticmethod
+    def _dataframe_append(df: pd.DataFrame, other: Any) -> pd.DataFrame:
+        # dataframe.append is deprecated
+        other_df = pd.DataFrame(other).set_index("datetime")
+        other_df.index.name = "datetime"
+        return pd.concat([df, other_df], axis=0)
+
+
+def price_advantage(
+    exec_price: float_or_ndarray,
+    baseline_price: float,
+    direction: OrderDir | int,
+) -> float_or_ndarray:
+    if baseline_price == 0:  # something is wrong with data. Should be nan here
+        if isinstance(exec_price, float):
+            return 0.0
+        else:
+            return np.zeros_like(exec_price)
+    if direction == OrderDir.BUY:
+        res = (1 - exec_price / baseline_price) * 10000
+    elif direction == OrderDir.SELL:
+        res = (exec_price / baseline_price - 1) * 10000
+    else:
+        raise ValueError(f"Unexpected order direction: {direction}")
+    res_wo_nan: np.ndarray = np.nan_to_num(res, nan=0.0)
+    if res_wo_nan.size == 1:
+        return res_wo_nan.item()
+    else:
+        return cast(float_or_ndarray, res_wo_nan)

Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/rl/order_execution/state.py

@@ -0,0 +1,101 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+import typing
+from typing import NamedTuple, Optional
+
+import numpy as np
+import pandas as pd
+from qlib.backtest import Order
+from qlib.typehint import TypedDict
+
+if typing.TYPE_CHECKING:
+    from qlib.rl.data.base import BaseIntradayBacktestData
+
+
+class SAOEMetrics(TypedDict):
+    """Metrics for SAOE accumulated for a "period".
+    It could be accumulated for a day, or a period of time (e.g., 30min), or calculated separately for every minute.
+
+    Warnings
+    --------
+    The type hints are for single elements. In lots of times, they can be vectorized.
+    For example, ``market_volume`` could be a list of float (or ndarray) rather tahn a single float.
+    """
+
+    stock_id: str
+    """Stock ID of this record."""
+    datetime: pd.Timestamp | pd.DatetimeIndex
+    """Datetime of this record (this is index in the dataframe)."""
+    direction: int
+    """Direction of the order. 0 for sell, 1 for buy."""
+
+    # Market information.
+    market_volume: np.ndarray | float
+    """(total) market volume traded in the period."""
+    market_price: np.ndarray | float
+    """Deal price. If it's a period of time, this is the average market deal price."""
+
+    # Strategy records.
+
+    amount: np.ndarray | float
+    """Total amount (volume) strategy intends to trade."""
+    inner_amount: np.ndarray | float
+    """Total amount that the lower-level strategy intends to trade
+    (might be larger than amount, e.g., to ensure ffr)."""
+
+    deal_amount: np.ndarray | float
+    """Amount that successfully takes effect (must be less than inner_amount)."""
+    trade_price: np.ndarray | float
+    """The average deal price for this strategy."""
+    trade_value: np.ndarray | float
+    """Total worth of trading. In the simple simulation, trade_value = deal_amount * price."""
+    position: np.ndarray | float
+    """Position left after this "period"."""
+
+    # Accumulated metrics
+
+    ffr: np.ndarray | float
+    """Completed how much percent of the daily order."""
+
+    pa: np.ndarray | float
+    """Price advantage compared to baseline (i.e., trade with baseline market price).
+    The baseline is trade price when using TWAP strategy to execute this order.
+    Please note that there could be data leak here).
+    Unit is BP (basis point, 1/10000)."""
+
+
+class SAOEState(NamedTuple):
+    """Data structure holding a state for SAOE simulator."""
+
+    order: Order
+    """The order we are dealing with."""
+    cur_time: pd.Timestamp
+    """Current time, e.g., 9:30."""
+    cur_step: int
+    """Current step, e.g., 0."""
+    position: float
+    """Current remaining volume to execute."""
+    history_exec: pd.DataFrame
+    """See :attr:`SingleAssetOrderExecution.history_exec`."""
+    history_steps: pd.DataFrame
+    """See :attr:`SingleAssetOrderExecution.history_steps`."""
+
+    metrics: Optional[SAOEMetrics]
+    """Daily metric, only available when the trading is in "done" state."""
+
+    backtest_data: BaseIntradayBacktestData
+    """Backtest data is included in the state.
+    Actually, only the time index of this data is needed, at this moment.
+    I include the full data so that algorithms (e.g., VWAP) that relies on the raw data can be implemented.
+    Interpreter can use this as they wish, but they should be careful not to leak future data.
+    """
+
+    ticks_per_step: int
+    """How many ticks for each step."""
+    ticks_index: pd.DatetimeIndex
+    """Trading ticks in all day, NOT sliced by order (defined in data). e.g., [9:30, 9:31, ..., 14:59]."""
+    ticks_for_order: pd.DatetimeIndex
+    """Trading ticks sliced by order, e.g., [9:45, 9:46, ..., 14:44]."""