Upload folder using huggingface_hub (part 3)

.gitattributes

@@ -62,3 +62,7 @@ Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/_libs/expanding.cpython
 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/temp.linux-x86_64-cpython-313/qlib/data/_libs/expanding.o filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/temp.linux-x86_64-cpython-313/qlib/data/_libs/rolling.o filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/temp.linux-x86_64-cpython-39/qlib/data/_libs/expanding.o filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/temp.linux-x86_64-cpython-39/qlib/data/_libs/rolling.o filter=lfs diff=lfs merge=lfs -text

Kronos/qlib/CHANGES.rst

@@ -0,0 +1,179 @@
+Changelog
+=========
+Here you can see the full list of changes between each QLib release.
+
+Version 0.1.0
+-------------
+This is the initial release of QLib library.
+
+Version 0.1.1
+-------------
+Performance optimize. Add more features and operators.
+
+Version 0.1.2
+-------------
+- Support operator syntax. Now ``High() - Low()`` is equivalent to ``Sub(High(), Low())``.
+- Add more technical indicators.
+
+Version 0.1.3
+-------------
+Bug fix and add instruments filtering mechanism.
+
+Version 0.2.0
+-------------
+- Redesign ``LocalProvider`` database format for performance improvement.
+- Support load features as string fields.
+- Add scripts for database construction.
+- More operators and technical indicators.
+
+Version 0.2.1
+-------------
+- Support registering user-defined ``Provider``.
+- Support use operators in string format, e.g. ``['Ref($close, 1)']`` is valid field format.
+- Support dynamic fields in ``$some_field`` format. And existing fields like ``Close()`` may be deprecated in the future.
+
+Version 0.2.2
+-------------
+- Add ``disk_cache`` for reusing features (enabled by default).
+- Add ``qlib.contrib`` for experimental model construction and evaluation.
+
+
+Version 0.2.3
+-------------
+- Add ``backtest`` module
+- Decoupling the Strategy, Account, Position, Exchange from the backtest module
+
+Version 0.2.4
+-------------
+- Add ``profit attribution`` module
+- Add ``rick_control`` and ``cost_control`` strategies
+
+Version 0.3.0
+-------------
+- Add ``estimator`` module
+
+Version 0.3.1
+-------------
+- Add ``filter`` module
+
+Version 0.3.2
+-------------
+- Add real price trading, if the ``factor`` field in the data set is incomplete, use ``adj_price`` trading
+- Refactor ``handler`` ``launcher`` ``trainer`` code
+- Support ``backtest`` configuration parameters in the configuration file
+- Fix bug in position ``amount`` is 0
+- Fix bug of ``filter`` module
+
+Version 0.3.3
+-------------
+- Fix bug of ``filter`` module
+
+Version 0.3.4
+-------------
+- Support for ``finetune model``
+- Refactor ``fetcher`` code
+
+Version 0.3.5
+-------------
+- Support multi-label training, you can provide multiple label in ``handler``. (But LightGBM doesn't support due to the algorithm itself)
+- Refactor ``handler`` code, dataset.py is no longer used, and you can deploy your own labels and features in ``feature_label_config``
+- Handler only offer DataFrame. Also, ``trainer`` and model.py only receive DataFrame
+- Change ``split_rolling_data``, we roll the data on market calendar now, not on normal date
+- Move some date config from ``handler`` to ``trainer``
+
+Version 0.4.0
+-------------
+- Add `data` package that holds all data-related codes
+- Reform the data provider structure
+- Create a server for data centralized management `qlib-server <https://amc-msra.visualstudio.com/trading-algo/_git/qlib-server>`_
+- Add a `ClientProvider` to work with server
+- Add a pluggable cache mechanism
+- Add a recursive backtracking algorithm to inspect the furthest reference date for an expression
+
+.. note::
+    The ``D.instruments`` function does not support ``start_time``, ``end_time``, and ``as_list`` parameters, if you want to get the results of previous versions of ``D.instruments``, you can do this:
+
+
+    >>> from qlib.data import D
+    >>> instruments = D.instruments(market='csi500')
+    >>> D.list_instruments(instruments=instruments, start_time='2015-01-01', end_time='2016-02-15', as_list=True)
+
+
+Version 0.4.1
+-------------
+- Add support Windows
+- Fix ``instruments`` type bug
+- Fix ``features`` is empty bug(It will cause failure in updating)
+- Fix ``cache`` lock and update bug
+- Fix use the same cache for the same field (the original space will add a new cache)
+- Change "logger handler" from config
+- Change model load support 0.4.0 later
+- The default value of the ``method`` parameter of ``risk_analysis`` function is changed from **ci** to **si**
+
+
+Version 0.4.2
+-------------
+- Refactor DataHandler
+- Add ``Alpha360`` DataHandler
+
+
+Version 0.4.3
+-------------
+- Implementing Online Inference and Trading Framework
+- Refactoring The interfaces of backtest and strategy module.
+
+
+Version 0.4.4
+-------------
+- Optimize cache generation performance
+- Add report module
+- Fix bug when using ``ServerDatasetCache`` offline.
+- In the previous version of ``long_short_backtest``, there is a case of ``np.nan`` in long_short. The current version ``0.4.4`` has been fixed, so ``long_short_backtest`` will be different from the previous version.
+- In the ``0.4.2`` version of ``risk_analysis`` function, ``N`` is ``250``, and ``N`` is ``252`` from ``0.4.3``, so ``0.4.2`` is ``0.002122`` smaller than the ``0.4.3`` the backtest result is slightly different between ``0.4.2`` and ``0.4.3``.
+- refactor the argument of backtest function.
+    - **NOTE**:
+      - The default arguments of topk margin strategy is changed. Please pass the arguments explicitly if you want to get the same backtest result as previous version.
+      - The TopkWeightStrategy is changed slightly. It will try to sell the stocks more than ``topk``.  (The backtest result of TopkAmountStrategy remains the same)
+- The margin ratio mechanism is supported in the Topk Margin strategies.
+
+
+Version 0.4.5
+-------------
+- Add multi-kernel implementation for both client and server.
+    - Support a new way to load data from client which skips dataset cache.
+    - Change the default dataset method from single kernel implementation to multi kernel implementation.
+- Accelerate the high frequency data reading by optimizing the relative modules.
+- Support a new method to write config file by using dict.
+
+Version 0.4.6
+-------------
+- Some bugs are fixed
+    - The default config in `Version 0.4.5` is not friendly to daily frequency data.
+    - Backtest error in TopkWeightStrategy when `WithInteract=True`.
+
+
+Version 0.5.0
+-------------
+- First opensource version
+    - Refine the docs, code
+    - Add baselines
+    - public data crawler
+
+
+Version 0.8.0
+-------------
+- The backtest is greatly refactored.
+    - Nested decision execution framework is supported
+    - There are lots of changes for daily trading, it is hard to list all of them. But a few important changes could be noticed
+        - The trading limitation is more accurate;
+            - In `previous version <https://github.com/microsoft/qlib/blob/v0.7.2/qlib/contrib/backtest/exchange.py#L160>`__, longing and shorting actions share the same action.
+            - In `current version <https://github.com/microsoft/qlib/blob/7c31012b507a3823117bddcc693fc64899460b2a/qlib/backtest/exchange.py#L304>`__, the trading limitation is different between logging and shorting action.
+        - The constant is different when calculating annualized metrics.
+            - `Current version <https://github.com/microsoft/qlib/blob/7c31012b507a3823117bddcc693fc64899460b2a/qlib/contrib/evaluate.py#L42>`_ uses more accurate constant than `previous version <https://github.com/microsoft/qlib/blob/v0.7.2/qlib/contrib/evaluate.py#L22>`__
+        - `A new version <https://github.com/microsoft/qlib/blob/7c31012b507a3823117bddcc693fc64899460b2a/qlib/tests/data.py#L17>`__ of data is released. Due to the unstability of Yahoo data source, the data may be different after downloading data again.
+        - Users could check out the backtesting results between  `Current version <https://github.com/microsoft/qlib/tree/7c31012b507a3823117bddcc693fc64899460b2a/examples/benchmarks>`__ and `previous version <https://github.com/microsoft/qlib/tree/v0.7.2/examples/benchmarks>`__
+
+
+Other Versions
+--------------
+Please refer to `Github release Notes <https://github.com/microsoft/qlib/releases>`_

Kronos/qlib/CODE_OF_CONDUCT.md

@@ -0,0 +1,9 @@
+# Microsoft Open Source Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+
+Resources:
+
+- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
+- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+- Contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with questions or concerns

Kronos/qlib/Dockerfile

@@ -0,0 +1,31 @@
+FROM continuumio/miniconda3:latest
+
+WORKDIR /qlib
+
+COPY . .
+
+RUN apt-get update && \
+    apt-get install -y build-essential
+
+RUN conda create --name qlib_env python=3.8 -y
+RUN echo "conda activate qlib_env" >> ~/.bashrc
+ENV PATH /opt/conda/envs/qlib_env/bin:$PATH
+
+RUN python -m pip install --upgrade pip
+
+RUN python -m pip install numpy==1.23.5
+RUN python -m pip install pandas==1.5.3
+RUN python -m pip install importlib-metadata==5.2.0
+RUN python -m pip install "cloudpickle<3"
+RUN python -m pip install scikit-learn==1.3.2
+
+RUN python -m pip install cython packaging tables matplotlib statsmodels
+RUN python -m pip install pybind11 cvxpy
+
+ARG IS_STABLE="yes"
+
+RUN if [ "$IS_STABLE" = "yes" ]; then \
+        python -m pip install pyqlib; \
+    else \
+        python setup.py install; \
+    fi

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/_libs/rolling.pyx

@@ -0,0 +1,207 @@
+# cython: profile=False
+# cython: boundscheck=False, wraparound=False, cdivision=True
+cimport cython
+cimport numpy as np
+import numpy as np
+
+from libc.math cimport sqrt, isnan, NAN
+from libcpp.deque cimport deque
+
+
+cdef class Rolling:
+    """1-D array rolling"""
+    cdef int window
+    cdef deque[double] barv
+    cdef int na_count
+    def __init__(self, int window):
+        self.window = window
+        self.na_count = window
+        cdef int i
+        for i in range(window):
+            self.barv.push_back(NAN)
+
+    cdef double update(self, double val):
+        pass
+
+
+cdef class Mean(Rolling):
+    """1-D array rolling mean"""
+    cdef double vsum
+    def __init__(self, int window):
+        super(Mean, self).__init__(window)
+        self.vsum = 0
+        
+    cdef double update(self, double val):
+        self.barv.push_back(val)
+        if not isnan(self.barv.front()):
+            self.vsum -= self.barv.front()
+        else:
+            self.na_count -= 1
+        self.barv.pop_front()
+        if isnan(val):
+            self.na_count += 1
+            # return NAN
+        else:
+            self.vsum += val
+        return self.vsum / (self.window - self.na_count)
+
+
+cdef class Slope(Rolling):
+    """1-D array rolling slope"""
+    cdef double i_sum # can be used as i2_sum
+    cdef double x_sum
+    cdef double x2_sum
+    cdef double y_sum
+    cdef double xy_sum
+    def __init__(self, int window):
+        super(Slope, self).__init__(window)
+        self.i_sum  = 0
+        self.x_sum  = 0
+        self.x2_sum = 0
+        self.y_sum  = 0
+        self.xy_sum = 0
+
+    cdef double update(self, double val):
+        self.barv.push_back(val)
+        self.xy_sum = self.xy_sum - self.y_sum
+        self.x2_sum = self.x2_sum + self.i_sum - 2*self.x_sum
+        self.x_sum = self.x_sum - self.i_sum
+        cdef double _val
+        _val = self.barv.front()
+        if not isnan(_val):
+            self.i_sum -= 1
+            self.y_sum -= _val
+        else:
+            self.na_count -= 1
+        self.barv.pop_front()
+        if isnan(val):
+            self.na_count += 1
+            # return NAN
+        else:
+            self.i_sum  += 1
+            self.x_sum  += self.window
+            self.x2_sum += self.window * self.window
+            self.y_sum  += val
+            self.xy_sum += self.window * val
+        cdef int N = self.window - self.na_count
+        return (N*self.xy_sum - self.x_sum*self.y_sum) / \
+            (N*self.x2_sum - self.x_sum*self.x_sum)
+
+    
+cdef class Resi(Rolling):
+    """1-D array rolling residuals"""
+    cdef double i_sum # can be used as i2_sum
+    cdef double x_sum
+    cdef double x2_sum
+    cdef double y_sum
+    cdef double xy_sum
+    def __init__(self, int window):
+        super(Resi, self).__init__(window)
+        self.i_sum  = 0
+        self.x_sum  = 0
+        self.x2_sum = 0
+        self.y_sum  = 0
+        self.xy_sum = 0
+
+    cdef double update(self, double val):
+        self.barv.push_back(val)
+        self.xy_sum = self.xy_sum - self.y_sum
+        self.x2_sum = self.x2_sum + self.i_sum - 2*self.x_sum
+        self.x_sum = self.x_sum - self.i_sum
+        cdef double _val
+        _val = self.barv.front()
+        if not isnan(_val):
+            self.i_sum -= 1
+            self.y_sum -= _val
+        else:
+            self.na_count -= 1
+        self.barv.pop_front()
+        if isnan(val):
+            self.na_count += 1
+            # return NAN
+        else:
+            self.i_sum  += 1
+            self.x_sum  += self.window
+            self.x2_sum += self.window * self.window
+            self.y_sum  += val
+            self.xy_sum += self.window * val
+        cdef int N = self.window - self.na_count
+        slope = (N*self.xy_sum - self.x_sum*self.y_sum) / \
+                (N*self.x2_sum - self.x_sum*self.x_sum)
+        x_mean = self.x_sum / N
+        y_mean = self.y_sum / N
+        interp = y_mean - slope*x_mean
+        return val - (slope*self.window + interp)
+
+    
+cdef class Rsquare(Rolling):
+    """1-D array rolling rsquare"""
+    cdef double i_sum
+    cdef double x_sum
+    cdef double x2_sum
+    cdef double y_sum
+    cdef double y2_sum
+    cdef double xy_sum
+    def __init__(self, int window):
+        super(Rsquare, self).__init__(window)
+        self.i_sum  = 0
+        self.x_sum  = 0
+        self.x2_sum = 0
+        self.y_sum  = 0
+        self.y2_sum = 0
+        self.xy_sum = 0
+
+    cdef double update(self, double val):
+        self.barv.push_back(val)
+        self.xy_sum = self.xy_sum - self.y_sum
+        self.x2_sum = self.x2_sum + self.i_sum - 2*self.x_sum
+        self.x_sum = self.x_sum - self.i_sum
+        cdef double _val
+        _val = self.barv.front()
+        if not isnan(_val):
+            self.i_sum  -= 1
+            self.y_sum  -= _val
+            self.y2_sum -= _val * _val
+        else:
+            self.na_count -= 1
+        self.barv.pop_front()
+        if isnan(val):
+            self.na_count += 1
+            # return NAN
+        else:
+            self.i_sum  += 1
+            self.x_sum  += self.window
+            self.x2_sum += self.window * self.window
+            self.y_sum  += val
+            self.y2_sum += val * val
+            self.xy_sum += self.window * val
+        cdef int N = self.window - self.na_count
+        cdef double rvalue
+        rvalue = (N*self.xy_sum - self.x_sum*self.y_sum) / \
+            sqrt((N*self.x2_sum - self.x_sum*self.x_sum) * (N*self.y2_sum - self.y_sum*self.y_sum))
+        return rvalue * rvalue
+
+    
+cdef np.ndarray[double, ndim=1] rolling(Rolling r, np.ndarray a):
+    cdef int  i
+    cdef int  N = len(a)
+    cdef np.ndarray[double, ndim=1] ret = np.empty(N)
+    for i in range(N):
+        ret[i] = r.update(a[i])
+    return ret
+
+def rolling_mean(np.ndarray a, int window):
+    cdef Mean r = Mean(window)
+    return rolling(r, a)
+
+def rolling_slope(np.ndarray a, int window):
+    cdef Slope r = Slope(window)
+    return rolling(r, a)
+
+def rolling_rsquare(np.ndarray a, int window):
+    cdef Rsquare r = Rsquare(window)
+    return rolling(r, a)
+
+def rolling_resi(np.ndarray a, int window):
+    cdef Resi r = Resi(window)
+    return rolling(r, a)

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

@@ -0,0 +1,281 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+from __future__ import division
+from __future__ import print_function
+
+import abc
+import pandas as pd
+from ..log import get_module_logger
+
+
+class Expression(abc.ABC):
+    """
+    Expression base class
+
+    Expression is designed to handle the calculation of data with the format below
+    data with two dimension for each instrument,
+
+    - feature
+    - time:  it  could be observation time or period time.
+
+        - period time is designed for Point-in-time database.  For example, the period time maybe 2014Q4, its value can observed for multiple times(different value may be observed at different time due to amendment).
+    """
+
+    def __str__(self):
+        return type(self).__name__
+
+    def __repr__(self):
+        return str(self)
+
+    def __gt__(self, other):
+        from .ops import Gt  # pylint: disable=C0415
+
+        return Gt(self, other)
+
+    def __ge__(self, other):
+        from .ops import Ge  # pylint: disable=C0415
+
+        return Ge(self, other)
+
+    def __lt__(self, other):
+        from .ops import Lt  # pylint: disable=C0415
+
+        return Lt(self, other)
+
+    def __le__(self, other):
+        from .ops import Le  # pylint: disable=C0415
+
+        return Le(self, other)
+
+    def __eq__(self, other):
+        from .ops import Eq  # pylint: disable=C0415
+
+        return Eq(self, other)
+
+    def __ne__(self, other):
+        from .ops import Ne  # pylint: disable=C0415
+
+        return Ne(self, other)
+
+    def __add__(self, other):
+        from .ops import Add  # pylint: disable=C0415
+
+        return Add(self, other)
+
+    def __radd__(self, other):
+        from .ops import Add  # pylint: disable=C0415
+
+        return Add(other, self)
+
+    def __sub__(self, other):
+        from .ops import Sub  # pylint: disable=C0415
+
+        return Sub(self, other)
+
+    def __rsub__(self, other):
+        from .ops import Sub  # pylint: disable=C0415
+
+        return Sub(other, self)
+
+    def __mul__(self, other):
+        from .ops import Mul  # pylint: disable=C0415
+
+        return Mul(self, other)
+
+    def __rmul__(self, other):
+        from .ops import Mul  # pylint: disable=C0415
+
+        return Mul(self, other)
+
+    def __div__(self, other):
+        from .ops import Div  # pylint: disable=C0415
+
+        return Div(self, other)
+
+    def __rdiv__(self, other):
+        from .ops import Div  # pylint: disable=C0415
+
+        return Div(other, self)
+
+    def __truediv__(self, other):
+        from .ops import Div  # pylint: disable=C0415
+
+        return Div(self, other)
+
+    def __rtruediv__(self, other):
+        from .ops import Div  # pylint: disable=C0415
+
+        return Div(other, self)
+
+    def __pow__(self, other):
+        from .ops import Power  # pylint: disable=C0415
+
+        return Power(self, other)
+
+    def __rpow__(self, other):
+        from .ops import Power  # pylint: disable=C0415
+
+        return Power(other, self)
+
+    def __and__(self, other):
+        from .ops import And  # pylint: disable=C0415
+
+        return And(self, other)
+
+    def __rand__(self, other):
+        from .ops import And  # pylint: disable=C0415
+
+        return And(other, self)
+
+    def __or__(self, other):
+        from .ops import Or  # pylint: disable=C0415
+
+        return Or(self, other)
+
+    def __ror__(self, other):
+        from .ops import Or  # pylint: disable=C0415
+
+        return Or(other, self)
+
+    def load(self, instrument, start_index, end_index, *args):
+        """load  feature
+        This function is responsible for loading feature/expression based on the expression engine.
+
+        The concrete implementation will be separated into two parts:
+
+        1) caching data, handle errors.
+
+            - This part is shared by all the expressions and implemented in Expression
+        2) processing and calculating data based on the specific expression.
+
+            - This part is different in each expression and implemented in each expression
+
+        Expression Engine is shared by different data.
+        Different data will have different extra information for `args`.
+
+        Parameters
+        ----------
+        instrument : str
+            instrument code.
+        start_index : str
+            feature start index [in calendar].
+        end_index : str
+            feature end  index  [in calendar].
+
+        *args may contain following information:
+        1) if it is used in basic expression engine data, it contains following arguments
+            freq: str
+                feature frequency.
+
+        2) if is used in PIT data, it contains following arguments
+            cur_pit:
+                it is designed for the point-in-time data.
+            period: int
+                This is used for query specific period.
+                The period is represented with int in Qlib. (e.g. 202001 may represent the first quarter in 2020)
+
+        Returns
+        ----------
+        pd.Series
+            feature series: The index of the series is the calendar index
+        """
+        from .cache import H  # pylint: disable=C0415
+
+        # cache
+        cache_key = str(self), instrument, start_index, end_index, *args
+        if cache_key in H["f"]:
+            return H["f"][cache_key]
+        if start_index is not None and end_index is not None and start_index > end_index:
+            raise ValueError("Invalid index range: {} {}".format(start_index, end_index))
+        try:
+            series = self._load_internal(instrument, start_index, end_index, *args)
+        except Exception as e:
+            get_module_logger("data").debug(
+                f"Loading data error: instrument={instrument}, expression={str(self)}, "
+                f"start_index={start_index}, end_index={end_index}, args={args}. "
+                f"error info: {str(e)}"
+            )
+            raise
+        series.name = str(self)
+        H["f"][cache_key] = series
+        return series
+
+    @abc.abstractmethod
+    def _load_internal(self, instrument, start_index, end_index, *args) -> pd.Series:
+        raise NotImplementedError("This function must be implemented in your newly defined feature")
+
+    @abc.abstractmethod
+    def get_longest_back_rolling(self):
+        """Get the longest length of historical data the feature has accessed
+
+        This is designed for getting the needed range of the data to calculate
+        the features in specific range at first.  However, situations like
+        Ref(Ref($close, -1), 1) can not be handled rightly.
+
+        So this will only used for detecting the length of historical data needed.
+        """
+        # TODO: forward operator like Ref($close, -1) is not supported yet.
+        raise NotImplementedError("This function must be implemented in your newly defined feature")
+
+    @abc.abstractmethod
+    def get_extended_window_size(self):
+        """get_extend_window_size
+
+        For to calculate this Operator in range[start_index, end_index]
+        We have to get the *leaf feature* in
+        range[start_index - lft_etd, end_index + rght_etd].
+
+        Returns
+        ----------
+        (int, int)
+            lft_etd, rght_etd
+        """
+        raise NotImplementedError("This function must be implemented in your newly defined feature")
+
+
+class Feature(Expression):
+    """Static Expression
+
+    This kind of feature will load data from provider
+    """
+
+    def __init__(self, name=None):
+        if name:
+            self._name = name
+        else:
+            self._name = type(self).__name__
+
+    def __str__(self):
+        return "$" + self._name
+
+    def _load_internal(self, instrument, start_index, end_index, freq):
+        # load
+        from .data import FeatureD  # pylint: disable=C0415
+
+        return FeatureD.feature(instrument, str(self), start_index, end_index, freq)
+
+    def get_longest_back_rolling(self):
+        return 0
+
+    def get_extended_window_size(self):
+        return 0, 0
+
+
+class PFeature(Feature):
+    def __str__(self):
+        return "$$" + self._name
+
+    def _load_internal(self, instrument, start_index, end_index, cur_time, period=None):
+        from .data import PITD  # pylint: disable=C0415
+
+        return PITD.period_feature(instrument, str(self), start_index, end_index, cur_time, period)
+
+
+class ExpressionOps(Expression):
+    """Operator Expression
+
+    This kind of feature will use operator for feature
+    construction on the fly.
+    """

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/cache.py

@@ -0,0 +1,1199 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+import stat
+import time
+import pickle
+import traceback
+import redis_lock
+import contextlib
+import abc
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from typing import Union, Iterable
+from collections import OrderedDict
+
+from ..config import C
+from ..utils import (
+    hash_args,
+    get_redis_connection,
+    read_bin,
+    parse_field,
+    remove_fields_space,
+    normalize_cache_fields,
+    normalize_cache_instruments,
+)
+from ..utils.pickle_utils import restricted_pickle_load
+
+from ..log import get_module_logger
+from .base import Feature
+from .ops import Operators  # pylint: disable=W0611  # noqa: F401
+
+
+class QlibCacheException(RuntimeError):
+    pass
+
+
+class MemCacheUnit(abc.ABC):
+    """Memory Cache Unit."""
+
+    def __init__(self, *args, **kwargs):
+        self.size_limit = kwargs.pop("size_limit", 0)
+        self._size = 0
+        self.od = OrderedDict()
+
+    def __setitem__(self, key, value):
+        # TODO: thread safe?__setitem__ failure might cause inconsistent size?
+
+        # precalculate the size after od.__setitem__
+        self._adjust_size(key, value)
+
+        self.od.__setitem__(key, value)
+
+        # move the key to end,make it latest
+        self.od.move_to_end(key)
+
+        if self.limited:
+            # pop the oldest items beyond size limit
+            while self._size > self.size_limit:
+                self.popitem(last=False)
+
+    def __getitem__(self, key):
+        v = self.od.__getitem__(key)
+        self.od.move_to_end(key)
+        return v
+
+    def __contains__(self, key):
+        return key in self.od
+
+    def __len__(self):
+        return self.od.__len__()
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}<size_limit:{self.size_limit if self.limited else 'no limit'} total_size:{self._size}>\n{self.od.__repr__()}"
+
+    def set_limit_size(self, limit):
+        self.size_limit = limit
+
+    @property
+    def limited(self):
+        """whether memory cache is limited"""
+        return self.size_limit > 0
+
+    @property
+    def total_size(self):
+        return self._size
+
+    def clear(self):
+        self._size = 0
+        self.od.clear()
+
+    def popitem(self, last=True):
+        k, v = self.od.popitem(last=last)
+        self._size -= self._get_value_size(v)
+
+        return k, v
+
+    def pop(self, key):
+        v = self.od.pop(key)
+        self._size -= self._get_value_size(v)
+
+        return v
+
+    def _adjust_size(self, key, value):
+        if key in self.od:
+            self._size -= self._get_value_size(self.od[key])
+
+        self._size += self._get_value_size(value)
+
+    @abc.abstractmethod
+    def _get_value_size(self, value):
+        raise NotImplementedError
+
+
+class MemCacheLengthUnit(MemCacheUnit):
+    def __init__(self, size_limit=0):
+        super().__init__(size_limit=size_limit)
+
+    def _get_value_size(self, value):
+        return 1
+
+
+class MemCacheSizeofUnit(MemCacheUnit):
+    def __init__(self, size_limit=0):
+        super().__init__(size_limit=size_limit)
+
+    def _get_value_size(self, value):
+        return sys.getsizeof(value)
+
+
+class MemCache:
+    """Memory cache."""
+
+    def __init__(self, mem_cache_size_limit=None, limit_type="length"):
+        """
+
+        Parameters
+        ----------
+        mem_cache_size_limit:
+            cache max size.
+        limit_type:
+            length or sizeof; length(call fun: len), size(call fun: sys.getsizeof).
+        """
+
+        size_limit = C.mem_cache_size_limit if mem_cache_size_limit is None else mem_cache_size_limit
+        limit_type = C.mem_cache_limit_type if limit_type is None else limit_type
+
+        if limit_type == "length":
+            klass = MemCacheLengthUnit
+        elif limit_type == "sizeof":
+            klass = MemCacheSizeofUnit
+        else:
+            raise ValueError(f"limit_type must be length or sizeof, your limit_type is {limit_type}")
+
+        self.__calendar_mem_cache = klass(size_limit)
+        self.__instrument_mem_cache = klass(size_limit)
+        self.__feature_mem_cache = klass(size_limit)
+
+    def __getitem__(self, key):
+        if key == "c":
+            return self.__calendar_mem_cache
+        elif key == "i":
+            return self.__instrument_mem_cache
+        elif key == "f":
+            return self.__feature_mem_cache
+        else:
+            raise KeyError("Unknown memcache unit")
+
+    def clear(self):
+        self.__calendar_mem_cache.clear()
+        self.__instrument_mem_cache.clear()
+        self.__feature_mem_cache.clear()
+
+
+class MemCacheExpire:
+    CACHE_EXPIRE = C.mem_cache_expire
+
+    @staticmethod
+    def set_cache(mem_cache, key, value):
+        """set cache
+
+        :param mem_cache: MemCache attribute('c'/'i'/'f').
+        :param key: cache key.
+        :param value: cache value.
+        """
+        mem_cache[key] = value, time.time()
+
+    @staticmethod
+    def get_cache(mem_cache, key):
+        """get mem cache
+
+        :param mem_cache: MemCache attribute('c'/'i'/'f').
+        :param key: cache key.
+        :return: cache value; if cache not exist, return None.
+        """
+        value = None
+        expire = False
+        if key in mem_cache:
+            value, latest_time = mem_cache[key]
+            expire = (time.time() - latest_time) > MemCacheExpire.CACHE_EXPIRE
+        return value, expire
+
+
+class CacheUtils:
+    LOCK_ID = "QLIB"
+
+    @staticmethod
+    def organize_meta_file():
+        pass
+
+    @staticmethod
+    def reset_lock():
+        r = get_redis_connection()
+        redis_lock.reset_all(r)
+
+    @staticmethod
+    def visit(cache_path: Union[str, Path]):
+        # FIXME: Because read_lock was canceled when reading the cache, multiple processes may have read and write exceptions here
+        try:
+            cache_path = Path(cache_path)
+            meta_path = cache_path.with_suffix(".meta")
+            with meta_path.open("rb") as f:
+                d = restricted_pickle_load(f)
+            with meta_path.open("wb") as f:
+                try:
+                    d["meta"]["last_visit"] = str(time.time())
+                    d["meta"]["visits"] = d["meta"]["visits"] + 1
+                except KeyError as key_e:
+                    raise KeyError("Unknown meta keyword") from key_e
+                pickle.dump(d, f, protocol=C.dump_protocol_version)
+        except Exception as e:
+            get_module_logger("CacheUtils").warning(f"visit {cache_path} cache error: {e}")
+
+    @staticmethod
+    def acquire(lock, lock_name):
+        try:
+            lock.acquire()
+        except redis_lock.AlreadyAcquired as lock_acquired:
+            raise QlibCacheException(
+                f"""It sees the key(lock:{repr(lock_name)[1:-1]}-wlock) of the redis lock has existed in your redis db now.
+                    You can use the following command to clear your redis keys and rerun your commands:
+                    $ redis-cli
+                    > select {C.redis_task_db}
+                    > del "lock:{repr(lock_name)[1:-1]}-wlock"
+                    > quit
+                    If the issue is not resolved, use "keys *" to find if multiple keys exist. If so, try using "flushall" to clear all the keys.
+                """
+            ) from lock_acquired
+
+    @staticmethod
+    @contextlib.contextmanager
+    def reader_lock(redis_t, lock_name: str):
+        current_cache_rlock = redis_lock.Lock(redis_t, f"{lock_name}-rlock")
+        current_cache_wlock = redis_lock.Lock(redis_t, f"{lock_name}-wlock")
+        lock_reader = f"{lock_name}-reader"
+        # make sure only one reader is entering
+        current_cache_rlock.acquire(timeout=60)
+        try:
+            current_cache_readers = redis_t.get(lock_reader)
+            if current_cache_readers is None or int(current_cache_readers) == 0:
+                CacheUtils.acquire(current_cache_wlock, lock_name)
+            redis_t.incr(lock_reader)
+        finally:
+            current_cache_rlock.release()
+        try:
+            yield
+        finally:
+            # make sure only one reader is leaving
+            current_cache_rlock.acquire(timeout=60)
+            try:
+                redis_t.decr(lock_reader)
+                if int(redis_t.get(lock_reader)) == 0:
+                    redis_t.delete(lock_reader)
+                    current_cache_wlock.reset()
+            finally:
+                current_cache_rlock.release()
+
+    @staticmethod
+    @contextlib.contextmanager
+    def writer_lock(redis_t, lock_name):
+        current_cache_wlock = redis_lock.Lock(redis_t, f"{lock_name}-wlock", id=CacheUtils.LOCK_ID)
+        CacheUtils.acquire(current_cache_wlock, lock_name)
+        try:
+            yield
+        finally:
+            current_cache_wlock.release()
+
+
+class BaseProviderCache:
+    """Provider cache base class"""
+
+    def __init__(self, provider):
+        self.provider = provider
+        self.logger = get_module_logger(self.__class__.__name__)
+
+    def __getattr__(self, attr):
+        return getattr(self.provider, attr)
+
+    @staticmethod
+    def check_cache_exists(cache_path: Union[str, Path], suffix_list: Iterable = (".index", ".meta")) -> bool:
+        cache_path = Path(cache_path)
+        for p in [cache_path] + [cache_path.with_suffix(_s) for _s in suffix_list]:
+            if not p.exists():
+                return False
+        return True
+
+    @staticmethod
+    def clear_cache(cache_path: Union[str, Path]):
+        for p in [
+            cache_path,
+            cache_path.with_suffix(".meta"),
+            cache_path.with_suffix(".index"),
+        ]:
+            if p.exists():
+                p.unlink()
+
+    @staticmethod
+    def get_cache_dir(dir_name: str, freq: str = None) -> Path:
+        cache_dir = Path(C.dpm.get_data_uri(freq)).joinpath(dir_name)
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        return cache_dir
+
+
+class ExpressionCache(BaseProviderCache):
+    """Expression cache mechanism base class.
+
+    This class is used to wrap expression provider with self-defined expression cache mechanism.
+
+    .. note:: Override the `_uri` and `_expression` method to create your own expression cache mechanism.
+    """
+
+    def expression(self, instrument, field, start_time, end_time, freq):
+        """Get expression data.
+
+        .. note:: Same interface as `expression` method in expression provider
+        """
+        try:
+            return self._expression(instrument, field, start_time, end_time, freq)
+        except NotImplementedError:
+            return self.provider.expression(instrument, field, start_time, end_time, freq)
+
+    def _uri(self, instrument, field, start_time, end_time, freq):
+        """Get expression cache file uri.
+
+        Override this method to define how to get expression cache file uri corresponding to users' own cache mechanism.
+        """
+        raise NotImplementedError("Implement this function to match your own cache mechanism")
+
+    def _expression(self, instrument, field, start_time, end_time, freq):
+        """Get expression data using cache.
+
+        Override this method to define how to get expression data corresponding to users' own cache mechanism.
+        """
+        raise NotImplementedError("Implement this method if you want to use expression cache")
+
+    def update(self, cache_uri: Union[str, Path], freq: str = "day"):
+        """Update expression cache to latest calendar.
+
+        Override this method to define how to update expression cache corresponding to users' own cache mechanism.
+
+        Parameters
+        ----------
+        cache_uri : str or Path
+            the complete uri of expression cache file (include dir path).
+        freq : str
+
+        Returns
+        -------
+        int
+            0(successful update)/ 1(no need to update)/ 2(update failure).
+        """
+        raise NotImplementedError("Implement this method if you want to make expression cache up to date")
+
+
+class DatasetCache(BaseProviderCache):
+    """Dataset cache mechanism base class.
+
+    This class is used to wrap dataset provider with self-defined dataset cache mechanism.
+
+    .. note:: Override the `_uri` and `_dataset` method to create your own dataset cache mechanism.
+    """
+
+    HDF_KEY = "df"
+
+    def dataset(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=1, inst_processors=[]
+    ):
+        """Get feature dataset.
+
+        .. note:: Same interface as `dataset` method in dataset provider
+
+        .. note:: The server use redis_lock to make sure
+            read-write conflicts will not be triggered
+            but client readers are not considered.
+        """
+        if disk_cache == 0:
+            # skip cache
+            return self.provider.dataset(
+                instruments, fields, start_time, end_time, freq, inst_processors=inst_processors
+            )
+        else:
+            # use and replace cache
+            try:
+                return self._dataset(
+                    instruments, fields, start_time, end_time, freq, disk_cache, inst_processors=inst_processors
+                )
+            except NotImplementedError:
+                return self.provider.dataset(
+                    instruments, fields, start_time, end_time, freq, inst_processors=inst_processors
+                )
+
+    def _uri(self, instruments, fields, start_time, end_time, freq, **kwargs):
+        """Get dataset cache file uri.
+
+        Override this method to define how to get dataset cache file uri corresponding to users' own cache mechanism.
+        """
+        raise NotImplementedError("Implement this function to match your own cache mechanism")
+
+    def _dataset(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=1, inst_processors=[]
+    ):
+        """Get feature dataset using cache.
+
+        Override this method to define how to get feature dataset corresponding to users' own cache mechanism.
+        """
+        raise NotImplementedError("Implement this method if you want to use dataset feature cache")
+
+    def _dataset_uri(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=1, inst_processors=[]
+    ):
+        """Get a uri of feature dataset using cache.
+        specially:
+            disk_cache=1 means using data set cache and return the uri of cache file.
+            disk_cache=0 means client knows the path of expression cache,
+                         server checks if the cache exists(if not, generate it), and client loads data by itself.
+        Override this method to define how to get feature dataset uri corresponding to users' own cache mechanism.
+        """
+        raise NotImplementedError(
+            "Implement this method if you want to use dataset feature cache as a cache file for client"
+        )
+
+    def update(self, cache_uri: Union[str, Path], freq: str = "day"):
+        """Update dataset cache to latest calendar.
+
+        Override this method to define how to update dataset cache corresponding to users' own cache mechanism.
+
+        Parameters
+        ----------
+        cache_uri : str or Path
+            the complete uri of dataset cache file (include dir path).
+        freq : str
+
+        Returns
+        -------
+        int
+            0(successful update)/ 1(no need to update)/ 2(update failure)
+        """
+        raise NotImplementedError("Implement this method if you want to make expression cache up to date")
+
+    @staticmethod
+    def cache_to_origin_data(data, fields):
+        """cache data to origin data
+
+        :param data: pd.DataFrame, cache data.
+        :param fields: feature fields.
+        :return: pd.DataFrame.
+        """
+        not_space_fields = remove_fields_space(fields)
+        data = data.loc[:, not_space_fields]
+        # set features fields
+        data.columns = [str(i) for i in fields]
+        return data
+
+    @staticmethod
+    def normalize_uri_args(instruments, fields, freq):
+        """normalize uri args"""
+        instruments = normalize_cache_instruments(instruments)
+        fields = normalize_cache_fields(fields)
+        freq = freq.lower()
+
+        return instruments, fields, freq
+
+
+class DiskExpressionCache(ExpressionCache):
+    """Prepared cache mechanism for server."""
+
+    def __init__(self, provider, **kwargs):
+        super(DiskExpressionCache, self).__init__(provider)
+        self.r = get_redis_connection()
+        # remote==True means client is using this module, writing behaviour will not be allowed.
+        self.remote = kwargs.get("remote", False)
+
+    def get_cache_dir(self, freq: str = None) -> Path:
+        return super(DiskExpressionCache, self).get_cache_dir(C.features_cache_dir_name, freq)
+
+    def _uri(self, instrument, field, start_time, end_time, freq):
+        field = remove_fields_space(field)
+        instrument = str(instrument).lower()
+        return hash_args(instrument, field, freq)
+
+    def _expression(self, instrument, field, start_time=None, end_time=None, freq="day"):
+        _cache_uri = self._uri(instrument=instrument, field=field, start_time=None, end_time=None, freq=freq)
+        _instrument_dir = self.get_cache_dir(freq).joinpath(instrument.lower())
+        cache_path = _instrument_dir.joinpath(_cache_uri)
+        # get calendar
+        from .data import Cal  # pylint: disable=C0415
+
+        _calendar = Cal.calendar(freq=freq)
+
+        _, _, start_index, end_index = Cal.locate_index(start_time, end_time, freq, future=False)
+
+        if self.check_cache_exists(cache_path, suffix_list=[".meta"]):
+            """
+            In most cases, we do not need reader_lock.
+            Because updating data is a small probability event compare to reading data.
+
+            """
+            # FIXME: Removing the reader lock may result in conflicts.
+            # with CacheUtils.reader_lock(self.r, 'expression-%s' % _cache_uri):
+
+            # modify expression cache meta file
+            try:
+                # FIXME: Multiple readers may result in error visit number
+                if not self.remote:
+                    CacheUtils.visit(cache_path)
+                series = read_bin(cache_path, start_index, end_index)
+                return series
+            except Exception:
+                series = None
+                self.logger.error("reading %s file error : %s" % (cache_path, traceback.format_exc()))
+            return series
+        else:
+            # normalize field
+            field = remove_fields_space(field)
+            # cache unavailable, generate the cache
+            _instrument_dir.mkdir(parents=True, exist_ok=True)
+            if not isinstance(eval(parse_field(field)), Feature):
+                # When the expression is not a raw feature
+                # generate expression cache if the feature is not a Feature
+                # instance
+                series = self.provider.expression(instrument, field, _calendar[0], _calendar[-1], freq)
+                if not series.empty:
+                    # This expression is empty, we don't generate any cache for it.
+                    with CacheUtils.writer_lock(self.r, f"{str(C.dpm.get_data_uri(freq))}:expression-{_cache_uri}"):
+                        self.gen_expression_cache(
+                            expression_data=series,
+                            cache_path=cache_path,
+                            instrument=instrument,
+                            field=field,
+                            freq=freq,
+                            last_update=str(_calendar[-1]),
+                        )
+                    return series.loc[start_index:end_index]
+                else:
+                    return series
+            else:
+                # If the expression is a raw feature(such as $close, $open)
+                return self.provider.expression(instrument, field, start_time, end_time, freq)
+
+    def gen_expression_cache(self, expression_data, cache_path, instrument, field, freq, last_update):
+        """use bin file to save like feature-data."""
+        # Make sure the cache runs right when the directory is deleted
+        # while running
+        meta = {
+            "info": {"instrument": instrument, "field": field, "freq": freq, "last_update": last_update},
+            "meta": {"last_visit": time.time(), "visits": 1},
+        }
+        self.logger.debug(f"generating expression cache: {meta}")
+        self.clear_cache(cache_path)
+        meta_path = cache_path.with_suffix(".meta")
+
+        with meta_path.open("wb") as f:
+            pickle.dump(meta, f, protocol=C.dump_protocol_version)
+        meta_path.chmod(stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
+        df = expression_data.to_frame()
+
+        r = np.hstack([df.index[0], expression_data]).astype("<f")
+        r.tofile(str(cache_path))
+
+    def update(self, sid, cache_uri, freq: str = "day"):
+        cp_cache_uri = self.get_cache_dir(freq).joinpath(sid).joinpath(cache_uri)
+        meta_path = cp_cache_uri.with_suffix(".meta")
+        if not self.check_cache_exists(cp_cache_uri, suffix_list=[".meta"]):
+            self.logger.info(f"The cache {cp_cache_uri} has corrupted. It will be removed")
+            self.clear_cache(cp_cache_uri)
+            return 2
+
+        with CacheUtils.writer_lock(self.r, f"{str(C.dpm.get_data_uri())}:expression-{cache_uri}"):
+            with meta_path.open("rb") as f:
+                d = restricted_pickle_load(f)
+            instrument = d["info"]["instrument"]
+            field = d["info"]["field"]
+            freq = d["info"]["freq"]
+            last_update_time = d["info"]["last_update"]
+
+            # get newest calendar
+            from .data import Cal, ExpressionD  # pylint: disable=C0415
+
+            whole_calendar = Cal.calendar(start_time=None, end_time=None, freq=freq)
+            # calendar since last updated.
+            new_calendar = Cal.calendar(start_time=last_update_time, end_time=None, freq=freq)
+
+            # get append data
+            if len(new_calendar) <= 1:
+                # Including last updated calendar, we only get 1 item.
+                # No future updating is needed.
+                return 1
+            else:
+                # get the data needed after the historical data are removed.
+                # The start index of new data
+                current_index = len(whole_calendar) - len(new_calendar) + 1
+
+                # The existing data length
+                size_bytes = os.path.getsize(cp_cache_uri)
+                ele_size = np.dtype("<f").itemsize
+                assert size_bytes % ele_size == 0
+                ele_n = size_bytes // ele_size - 1
+
+                expr = ExpressionD.get_expression_instance(field)
+                lft_etd, rght_etd = expr.get_extended_window_size()
+                # The expression used the future data after rght_etd days.
+                # So the last rght_etd data should be removed.
+                # There are most `ele_n` period of data can be remove
+                remove_n = min(rght_etd, ele_n)
+                assert new_calendar[1] == whole_calendar[current_index]
+                data = self.provider.expression(
+                    instrument, field, whole_calendar[current_index - remove_n], new_calendar[-1], freq
+                )
+                with open(cp_cache_uri, "ab") as f:
+                    data = np.array(data).astype("<f")
+                    # Remove the last bits
+                    f.truncate(size_bytes - ele_size * remove_n)
+                    f.write(data)
+                # update meta file
+                d["info"]["last_update"] = str(new_calendar[-1])
+                with meta_path.open("wb") as f:
+                    pickle.dump(d, f, protocol=C.dump_protocol_version)
+        return 0
+
+
+class DiskDatasetCache(DatasetCache):
+    """Prepared cache mechanism for server."""
+
+    def __init__(self, provider, **kwargs):
+        super(DiskDatasetCache, self).__init__(provider)
+        self.r = get_redis_connection()
+        self.remote = kwargs.get("remote", False)
+
+    @staticmethod
+    def _uri(instruments, fields, start_time, end_time, freq, disk_cache=1, inst_processors=[], **kwargs):
+        return hash_args(*DatasetCache.normalize_uri_args(instruments, fields, freq), disk_cache, inst_processors)
+
+    def get_cache_dir(self, freq: str = None) -> Path:
+        return super(DiskDatasetCache, self).get_cache_dir(C.dataset_cache_dir_name, freq)
+
+    @classmethod
+    def read_data_from_cache(cls, cache_path: Union[str, Path], start_time, end_time, fields):
+        """read_cache_from
+
+        This function can read data from the disk cache dataset
+
+        :param cache_path:
+        :param start_time:
+        :param end_time:
+        :param fields: The fields order of the dataset cache is sorted. So rearrange the columns to make it consistent.
+        :return:
+        """
+
+        im = DiskDatasetCache.IndexManager(cache_path)
+        index_data = im.get_index(start_time, end_time)
+        if index_data.shape[0] > 0:
+            start, stop = (
+                index_data["start"].iloc[0].item(),
+                index_data["end"].iloc[-1].item(),
+            )
+        else:
+            start = stop = 0
+
+        with pd.HDFStore(cache_path, mode="r") as store:
+            if "/{}".format(im.KEY) in store.keys():
+                df = store.select(key=im.KEY, start=start, stop=stop)
+                df = df.swaplevel("datetime", "instrument").sort_index()
+                # read cache and need to replace not-space fields to field
+                df = cls.cache_to_origin_data(df, fields)
+
+            else:
+                df = pd.DataFrame(columns=fields)
+        return df
+
+    def _dataset(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=0, inst_processors=[]
+    ):
+        if disk_cache == 0:
+            # In this case, data_set cache is configured but will not be used.
+            return self.provider.dataset(
+                instruments, fields, start_time, end_time, freq, inst_processors=inst_processors
+            )
+        # FIXME: The cache after resample, when read again and intercepted with end_time, results in incomplete data date
+        if inst_processors:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support inst_processor. "
+                f"Please use `D.features(disk_cache=0)` or `qlib.init(dataset_cache=None)`"
+            )
+        _cache_uri = self._uri(
+            instruments=instruments,
+            fields=fields,
+            start_time=None,
+            end_time=None,
+            freq=freq,
+            disk_cache=disk_cache,
+            inst_processors=inst_processors,
+        )
+
+        cache_path = self.get_cache_dir(freq).joinpath(_cache_uri)
+
+        features = pd.DataFrame()
+        gen_flag = False
+
+        if self.check_cache_exists(cache_path):
+            if disk_cache == 1:
+                # use cache
+                with CacheUtils.reader_lock(self.r, f"{str(C.dpm.get_data_uri(freq))}:dataset-{_cache_uri}"):
+                    CacheUtils.visit(cache_path)
+                    features = self.read_data_from_cache(cache_path, start_time, end_time, fields)
+            elif disk_cache == 2:
+                gen_flag = True
+        else:
+            gen_flag = True
+
+        if gen_flag:
+            # cache unavailable, generate the cache
+            with CacheUtils.writer_lock(self.r, f"{str(C.dpm.get_data_uri(freq))}:dataset-{_cache_uri}"):
+                features = self.gen_dataset_cache(
+                    cache_path=cache_path,
+                    instruments=instruments,
+                    fields=fields,
+                    freq=freq,
+                    inst_processors=inst_processors,
+                )
+            if not features.empty:
+                features = features.sort_index().loc(axis=0)[:, start_time:end_time]
+        return features
+
+    def _dataset_uri(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=0, inst_processors=[]
+    ):
+        if disk_cache == 0:
+            # In this case, server only checks the expression cache.
+            # The client will load the cache data by itself.
+            from .data import LocalDatasetProvider  # pylint: disable=C0415
+
+            LocalDatasetProvider.multi_cache_walker(instruments, fields, start_time, end_time, freq)
+            return ""
+        # FIXME: The cache after resample, when read again and intercepted with end_time, results in incomplete data date
+        if inst_processors:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support inst_processor. "
+                f"Please use `D.features(disk_cache=0)` or `qlib.init(dataset_cache=None)`"
+            )
+        _cache_uri = self._uri(
+            instruments=instruments,
+            fields=fields,
+            start_time=None,
+            end_time=None,
+            freq=freq,
+            disk_cache=disk_cache,
+            inst_processors=inst_processors,
+        )
+        cache_path = self.get_cache_dir(freq).joinpath(_cache_uri)
+
+        if self.check_cache_exists(cache_path):
+            self.logger.debug(f"The cache dataset has already existed {cache_path}. Return the uri directly")
+            with CacheUtils.reader_lock(self.r, f"{str(C.dpm.get_data_uri(freq))}:dataset-{_cache_uri}"):
+                CacheUtils.visit(cache_path)
+            return _cache_uri
+        else:
+            # cache unavailable, generate the cache
+            with CacheUtils.writer_lock(self.r, f"{str(C.dpm.get_data_uri(freq))}:dataset-{_cache_uri}"):
+                self.gen_dataset_cache(
+                    cache_path=cache_path,
+                    instruments=instruments,
+                    fields=fields,
+                    freq=freq,
+                    inst_processors=inst_processors,
+                )
+            return _cache_uri
+
+    class IndexManager:
+        """
+        The lock is not considered in the class. Please consider the lock outside the code.
+        This class is the proxy of the disk data.
+        """
+
+        KEY = "df"
+
+        def __init__(self, cache_path: Union[str, Path]):
+            self.index_path = cache_path.with_suffix(".index")
+            self._data = None
+            self.logger = get_module_logger(self.__class__.__name__)
+
+        def get_index(self, start_time=None, end_time=None):
+            # TODO: fast read index from the disk.
+            if self._data is None:
+                self.sync_from_disk()
+            return self._data.loc[start_time:end_time].copy()
+
+        def sync_to_disk(self):
+            if self._data is None:
+                raise ValueError("No data to sync to disk.")
+            self._data.sort_index(inplace=True)
+            self._data.to_hdf(self.index_path, key=self.KEY, mode="w", format="table")
+            # The index should be readable for all users
+            self.index_path.chmod(stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
+
+        def sync_from_disk(self):
+            # The file will not be closed directly if we read_hdf from the disk directly
+            with pd.HDFStore(self.index_path, mode="r") as store:
+                if "/{}".format(self.KEY) in store.keys():
+                    self._data = pd.read_hdf(store, key=self.KEY)
+                else:
+                    self._data = pd.DataFrame()
+
+        def update(self, data, sync=True):
+            self._data = data.astype(np.int32).copy()
+            if sync:
+                self.sync_to_disk()
+
+        def append_index(self, data, to_disk=True):
+            data = data.astype(np.int32).copy()
+            data.sort_index(inplace=True)
+            self._data = pd.concat([self._data, data])
+            if to_disk:
+                with pd.HDFStore(self.index_path) as store:
+                    store.append(self.KEY, data, append=True)
+
+        @staticmethod
+        def build_index_from_data(data, start_index=0):
+            if data.empty:
+                return pd.DataFrame()
+            line_data = data.groupby("datetime", group_keys=False).size()
+            line_data.sort_index(inplace=True)
+            index_end = line_data.cumsum()
+            index_start = index_end.shift(1, fill_value=0)
+
+            index_data = pd.DataFrame()
+            index_data["start"] = index_start
+            index_data["end"] = index_end
+            index_data += start_index
+            return index_data
+
+    def gen_dataset_cache(self, cache_path: Union[str, Path], instruments, fields, freq, inst_processors=[]):
+        """gen_dataset_cache
+
+        .. note:: This function does not consider the cache read write lock. Please
+            acquire the lock outside this function
+
+        The format the cache contains 3 parts(followed by typical filename).
+
+        - index : cache/d41366901e25de3ec47297f12e2ba11d.index
+
+            - The content of the file may be in following format(pandas.Series)
+
+                .. code-block:: python
+
+                                        start end
+                    1999-11-10 00:00:00     0   1
+                    1999-11-11 00:00:00     1   2
+                    1999-11-12 00:00:00     2   3
+                    ...
+
+                .. note:: The start is closed. The end is open!!!!!
+
+            - Each line contains two element <start_index, end_index> with a timestamp as its index.
+            - It indicates the `start_index` (included) and `end_index` (excluded) of the data for `timestamp`
+
+        - meta data: cache/d41366901e25de3ec47297f12e2ba11d.meta
+
+        - data     : cache/d41366901e25de3ec47297f12e2ba11d
+
+            - This is a hdf file sorted by datetime
+
+        :param cache_path:  The path to store the cache.
+        :param instruments:  The instruments to store the cache.
+        :param fields:  The fields to store the cache.
+        :param freq:  The freq to store the cache.
+        :param inst_processors:  Instrument processors.
+
+        :return type pd.DataFrame; The fields of the returned DataFrame are consistent with the parameters of the function.
+        """
+        # get calendar
+        from .data import Cal  # pylint: disable=C0415
+
+        cache_path = Path(cache_path)
+        _calendar = Cal.calendar(freq=freq)
+        self.logger.debug(f"Generating dataset cache {cache_path}")
+        # Make sure the cache runs right when the directory is deleted
+        # while running
+        self.clear_cache(cache_path)
+
+        features = self.provider.dataset(
+            instruments, fields, _calendar[0], _calendar[-1], freq, inst_processors=inst_processors
+        )
+
+        if features.empty:
+            return features
+
+        # swap index and sorted
+        features = features.swaplevel("instrument", "datetime").sort_index()
+
+        # write cache data
+        with pd.HDFStore(str(cache_path.with_suffix(".data"))) as store:
+            cache_to_orig_map = dict(zip(remove_fields_space(features.columns), features.columns))
+            orig_to_cache_map = dict(zip(features.columns, remove_fields_space(features.columns)))
+            cache_features = features[list(cache_to_orig_map.values())].rename(columns=orig_to_cache_map)
+            # cache columns
+            cache_columns = sorted(cache_features.columns)
+            cache_features = cache_features.loc[:, cache_columns]
+            cache_features = cache_features.loc[:, ~cache_features.columns.duplicated()]
+            store.append(DatasetCache.HDF_KEY, cache_features, append=False)
+        # write meta file
+        meta = {
+            "info": {
+                "instruments": instruments,
+                "fields": list(cache_features.columns),
+                "freq": freq,
+                "last_update": str(_calendar[-1]),  # The last_update to store the cache
+                "inst_processors": inst_processors,  # The last_update to store the cache
+            },
+            "meta": {"last_visit": time.time(), "visits": 1},
+        }
+        with cache_path.with_suffix(".meta").open("wb") as f:
+            pickle.dump(meta, f, protocol=C.dump_protocol_version)
+        cache_path.with_suffix(".meta").chmod(stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
+        # write index file
+        im = DiskDatasetCache.IndexManager(cache_path)
+        index_data = im.build_index_from_data(features)
+        im.update(index_data)
+
+        # rename the file after the cache has been generated
+        # this doesn't work well on windows, but our server won't use windows
+        # temporarily
+        cache_path.with_suffix(".data").rename(cache_path)
+        # the fields of the cached features are converted to the original fields
+        return features.swaplevel("datetime", "instrument")
+
+    def update(self, cache_uri, freq: str = "day"):
+        cp_cache_uri = self.get_cache_dir(freq).joinpath(cache_uri)
+        meta_path = cp_cache_uri.with_suffix(".meta")
+        if not self.check_cache_exists(cp_cache_uri):
+            self.logger.info(f"The cache {cp_cache_uri} has corrupted. It will be removed")
+            self.clear_cache(cp_cache_uri)
+            return 2
+
+        im = DiskDatasetCache.IndexManager(cp_cache_uri)
+        with CacheUtils.writer_lock(self.r, f"{str(C.dpm.get_data_uri())}:dataset-{cache_uri}"):
+            with meta_path.open("rb") as f:
+                d = restricted_pickle_load(f)
+            instruments = d["info"]["instruments"]
+            fields = d["info"]["fields"]
+            freq = d["info"]["freq"]
+            last_update_time = d["info"]["last_update"]
+            inst_processors = d["info"].get("inst_processors", [])
+            index_data = im.get_index()
+
+            self.logger.debug("Updating dataset: {}".format(d))
+            from .data import Inst  # pylint: disable=C0415
+
+            if Inst.get_inst_type(instruments) == Inst.DICT:
+                self.logger.info(f"The file {cache_uri} has dict cache. Skip updating")
+                return 1
+
+            # get newest calendar
+            from .data import Cal  # pylint: disable=C0415
+
+            whole_calendar = Cal.calendar(start_time=None, end_time=None, freq=freq)
+            # The calendar since last updated
+            new_calendar = Cal.calendar(start_time=last_update_time, end_time=None, freq=freq)
+
+            # get append data
+            if len(new_calendar) <= 1:
+                # Including last updated calendar, we only get 1 item.
+                # No future updating is needed.
+                return 1
+            else:
+                # get the data needed after the historical data are removed.
+                # The start index of new data
+                current_index = len(whole_calendar) - len(new_calendar) + 1
+
+                # To avoid recursive import
+                from .data import ExpressionD  # pylint: disable=C0415
+
+                # The existing data length
+                lft_etd = rght_etd = 0
+                for field in fields:
+                    expr = ExpressionD.get_expression_instance(field)
+                    l, r = expr.get_extended_window_size()
+                    lft_etd = max(lft_etd, l)
+                    rght_etd = max(rght_etd, r)
+                # remove the period that should be updated.
+                if index_data.empty:
+                    # We don't have any data for such dataset. Nothing to remove
+                    rm_n_period = rm_lines = 0
+                else:
+                    rm_n_period = min(rght_etd, index_data.shape[0])
+                    rm_lines = (
+                        (index_data["end"] - index_data["start"])
+                        .loc[whole_calendar[current_index - rm_n_period] :]
+                        .sum()
+                        .item()
+                    )
+
+                data = self.provider.dataset(
+                    instruments,
+                    fields,
+                    whole_calendar[current_index - rm_n_period],
+                    new_calendar[-1],
+                    freq,
+                    inst_processors=inst_processors,
+                )
+
+                if not data.empty:
+                    data.reset_index(inplace=True)
+                    data.set_index(["datetime", "instrument"], inplace=True)
+                    data.sort_index(inplace=True)
+                else:
+                    return 0  # No data to update cache
+
+                store = pd.HDFStore(cp_cache_uri)
+                # FIXME:
+                # Because the feature cache are stored as .bin file.
+                # So the series read from features are all float32.
+                # However, the first dataset cache is calculated based on the
+                # raw data. So the data type may be float64.
+                # Different data type will result in failure of appending data
+                if "/{}".format(DatasetCache.HDF_KEY) in store.keys():
+                    schema = store.select(DatasetCache.HDF_KEY, start=0, stop=0)
+                    for col, dtype in schema.dtypes.items():
+                        data[col] = data[col].astype(dtype)
+                if rm_lines > 0:
+                    store.remove(key=im.KEY, start=-rm_lines)
+                store.append(DatasetCache.HDF_KEY, data)
+                store.close()
+
+                # update index file
+                new_index_data = im.build_index_from_data(
+                    data.loc(axis=0)[whole_calendar[current_index] :, :],
+                    start_index=0 if index_data.empty else index_data["end"].iloc[-1],
+                )
+                im.append_index(new_index_data)
+
+                # update meta file
+                d["info"]["last_update"] = str(new_calendar[-1])
+                with meta_path.open("wb") as f:
+                    pickle.dump(d, f, protocol=C.dump_protocol_version)
+                return 0
+
+
+class SimpleDatasetCache(DatasetCache):
+    """Simple dataset cache that can be used locally or on client."""
+
+    def __init__(self, provider):
+        super(SimpleDatasetCache, self).__init__(provider)
+        try:
+            self.local_cache_path: Path = Path(C["local_cache_path"]).expanduser().resolve()
+        except (KeyError, TypeError):
+            self.logger.error("Assign a local_cache_path in config if you want to use this cache mechanism")
+            raise
+        self.logger.info(
+            f"DatasetCache directory: {self.local_cache_path}, "
+            f"modify the cache directory via the local_cache_path in the config"
+        )
+
+    def _uri(self, instruments, fields, start_time, end_time, freq, disk_cache=1, inst_processors=[], **kwargs):
+        instruments, fields, freq = self.normalize_uri_args(instruments, fields, freq)
+        return hash_args(
+            instruments, fields, start_time, end_time, freq, disk_cache, str(self.local_cache_path), inst_processors
+        )
+
+    def _dataset(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=1, inst_processors=[]
+    ):
+        if disk_cache == 0:
+            # In this case, data_set cache is configured but will not be used.
+            return self.provider.dataset(instruments, fields, start_time, end_time, freq)
+        self.local_cache_path.mkdir(exist_ok=True, parents=True)
+        cache_file = self.local_cache_path.joinpath(
+            self._uri(
+                instruments, fields, start_time, end_time, freq, disk_cache=disk_cache, inst_processors=inst_processors
+            )
+        )
+        gen_flag = False
+
+        if cache_file.exists():
+            if disk_cache == 1:
+                # use cache
+                df = pd.read_pickle(cache_file)
+                return self.cache_to_origin_data(df, fields)
+            elif disk_cache == 2:
+                # replace cache
+                gen_flag = True
+        else:
+            gen_flag = True
+
+        if gen_flag:
+            data = self.provider.dataset(
+                instruments, normalize_cache_fields(fields), start_time, end_time, freq, inst_processors=inst_processors
+            )
+            data.to_pickle(cache_file)
+            return self.cache_to_origin_data(data, fields)
+
+
+class DatasetURICache(DatasetCache):
+    """Prepared cache mechanism for server."""
+
+    def _uri(self, instruments, fields, start_time, end_time, freq, disk_cache=1, inst_processors=[], **kwargs):
+        return hash_args(*self.normalize_uri_args(instruments, fields, freq), disk_cache, inst_processors)
+
+    def dataset(
+        self, instruments, fields, start_time=None, end_time=None, freq="day", disk_cache=0, inst_processors=[]
+    ):
+        if "local" in C.dataset_provider.lower():
+            # use LocalDatasetProvider
+            return self.provider.dataset(
+                instruments, fields, start_time, end_time, freq, inst_processors=inst_processors
+            )
+
+        if disk_cache == 0:
+            # do not use data_set cache, load data from remote expression cache directly
+            return self.provider.dataset(
+                instruments,
+                fields,
+                start_time,
+                end_time,
+                freq,
+                disk_cache,
+                return_uri=False,
+                inst_processors=inst_processors,
+            )
+        # FIXME: The cache after resample, when read again and intercepted with end_time, results in incomplete data date
+        if inst_processors:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support inst_processor. "
+                f"Please use `D.features(disk_cache=0)` or `qlib.init(dataset_cache=None)`"
+            )
+        # use ClientDatasetProvider
+        feature_uri = self._uri(
+            instruments, fields, None, None, freq, disk_cache=disk_cache, inst_processors=inst_processors
+        )
+        value, expire = MemCacheExpire.get_cache(H["f"], feature_uri)
+        mnt_feature_uri = C.dpm.get_data_uri(freq).joinpath(C.dataset_cache_dir_name).joinpath(feature_uri)
+        if value is None or expire or not mnt_feature_uri.exists():
+            df, uri = self.provider.dataset(
+                instruments,
+                fields,
+                start_time,
+                end_time,
+                freq,
+                disk_cache,
+                return_uri=True,
+                inst_processors=inst_processors,
+            )
+            # cache uri
+            MemCacheExpire.set_cache(H["f"], uri, uri)
+            # cache DataFrame
+            # HZ['f'][uri] = df.copy()
+            get_module_logger("cache").debug(f"get feature from {C.dataset_provider}")
+        else:
+            df = DiskDatasetCache.read_data_from_cache(mnt_feature_uri, start_time, end_time, fields)
+            get_module_logger("cache").debug("get feature from uri cache")
+
+        return df
+
+
+class CalendarCache(BaseProviderCache):
+    pass
+
+
+class MemoryCalendarCache(CalendarCache):
+    def calendar(self, start_time=None, end_time=None, freq="day", future=False):
+        uri = self._uri(start_time, end_time, freq, future)
+        result, expire = MemCacheExpire.get_cache(H["c"], uri)
+        if result is None or expire:
+            result = self.provider.calendar(start_time, end_time, freq, future)
+            MemCacheExpire.set_cache(H["c"], uri, result)
+
+            get_module_logger("data").debug(f"get calendar from {C.calendar_provider}")
+        else:
+            get_module_logger("data").debug("get calendar from local cache")
+
+        return result
+
+
+H = MemCache()

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/client.py

@@ -0,0 +1,103 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+from __future__ import division, print_function
+
+import json
+
+import socketio
+
+import qlib
+
+from ..log import get_module_logger
+
+
+class Client:
+    """A client class
+
+    Provide the connection tool functions for ClientProvider.
+    """
+
+    def __init__(self, host, port):
+        super(Client, self).__init__()
+        self.sio = socketio.Client()
+        self.server_host = host
+        self.server_port = port
+        self.logger = get_module_logger(self.__class__.__name__)
+        # bind connect/disconnect callbacks
+        self.sio.on(
+            "connect",
+            lambda: self.logger.debug("Connect to server {}".format(self.sio.connection_url)),
+        )
+        self.sio.on("disconnect", lambda: self.logger.debug("Disconnect from server!"))
+
+    def connect_server(self):
+        """Connect to server."""
+        try:
+            self.sio.connect(f"ws://{self.server_host}:{self.server_port}")
+        except socketio.exceptions.ConnectionError:
+            self.logger.error("Cannot connect to server - check your network or server status")
+
+    def disconnect(self):
+        """Disconnect from server."""
+        try:
+            self.sio.eio.disconnect(True)
+        except Exception as e:
+            self.logger.error("Cannot disconnect from server : %s" % e)
+
+    def send_request(self, request_type, request_content, msg_queue, msg_proc_func=None):
+        """Send a certain request to server.
+
+        Parameters
+        ----------
+        request_type : str
+            type of proposed request, 'calendar'/'instrument'/'feature'.
+        request_content : dict
+            records the information of the request.
+        msg_proc_func : func
+            the function to process the message when receiving response, should have arg `*args`.
+        msg_queue: Queue
+            The queue to pass the message after callback.
+        """
+        head_info = {"version": qlib.__version__}
+
+        def request_callback(*args):
+            """callback_wrapper
+
+            :param *args: args[0] is the response content
+            """
+            # args[0] is the response content
+            self.logger.debug("receive data and enter queue")
+            msg = dict(args[0])
+            if msg["detailed_info"] is not None:
+                if msg["status"] != 0:
+                    self.logger.error(msg["detailed_info"])
+                else:
+                    self.logger.info(msg["detailed_info"])
+            if msg["status"] != 0:
+                ex = ValueError(f"Bad response(status=={msg['status']}), detailed info: {msg['detailed_info']}")
+                msg_queue.put(ex)
+            else:
+                if msg_proc_func is not None:
+                    try:
+                        ret = msg_proc_func(msg["result"])
+                    except Exception as e:
+                        self.logger.exception("Error when processing message.")
+                        ret = e
+                else:
+                    ret = msg["result"]
+                msg_queue.put(ret)
+            self.disconnect()
+            self.logger.debug("disconnected")
+
+        self.logger.debug("try connecting")
+        self.connect_server()
+        self.logger.debug("connected")
+        # The pickle is for passing some parameters with special type(such as
+        # pd.Timestamp)
+        request_content = {"head": head_info, "body": json.dumps(request_content, default=str)}
+        self.sio.on(request_type + "_response", request_callback)
+        self.logger.debug("try sending")
+        self.sio.emit(request_type + "_request", request_content)
+        self.sio.wait()

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

@@ -0,0 +1,1332 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+from __future__ import division
+from __future__ import print_function
+
+import re
+import abc
+import copy
+import queue
+import bisect
+import numpy as np
+import pandas as pd
+from typing import List, Union, Optional
+
+# For supporting multiprocessing in outer code, joblib is used
+from joblib import delayed
+
+from .cache import H
+from ..config import C
+from .inst_processor import InstProcessor
+
+from ..log import get_module_logger
+from .cache import DiskDatasetCache
+from ..utils import (
+    Wrapper,
+    init_instance_by_config,
+    register_wrapper,
+    get_module_by_module_path,
+    parse_field,
+    hash_args,
+    normalize_cache_fields,
+    code_to_fname,
+    time_to_slc_point,
+    read_period_data,
+    get_period_list,
+)
+from ..utils.paral import ParallelExt
+from .ops import Operators  # pylint: disable=W0611  # noqa: F401
+
+
+class ProviderBackendMixin:
+    """
+    This helper class tries to make the provider based on storage backend more convenient
+    It is not necessary to inherent this class if that provider don't rely on the backend storage
+    """
+
+    def get_default_backend(self):
+        backend = {}
+        provider_name: str = re.findall("[A-Z][^A-Z]*", self.__class__.__name__)[-2]
+        # set default storage class
+        backend.setdefault("class", f"File{provider_name}Storage")
+        # set default storage module
+        backend.setdefault("module_path", "qlib.data.storage.file_storage")
+        return backend
+
+    def backend_obj(self, **kwargs):
+        backend = self.backend if self.backend else self.get_default_backend()
+        backend = copy.deepcopy(backend)
+        backend.setdefault("kwargs", {}).update(**kwargs)
+        return init_instance_by_config(backend)
+
+
+class CalendarProvider(abc.ABC):
+    """Calendar provider base class
+
+    Provide calendar data.
+    """
+
+    def calendar(self, start_time=None, end_time=None, freq="day", future=False):
+        """Get calendar of certain market in given time range.
+
+        Parameters
+        ----------
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        freq : str
+            time frequency, available: year/quarter/month/week/day.
+        future : bool
+            whether including future trading day.
+
+        Returns
+        ----------
+        list
+            calendar list
+        """
+        _calendar, _calendar_index = self._get_calendar(freq, future)
+        if start_time == "None":
+            start_time = None
+        if end_time == "None":
+            end_time = None
+        # strip
+        if start_time:
+            start_time = pd.Timestamp(start_time)
+            if start_time > _calendar[-1]:
+                return np.array([])
+        else:
+            start_time = _calendar[0]
+        if end_time:
+            end_time = pd.Timestamp(end_time)
+            if end_time < _calendar[0]:
+                return np.array([])
+        else:
+            end_time = _calendar[-1]
+        _, _, si, ei = self.locate_index(start_time, end_time, freq, future)
+        return _calendar[si : ei + 1]
+
+    def locate_index(
+        self, start_time: Union[pd.Timestamp, str], end_time: Union[pd.Timestamp, str], freq: str, future: bool = False
+    ):
+        """Locate the start time index and end time index in a calendar under certain frequency.
+
+        Parameters
+        ----------
+        start_time : pd.Timestamp
+            start of the time range.
+        end_time : pd.Timestamp
+            end of the time range.
+        freq : str
+            time frequency, available: year/quarter/month/week/day.
+        future : bool
+            whether including future trading day.
+
+        Returns
+        -------
+        pd.Timestamp
+            the real start time.
+        pd.Timestamp
+            the real end time.
+        int
+            the index of start time.
+        int
+            the index of end time.
+        """
+        start_time = pd.Timestamp(start_time)
+        end_time = pd.Timestamp(end_time)
+        calendar, calendar_index = self._get_calendar(freq=freq, future=future)
+        if start_time not in calendar_index:
+            try:
+                start_time = calendar[bisect.bisect_left(calendar, start_time)]
+            except IndexError as index_e:
+                raise IndexError(
+                    "`start_time` uses a future date, if you want to get future trading days, you can use: `future=True`"
+                ) from index_e
+        start_index = calendar_index[start_time]
+        if end_time not in calendar_index:
+            end_time = calendar[bisect.bisect_right(calendar, end_time) - 1]
+        end_index = calendar_index[end_time]
+        return start_time, end_time, start_index, end_index
+
+    def _get_calendar(self, freq, future):
+        """Load calendar using memcache.
+
+        Parameters
+        ----------
+        freq : str
+            frequency of read calendar file.
+        future : bool
+            whether including future trading day.
+
+        Returns
+        -------
+        list
+            list of timestamps.
+        dict
+            dict composed by timestamp as key and index as value for fast search.
+        """
+        flag = f"{freq}_future_{future}"
+        if flag not in H["c"]:
+            _calendar = np.array(self.load_calendar(freq, future))
+            _calendar_index = {x: i for i, x in enumerate(_calendar)}  # for fast search
+            H["c"][flag] = _calendar, _calendar_index
+        return H["c"][flag]
+
+    def _uri(self, start_time, end_time, freq, future=False):
+        """Get the uri of calendar generation task."""
+        return hash_args(start_time, end_time, freq, future)
+
+    def load_calendar(self, freq, future):
+        """Load original calendar timestamp from file.
+
+        Parameters
+        ----------
+        freq : str
+            frequency of read calendar file.
+        future: bool
+
+        Returns
+        ----------
+        list
+            list of timestamps
+        """
+        raise NotImplementedError("Subclass of CalendarProvider must implement `load_calendar` method")
+
+
+class InstrumentProvider(abc.ABC):
+    """Instrument provider base class
+
+    Provide instrument data.
+    """
+
+    @staticmethod
+    def instruments(market: Union[List, str] = "all", filter_pipe: Union[List, None] = None):
+        """Get the general config dictionary for a base market adding several dynamic filters.
+
+        Parameters
+        ----------
+        market : Union[List, str]
+            str:
+                market/industry/index shortname, e.g. all/sse/szse/sse50/csi300/csi500.
+            list:
+                ["ID1", "ID2"]. A list of stocks
+        filter_pipe : list
+            the list of dynamic filters.
+
+        Returns
+        ----------
+        dict: if isinstance(market, str)
+            dict of stockpool config.
+
+            {`market` => base market name, `filter_pipe` => list of filters}
+
+            example :
+
+            .. code-block::
+
+                {'market': 'csi500',
+                'filter_pipe': [{'filter_type': 'ExpressionDFilter',
+                'rule_expression': '$open<40',
+                'filter_start_time': None,
+                'filter_end_time': None,
+                'keep': False},
+                {'filter_type': 'NameDFilter',
+                'name_rule_re': 'SH[0-9]{4}55',
+                'filter_start_time': None,
+                'filter_end_time': None}]}
+
+        list: if isinstance(market, list)
+            just return the original list directly.
+            NOTE: this will make the instruments compatible with more cases. The user code will be simpler.
+        """
+        if isinstance(market, list):
+            return market
+        from .filter import SeriesDFilter  # pylint: disable=C0415
+
+        if filter_pipe is None:
+            filter_pipe = []
+        config = {"market": market, "filter_pipe": []}
+        # the order of the filters will affect the result, so we need to keep
+        # the order
+        for filter_t in filter_pipe:
+            if isinstance(filter_t, dict):
+                _config = filter_t
+            elif isinstance(filter_t, SeriesDFilter):
+                _config = filter_t.to_config()
+            else:
+                raise TypeError(
+                    f"Unsupported filter types: {type(filter_t)}! Filter only supports dict or isinstance(filter, SeriesDFilter)"
+                )
+            config["filter_pipe"].append(_config)
+        return config
+
+    @abc.abstractmethod
+    def list_instruments(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
+        """List the instruments based on a certain stockpool config.
+
+        Parameters
+        ----------
+        instruments : dict
+            stockpool config.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        as_list : bool
+            return instruments as list or dict.
+
+        Returns
+        -------
+        dict or list
+            instruments list or dictionary with time spans
+        """
+        raise NotImplementedError("Subclass of InstrumentProvider must implement `list_instruments` method")
+
+    def _uri(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
+        return hash_args(instruments, start_time, end_time, freq, as_list)
+
+    # instruments type
+    LIST = "LIST"
+    DICT = "DICT"
+    CONF = "CONF"
+
+    @classmethod
+    def get_inst_type(cls, inst):
+        if "market" in inst:
+            return cls.CONF
+        if isinstance(inst, dict):
+            return cls.DICT
+        if isinstance(inst, (list, tuple, pd.Index, np.ndarray)):
+            return cls.LIST
+        raise ValueError(f"Unknown instrument type {inst}")
+
+
+class FeatureProvider(abc.ABC):
+    """Feature provider class
+
+    Provide feature data.
+    """
+
+    @abc.abstractmethod
+    def feature(self, instrument, field, start_time, end_time, freq):
+        """Get feature data.
+
+        Parameters
+        ----------
+        instrument : str
+            a certain instrument.
+        field : str
+            a certain field of feature.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        freq : str
+            time frequency, available: year/quarter/month/week/day.
+
+        Returns
+        -------
+        pd.Series
+            data of a certain feature
+        """
+        raise NotImplementedError("Subclass of FeatureProvider must implement `feature` method")
+
+
+class PITProvider(abc.ABC):
+    @abc.abstractmethod
+    def period_feature(
+        self,
+        instrument,
+        field,
+        start_index: int,
+        end_index: int,
+        cur_time: pd.Timestamp,
+        period: Optional[int] = None,
+    ) -> pd.Series:
+        """
+        get the historical periods data series between `start_index` and `end_index`
+
+        Parameters
+        ----------
+        start_index: int
+            start_index is a relative index to the latest period to cur_time
+
+        end_index: int
+            end_index is a relative index to the latest period to cur_time
+            in most cases, the start_index and end_index will be a non-positive values
+            For example, start_index == -3 end_index == 0 and current period index is cur_idx,
+            then the data between [start_index + cur_idx, end_index + cur_idx] will be retrieved.
+
+        period: int
+            This is used for query specific period.
+            The period is represented with int in Qlib. (e.g. 202001 may represent the first quarter in 2020)
+            NOTE: `period`  will override `start_index` and `end_index`
+
+        Returns
+        -------
+        pd.Series
+            The index will be integers to indicate the periods of the data
+            An typical examples will be
+            TODO
+
+        Raises
+        ------
+        FileNotFoundError
+            This exception will be raised if the queried data do not exist.
+        """
+        raise NotImplementedError(f"Please implement the `period_feature` method")
+
+
+class ExpressionProvider(abc.ABC):
+    """Expression provider class
+
+    Provide Expression data.
+    """
+
+    def __init__(self):
+        self.expression_instance_cache = {}
+
+    def get_expression_instance(self, field):
+        try:
+            if field in self.expression_instance_cache:
+                expression = self.expression_instance_cache[field]
+            else:
+                expression = eval(parse_field(field))
+                self.expression_instance_cache[field] = expression
+        except NameError as e:
+            get_module_logger("data").exception(
+                "ERROR: field [%s] contains invalid operator/variable [%s]" % (str(field), str(e).split()[1])
+            )
+            raise
+        except SyntaxError:
+            get_module_logger("data").exception("ERROR: field [%s] contains invalid syntax" % str(field))
+            raise
+        return expression
+
+    @abc.abstractmethod
+    def expression(self, instrument, field, start_time=None, end_time=None, freq="day") -> pd.Series:
+        """Get Expression data.
+
+        The responsibility of `expression`
+        - parse the `field` and `load` the according data.
+        - When loading the data, it should handle the time dependency of the data. `get_expression_instance` is commonly used in this method
+
+        Parameters
+        ----------
+        instrument : str
+            a certain instrument.
+        field : str
+            a certain field of feature.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        freq : str
+            time frequency, available: year/quarter/month/week/day.
+
+        Returns
+        -------
+        pd.Series
+            data of a certain expression
+
+            The data has two types of format
+
+            1) expression with datetime index
+
+            2) expression with integer index
+
+                - because the datetime is not as good as
+        """
+        raise NotImplementedError("Subclass of ExpressionProvider must implement `Expression` method")
+
+
+class DatasetProvider(abc.ABC):
+    """Dataset provider class
+
+    Provide Dataset data.
+    """
+
+    @abc.abstractmethod
+    def dataset(self, instruments, fields, start_time=None, end_time=None, freq="day", inst_processors=[]):
+        """Get dataset data.
+
+        Parameters
+        ----------
+        instruments : list or dict
+            list/dict of instruments or dict of stockpool config.
+        fields : list
+            list of feature instances.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        freq : str
+            time frequency.
+        inst_processors:  Iterable[Union[dict, InstProcessor]]
+            the operations performed on each instrument
+
+        Returns
+        ----------
+        pd.DataFrame
+            a pandas dataframe with <instrument, datetime> index.
+        """
+        raise NotImplementedError("Subclass of DatasetProvider must implement `Dataset` method")
+
+    def _uri(
+        self,
+        instruments,
+        fields,
+        start_time=None,
+        end_time=None,
+        freq="day",
+        disk_cache=1,
+        inst_processors=[],
+        **kwargs,
+    ):
+        """Get task uri, used when generating rabbitmq task in qlib_server
+
+        Parameters
+        ----------
+        instruments : list or dict
+            list/dict of instruments or dict of stockpool config.
+        fields : list
+            list of feature instances.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+        freq : str
+            time frequency.
+        disk_cache : int
+            whether to skip(0)/use(1)/replace(2) disk_cache.
+
+        """
+        # TODO: qlib-server support inst_processors
+        return DiskDatasetCache._uri(instruments, fields, start_time, end_time, freq, disk_cache, inst_processors)
+
+    @staticmethod
+    def get_instruments_d(instruments, freq):
+        """
+        Parse different types of input instruments to output instruments_d
+        Wrong format of input instruments will lead to exception.
+
+        """
+        if isinstance(instruments, dict):
+            if "market" in instruments:
+                # dict of stockpool config
+                instruments_d = Inst.list_instruments(instruments=instruments, freq=freq, as_list=False)
+            else:
+                # dict of instruments and timestamp
+                instruments_d = instruments
+        elif isinstance(instruments, (list, tuple, pd.Index, np.ndarray)):
+            # list or tuple of a group of instruments
+            instruments_d = list(instruments)
+        else:
+            raise ValueError("Unsupported input type for param `instrument`")
+        return instruments_d
+
+    @staticmethod
+    def get_column_names(fields):
+        """
+        Get column names from input fields
+
+        """
+        if len(fields) == 0:
+            raise ValueError("fields cannot be empty")
+        column_names = [str(f) for f in fields]
+        return column_names
+
+    @staticmethod
+    def parse_fields(fields):
+        # parse and check the input fields
+        return [ExpressionD.get_expression_instance(f) for f in fields]
+
+    @staticmethod
+    def dataset_processor(instruments_d, column_names, start_time, end_time, freq, inst_processors=[]):
+        """
+        Load and process the data, return the data set.
+        - default using multi-kernel method.
+
+        """
+        normalize_column_names = normalize_cache_fields(column_names)
+        # One process for one task, so that the memory will be freed quicker.
+        workers = max(min(C.get_kernels(freq), len(instruments_d)), 1)
+
+        # create iterator
+        if isinstance(instruments_d, dict):
+            it = instruments_d.items()
+        else:
+            it = zip(instruments_d, [None] * len(instruments_d))
+
+        inst_l = []
+        task_l = []
+        for inst, spans in it:
+            inst_l.append(inst)
+            task_l.append(
+                delayed(DatasetProvider.inst_calculator)(
+                    inst, start_time, end_time, freq, normalize_column_names, spans, C, inst_processors
+                )
+            )
+
+        data = dict(
+            zip(
+                inst_l,
+                ParallelExt(n_jobs=workers, backend=C.joblib_backend, maxtasksperchild=C.maxtasksperchild)(task_l),
+            )
+        )
+
+        new_data = dict()
+        for inst in sorted(data.keys()):
+            if len(data[inst]) > 0:
+                # NOTE: Python version >= 3.6; in versions after python3.6, dict will always guarantee the insertion order
+                new_data[inst] = data[inst]
+
+        if len(new_data) > 0:
+            data = pd.concat(new_data, names=["instrument"], sort=False)
+            data = DiskDatasetCache.cache_to_origin_data(data, column_names)
+        else:
+            data = pd.DataFrame(
+                index=pd.MultiIndex.from_arrays([[], []], names=("instrument", "datetime")),
+                columns=column_names,
+                dtype=np.float32,
+            )
+
+        return data
+
+    @staticmethod
+    def inst_calculator(inst, start_time, end_time, freq, column_names, spans=None, g_config=None, inst_processors=[]):
+        """
+        Calculate the expressions for **one** instrument, return a df result.
+        If the expression has been calculated before, load from cache.
+
+        return value: A data frame with index 'datetime' and other data columns.
+
+        """
+        # FIXME: Windows OS or MacOS using spawn: https://docs.python.org/3.8/library/multiprocessing.html?highlight=spawn#contexts-and-start-methods
+        # NOTE: This place is compatible with windows, windows multi-process is spawn
+        C.register_from_C(g_config)
+
+        obj = dict()
+        for field in column_names:
+            #  The client does not have expression provider, the data will be loaded from cache using static method.
+            obj[field] = ExpressionD.expression(inst, field, start_time, end_time, freq)
+
+        data = pd.DataFrame(obj)
+        if not data.empty and not np.issubdtype(data.index.dtype, np.dtype("M")):
+            # If the underlaying provides the data not in datetime format, we'll convert it into datetime format
+            _calendar = Cal.calendar(freq=freq)
+            data.index = _calendar[data.index.values.astype(int)]
+        data.index.names = ["datetime"]
+
+        if not data.empty and spans is not None:
+            mask = np.zeros(len(data), dtype=bool)
+            for begin, end in spans:
+                mask |= (data.index >= begin) & (data.index <= end)
+            data = data[mask]
+
+        for _processor in inst_processors:
+            if _processor:
+                _processor_obj = init_instance_by_config(_processor, accept_types=InstProcessor)
+                data = _processor_obj(data, instrument=inst)
+        return data
+
+
+class LocalCalendarProvider(CalendarProvider, ProviderBackendMixin):
+    """Local calendar data provider class
+
+    Provide calendar data from local data source.
+    """
+
+    def __init__(self, remote=False, backend={}):
+        super().__init__()
+        self.remote = remote
+        self.backend = backend
+
+    def load_calendar(self, freq, future):
+        """Load original calendar timestamp from file.
+
+        Parameters
+        ----------
+        freq : str
+            frequency of read calendar file.
+        future: bool
+        Returns
+        ----------
+        list
+            list of timestamps
+        """
+        try:
+            backend_obj = self.backend_obj(freq=freq, future=future).data
+        except ValueError:
+            if future:
+                get_module_logger("data").warning(
+                    f"load calendar error: freq={freq}, future={future}; return current calendar!"
+                )
+                get_module_logger("data").warning(
+                    "You can get future calendar by referring to the following document: https://github.com/microsoft/qlib/blob/main/scripts/data_collector/contrib/README.md"
+                )
+                backend_obj = self.backend_obj(freq=freq, future=False).data
+            else:
+                raise
+
+        return [pd.Timestamp(x) for x in backend_obj]
+
+
+class LocalInstrumentProvider(InstrumentProvider, ProviderBackendMixin):
+    """Local instrument data provider class
+
+    Provide instrument data from local data source.
+    """
+
+    def __init__(self, backend={}) -> None:
+        super().__init__()
+        self.backend = backend
+
+    def _load_instruments(self, market, freq):
+        return self.backend_obj(market=market, freq=freq).data
+
+    def list_instruments(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
+        market = instruments["market"]
+        if market in H["i"]:
+            _instruments = H["i"][market]
+        else:
+            _instruments = self._load_instruments(market, freq=freq)
+            H["i"][market] = _instruments
+        # strip
+        # use calendar boundary
+        cal = Cal.calendar(freq=freq)
+        start_time = pd.Timestamp(start_time or cal[0])
+        end_time = pd.Timestamp(end_time or cal[-1])
+        _instruments_filtered = {
+            inst: list(
+                filter(
+                    lambda x: x[0] <= x[1],
+                    [(max(start_time, pd.Timestamp(x[0])), min(end_time, pd.Timestamp(x[1]))) for x in spans],
+                )
+            )
+            for inst, spans in _instruments.items()
+        }
+        _instruments_filtered = {key: value for key, value in _instruments_filtered.items() if value}
+        # filter
+        filter_pipe = instruments["filter_pipe"]
+        for filter_config in filter_pipe:
+            from . import filter as F  # pylint: disable=C0415
+
+            filter_t = getattr(F, filter_config["filter_type"]).from_config(filter_config)
+            _instruments_filtered = filter_t(_instruments_filtered, start_time, end_time, freq)
+        # as list
+        if as_list:
+            return list(_instruments_filtered)
+        return _instruments_filtered
+
+
+class LocalFeatureProvider(FeatureProvider, ProviderBackendMixin):
+    """Local feature data provider class
+
+    Provide feature data from local data source.
+    """
+
+    def __init__(self, remote=False, backend={}):
+        super().__init__()
+        self.remote = remote
+        self.backend = backend
+
+    def feature(self, instrument, field, start_index, end_index, freq):
+        # validate
+        field = str(field)[1:]
+        instrument = code_to_fname(instrument)
+        return self.backend_obj(instrument=instrument, field=field, freq=freq)[start_index : end_index + 1]
+
+
+class LocalPITProvider(PITProvider):
+    # TODO: Add PIT backend file storage
+    # NOTE: This class is not multi-threading-safe!!!!
+
+    def period_feature(self, instrument, field, start_index, end_index, cur_time, period=None):
+        if not isinstance(cur_time, pd.Timestamp):
+            raise ValueError(
+                f"Expected pd.Timestamp for `cur_time`, got '{cur_time}'. Advices: you can't query PIT data directly(e.g. '$$roewa_q'), you must use `P` operator to convert data to each day (e.g. 'P($$roewa_q)')"
+            )
+
+        assert end_index <= 0  # PIT don't support querying future data
+
+        DATA_RECORDS = [
+            ("date", C.pit_record_type["date"]),
+            ("period", C.pit_record_type["period"]),
+            ("value", C.pit_record_type["value"]),
+            ("_next", C.pit_record_type["index"]),
+        ]
+        VALUE_DTYPE = C.pit_record_type["value"]
+
+        field = str(field).lower()[2:]
+        instrument = code_to_fname(instrument)
+
+        # {For acceleration
+        # start_index, end_index, cur_index = kwargs["info"]
+        # if cur_index == start_index:
+        #     if not hasattr(self, "all_fields"):
+        #         self.all_fields = []
+        #     self.all_fields.append(field)
+        #     if not hasattr(self, "period_index"):
+        #         self.period_index = {}
+        #     if field not in self.period_index:
+        #         self.period_index[field] = {}
+        # For acceleration}
+
+        if not field.endswith("_q") and not field.endswith("_a"):
+            raise ValueError("period field must ends with '_q' or '_a'")
+        quarterly = field.endswith("_q")
+        index_path = C.dpm.get_data_uri() / "financial" / instrument.lower() / f"{field}.index"
+        data_path = C.dpm.get_data_uri() / "financial" / instrument.lower() / f"{field}.data"
+        if not (index_path.exists() and data_path.exists()):
+            raise FileNotFoundError("No file is found.")
+        # NOTE: The most significant performance loss is here.
+        # Does the acceleration that makes the program complicated really matters?
+        # - It makes parameters of the interface complicate
+        # - It does not performance in the optimal way (places all the pieces together, we may achieve higher performance)
+        #    - If we design it carefully, we can go through for only once to get the historical evolution of the data.
+        # So I decide to deprecated previous implementation and keep the logic of the program simple
+        # Instead, I'll add a cache for the index file.
+        data = np.fromfile(data_path, dtype=DATA_RECORDS)
+
+        # find all revision periods before `cur_time`
+        cur_time_int = int(cur_time.year) * 10000 + int(cur_time.month) * 100 + int(cur_time.day)
+        loc = np.searchsorted(data["date"], cur_time_int, side="right")
+        if loc <= 0:
+            return pd.Series(dtype=C.pit_record_type["value"])
+        last_period = data["period"][:loc].max()  # return the latest quarter
+        first_period = data["period"][:loc].min()
+        period_list = get_period_list(first_period, last_period, quarterly)
+        if period is not None:
+            # NOTE: `period` has higher priority than `start_index` & `end_index`
+            if period not in period_list:
+                return pd.Series(dtype=C.pit_record_type["value"])
+            else:
+                period_list = [period]
+        else:
+            period_list = period_list[max(0, len(period_list) + start_index - 1) : len(period_list) + end_index]
+        value = np.full((len(period_list),), np.nan, dtype=VALUE_DTYPE)
+        for i, p in enumerate(period_list):
+            # last_period_index = self.period_index[field].get(period)  # For acceleration
+            value[i], now_period_index = read_period_data(
+                index_path, data_path, p, cur_time_int, quarterly  # , last_period_index  # For acceleration
+            )
+            # self.period_index[field].update({period: now_period_index})  # For acceleration
+        # NOTE: the index is period_list; So it may result in unexpected values(e.g. nan)
+        # when calculation between different features and only part of its financial indicator is published
+        series = pd.Series(value, index=period_list, dtype=VALUE_DTYPE)
+
+        # {For acceleration
+        # if cur_index == end_index:
+        #     self.all_fields.remove(field)
+        #     if not len(self.all_fields):
+        #         del self.all_fields
+        #         del self.period_index
+        # For acceleration}
+
+        return series
+
+
+class LocalExpressionProvider(ExpressionProvider):
+    """Local expression data provider class
+
+    Provide expression data from local data source.
+    """
+
+    def __init__(self, time2idx=True):
+        super().__init__()
+        self.time2idx = time2idx
+
+    def expression(self, instrument, field, start_time=None, end_time=None, freq="day"):
+        expression = self.get_expression_instance(field)
+        start_time = time_to_slc_point(start_time)
+        end_time = time_to_slc_point(end_time)
+
+        # Two kinds of queries are supported
+        # - Index-based expression: this may save a lot of memory because the datetime index is not saved on the disk
+        # - Data with datetime index expression: this will make it more convenient to integrating with some existing databases
+        if self.time2idx:
+            _, _, start_index, end_index = Cal.locate_index(start_time, end_time, freq=freq, future=False)
+            lft_etd, rght_etd = expression.get_extended_window_size()
+            query_start, query_end = max(0, start_index - lft_etd), end_index + rght_etd
+        else:
+            start_index, end_index = query_start, query_end = start_time, end_time
+
+        try:
+            series = expression.load(instrument, query_start, query_end, freq)
+        except Exception as e:
+            get_module_logger("data").debug(
+                f"Loading expression error: "
+                f"instrument={instrument}, field=({field}), start_time={start_time}, end_time={end_time}, freq={freq}. "
+                f"error info: {str(e)}"
+            )
+            raise
+        # Ensure that each column type is consistent
+        # FIXME:
+        # 1) The stock data is currently float. If there is other types of data, this part needs to be re-implemented.
+        # 2) The precision should be configurable
+        try:
+            series = series.astype(np.float32)
+        except ValueError:
+            pass
+        except TypeError:
+            pass
+        if not series.empty:
+            series = series.loc[start_index:end_index]
+        return series
+
+
+class LocalDatasetProvider(DatasetProvider):
+    """Local dataset data provider class
+
+    Provide dataset data from local data source.
+    """
+
+    def __init__(self, align_time: bool = True):
+        """
+        Parameters
+        ----------
+        align_time : bool
+            Will we align the time to calendar
+            the frequency is flexible in some dataset and can't be aligned.
+            For the data with fixed frequency with a shared calendar, the align data to the calendar will provides following benefits
+
+            - Align queries to the same parameters, so the cache can be shared.
+        """
+        super().__init__()
+        self.align_time = align_time
+
+    def dataset(
+        self,
+        instruments,
+        fields,
+        start_time=None,
+        end_time=None,
+        freq="day",
+        inst_processors=[],
+    ):
+        instruments_d = self.get_instruments_d(instruments, freq)
+        column_names = self.get_column_names(fields)
+        if self.align_time:
+            # NOTE: if the frequency is a fixed value.
+            # align the data to fixed calendar point
+            cal = Cal.calendar(start_time, end_time, freq)
+            if len(cal) == 0:
+                return pd.DataFrame(
+                    index=pd.MultiIndex.from_arrays([[], []], names=("instrument", "datetime")), columns=column_names
+                )
+            start_time = cal[0]
+            end_time = cal[-1]
+        data = self.dataset_processor(
+            instruments_d, column_names, start_time, end_time, freq, inst_processors=inst_processors
+        )
+
+        return data
+
+    @staticmethod
+    def multi_cache_walker(instruments, fields, start_time=None, end_time=None, freq="day"):
+        """
+        This method is used to prepare the expression cache for the client.
+        Then the client will load the data from expression cache by itself.
+
+        """
+        instruments_d = DatasetProvider.get_instruments_d(instruments, freq)
+        column_names = DatasetProvider.get_column_names(fields)
+        cal = Cal.calendar(start_time, end_time, freq)
+        if len(cal) == 0:
+            return
+        start_time = cal[0]
+        end_time = cal[-1]
+        workers = max(min(C.kernels, len(instruments_d)), 1)
+
+        ParallelExt(n_jobs=workers, backend=C.joblib_backend, maxtasksperchild=C.maxtasksperchild)(
+            delayed(LocalDatasetProvider.cache_walker)(inst, start_time, end_time, freq, column_names)
+            for inst in instruments_d
+        )
+
+    @staticmethod
+    def cache_walker(inst, start_time, end_time, freq, column_names):
+        """
+        If the expressions of one instrument haven't been calculated before,
+        calculate it and write it into expression cache.
+
+        """
+        for field in column_names:
+            ExpressionD.expression(inst, field, start_time, end_time, freq)
+
+
+class ClientCalendarProvider(CalendarProvider):
+    """Client calendar data provider class
+
+    Provide calendar data by requesting data from server as a client.
+    """
+
+    def __init__(self):
+        self.conn = None
+        self.queue = queue.Queue()
+
+    def set_conn(self, conn):
+        self.conn = conn
+
+    def calendar(self, start_time=None, end_time=None, freq="day", future=False):
+        self.conn.send_request(
+            request_type="calendar",
+            request_content={"start_time": str(start_time), "end_time": str(end_time), "freq": freq, "future": future},
+            msg_queue=self.queue,
+            msg_proc_func=lambda response_content: [pd.Timestamp(c) for c in response_content],
+        )
+        result = self.queue.get(timeout=C["timeout"])
+        return result
+
+
+class ClientInstrumentProvider(InstrumentProvider):
+    """Client instrument data provider class
+
+    Provide instrument data by requesting data from server as a client.
+    """
+
+    def __init__(self):
+        self.conn = None
+        self.queue = queue.Queue()
+
+    def set_conn(self, conn):
+        self.conn = conn
+
+    def list_instruments(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
+        def inst_msg_proc_func(response_content):
+            if isinstance(response_content, dict):
+                instrument = {
+                    i: [(pd.Timestamp(s), pd.Timestamp(e)) for s, e in t] for i, t in response_content.items()
+                }
+            else:
+                instrument = response_content
+            return instrument
+
+        self.conn.send_request(
+            request_type="instrument",
+            request_content={
+                "instruments": instruments,
+                "start_time": str(start_time),
+                "end_time": str(end_time),
+                "freq": freq,
+                "as_list": as_list,
+            },
+            msg_queue=self.queue,
+            msg_proc_func=inst_msg_proc_func,
+        )
+        result = self.queue.get(timeout=C["timeout"])
+        if isinstance(result, Exception):
+            raise result
+        get_module_logger("data").debug("get result")
+        return result
+
+
+class ClientDatasetProvider(DatasetProvider):
+    """Client dataset data provider class
+
+    Provide dataset data by requesting data from server as a client.
+    """
+
+    def __init__(self):
+        self.conn = None
+
+    def set_conn(self, conn):
+        self.conn = conn
+        self.queue = queue.Queue()
+
+    def dataset(
+        self,
+        instruments,
+        fields,
+        start_time=None,
+        end_time=None,
+        freq="day",
+        disk_cache=0,
+        return_uri=False,
+        inst_processors=[],
+    ):
+        if Inst.get_inst_type(instruments) == Inst.DICT:
+            get_module_logger("data").warning(
+                "Getting features from a dict of instruments is not recommended because the features will not be "
+                "cached! "
+                "The dict of instruments will be cleaned every day."
+            )
+
+        if disk_cache == 0:
+            """
+            Call the server to generate the expression cache.
+            Then load the data from the expression cache directly.
+            - default using multi-kernel method.
+
+            """
+            self.conn.send_request(
+                request_type="feature",
+                request_content={
+                    "instruments": instruments,
+                    "fields": fields,
+                    "start_time": start_time,
+                    "end_time": end_time,
+                    "freq": freq,
+                    "disk_cache": 0,
+                },
+                msg_queue=self.queue,
+            )
+            feature_uri = self.queue.get(timeout=C["timeout"])
+            if isinstance(feature_uri, Exception):
+                raise feature_uri
+            else:
+                instruments_d = self.get_instruments_d(instruments, freq)
+                column_names = self.get_column_names(fields)
+                cal = Cal.calendar(start_time, end_time, freq)
+                if len(cal) == 0:
+                    return pd.DataFrame(
+                        index=pd.MultiIndex.from_arrays([[], []], names=("instrument", "datetime")),
+                        columns=column_names,
+                    )
+                start_time = cal[0]
+                end_time = cal[-1]
+
+                data = self.dataset_processor(instruments_d, column_names, start_time, end_time, freq, inst_processors)
+                if return_uri:
+                    return data, feature_uri
+                else:
+                    return data
+        else:
+            """
+            Call the server to generate the data-set cache, get the uri of the cache file.
+            Then load the data from the file on NFS directly.
+            - using single-process implementation.
+
+            """
+            # TODO: support inst_processors, need to change the code of qlib-server at the same time
+            # FIXME: The cache after resample, when read again and intercepted with end_time, results in incomplete data date
+            if inst_processors:
+                raise ValueError(
+                    f"{self.__class__.__name__} does not support inst_processor. "
+                    f"Please use `D.features(disk_cache=0)` or `qlib.init(dataset_cache=None)`"
+                )
+            self.conn.send_request(
+                request_type="feature",
+                request_content={
+                    "instruments": instruments,
+                    "fields": fields,
+                    "start_time": start_time,
+                    "end_time": end_time,
+                    "freq": freq,
+                    "disk_cache": 1,
+                },
+                msg_queue=self.queue,
+            )
+            # - Done in callback
+            feature_uri = self.queue.get(timeout=C["timeout"])
+            if isinstance(feature_uri, Exception):
+                raise feature_uri
+            get_module_logger("data").debug("get result")
+            try:
+                # pre-mound nfs, used for demo
+                mnt_feature_uri = C.dpm.get_data_uri(freq).joinpath(C.dataset_cache_dir_name, feature_uri)
+                df = DiskDatasetCache.read_data_from_cache(mnt_feature_uri, start_time, end_time, fields)
+                get_module_logger("data").debug("finish slicing data")
+                if return_uri:
+                    return df, feature_uri
+                return df
+            except AttributeError as attribute_e:
+                raise IOError("Unable to fetch instruments from remote server!") from attribute_e
+
+
+class BaseProvider:
+    """Local provider class
+    It is a set of interface that allow users to access data.
+    Because PITD is not exposed publicly to users, so it is not included in the interface.
+
+    To keep compatible with old qlib provider.
+    """
+
+    def calendar(self, start_time=None, end_time=None, freq="day", future=False):
+        return Cal.calendar(start_time, end_time, freq, future=future)
+
+    def instruments(self, market="all", filter_pipe=None, start_time=None, end_time=None):
+        if start_time is not None or end_time is not None:
+            get_module_logger("Provider").warning(
+                "The instruments corresponds to a stock pool. "
+                "Parameters `start_time` and `end_time` does not take effect now."
+            )
+        return InstrumentProvider.instruments(market, filter_pipe)
+
+    def list_instruments(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
+        return Inst.list_instruments(instruments, start_time, end_time, freq, as_list)
+
+    def features(
+        self,
+        instruments,
+        fields,
+        start_time=None,
+        end_time=None,
+        freq="day",
+        disk_cache=None,
+        inst_processors=[],
+    ):
+        """
+        Parameters
+        ----------
+        disk_cache : int
+            whether to skip(0)/use(1)/replace(2) disk_cache
+
+
+        This function will try to use cache method which has a keyword `disk_cache`,
+        and will use provider method if a type error is raised because the DatasetD instance
+        is a provider class.
+        """
+        disk_cache = C.default_disk_cache if disk_cache is None else disk_cache
+        fields = list(fields)  # In case of tuple.
+        try:
+            return DatasetD.dataset(
+                instruments, fields, start_time, end_time, freq, disk_cache, inst_processors=inst_processors
+            )
+        except TypeError:
+            return DatasetD.dataset(instruments, fields, start_time, end_time, freq, inst_processors=inst_processors)
+
+
+class LocalProvider(BaseProvider):
+    def _uri(self, type, **kwargs):
+        """_uri
+        The server hope to get the uri of the request. The uri will be decided
+        by the dataprovider. For ex, different cache layer has different uri.
+
+        :param type: The type of resource for the uri
+        :param **kwargs:
+        """
+        if type == "calendar":
+            return Cal._uri(**kwargs)
+        elif type == "instrument":
+            return Inst._uri(**kwargs)
+        elif type == "feature":
+            return DatasetD._uri(**kwargs)
+
+    def features_uri(self, instruments, fields, start_time, end_time, freq, disk_cache=1):
+        """features_uri
+
+        Return the uri of the generated cache of features/dataset
+
+        :param disk_cache:
+        :param instruments:
+        :param fields:
+        :param start_time:
+        :param end_time:
+        :param freq:
+        """
+        return DatasetD._dataset_uri(instruments, fields, start_time, end_time, freq, disk_cache)
+
+
+class ClientProvider(BaseProvider):
+    """Client Provider
+
+    Requesting data from server as a client. Can propose requests:
+
+        - Calendar : Directly respond a list of calendars
+        - Instruments (without filter): Directly respond a list/dict of instruments
+        - Instruments (with filters):  Respond a list/dict of instruments
+        - Features : Respond a cache uri
+
+    The general workflow is described as follows:
+    When the user use client provider to propose a request, the client provider will connect the server and send the request. The client will start to wait for the response. The response will be made instantly indicating whether the cache is available. The waiting procedure will terminate only when the client get the response saying `feature_available` is true.
+    `BUG` : Everytime we make request for certain data we need to connect to the server, wait for the response and disconnect from it. We can't make a sequence of requests within one connection. You can refer to https://python-socketio.readthedocs.io/en/latest/client.html for documentation of python-socketIO client.
+    """
+
+    def __init__(self):
+        def is_instance_of_provider(instance: object, cls: type):
+            if isinstance(instance, Wrapper):
+                p = getattr(instance, "_provider", None)
+
+                return False if p is None else isinstance(p, cls)
+
+            return isinstance(instance, cls)
+
+        from .client import Client  # pylint: disable=C0415
+
+        self.client = Client(C.flask_server, C.flask_port)
+        self.logger = get_module_logger(self.__class__.__name__)
+        if is_instance_of_provider(Cal, ClientCalendarProvider):
+            Cal.set_conn(self.client)
+        if is_instance_of_provider(Inst, ClientInstrumentProvider):
+            Inst.set_conn(self.client)
+        if hasattr(DatasetD, "provider"):
+            DatasetD.provider.set_conn(self.client)
+        else:
+            DatasetD.set_conn(self.client)
+
+
+import sys
+
+if sys.version_info >= (3, 9):
+    from typing import Annotated
+
+    CalendarProviderWrapper = Annotated[CalendarProvider, Wrapper]
+    InstrumentProviderWrapper = Annotated[InstrumentProvider, Wrapper]
+    FeatureProviderWrapper = Annotated[FeatureProvider, Wrapper]
+    PITProviderWrapper = Annotated[PITProvider, Wrapper]
+    ExpressionProviderWrapper = Annotated[ExpressionProvider, Wrapper]
+    DatasetProviderWrapper = Annotated[DatasetProvider, Wrapper]
+    BaseProviderWrapper = Annotated[BaseProvider, Wrapper]
+else:
+    CalendarProviderWrapper = CalendarProvider
+    InstrumentProviderWrapper = InstrumentProvider
+    FeatureProviderWrapper = FeatureProvider
+    PITProviderWrapper = PITProvider
+    ExpressionProviderWrapper = ExpressionProvider
+    DatasetProviderWrapper = DatasetProvider
+    BaseProviderWrapper = BaseProvider
+
+Cal: CalendarProviderWrapper = Wrapper()
+Inst: InstrumentProviderWrapper = Wrapper()
+FeatureD: FeatureProviderWrapper = Wrapper()
+PITD: PITProviderWrapper = Wrapper()
+ExpressionD: ExpressionProviderWrapper = Wrapper()
+DatasetD: DatasetProviderWrapper = Wrapper()
+D: BaseProviderWrapper = Wrapper()
+
+
+def register_all_wrappers(C):
+    """register_all_wrappers"""
+    logger = get_module_logger("data")
+    module = get_module_by_module_path("qlib.data")
+
+    _calendar_provider = init_instance_by_config(C.calendar_provider, module)
+    if getattr(C, "calendar_cache", None) is not None:
+        _calendar_provider = init_instance_by_config(C.calendar_cache, module, provide=_calendar_provider)
+    register_wrapper(Cal, _calendar_provider, "qlib.data")
+    logger.debug(f"registering Cal {C.calendar_provider}-{C.calendar_cache}")
+
+    _instrument_provider = init_instance_by_config(C.instrument_provider, module)
+    register_wrapper(Inst, _instrument_provider, "qlib.data")
+    logger.debug(f"registering Inst {C.instrument_provider}")
+
+    if getattr(C, "feature_provider", None) is not None:
+        feature_provider = init_instance_by_config(C.feature_provider, module)
+        register_wrapper(FeatureD, feature_provider, "qlib.data")
+        logger.debug(f"registering FeatureD {C.feature_provider}")
+
+    if getattr(C, "pit_provider", None) is not None:
+        pit_provider = init_instance_by_config(C.pit_provider, module)
+        register_wrapper(PITD, pit_provider, "qlib.data")
+        logger.debug(f"registering PITD {C.pit_provider}")
+
+    if getattr(C, "expression_provider", None) is not None:
+        # This provider is unnecessary in client provider
+        _eprovider = init_instance_by_config(C.expression_provider, module)
+        if getattr(C, "expression_cache", None) is not None:
+            _eprovider = init_instance_by_config(C.expression_cache, module, provider=_eprovider)
+        register_wrapper(ExpressionD, _eprovider, "qlib.data")
+        logger.debug(f"registering ExpressionD {C.expression_provider}-{C.expression_cache}")
+
+    _dprovider = init_instance_by_config(C.dataset_provider, module)
+    if getattr(C, "dataset_cache", None) is not None:
+        _dprovider = init_instance_by_config(C.dataset_cache, module, provider=_dprovider)
+    register_wrapper(DatasetD, _dprovider, "qlib.data")
+    logger.debug(f"registering DatasetD {C.dataset_provider}-{C.dataset_cache}")
+
+    register_wrapper(D, C.provider, "qlib.data")
+    logger.debug(f"registering D {C.provider}")

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/dataset/__init__.py

@@ -0,0 +1,722 @@
+from ...utils.serial import Serializable
+from typing import Callable, Union, List, Tuple, Dict, Text, Optional
+from ...utils import init_instance_by_config, np_ffill, time_to_slc_point
+from ...log import get_module_logger
+from .handler import DataHandler, DataHandlerLP
+from copy import copy, deepcopy
+from inspect import getfullargspec
+import pandas as pd
+import numpy as np
+import bisect
+from ...utils import lazy_sort_index
+from .utils import get_level_index
+
+
+class Dataset(Serializable):
+    """
+    Preparing data for model training and inferencing.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        init is designed to finish following steps:
+
+        - init the sub instance and the state of the dataset(info to prepare the data)
+            - The name of essential state for preparing data should not start with '_' so that it could be serialized on disk when serializing.
+
+        - setup data
+            - The data related attributes' names should start with '_' so that it will not be saved on disk when serializing.
+
+        The data could specify the info to calculate the essential data for preparation
+        """
+        self.setup_data(**kwargs)
+        super().__init__()
+
+    def config(self, **kwargs):
+        """
+        config is designed to configure and parameters that cannot be learned from the data
+        """
+        super().config(**kwargs)
+
+    def setup_data(self, **kwargs):
+        """
+        Setup the data.
+
+        We split the setup_data function for following situation:
+
+        - User have a Dataset object with learned status on disk.
+
+        - User load the Dataset object from the disk.
+
+        - User call `setup_data` to load new data.
+
+        - User prepare data for model based on previous status.
+        """
+
+    def prepare(self, **kwargs) -> object:
+        """
+        The type of dataset depends on the model. (It could be pd.DataFrame, pytorch.DataLoader, etc.)
+        The parameters should specify the scope for the prepared data
+        The method should:
+        - process the data
+
+        - return the processed data
+
+        Returns
+        -------
+        object:
+            return the object
+        """
+
+
+class DatasetH(Dataset):
+    """
+    Dataset with Data(H)andler
+
+    User should try to put the data preprocessing functions into handler.
+    Only following data processing functions should be placed in Dataset:
+
+    - The processing is related to specific model.
+
+    - The processing is related to data split.
+    """
+
+    def __init__(
+        self,
+        handler: Union[Dict, DataHandler],
+        segments: Dict[Text, Tuple],
+        fetch_kwargs: Dict = {},
+        **kwargs,
+    ):
+        """
+        Setup the underlying data.
+
+        Parameters
+        ----------
+        handler : Union[dict, DataHandler]
+            handler could be:
+
+            - instance of `DataHandler`
+
+            - config of `DataHandler`.  Please refer to `DataHandler`
+
+        segments : dict
+            Describe the options to segment the data.
+            Here are some examples:
+
+            .. code-block::
+
+                1) 'segments': {
+                        'train': ("2008-01-01", "2014-12-31"),
+                        'valid': ("2017-01-01", "2020-08-01",),
+                        'test': ("2015-01-01", "2016-12-31",),
+                    }
+                2) 'segments': {
+                        'insample': ("2008-01-01", "2014-12-31"),
+                        'outsample': ("2017-01-01", "2020-08-01",),
+                    }
+        """
+        self.handler: DataHandler = init_instance_by_config(handler, accept_types=DataHandler)
+        self.segments = segments.copy()
+        self.fetch_kwargs = copy(fetch_kwargs)
+        super().__init__(**kwargs)
+
+    def config(self, handler_kwargs: dict = None, **kwargs):
+        """
+        Initialize the DatasetH
+
+        Parameters
+        ----------
+        handler_kwargs : dict
+            Config of DataHandler, which could include the following arguments:
+
+            - arguments of DataHandler.conf_data, such as 'instruments', 'start_time' and 'end_time'.
+
+        kwargs : dict
+            Config of DatasetH, such as
+
+            - segments : dict
+                Config of segments which is same as 'segments' in self.__init__
+
+        """
+        if handler_kwargs is not None:
+            self.handler.config(**handler_kwargs)
+        if "segments" in kwargs:
+            self.segments = deepcopy(kwargs.pop("segments"))
+        super().config(**kwargs)
+
+    def setup_data(self, handler_kwargs: dict = None, **kwargs):
+        """
+        Setup the Data
+
+        Parameters
+        ----------
+        handler_kwargs : dict
+            init arguments of DataHandler, which could include the following arguments:
+
+            - init_type : Init Type of Handler
+
+            - enable_cache : whether to enable cache
+
+        """
+        super().setup_data(**kwargs)
+        if handler_kwargs is not None:
+            self.handler.setup_data(**handler_kwargs)
+
+    def __repr__(self):
+        return "{name}(handler={handler}, segments={segments})".format(
+            name=self.__class__.__name__, handler=self.handler, segments=self.segments
+        )
+
+    def _prepare_seg(self, slc, **kwargs):
+        """
+        Give a query, retrieve the according data
+
+        Parameters
+        ----------
+        slc : please refer to the docs of `prepare`
+                NOTE: it may not be an instance of slice. It may be a segment of `segments` from `def prepare`
+        """
+        if hasattr(self, "fetch_kwargs"):
+            return self.handler.fetch(slc, **kwargs, **self.fetch_kwargs)
+        else:
+            return self.handler.fetch(slc, **kwargs)
+
+    def prepare(
+        self,
+        segments: Union[List[Text], Tuple[Text], Text, slice, pd.Index],
+        col_set=DataHandler.CS_ALL,
+        data_key=DataHandlerLP.DK_I,
+        **kwargs,
+    ) -> Union[List[pd.DataFrame], pd.DataFrame]:
+        """
+        Prepare the data for learning and inference.
+
+        Parameters
+        ----------
+        segments : Union[List[Text], Tuple[Text], Text, slice]
+            Describe the scope of the data to be prepared
+            Here are some examples:
+
+            - 'train'
+
+            - ['train', 'valid']
+
+        col_set : str
+            The col_set will be passed to self.handler when fetching data.
+            TODO: make it automatic:
+
+            - select DK_I for test data
+            - select DK_L for training data.
+        data_key : str
+            The data to fetch:  DK_*
+            Default is DK_I, which indicate fetching data for **inference**.
+
+        kwargs :
+            The parameters that kwargs may contain:
+                flt_col : str
+                    It only exists in TSDatasetH, can be used to add a column of data(True or False) to filter data.
+                    This parameter is only supported when it is an instance of TSDatasetH.
+
+        Returns
+        -------
+        Union[List[pd.DataFrame], pd.DataFrame]:
+
+        Raises
+        ------
+        NotImplementedError:
+        """
+        seg_kwargs = {"col_set": col_set, "data_key": data_key}
+        seg_kwargs.update(kwargs)
+
+        # Conflictions may happen here
+        # - The fetched data and the segment key may both be string
+        # To resolve the confliction
+        # - The segment name will have higher priorities
+
+        # 1) Use it as segment name first
+        # 1.1) directly fetch split like "train" "valid" "test"
+        if isinstance(segments, str) and segments in self.segments:
+            return self._prepare_seg(self.segments[segments], **seg_kwargs)
+
+        # 1.2) fetch multiple splits like ["train", "valid"] ["train", "valid", "test"]
+        if isinstance(segments, (list, tuple)) and all(seg in self.segments for seg in segments):
+            return [self._prepare_seg(self.segments[seg], **seg_kwargs) for seg in segments]
+
+        # 2) Use pass it directly to prepare a single seg
+        return self._prepare_seg(segments, **seg_kwargs)
+
+    # helper functions
+    @staticmethod
+    def get_min_time(segments):
+        return DatasetH._get_extrema(segments, 0, (lambda a, b: a > b))
+
+    @staticmethod
+    def get_max_time(segments):
+        return DatasetH._get_extrema(segments, 1, (lambda a, b: a < b))
+
+    @staticmethod
+    def _get_extrema(segments, idx: int, cmp: Callable, key_func=pd.Timestamp):
+        """it will act like sort and return the max value or None"""
+        candidate = None
+        for _, seg in segments.items():
+            point = seg[idx]
+            if point is None:
+                # None indicates unbounded, return directly
+                return None
+            elif candidate is None or cmp(key_func(candidate), key_func(point)):
+                candidate = point
+        return candidate
+
+
+class TSDataSampler:
+    """
+    (T)ime-(S)eries DataSampler
+    This is the result of TSDatasetH
+
+    It works like `torch.data.utils.Dataset`, it provides a very convenient interface for constructing time-series
+    dataset based on tabular data.
+    - On time step dimension, the smaller index indicates the historical data and the larger index indicates the future
+      data.
+
+    If user have further requirements for processing data, user could process them based on `TSDataSampler` or create
+    more powerful subclasses.
+
+    Known Issues:
+    - For performance issues, this Sampler will convert dataframe into arrays for better performance. This could result
+      in a different data type
+
+
+    Indices design:
+        TSDataSampler has a index mechanism to help users query time-series data efficiently.
+
+        The definition of related variables:
+            data_arr: np.ndarray
+                The original data. it will contains all the original data.
+                The querying are often for time-series of a specific stock.
+                By leveraging this data charactoristics to speed up querying, the multi-index of data_arr is rearranged in (instrument, datetime) order
+
+            data_index: pd.MultiIndex with index order <instrument, datetime>
+                it has the same shape with `idx_map`. Each elements of them are expected to be aligned.
+
+            idx_map: np.ndarray
+                It is the indexable data. It originates from data_arr, and then filtered by 1) `start` and `end`  2) `flt_data`
+                    The extra data in data_arr is useful in following cases
+                    1) creating meaningful time series data before `start` instead of padding them with zeros
+                    2) some data are excluded by `flt_data` (e.g. no <X, y> sample pair for that index). but they are still used in time-series in X
+
+                Finnally, it will look like.
+
+                array([[  0,   0],
+                       [  1,   0],
+                       [  2,   0],
+                       ...,
+                       [241, 348],
+                       [242, 348],
+                       [243, 348]], dtype=int32)
+
+                It list all indexable data(some data only used in historical time series data may not be indexabla), the values are the corresponding row and col in idx_df
+            idx_df: pd.DataFrame
+                It aims to map the <datetime, instrument> key to the original position in data_arr
+
+                For example, it may look like (NOTE: the index for a instrument time-series is continoues in memory)
+
+                    instrument SH600000 SH600008 SH600009 SH600010 SH600011 SH600015  ...
+                    datetime
+                    2017-01-03        0      242      473      717      NaN      974  ...
+                    2017-01-04        1      243      474      718      NaN      975  ...
+                    2017-01-05        2      244      475      719      NaN      976  ...
+                    2017-01-06        3      245      476      720      NaN      977  ...
+
+            With these two indices(idx_map, idx_df) and original data(data_arr), we can make the following queries fast (implemented in __getitem__)
+            (1) Get the i-th indexable sample(time-series):   (indexable sample index) -> [idx_map] -> (row col) -> [idx_df] -> (index in data_arr)
+            (2) Get the specific sample by <datetime, instrument>:  (<datetime, instrument>, i.e. <row, col>) -> [idx_df] -> (index in data_arr)
+            (3) Get the index of a time-series data:   (get the <row, col>, refer to (1), (2)) -> [idx_df] -> (all indices in data_arr for time-series)
+    """
+
+    # Please refer to the docstring of TSDataSampler for the definition of following attributes
+    data_arr: np.ndarray
+    data_index: pd.MultiIndex
+    idx_map: np.ndarray
+    idx_df: pd.DataFrame
+
+    def __init__(
+        self,
+        data: pd.DataFrame,
+        start,
+        end,
+        step_len: int,
+        fillna_type: str = "none",
+        dtype=None,
+        flt_data=None,
+    ):
+        """
+        Build a dataset which looks like torch.data.utils.Dataset.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            The raw tabular data whose index order is <"datetime", "instrument">
+        start :
+            The indexable start time
+        end :
+            The indexable end time
+        step_len : int
+            The length of the time-series step
+        fillna_type : int
+            How will qlib handle the sample if there is on sample in a specific date.
+            none:
+                fill with np.nan
+            ffill:
+                ffill with previous sample
+            ffill+bfill:
+                ffill with previous samples first and fill with later samples second
+        flt_data : pd.Series
+            a column of data(True or False) to filter data. Its index order is <"datetime", "instrument">
+            This feature is essential because:
+            - We want some sample not included due to label-based filtering, but we can't filter them at the beginning due to the features is still important in the feature.
+            None:
+                kepp all data
+
+        """
+        self.start = start
+        self.end = end
+        self.step_len = step_len
+        self.fillna_type = fillna_type
+        assert get_level_index(data, "datetime") == 0
+        self.data = data.swaplevel().sort_index().copy()
+        data.drop(
+            data.columns, axis=1, inplace=True
+        )  # data is useless since it's passed to a transposed one, hard code to free the memory of this dataframe to avoid three big dataframe in the memory(including: data, self.data, self.data_arr)
+
+        kwargs = {"object": self.data}
+        if dtype is not None:
+            kwargs["dtype"] = dtype
+
+        self.data_arr = np.array(**kwargs)  # Get index from numpy.array will much faster than DataFrame.values!
+        # NOTE:
+        # - append last line with full NaN for better performance in `__getitem__`
+        # - Keep the same dtype will result in a better performance
+        self.data_arr = np.append(
+            self.data_arr,
+            np.full((1, self.data_arr.shape[1]), np.nan, dtype=self.data_arr.dtype),
+            axis=0,
+        )
+        self.nan_idx = len(self.data_arr) - 1  # The last line is all NaN; setting it to -1 can cause bug #1716
+
+        # the data type will be changed
+        # The index of usable data is between start_idx and end_idx
+        self.idx_df, self.idx_map = self.build_index(self.data)
+        self.data_index = deepcopy(self.data.index)
+
+        if flt_data is not None:
+            if isinstance(flt_data, pd.DataFrame):
+                assert len(flt_data.columns) == 1
+                flt_data = flt_data.iloc[:, 0]
+            # NOTE: bool(np.nan) is True !!!!!!!!
+            # make sure reindex comes first. Otherwise extra NaN may appear.
+            flt_data = flt_data.swaplevel()
+            flt_data = flt_data.reindex(self.data_index).fillna(False).astype(bool)
+            self.flt_data = flt_data.values
+            self.idx_map = self.flt_idx_map(self.flt_data, self.idx_map)
+            self.data_index = self.data_index[np.where(self.flt_data)[0]]
+        self.idx_map = self.idx_map2arr(self.idx_map)
+        self.idx_map, self.data_index = self.slice_idx_map_and_data_index(
+            self.idx_map, self.idx_df, self.data_index, start, end
+        )
+
+        self.idx_arr = np.array(self.idx_df.values, dtype=np.float64)  # for better performance
+        del self.data  # save memory
+
+    @staticmethod
+    def slice_idx_map_and_data_index(
+        idx_map,
+        idx_df,
+        data_index,
+        start,
+        end,
+    ):
+        assert (
+            len(idx_map) == data_index.shape[0]
+        )  # make sure idx_map and data_index is same so index of idx_map can be used on data_index
+
+        start_row_idx, end_row_idx = idx_df.index.slice_locs(start=time_to_slc_point(start), end=time_to_slc_point(end))
+
+        time_flter_idx = (idx_map[:, 0] < end_row_idx) & (idx_map[:, 0] >= start_row_idx)
+        return idx_map[time_flter_idx], data_index[time_flter_idx]
+
+    @staticmethod
+    def idx_map2arr(idx_map):
+        # pytorch data sampler will have better memory control without large dict or list
+        # - https://github.com/pytorch/pytorch/issues/13243
+        # - https://github.com/airctic/icevision/issues/613
+        # So we convert the dict into int array.
+        # The arr_map is expected to behave the same as idx_map
+
+        dtype = np.int32
+        # set a index out of bound to indicate the none existing
+        no_existing_idx = (np.iinfo(dtype).max, np.iinfo(dtype).max)
+
+        max_idx = max(idx_map.keys())
+        arr_map = []
+        for i in range(max_idx + 1):
+            arr_map.append(idx_map.get(i, no_existing_idx))
+        arr_map = np.array(arr_map, dtype=dtype)
+        return arr_map
+
+    @staticmethod
+    def flt_idx_map(flt_data, idx_map):
+        idx = 0
+        new_idx_map = {}
+        for i, exist in enumerate(flt_data):
+            if exist:
+                new_idx_map[idx] = idx_map[i]
+                idx += 1
+        return new_idx_map
+
+    def get_index(self):
+        """
+        Get the pandas index of the data, it will be useful in following scenarios
+        - Special sampler will be used (e.g. user want to sample day by day)
+        """
+        return self.data_index.swaplevel()  # to align the order of multiple index of original data received by __init__
+
+    def config(self, **kwargs):
+        # Config the attributes
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    @staticmethod
+    def build_index(data: pd.DataFrame) -> Tuple[pd.DataFrame, dict]:
+        """
+        The relation of the data
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            A DataFrame with index in order <instrument, datetime>
+
+                                      RSQR5     RESI5     WVMA5    LABEL0
+            instrument datetime
+            SH600000   2017-01-03  0.016389  0.461632 -1.154788 -0.048056
+                       2017-01-04  0.884545 -0.110597 -1.059332 -0.030139
+                       2017-01-05  0.507540 -0.535493 -1.099665 -0.644983
+                       2017-01-06 -1.267771 -0.669685 -1.636733  0.295366
+                       2017-01-09  0.339346  0.074317 -0.984989  0.765540
+
+        Returns
+        -------
+        Tuple[pd.DataFrame, dict]:
+            1) the first element:  reshape the original index into a <datetime(row), instrument(column)> 2D dataframe
+                instrument SH600000 SH600008 SH600009 SH600010 SH600011 SH600015  ...
+                datetime
+                2017-01-03        0      242      473      717      NaN      974  ...
+                2017-01-04        1      243      474      718      NaN      975  ...
+                2017-01-05        2      244      475      719      NaN      976  ...
+                2017-01-06        3      245      476      720      NaN      977  ...
+            2) the second element:  {<original index>: <row, col>}
+        """
+        # object incase of pandas converting int to float
+        idx_df = pd.Series(range(data.shape[0]), index=data.index, dtype=object)
+        idx_df = lazy_sort_index(idx_df.unstack())
+        # NOTE: the correctness of `__getitem__` depends on columns sorted here
+        idx_df = lazy_sort_index(idx_df, axis=1).T
+
+        idx_map = {}
+        for i, (_, row) in enumerate(idx_df.iterrows()):
+            for j, real_idx in enumerate(row):
+                if not np.isnan(real_idx):
+                    idx_map[real_idx] = (i, j)
+        return idx_df, idx_map
+
+    @property
+    def empty(self):
+        return len(self) == 0
+
+    def _get_indices(self, row: int, col: int) -> np.array:
+        """
+        get series indices of self.data_arr from the row, col indices of self.idx_df
+
+        Parameters
+        ----------
+        row : int
+            the row in self.idx_df
+        col : int
+            the col in self.idx_df
+
+        Returns
+        -------
+        np.array:
+            The indices of data of the data
+        """
+        indices = self.idx_arr[max(row - self.step_len + 1, 0) : row + 1, col]
+
+        if len(indices) < self.step_len:
+            indices = np.concatenate([np.full((self.step_len - len(indices),), np.nan), indices])
+
+        if self.fillna_type == "ffill":
+            indices = np_ffill(indices)
+        elif self.fillna_type == "ffill+bfill":
+            indices = np_ffill(np_ffill(indices)[::-1])[::-1]
+        else:
+            assert self.fillna_type == "none"
+        return indices
+
+    def _get_row_col(self, idx) -> Tuple[int]:
+        """
+        get the col index and row index of a given sample index in self.idx_df
+
+        Parameters
+        ----------
+        idx :
+            the input of  `__getitem__`
+
+        Returns
+        -------
+        Tuple[int]:
+            the row and col index
+        """
+        # The the right row number `i` and col number `j` in idx_df
+        if isinstance(idx, (int, np.integer)):
+            real_idx = idx
+            if 0 <= real_idx < len(self.idx_map):
+                i, j = self.idx_map[real_idx]  # TODO: The performance of this line is not good
+            else:
+                raise KeyError(f"{real_idx} is out of [0, {len(self.idx_map)})")
+        elif isinstance(idx, tuple):
+            # <TSDataSampler object>["datetime", "instruments"]
+            date, inst = idx
+            date = pd.Timestamp(date)
+            i = bisect.bisect_right(self.idx_df.index, date) - 1
+            # NOTE: This relies on the idx_df columns sorted in `__init__`
+            j = bisect.bisect_left(self.idx_df.columns, inst)
+        else:
+            raise NotImplementedError(f"This type of input is not supported")
+        return i, j
+
+    def __getitem__(self, idx: Union[int, Tuple[object, str], List[int]]):
+        """
+        # We have two method to get the time-series of a sample
+        tsds is a instance of TSDataSampler
+
+        # 1) sample by int index directly
+        tsds[len(tsds) - 1]
+
+        # 2) sample by <datetime,instrument> index
+        tsds['2016-12-31', "SZ300315"]
+
+        # The return value will be similar to the data retrieved by following code
+        df.loc(axis=0)['2015-01-01':'2016-12-31', "SZ300315"].iloc[-30:]
+
+        Parameters
+        ----------
+        idx : Union[int, Tuple[object, str]]
+        """
+        # Multi-index type
+        mtit = (list, np.ndarray)
+        if isinstance(idx, mtit):
+            indices = [self._get_indices(*self._get_row_col(i)) for i in idx]
+            indices = np.concatenate(indices)
+        else:
+            indices = self._get_indices(*self._get_row_col(idx))
+
+        # 1) for better performance, use the last nan line for padding the lost date
+        # 2) In case of precision problems. We use np.float64. # TODO: I'm not sure if whether np.float64 will result in
+        # precision problems. It will not cause any problems in my tests at least
+        indices = np.nan_to_num(indices.astype(np.float64), nan=self.nan_idx).astype(int)
+
+        if (np.diff(indices) == 1).all():  # slicing instead of indexing for speeding up.
+            data = self.data_arr[indices[0] : indices[-1] + 1]
+        else:
+            data = self.data_arr[indices]
+        if isinstance(idx, mtit):
+            # if we get multiple indexes, addition dimension should be added.
+            # <sample_idx, step_idx, feature_idx>
+            data = data.reshape(-1, self.step_len, *data.shape[1:])
+        return data
+
+    def __len__(self):
+        return len(self.idx_map)
+
+
+class TSDatasetH(DatasetH):
+    """
+    (T)ime-(S)eries Dataset (H)andler
+
+
+    Convert the tabular data to Time-Series data
+
+    Requirements analysis
+
+    The typical workflow of a user to get time-series data for an sample
+    - process features
+    - slice proper data from data handler:  dimension of sample <feature, >
+    - Build relation of samples by <time, instrument> index
+        - Be able to sample times series of data <timestep, feature>
+        - It will be better if the interface is like "torch.utils.data.Dataset"
+    - User could build customized batch based on the data
+        - The dimension of a batch of data <batch_idx, feature, timestep>
+    """
+
+    DEFAULT_STEP_LEN = 30
+
+    def __init__(self, step_len=DEFAULT_STEP_LEN, flt_col: Optional[str] = None, **kwargs):
+        self.step_len = step_len
+        self.flt_col = flt_col
+        super().__init__(**kwargs)
+
+    def config(self, **kwargs):
+        if "step_len" in kwargs:
+            self.step_len = kwargs.pop("step_len")
+        super().config(**kwargs)
+
+    def setup_data(self, **kwargs):
+        super().setup_data(**kwargs)
+        # make sure the calendar is updated to latest when loading data from new config
+        cal = self.handler.fetch(col_set=self.handler.CS_RAW).index.get_level_values("datetime").unique()
+        self.cal = sorted(cal)
+
+    @staticmethod
+    def _extend_slice(slc: slice, cal: list, step_len: int) -> slice:
+        # Dataset decide how to slice data(Get more data for timeseries).
+        start, end = slc.start, slc.stop
+        start_idx = bisect.bisect_left(cal, pd.Timestamp(start))
+        pad_start_idx = max(0, start_idx - step_len)
+        pad_start = cal[pad_start_idx]
+        return slice(pad_start, end)
+
+    def _prepare_seg(self, slc: slice, **kwargs) -> TSDataSampler:
+        """
+        split the _prepare_raw_seg is to leave a hook for data preprocessing before creating processing data
+        NOTE: TSDatasetH only support slc segment on datetime !!!
+        """
+        dtype = kwargs.pop("dtype", None)
+        if not isinstance(slc, slice):
+            slc = slice(*slc)
+        if (flt_col := kwargs.pop("flt_col", None)) is None:
+            flt_col = self.flt_col
+
+        # TSDatasetH will retrieve more data for complete time-series
+        ext_slice = self._extend_slice(slc, self.cal, self.step_len)
+        data = super()._prepare_seg(ext_slice, **kwargs)
+
+        flt_kwargs = deepcopy(kwargs)
+        if flt_col is not None:
+            flt_kwargs["col_set"] = flt_col
+            flt_data = super()._prepare_seg(ext_slice, **flt_kwargs)
+            assert len(flt_data.columns) == 1
+        else:
+            flt_data = None
+
+        tsds = TSDataSampler(
+            data=data,
+            start=slc.start,
+            end=slc.stop,
+            step_len=self.step_len,
+            dtype=dtype,
+            flt_data=flt_data,
+        )
+        return tsds
+
+
+__all__ = ["Optional", "Dataset", "DatasetH"]

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/dataset/handler.py

@@ -0,0 +1,785 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+# coding=utf-8
+from abc import abstractmethod
+import warnings
+from typing import Callable, Union, Tuple, List, Iterator, Optional
+
+import pandas as pd
+
+from qlib.typehint import Literal
+from ...log import get_module_logger, TimeInspector
+from ...utils import init_instance_by_config
+from ...utils.serial import Serializable
+from .utils import fetch_df_by_index, fetch_df_by_col
+from ...utils import lazy_sort_index
+from .loader import DataLoader
+
+from . import processor as processor_module
+from . import loader as data_loader_module
+
+DATA_KEY_TYPE = Literal["raw", "infer", "learn"]
+
+
+class DataHandlerABC(Serializable):
+    """
+    Interface for data handler.
+
+    This class does not assume the internal data structure of the data handler.
+    It only defines the interface for external users (uses DataFrame as the internal data structure).
+
+    In the future, the data handler's more detailed implementation should be refactored. Here are some guidelines:
+
+    It covers several components:
+
+    - [data loader] -> internal representation of the data -> data preprocessing -> interface adaptor for the fetch interface
+    - The workflow to combine them all:
+      The workflow may be very complicated. DataHandlerLP is one of the practices, but it can't satisfy all the requirements.
+      So leaving the flexibility to the user to implement the workflow is a more reasonable choice.
+    """
+
+    def __init__(self, *args, **kwargs):  # pylint: disable=W0246
+        """
+        We should define how to get ready for the fetching.
+        """
+        super().__init__(*args, **kwargs)
+
+    CS_ALL = "__all"  # return all columns with single-level index column
+    CS_RAW = "__raw"  # return raw data with multi-level index column
+
+    # data key
+    DK_R: DATA_KEY_TYPE = "raw"
+    DK_I: DATA_KEY_TYPE = "infer"
+    DK_L: DATA_KEY_TYPE = "learn"
+
+    @abstractmethod
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = CS_ALL,
+        data_key: DATA_KEY_TYPE = DK_I,
+    ) -> pd.DataFrame:
+        pass
+
+
+class DataHandler(DataHandlerABC):
+    """
+    The motivation of DataHandler:
+
+    - It provides an implementation of BaseDataHandler that we implement with:
+        - Handling responses with an internal loaded DataFrame
+        - The DataFrame is loaded by a data loader.
+
+    The steps to using a handler
+    1. initialized data handler  (call by `init`).
+    2. use the data.
+
+
+    The data handler try to maintain a handler with 2 level.
+    `datetime` & `instruments`.
+
+    Any order of the index level can be supported (The order will be implied in the data).
+    The order  <`datetime`, `instruments`> will be used when the dataframe index name is missed.
+
+    Example of the data:
+    The multi-index of the columns is optional.
+
+    .. code-block:: text
+
+                                feature                                                            label
+                                $close     $volume  Ref($close, 1)  Mean($close, 3)  $high-$low  LABEL0
+        datetime   instrument
+        2010-01-04 SH600000    81.807068  17145150.0       83.737389        83.016739    2.741058  0.0032
+                   SH600004    13.313329  11800983.0       13.313329        13.317701    0.183632  0.0042
+                   SH600005    37.796539  12231662.0       38.258602        37.919757    0.970325  0.0289
+
+
+    Tips for improving the performance of datahandler
+    - Fetching data with `col_set=CS_RAW` will return the raw data and may avoid pandas from copying the data when calling `loc`
+    """
+
+    _data: pd.DataFrame  # underlying data.
+
+    def __init__(
+        self,
+        instruments=None,
+        start_time=None,
+        end_time=None,
+        data_loader: Union[dict, str, DataLoader] = None,
+        init_data=True,
+        fetch_orig=True,
+    ):
+        """
+        Parameters
+        ----------
+        instruments :
+            The stock list to retrieve.
+        start_time :
+            start_time of the original data.
+        end_time :
+            end_time of the original data.
+        data_loader : Union[dict, str, DataLoader]
+            data loader to load the data.
+        init_data :
+            initialize the original data in the constructor.
+        fetch_orig : bool
+            Return the original data instead of copy if possible.
+        """
+
+        # Setup data loader
+        assert data_loader is not None  # to make start_time end_time could have None default value
+
+        # what data source to load data
+        self.data_loader = init_instance_by_config(
+            data_loader,
+            None if (isinstance(data_loader, dict) and "module_path" in data_loader) else data_loader_module,
+            accept_types=DataLoader,
+        )
+
+        # what data to be loaded from data source
+        # For IDE auto-completion.
+        self.instruments = instruments
+        self.start_time = start_time
+        self.end_time = end_time
+
+        self.fetch_orig = fetch_orig
+        if init_data:
+            with TimeInspector.logt("Init data"):
+                self.setup_data()
+        super().__init__()
+
+    def config(self, **kwargs):
+        """
+        configuration of data.
+        # what data to be loaded from data source
+
+        This method will be used when loading pickled handler from dataset.
+        The data will be initialized with different time range.
+
+        """
+        attr_list = {"instruments", "start_time", "end_time"}
+        for k, v in kwargs.items():
+            if k in attr_list:
+                setattr(self, k, v)
+
+        for attr in attr_list:
+            if attr in kwargs:
+                kwargs.pop(attr)
+
+        super().config(**kwargs)
+
+    def setup_data(self, enable_cache: bool = False):
+        """
+        Set Up the data in case of running initialization for multiple time
+
+        It is responsible for maintaining following variable
+        1) self._data
+
+        Parameters
+        ----------
+        enable_cache : bool
+            default value is false:
+
+            - if `enable_cache` == True:
+
+                the processed data will be saved on disk, and handler will load the cached data from the disk directly
+                when we call `init` next time
+        """
+        # Setup data.
+        # _data may be with multiple column index level. The outer level indicates the feature set name
+        with TimeInspector.logt("Loading data"):
+            # make sure the fetch method is based on an index-sorted pd.DataFrame
+            self._data = lazy_sort_index(self.data_loader.load(self.instruments, self.start_time, self.end_time))
+        # TODO: cache
+
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = DataHandlerABC.CS_ALL,
+        data_key: DATA_KEY_TYPE = DataHandlerABC.DK_I,
+        squeeze: bool = False,
+        proc_func: Optional[Callable] = None,
+    ) -> pd.DataFrame:
+        """
+        fetch data from underlying data source
+
+        Design motivation:
+        - providing a unified interface for underlying data.
+        - Potential to make the interface more friendly.
+        - User can improve performance when fetching data in this extra layer
+
+        Parameters
+        ----------
+        selector : Union[pd.Timestamp, slice, str]
+            describe how to select data by index
+            It can be categories as following
+
+            - fetch single index
+            - fetch a range of index
+
+                - a slice range
+                - pd.Index for specific indexes
+
+            Following conflicts may occur
+
+            - Does ["20200101", "20210101"] mean selecting this slice or these two days?
+
+                - slice have higher priorities
+
+        level : Union[str, int]
+            which index level to select the data
+
+        col_set : Union[str, List[str]]
+
+            - if isinstance(col_set, str):
+
+                select a set of meaningful, pd.Index columns.(e.g. features, columns)
+
+                - if col_set == CS_RAW:
+
+                    the raw dataset will be returned.
+
+            - if isinstance(col_set, List[str]):
+
+                select several sets of meaningful columns, the returned data has multiple levels
+
+        proc_func: Callable
+
+            - Give a hook for processing data before fetching
+            - An example to explain the necessity of the hook:
+
+                - A Dataset learned some processors to process data which is related to data segmentation
+                - It will apply them every time when preparing data.
+                - The learned processor require the dataframe remains the same format when fitting and applying
+                - However the data format will change according to the parameters.
+                - So the processors should be applied to the underlayer data.
+
+        squeeze : bool
+            whether squeeze columns and index
+
+        Returns
+        -------
+        pd.DataFrame.
+        """
+        # DataHandler is an example with only one dataframe, so data_key is not used.
+        _ = data_key  # avoid linting errors (e.g., unused-argument)
+        return self._fetch_data(
+            data_storage=self._data,
+            selector=selector,
+            level=level,
+            col_set=col_set,
+            squeeze=squeeze,
+            proc_func=proc_func,
+        )
+
+    def _fetch_data(
+        self,
+        data_storage,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = DataHandlerABC.CS_ALL,
+        squeeze: bool = False,
+        proc_func: Callable = None,
+    ):
+        # This method is extracted for sharing in subclasses
+        from .storage import BaseHandlerStorage  # pylint: disable=C0415
+
+        # Following conflicts may occur
+        # - Does [20200101", "20210101"] mean selecting this slice or these two days?
+        # To solve this issue
+        #   - slice have higher priorities (except when level is none)
+        if isinstance(selector, (tuple, list)) and level is not None:
+            # when level is None, the argument will be passed in directly
+            # we don't have to convert it into slice
+            try:
+                selector = slice(*selector)
+            except ValueError:
+                get_module_logger("DataHandlerLP").info(f"Fail to converting to query to slice. It will used directly")
+
+        if isinstance(data_storage, pd.DataFrame):
+            data_df = data_storage
+            if proc_func is not None:
+                # FIXME: fetching by time first will be more friendly to `proc_func`
+                # Copy in case of `proc_func` changing the data inplace....
+                data_df = proc_func(fetch_df_by_index(data_df, selector, level, fetch_orig=self.fetch_orig).copy())
+                data_df = fetch_df_by_col(data_df, col_set)
+            else:
+                # Fetch column  first will be more friendly to SepDataFrame
+                data_df = fetch_df_by_col(data_df, col_set)
+                data_df = fetch_df_by_index(data_df, selector, level, fetch_orig=self.fetch_orig)
+        elif isinstance(data_storage, BaseHandlerStorage):
+            if proc_func is not None:
+                raise ValueError(f"proc_func is not supported by the storage {type(data_storage)}")
+            data_df = data_storage.fetch(selector=selector, level=level, col_set=col_set, fetch_orig=self.fetch_orig)
+        else:
+            raise TypeError(f"data_storage should be pd.DataFrame|HashingStockStorage, not {type(data_storage)}")
+
+        if squeeze:
+            # squeeze columns
+            data_df = data_df.squeeze()
+            # squeeze index
+            if isinstance(selector, (str, pd.Timestamp)):
+                data_df = data_df.reset_index(level=level, drop=True)
+        return data_df
+
+    def get_cols(self, col_set=DataHandlerABC.CS_ALL) -> list:
+        """
+        get the column names
+
+        Parameters
+        ----------
+        col_set : str
+            select a set of meaningful columns.(e.g. features, columns)
+
+        Returns
+        -------
+        list:
+            list of column names
+        """
+        df = self._data.head()
+        df = fetch_df_by_col(df, col_set)
+        return df.columns.to_list()
+
+    def get_range_selector(self, cur_date: Union[pd.Timestamp, str], periods: int) -> slice:
+        """
+        get range selector by number of periods
+
+        Args:
+            cur_date (pd.Timestamp or str): current date
+            periods (int): number of periods
+        """
+        trading_dates = self._data.index.unique(level="datetime")
+        cur_loc = trading_dates.get_loc(cur_date)
+        pre_loc = cur_loc - periods + 1
+        if pre_loc < 0:
+            warnings.warn("`periods` is too large. the first date will be returned.")
+            pre_loc = 0
+        ref_date = trading_dates[pre_loc]
+        return slice(ref_date, cur_date)
+
+    def get_range_iterator(
+        self, periods: int, min_periods: Optional[int] = None, **kwargs
+    ) -> Iterator[Tuple[pd.Timestamp, pd.DataFrame]]:
+        """
+        get an iterator of sliced data with given periods
+
+        Args:
+            periods (int): number of periods.
+            min_periods (int): minimum periods for sliced dataframe.
+            kwargs (dict): will be passed to `self.fetch`.
+        """
+        trading_dates = self._data.index.unique(level="datetime")
+        if min_periods is None:
+            min_periods = periods
+        for cur_date in trading_dates[min_periods:]:
+            selector = self.get_range_selector(cur_date, periods)
+            yield cur_date, self.fetch(selector, **kwargs)
+
+
+class DataHandlerLP(DataHandler):
+    """
+    Motivation:
+    - For the case that we hope using different processor workflows for learning and inference;
+
+
+    DataHandler with **(L)earnable (P)rocessor**
+
+    This handler will produce three pieces of data in pd.DataFrame format.
+
+    - DK_R / self._data: the raw data loaded from the loader
+    - DK_I / self._infer: the data processed for inference
+    - DK_L / self._learn: the data processed for learning model.
+
+    The motivation of using different processor workflows for learning and inference
+    Here are some examples.
+
+    - The instrument universe for learning and inference may be different.
+    - The processing of some samples may rely on label (for example, some samples hit the limit may need extra processing or be dropped).
+
+        - These processors only apply to the learning phase.
+
+    Tips for data handler
+
+    - To reduce the memory cost
+
+        - `drop_raw=True`: this will modify the data inplace on raw data;
+
+    - Please note processed data like `self._infer` or `self._learn` are concepts different from `segments` in Qlib's `Dataset` like "train" and "test"
+
+        - Processed data like `self._infer` or `self._learn` are underlying data processed with different processors
+        - `segments` in Qlib's `Dataset` like "train" and "test" are simply the time segmentations when querying data("train" are often before "test" in time-series).
+        - For example, you can query `data._infer` processed by `infer_processors` in the "train" time segmentation.
+    """
+
+    # based on `self._data`, _infer and _learn are genrated after processors
+    _infer: pd.DataFrame  # data for inference
+    _learn: pd.DataFrame  # data for learning models
+
+    # map data_key to attribute name
+    ATTR_MAP = {DataHandler.DK_R: "_data", DataHandler.DK_I: "_infer", DataHandler.DK_L: "_learn"}
+
+    # process type
+    PTYPE_I = "independent"
+    # - self._infer will be processed by shared_processors + infer_processors
+    # - self._learn will be processed by shared_processors + learn_processors
+
+    # NOTE:
+    PTYPE_A = "append"
+
+    # - self._infer will be processed by shared_processors + infer_processors
+    # - self._learn will be processed by shared_processors + infer_processors + learn_processors
+    #   - (e.g. self._infer processed by learn_processors )
+
+    def __init__(
+        self,
+        instruments=None,
+        start_time=None,
+        end_time=None,
+        data_loader: Union[dict, str, DataLoader] = None,
+        infer_processors: List = [],
+        learn_processors: List = [],
+        shared_processors: List = [],
+        process_type=PTYPE_A,
+        drop_raw=False,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        infer_processors : list
+            - list of <description info> of processors to generate data for inference
+
+            - example of <description info>:
+
+            .. code-block::
+
+                1) classname & kwargs:
+                    {
+                        "class": "MinMaxNorm",
+                        "kwargs": {
+                            "fit_start_time": "20080101",
+                            "fit_end_time": "20121231"
+                        }
+                    }
+                2) Only classname:
+                    "DropnaFeature"
+                3) object instance of Processor
+
+        learn_processors : list
+            similar to infer_processors, but for generating data for learning models
+
+        process_type: str
+            PTYPE_I = 'independent'
+
+            - self._infer will be processed by infer_processors
+
+            - self._learn will be processed by learn_processors
+
+            PTYPE_A = 'append'
+
+            - self._infer will be processed by infer_processors
+
+            - self._learn will be processed by infer_processors + learn_processors
+
+              - (e.g. self._infer processed by learn_processors )
+        drop_raw: bool
+            Whether to drop the raw data
+        """
+
+        # Setup preprocessor
+        self.infer_processors = []  # for lint
+        self.learn_processors = []  # for lint
+        self.shared_processors = []  # for lint
+        for pname in "infer_processors", "learn_processors", "shared_processors":
+            for proc in locals()[pname]:
+                getattr(self, pname).append(
+                    init_instance_by_config(
+                        proc,
+                        None if (isinstance(proc, dict) and "module_path" in proc) else processor_module,
+                        accept_types=processor_module.Processor,
+                    )
+                )
+
+        self.process_type = process_type
+        self.drop_raw = drop_raw
+        super().__init__(instruments, start_time, end_time, data_loader, **kwargs)
+
+    def get_all_processors(self):
+        return self.shared_processors + self.infer_processors + self.learn_processors
+
+    def fit(self):
+        """
+        fit data without processing the data
+        """
+        for proc in self.get_all_processors():
+            with TimeInspector.logt(f"{proc.__class__.__name__}"):
+                proc.fit(self._data)
+
+    def fit_process_data(self):
+        """
+        fit and process data
+
+        The input of the `fit` will be the output of the previous processor
+        """
+        self.process_data(with_fit=True)
+
+    @staticmethod
+    def _run_proc_l(
+        df: pd.DataFrame, proc_l: List[processor_module.Processor], with_fit: bool, check_for_infer: bool
+    ) -> pd.DataFrame:
+        for proc in proc_l:
+            if check_for_infer and not proc.is_for_infer():
+                raise TypeError("Only processors usable for inference can be used in `infer_processors` ")
+            with TimeInspector.logt(f"{proc.__class__.__name__}"):
+                if with_fit:
+                    proc.fit(df)
+                df = proc(df)
+        return df
+
+    @staticmethod
+    def _is_proc_readonly(proc_l: List[processor_module.Processor]):
+        """
+        NOTE: it will return True if `len(proc_l) == 0`
+        """
+        for p in proc_l:
+            if not p.readonly():
+                return False
+        return True
+
+    def process_data(self, with_fit: bool = False):
+        """
+        process_data data. Fun `processor.fit` if necessary
+
+        Notation: (data)  [processor]
+
+        # data processing flow of self.process_type == DataHandlerLP.PTYPE_I
+
+        .. code-block:: text
+
+            (self._data)-[shared_processors]-(_shared_df)-[learn_processors]-(_learn_df)
+                                                   \\
+                                                    -[infer_processors]-(_infer_df)
+
+        # data processing flow of self.process_type == DataHandlerLP.PTYPE_A
+
+        .. code-block:: text
+
+            (self._data)-[shared_processors]-(_shared_df)-[infer_processors]-(_infer_df)-[learn_processors]-(_learn_df)
+
+        Parameters
+        ----------
+        with_fit : bool
+            The input of the `fit` will be the output of the previous processor
+        """
+        # shared data processors
+        # 1) assign
+        _shared_df = self._data
+        if not self._is_proc_readonly(self.shared_processors):  # avoid modifying the original data
+            _shared_df = _shared_df.copy()
+        # 2) process
+        _shared_df = self._run_proc_l(_shared_df, self.shared_processors, with_fit=with_fit, check_for_infer=True)
+
+        # data for inference
+        # 1) assign
+        _infer_df = _shared_df
+        if not self._is_proc_readonly(self.infer_processors):  # avoid modifying the original data
+            _infer_df = _infer_df.copy()
+        # 2) process
+        _infer_df = self._run_proc_l(_infer_df, self.infer_processors, with_fit=with_fit, check_for_infer=True)
+
+        self._infer = _infer_df
+
+        # data for learning
+        # 1) assign
+        if self.process_type == DataHandlerLP.PTYPE_I:
+            _learn_df = _shared_df
+        elif self.process_type == DataHandlerLP.PTYPE_A:
+            # based on `infer_df` and append the processor
+            _learn_df = _infer_df
+        else:
+            raise NotImplementedError(f"This type of input is not supported")
+        if not self._is_proc_readonly(self.learn_processors):  # avoid modifying the original  data
+            _learn_df = _learn_df.copy()
+        # 2) process
+        _learn_df = self._run_proc_l(_learn_df, self.learn_processors, with_fit=with_fit, check_for_infer=False)
+
+        self._learn = _learn_df
+
+        if self.drop_raw:
+            del self._data
+
+    def config(self, processor_kwargs: dict = None, **kwargs):
+        """
+        configuration of data.
+        # what data to be loaded from data source
+
+        This method will be used when loading pickled handler from dataset.
+        The data will be initialized with different time range.
+
+        """
+        super().config(**kwargs)
+        if processor_kwargs is not None:
+            for processor in self.get_all_processors():
+                processor.config(**processor_kwargs)
+
+    # init type
+    IT_FIT_SEQ = "fit_seq"  # the input of `fit` will be the output of the previous processor
+    IT_FIT_IND = "fit_ind"  # the input of `fit` will be the original df
+    IT_LS = "load_state"  # The state of the object has been load by pickle
+
+    def setup_data(self, init_type: str = IT_FIT_SEQ, **kwargs):
+        """
+        Set up the data in case of running initialization for multiple time
+
+        Parameters
+        ----------
+        init_type : str
+            The type `IT_*` listed above.
+        enable_cache : bool
+            default value is false:
+
+            - if `enable_cache` == True:
+
+                the processed data will be saved on disk, and handler will load the cached data from the disk directly
+                when we call `init` next time
+        """
+        # init raw data
+        super().setup_data(**kwargs)
+
+        with TimeInspector.logt("fit & process data"):
+            if init_type == DataHandlerLP.IT_FIT_IND:
+                self.fit()
+                self.process_data()
+            elif init_type == DataHandlerLP.IT_LS:
+                self.process_data()
+            elif init_type == DataHandlerLP.IT_FIT_SEQ:
+                self.fit_process_data()
+            else:
+                raise NotImplementedError(f"This type of input is not supported")
+
+        # TODO: Be able to cache handler data. Save the memory for data processing
+
+    def _get_df_by_key(self, data_key: DATA_KEY_TYPE = DataHandlerABC.DK_I) -> pd.DataFrame:
+        if data_key == self.DK_R and self.drop_raw:
+            raise AttributeError(
+                "DataHandlerLP has not attribute _data, please set drop_raw = False if you want to use raw data"
+            )
+        df = getattr(self, self.ATTR_MAP[data_key])
+        return df
+
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set=DataHandler.CS_ALL,
+        data_key: DATA_KEY_TYPE = DataHandler.DK_I,
+        squeeze: bool = False,
+        proc_func: Callable = None,
+    ) -> pd.DataFrame:
+        """
+        fetch data from underlying data source
+
+        Parameters
+        ----------
+        selector : Union[pd.Timestamp, slice, str]
+            describe how to select data by index.
+        level : Union[str, int]
+            which index level to select the data.
+        col_set : str
+            select a set of meaningful columns.(e.g. features, columns).
+        data_key : str
+            the data to fetch:  DK_*.
+        proc_func: Callable
+            please refer to the doc of DataHandler.fetch
+
+        Returns
+        -------
+        pd.DataFrame:
+        """
+
+        return self._fetch_data(
+            data_storage=self._get_df_by_key(data_key),
+            selector=selector,
+            level=level,
+            col_set=col_set,
+            squeeze=squeeze,
+            proc_func=proc_func,
+        )
+
+    def get_cols(self, col_set=DataHandler.CS_ALL, data_key: DATA_KEY_TYPE = DataHandlerABC.DK_I) -> list:
+        """
+        get the column names
+
+        Parameters
+        ----------
+        col_set : str
+            select a set of meaningful columns.(e.g. features, columns).
+        data_key : DATA_KEY_TYPE
+            the data to fetch:  DK_*.
+
+        Returns
+        -------
+        list:
+            list of column names
+        """
+        df = self._get_df_by_key(data_key).head()
+        df = fetch_df_by_col(df, col_set)
+        return df.columns.to_list()
+
+    @classmethod
+    def cast(cls, handler: "DataHandlerLP") -> "DataHandlerLP":
+        """
+        Motivation
+
+        - A user creates a datahandler in his customized package. Then he wants to share the processed handler to
+          other users without introduce the package dependency and complicated data processing logic.
+        - This class make it possible by casting the class to DataHandlerLP and only keep the processed data
+
+        Parameters
+        ----------
+        handler : DataHandlerLP
+            A subclass of DataHandlerLP
+
+        Returns
+        -------
+        DataHandlerLP:
+            the converted processed data
+        """
+        new_hd: DataHandlerLP = object.__new__(DataHandlerLP)
+        new_hd.from_cast = True  # add a mark for the cast instance
+
+        for key in list(DataHandlerLP.ATTR_MAP.values()) + [
+            "instruments",
+            "start_time",
+            "end_time",
+            "fetch_orig",
+            "drop_raw",
+        ]:
+            setattr(new_hd, key, getattr(handler, key, None))
+        return new_hd
+
+    @classmethod
+    def from_df(cls, df: pd.DataFrame) -> "DataHandlerLP":
+        """
+        Motivation:
+        - When user want to get a quick data handler.
+
+        The created data handler will have only one shared Dataframe without processors.
+        After creating the handler, user may often want to dump the handler for reuse
+        Here is a typical use case
+
+        .. code-block:: python
+
+            from qlib.data.dataset import DataHandlerLP
+            dh = DataHandlerLP.from_df(df)
+            dh.to_pickle(fname, dump_all=True)
+
+        TODO:
+        - The StaticDataLoader is quite slow. It don't have to copy the data again...
+
+        """
+        loader = data_loader_module.StaticDataLoader(df)
+        return cls(data_loader=loader)

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/dataset/loader.py

@@ -0,0 +1,414 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import abc
+from pathlib import Path
+import warnings
+import pandas as pd
+
+from typing import Tuple, Union, List, Dict
+
+from qlib.data import D
+from qlib.utils import load_dataset, init_instance_by_config, time_to_slc_point
+from qlib.utils.pickle_utils import restricted_pickle_load
+from qlib.log import get_module_logger
+from qlib.utils.serial import Serializable
+
+
+class DataLoader(abc.ABC):
+    """
+    DataLoader is designed for loading raw data from original data source.
+    """
+
+    @abc.abstractmethod
+    def load(self, instruments, start_time=None, end_time=None) -> pd.DataFrame:
+        """
+        load the data as pd.DataFrame.
+
+        Example of the data (The multi-index of the columns is optional.):
+
+            .. code-block:: text
+
+                                        feature                                                             label
+                                        $close     $volume     Ref($close, 1)  Mean($close, 3)  $high-$low  LABEL0
+                datetime    instrument
+                2010-01-04  SH600000    81.807068  17145150.0       83.737389        83.016739    2.741058  0.0032
+                            SH600004    13.313329  11800983.0       13.313329        13.317701    0.183632  0.0042
+                            SH600005    37.796539  12231662.0       38.258602        37.919757    0.970325  0.0289
+
+
+        Parameters
+        ----------
+        instruments : str or dict
+            it can either be the market name or the config file of instruments generated by InstrumentProvider.
+            If the value of instruments is None, it means that no filtering is done.
+        start_time : str
+            start of the time range.
+        end_time : str
+            end of the time range.
+
+        Returns
+        -------
+        pd.DataFrame:
+            data load from the under layer source
+
+        Raise
+        -----
+        KeyError:
+            if the instruments filter is not supported, raise KeyError
+        """
+
+
+class DLWParser(DataLoader):
+    """
+    (D)ata(L)oader (W)ith (P)arser for features and names
+
+    Extracting this class so that QlibDataLoader and other dataloaders(such as QdbDataLoader) can share the fields.
+    """
+
+    def __init__(self, config: Union[list, tuple, dict]):
+        """
+        Parameters
+        ----------
+        config : Union[list, tuple, dict]
+            Config will be used to describe the fields and column names
+
+            .. code-block::
+
+                <config> := {
+                    "group_name1": <fields_info1>
+                    "group_name2": <fields_info2>
+                }
+                or
+                <config> := <fields_info>
+
+                <fields_info> := ["expr", ...] | (["expr", ...], ["col_name", ...])
+                # NOTE: list or tuple will be treated as the things when parsing
+        """
+        self.is_group = isinstance(config, dict)
+
+        if self.is_group:
+            self.fields = {grp: self._parse_fields_info(fields_info) for grp, fields_info in config.items()}
+        else:
+            self.fields = self._parse_fields_info(config)
+
+    def _parse_fields_info(self, fields_info: Union[list, tuple]) -> Tuple[list, list]:
+        if len(fields_info) == 0:
+            raise ValueError("The size of fields must be greater than 0")
+
+        if not isinstance(fields_info, (list, tuple)):
+            raise TypeError("Unsupported type")
+
+        if isinstance(fields_info[0], str):
+            exprs = names = fields_info
+        elif isinstance(fields_info[0], (list, tuple)):
+            exprs, names = fields_info
+        else:
+            raise NotImplementedError(f"This type of input is not supported")
+        return exprs, names
+
+    @abc.abstractmethod
+    def load_group_df(
+        self,
+        instruments,
+        exprs: list,
+        names: list,
+        start_time: Union[str, pd.Timestamp] = None,
+        end_time: Union[str, pd.Timestamp] = None,
+        gp_name: str = None,
+    ) -> pd.DataFrame:
+        """
+        load the dataframe for specific group
+
+        Parameters
+        ----------
+        instruments :
+            the instruments.
+        exprs : list
+            the expressions to describe the content of the data.
+        names : list
+            the name of the data.
+
+        Returns
+        -------
+        pd.DataFrame:
+            the queried dataframe.
+        """
+
+    def load(self, instruments=None, start_time=None, end_time=None) -> pd.DataFrame:
+        if self.is_group:
+            df = pd.concat(
+                {
+                    grp: self.load_group_df(instruments, exprs, names, start_time, end_time, grp)
+                    for grp, (exprs, names) in self.fields.items()
+                },
+                axis=1,
+            )
+        else:
+            exprs, names = self.fields
+            df = self.load_group_df(instruments, exprs, names, start_time, end_time)
+        return df
+
+
+class QlibDataLoader(DLWParser):
+    """Same as QlibDataLoader. The fields can be define by config"""
+
+    def __init__(
+        self,
+        config: Tuple[list, tuple, dict],
+        filter_pipe: List = None,
+        swap_level: bool = True,
+        freq: Union[str, dict] = "day",
+        inst_processors: Union[dict, list] = None,
+    ):
+        """
+        Parameters
+        ----------
+        config : Tuple[list, tuple, dict]
+            Please refer to the doc of DLWParser
+        filter_pipe :
+            Filter pipe for the instruments
+        swap_level :
+            Whether to swap level of MultiIndex
+        freq:  dict or str
+            If type(config) == dict and type(freq) == str, load config data using freq.
+            If type(config) == dict and type(freq) == dict, load config[<group_name>] data using freq[<group_name>]
+        inst_processors: dict | list
+            If inst_processors is not None and type(config) == dict; load config[<group_name>] data using inst_processors[<group_name>]
+            If inst_processors is a list, then it will be applied to all groups.
+        """
+        self.filter_pipe = filter_pipe
+        self.swap_level = swap_level
+        self.freq = freq
+
+        # sample
+        self.inst_processors = inst_processors if inst_processors is not None else {}
+        assert isinstance(
+            self.inst_processors, (dict, list)
+        ), f"inst_processors(={self.inst_processors}) must be dict or list"
+
+        super().__init__(config)
+
+        if self.is_group:
+            # check sample config
+            if isinstance(freq, dict):
+                for _gp in config.keys():
+                    if _gp not in freq:
+                        raise ValueError(f"freq(={freq}) missing group(={_gp})")
+                assert (
+                    self.inst_processors
+                ), f"freq(={self.freq}), inst_processors(={self.inst_processors}) cannot be None/empty"
+
+    def load_group_df(
+        self,
+        instruments,
+        exprs: list,
+        names: list,
+        start_time: Union[str, pd.Timestamp] = None,
+        end_time: Union[str, pd.Timestamp] = None,
+        gp_name: str = None,
+    ) -> pd.DataFrame:
+        if instruments is None:
+            warnings.warn("`instruments` is not set, will load all stocks")
+            instruments = "all"
+        if isinstance(instruments, str):
+            instruments = D.instruments(instruments, filter_pipe=self.filter_pipe)
+        elif self.filter_pipe is not None:
+            warnings.warn("`filter_pipe` is not None, but it will not be used with `instruments` as list")
+
+        freq = self.freq[gp_name] if isinstance(self.freq, dict) else self.freq
+        inst_processors = (
+            self.inst_processors if isinstance(self.inst_processors, list) else self.inst_processors.get(gp_name, [])
+        )
+        df = D.features(instruments, exprs, start_time, end_time, freq=freq, inst_processors=inst_processors)
+        df.columns = names
+        if self.swap_level:
+            df = df.swaplevel().sort_index()  # NOTE: if swaplevel, return <datetime, instrument>
+        return df
+
+
+class StaticDataLoader(DataLoader, Serializable):
+    """
+    DataLoader that supports loading data from file or as provided.
+    """
+
+    include_attr = ["_config"]
+
+    def __init__(self, config: Union[dict, str, pd.DataFrame], join="outer"):
+        """
+        Parameters
+        ----------
+        config : dict
+            {fields_group: <path or object>}
+        join : str
+            How to align different dataframes
+        """
+        self._config = config  # using "_" to avoid confliction with the method `config` of Serializable
+        self.join = join
+        self._data = None
+
+    def __getstate__(self) -> dict:
+        # avoid pickling `self._data`
+        return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+
+    def load(self, instruments=None, start_time=None, end_time=None) -> pd.DataFrame:
+        self._maybe_load_raw_data()
+
+        # 1) Filter by instruments
+        if instruments is None:
+            df = self._data
+        else:
+            df = self._data.loc(axis=0)[:, instruments]
+
+        # 2) Filter by Datetime
+        if start_time is None and end_time is None:
+            return df  # NOTE: avoid copy by loc
+        # pd.Timestamp(None) == NaT, use NaT as index can not fetch correct thing, so do not change None.
+        start_time = time_to_slc_point(start_time)
+        end_time = time_to_slc_point(end_time)
+        return df.loc[start_time:end_time]
+
+    def _maybe_load_raw_data(self):
+        if self._data is not None:
+            return
+        if isinstance(self._config, dict):
+            self._data = pd.concat(
+                {fields_group: load_dataset(path_or_obj) for fields_group, path_or_obj in self._config.items()},
+                axis=1,
+                join=self.join,
+            )
+            self._data.sort_index(inplace=True)
+        elif isinstance(self._config, (str, Path)):
+            if str(self._config).strip().endswith(".parquet"):
+                self._data = pd.read_parquet(self._config, engine="pyarrow")
+            else:
+                with Path(self._config).open("rb") as f:
+                    self._data = restricted_pickle_load(f)
+        elif isinstance(self._config, pd.DataFrame):
+            self._data = self._config
+
+
+class NestedDataLoader(DataLoader):
+    """
+    We have multiple DataLoader, we can use this class to combine them.
+    """
+
+    def __init__(self, dataloader_l: List[Dict], join="left") -> None:
+        """
+
+        Parameters
+        ----------
+        dataloader_l : list[dict]
+            A list of dataloader, for exmaple
+
+            .. code-block:: python
+
+                nd = NestedDataLoader(
+                    dataloader_l=[
+                        {
+                            "class": "qlib.contrib.data.loader.Alpha158DL",
+                        }, {
+                            "class": "qlib.contrib.data.loader.Alpha360DL",
+                            "kwargs": {
+                                "config": {
+                                    "label": ( ["Ref($close, -2)/Ref($close, -1) - 1"], ["LABEL0"])
+                                }
+                            }
+                        }
+                    ]
+                )
+        join :
+            it will pass to pd.concat when merging it.
+        """
+        super().__init__()
+        self.data_loader_l = [
+            (dl if isinstance(dl, DataLoader) else init_instance_by_config(dl)) for dl in dataloader_l
+        ]
+        self.join = join
+
+    def load(self, instruments=None, start_time=None, end_time=None) -> pd.DataFrame:
+        df_full = None
+        for dl in self.data_loader_l:
+            try:
+                df_current = dl.load(instruments, start_time, end_time)
+            except KeyError:
+                warnings.warn(
+                    "If the value of `instruments` cannot be processed, it will set instruments to None to get all the data."
+                )
+                df_current = dl.load(instruments=None, start_time=start_time, end_time=end_time)
+            if df_full is None:
+                df_full = df_current
+            else:
+                current_columns = df_current.columns.tolist()
+                full_columns = df_full.columns.tolist()
+                columns_to_drop = [col for col in current_columns if col in full_columns]
+                df_full.drop(columns=columns_to_drop, inplace=True)
+                df_full = pd.merge(df_full, df_current, left_index=True, right_index=True, how=self.join)
+        return df_full.sort_index(axis=1)
+
+
+class DataLoaderDH(DataLoader):
+    """DataLoaderDH
+    DataLoader based on (D)ata (H)andler
+    It is designed to load multiple data from data handler
+    - If you just want to load data from single datahandler, you can write them in single data handler
+
+    TODO: What make this module not that easy to use.
+
+    - For online scenario
+
+        - The underlayer data handler should be configured. But data loader doesn't provide such interface & hook.
+    """
+
+    def __init__(self, handler_config: dict, fetch_kwargs: dict = {}, is_group=False):
+        """
+        Parameters
+        ----------
+        handler_config : dict
+            handler_config will be used to describe the handlers
+
+            .. code-block::
+
+                <handler_config> := {
+                    "group_name1": <handler>
+                    "group_name2": <handler>
+                }
+                or
+                <handler_config> := <handler>
+                <handler> := DataHandler Instance | DataHandler Config
+
+        fetch_kwargs : dict
+            fetch_kwargs will be used to describe the different arguments of fetch method, such as col_set, squeeze, data_key, etc.
+
+        is_group: bool
+            is_group will be used to describe whether the key of handler_config is group
+
+        """
+        from qlib.data.dataset.handler import DataHandler  # pylint: disable=C0415
+
+        if is_group:
+            self.handlers = {
+                grp: init_instance_by_config(config, accept_types=DataHandler) for grp, config in handler_config.items()
+            }
+        else:
+            self.handlers = init_instance_by_config(handler_config, accept_types=DataHandler)
+
+        self.is_group = is_group
+        self.fetch_kwargs = {"col_set": DataHandler.CS_RAW}
+        self.fetch_kwargs.update(fetch_kwargs)
+
+    def load(self, instruments=None, start_time=None, end_time=None) -> pd.DataFrame:
+        if instruments is not None:
+            get_module_logger(self.__class__.__name__).warning(f"instruments[{instruments}] is ignored")
+
+        if self.is_group:
+            df = pd.concat(
+                {
+                    grp: dh.fetch(selector=slice(start_time, end_time), level="datetime", **self.fetch_kwargs)
+                    for grp, dh in self.handlers.items()
+                },
+                axis=1,
+            )
+        else:
+            df = self.handlers.fetch(selector=slice(start_time, end_time), level="datetime", **self.fetch_kwargs)
+        return df

Kronos/qlib/build/lib.linux-x86_64-cpython-39/qlib/data/dataset/processor.py

@@ -0,0 +1,419 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import abc
+from typing import Union, Text, Optional
+import numpy as np
+import pandas as pd
+
+from qlib.utils.data import robust_zscore, zscore
+from ...constant import EPS
+from .utils import fetch_df_by_index
+from ...utils.serial import Serializable
+from ...utils.paral import datetime_groupby_apply
+from qlib.data.inst_processor import InstProcessor
+from qlib.data import D
+
+
+def get_group_columns(df: pd.DataFrame, group: Union[Text, None]):
+    """
+    get a group of columns from multi-index columns DataFrame
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        with multi of columns.
+    group : str
+        the name of the feature group, i.e. the first level value of the group index.
+    """
+    if group is None:
+        return df.columns
+    else:
+        return df.columns[df.columns.get_loc(group)]
+
+
+class Processor(Serializable):
+    def fit(self, df: pd.DataFrame = None):
+        """
+        learn data processing parameters
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            When we fit and process data with processor one by one. The fit function reiles on the output of previous
+            processor, i.e. `df`.
+
+        """
+
+    @abc.abstractmethod
+    def __call__(self, df: pd.DataFrame):
+        """
+        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 is_for_infer(self) -> bool:
+        """
+        Is this processor usable for inference
+        Some processors are not usable for inference.
+
+        Returns
+        -------
+        bool:
+            if it is usable for infenrece.
+        """
+        return True
+
+    def readonly(self) -> bool:
+        """
+        Does the processor treat the input data readonly (i.e. does not write the input data) when processing
+
+        Knowning the readonly information is helpful to the Handler to avoid uncessary copy
+        """
+        return False
+
+    def config(self, **kwargs):
+        attr_list = {"fit_start_time", "fit_end_time"}
+        for k, v in kwargs.items():
+            if k in attr_list and hasattr(self, k):
+                setattr(self, k, v)
+
+        for attr in attr_list:
+            if attr in kwargs:
+                kwargs.pop(attr)
+        super().config(**kwargs)
+
+
+class DropnaProcessor(Processor):
+    def __init__(self, fields_group=None):
+        self.fields_group = fields_group
+
+    def __call__(self, df):
+        return df.dropna(subset=get_group_columns(df, self.fields_group))
+
+    def readonly(self):
+        return True
+
+
+class DropnaLabel(DropnaProcessor):
+    def __init__(self, fields_group="label"):
+        super().__init__(fields_group=fields_group)
+
+    def is_for_infer(self) -> bool:
+        """The samples are dropped according to label. So it is not usable for inference"""
+        return False
+
+
+class DropCol(Processor):
+    def __init__(self, col_list=[]):
+        self.col_list = col_list
+
+    def __call__(self, df):
+        if isinstance(df.columns, pd.MultiIndex):
+            mask = df.columns.get_level_values(-1).isin(self.col_list)
+        else:
+            mask = df.columns.isin(self.col_list)
+        return df.loc[:, ~mask]
+
+    def readonly(self):
+        return True
+
+
+class FilterCol(Processor):
+    def __init__(self, fields_group="feature", col_list=[]):
+        self.fields_group = fields_group
+        self.col_list = col_list
+
+    def __call__(self, df):
+        cols = get_group_columns(df, self.fields_group)
+        all_cols = df.columns
+        diff_cols = np.setdiff1d(all_cols.get_level_values(-1), cols.get_level_values(-1))
+        self.col_list = np.union1d(diff_cols, self.col_list)
+        mask = df.columns.get_level_values(-1).isin(self.col_list)
+        return df.loc[:, mask]
+
+    def readonly(self):
+        return True
+
+
+class TanhProcess(Processor):
+    """Use tanh to process noise data"""
+
+    def __call__(self, df):
+        def tanh_denoise(data):
+            mask = data.columns.get_level_values(1).str.contains("LABEL")
+            col = df.columns[~mask]
+            data[col] = data[col] - 1
+            data[col] = np.tanh(data[col])
+
+            return data
+
+        return tanh_denoise(df)
+
+
+class ProcessInf(Processor):
+    """Process infinity"""
+
+    def __call__(self, df):
+        def replace_inf(data):
+            def process_inf(df):
+                for col in df.columns:
+                    # FIXME: Such behavior is very weird
+                    df[col] = df[col].replace([np.inf, -np.inf], df[col][~np.isinf(df[col])].mean())
+                return df
+
+            data = datetime_groupby_apply(data, process_inf)
+            data.sort_index(inplace=True)
+            return data
+
+        return replace_inf(df)
+
+
+class Fillna(Processor):
+    """Process NaN"""
+
+    def __init__(self, fields_group=None, fill_value=0):
+        self.fields_group = fields_group
+        self.fill_value = fill_value
+
+    def __call__(self, df):
+        if self.fields_group is None:
+            df.fillna(self.fill_value, inplace=True)
+        else:
+            # this implementation is extremely slow
+            # df.fillna({col: self.fill_value for col in cols}, inplace=True)
+            df[self.fields_group] = df[self.fields_group].fillna(self.fill_value)
+        return df
+
+
+class MinMaxNorm(Processor):
+    def __init__(self, fit_start_time, fit_end_time, fields_group=None):
+        # NOTE: correctly set the `fit_start_time` and `fit_end_time` is very important !!!
+        # `fit_end_time` **must not** include any information from the test data!!!
+        self.fit_start_time = fit_start_time
+        self.fit_end_time = fit_end_time
+        self.fields_group = fields_group
+
+    def fit(self, df: pd.DataFrame = None):
+        df = fetch_df_by_index(df, slice(self.fit_start_time, self.fit_end_time), level="datetime")
+        cols = get_group_columns(df, self.fields_group)
+        self.min_val = np.nanmin(df[cols].values, axis=0)
+        self.max_val = np.nanmax(df[cols].values, axis=0)
+        self.ignore = self.min_val == self.max_val
+        # To improve the speed, we set the value of `min_val` to `0` for the columns that do not need to be processed,
+        # and the value of `max_val` to `1`, when using `(x - min_val) / (max_val - min_val)` for uniform calculation,
+        # the columns that do not need to be processed will be calculated by `(x - 0) / (1 - 0)`,
+        # as you can see, the columns that do not need to be processed, will not be affected.
+        for _i, _con in enumerate(self.ignore):
+            if _con:
+                self.min_val[_i] = 0
+                self.max_val[_i] = 1
+        self.cols = cols
+
+    def __call__(self, df):
+        def normalize(x, min_val=self.min_val, max_val=self.max_val):
+            return (x - min_val) / (max_val - min_val)
+
+        df.loc(axis=1)[self.cols] = normalize(df[self.cols].values)
+        return df
+
+
+class ZScoreNorm(Processor):
+    """ZScore Normalization"""
+
+    def __init__(self, fit_start_time, fit_end_time, fields_group=None):
+        # NOTE: correctly set the `fit_start_time` and `fit_end_time` is very important !!!
+        # `fit_end_time` **must not** include any information from the test data!!!
+        self.fit_start_time = fit_start_time
+        self.fit_end_time = fit_end_time
+        self.fields_group = fields_group
+
+    def fit(self, df: pd.DataFrame = None):
+        df = fetch_df_by_index(df, slice(self.fit_start_time, self.fit_end_time), level="datetime")
+        cols = get_group_columns(df, self.fields_group)
+        self.mean_train = np.nanmean(df[cols].values, axis=0)
+        self.std_train = np.nanstd(df[cols].values, axis=0)
+        self.ignore = self.std_train == 0
+        # To improve the speed, we set the value of `std_train` to `1` for the columns that do not need to be processed,
+        # and the value of `mean_train` to `0`, when using `(x - mean_train) / std_train` for uniform calculation,
+        # the columns that do not need to be processed will be calculated by `(x - 0) / 1`,
+        # as you can see, the columns that do not need to be processed, will not be affected.
+        for _i, _con in enumerate(self.ignore):
+            if _con:
+                self.std_train[_i] = 1
+                self.mean_train[_i] = 0
+        self.cols = cols
+
+    def __call__(self, df):
+        def normalize(x, mean_train=self.mean_train, std_train=self.std_train):
+            return (x - mean_train) / std_train
+
+        df.loc(axis=1)[self.cols] = normalize(df[self.cols].values)
+        return df
+
+
+class RobustZScoreNorm(Processor):
+    """Robust ZScore Normalization
+
+    Use robust statistics for Z-Score normalization:
+        mean(x) = median(x)
+        std(x) = MAD(x) * 1.4826
+
+    Reference:
+        https://en.wikipedia.org/wiki/Median_absolute_deviation.
+    """
+
+    def __init__(self, fit_start_time, fit_end_time, fields_group=None, clip_outlier=True):
+        # NOTE: correctly set the `fit_start_time` and `fit_end_time` is very important !!!
+        # `fit_end_time` **must not** include any information from the test data!!!
+        self.fit_start_time = fit_start_time
+        self.fit_end_time = fit_end_time
+        self.fields_group = fields_group
+        self.clip_outlier = clip_outlier
+
+    def fit(self, df: pd.DataFrame = None):
+        df = fetch_df_by_index(df, slice(self.fit_start_time, self.fit_end_time), level="datetime")
+        self.cols = get_group_columns(df, self.fields_group)
+        X = df[self.cols].values
+        self.mean_train = np.nanmedian(X, axis=0)
+        self.std_train = np.nanmedian(np.abs(X - self.mean_train), axis=0)
+        self.std_train += EPS
+        self.std_train *= 1.4826
+
+    def __call__(self, df):
+        X = df[self.cols]
+        X -= self.mean_train
+        X /= self.std_train
+        if self.clip_outlier:
+            X = np.clip(X, -3, 3)
+        df[self.cols] = X
+        return df
+
+
+class CSZScoreNorm(Processor):
+    """Cross Sectional ZScore Normalization"""
+
+    def __init__(self, fields_group=None, method="zscore"):
+        self.fields_group = fields_group
+        if method == "zscore":
+            self.zscore_func = zscore
+        elif method == "robust":
+            self.zscore_func = robust_zscore
+        else:
+            raise NotImplementedError(f"This type of input is not supported")
+
+    def __call__(self, df):
+        # try not modify original dataframe
+        if not isinstance(self.fields_group, list):
+            self.fields_group = [self.fields_group]
+        # depress warning by references:
+        # https://stackoverflow.com/questions/20625582/how-to-deal-with-settingwithcopywarning-in-pandas
+        # https://pandas.pydata.org/pandas-docs/stable/user_guide/options.html#getting-and-setting-options
+        with pd.option_context("mode.chained_assignment", None):
+            for g in self.fields_group:
+                cols = get_group_columns(df, g)
+                df[cols] = df[cols].groupby("datetime", group_keys=False).apply(self.zscore_func)
+        return df
+
+
+class CSRankNorm(Processor):
+    """
+    Cross Sectional Rank Normalization.
+    "Cross Sectional" is often used to describe data operations.
+    The operations across different stocks are often called Cross Sectional Operation.
+
+    For example, CSRankNorm is an operation that grouping the data by each day and rank `across` all the stocks in each day.
+
+    Explanation about 3.46 & 0.5
+
+    .. code-block:: python
+
+        import numpy as np
+        import pandas as pd
+        x = np.random.random(10000)  # for any variable
+        x_rank = pd.Series(x).rank(pct=True)  # if it is converted to rank, it will be a uniform distributed
+        x_rank_norm = (x_rank - x_rank.mean()) / x_rank.std()  # Normally, we will normalize it to make it like normal distribution
+
+        x_rank.mean()   # accounts for 0.5
+        1 / x_rank.std()  # accounts for 3.46
+
+    """
+
+    def __init__(self, fields_group=None):
+        self.fields_group = fields_group
+
+    def __call__(self, df):
+        # try not modify original dataframe
+        cols = get_group_columns(df, self.fields_group)
+        t = df[cols].groupby("datetime", group_keys=False).rank(pct=True)
+        t -= 0.5
+        t *= 3.46  # NOTE: towards unit std
+        df[cols] = t
+        return df
+
+
+class CSZFillna(Processor):
+    """Cross Sectional Fill Nan"""
+
+    def __init__(self, fields_group=None):
+        self.fields_group = fields_group
+
+    def __call__(self, df):
+        cols = get_group_columns(df, self.fields_group)
+        df[cols] = df[cols].groupby("datetime", group_keys=False).apply(lambda x: x.fillna(x.mean()))
+        return df
+
+
+class HashStockFormat(Processor):
+    """Process the storage of from df into hasing stock format"""
+
+    def __call__(self, df: pd.DataFrame):
+        from .storage import HashingStockStorage  # pylint: disable=C0415
+
+        return HashingStockStorage.from_df(df)
+
+
+class TimeRangeFlt(InstProcessor):
+    """
+    This is a filter to filter stock.
+    Only keep the data that exist from start_time to end_time (the existence in the middle is not checked.)
+    WARNING:  It may induce leakage!!!
+    """
+
+    def __init__(
+        self,
+        start_time: Optional[Union[pd.Timestamp, str]] = None,
+        end_time: Optional[Union[pd.Timestamp, str]] = None,
+        freq: str = "day",
+    ):
+        """
+        Parameters
+        ----------
+        start_time : Optional[Union[pd.Timestamp, str]]
+            The data must start earlier (or equal) than `start_time`
+            None indicates data will not be filtered based on `start_time`
+        end_time : Optional[Union[pd.Timestamp, str]]
+            similar to start_time
+        freq : str
+            The frequency of the calendar
+        """
+        # Align to calendar before filtering
+        cal = D.calendar(start_time=start_time, end_time=end_time, freq=freq)
+        self.start_time = None if start_time is None else cal[0]
+        self.end_time = None if end_time is None else cal[-1]
+
+    def __call__(self, df: pd.DataFrame, instrument, *args, **kwargs):
+        if (
+            df.empty
+            or (self.start_time is None or df.index.min() <= self.start_time)
+            and (self.end_time is None or df.index.max() >= self.end_time)
+        ):
+            return df
+        return df.head(0)

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

@@ -0,0 +1,191 @@
+from abc import abstractmethod
+import pandas as pd
+import numpy as np
+
+from .handler import DataHandler
+from typing import Union, List
+from qlib.log import get_module_logger
+
+from .utils import get_level_index, fetch_df_by_index, fetch_df_by_col
+
+
+class BaseHandlerStorage:
+    """
+    Base data storage for datahandler
+    - pd.DataFrame is the default data storage format in Qlib datahandler
+    - If users want to use custom data storage, they should define subclass inherited BaseHandlerStorage, and implement the following method
+    """
+
+    @abstractmethod
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = DataHandler.CS_ALL,
+        fetch_orig: bool = True,
+    ) -> pd.DataFrame:
+        """fetch data from the data storage
+
+        Parameters
+        ----------
+        selector : Union[pd.Timestamp, slice, str]
+            describe how to select data by index
+        level : Union[str, int]
+            which index level to select the data
+            - if level is None, apply selector to df directly
+        col_set : Union[str, List[str]]
+            - if isinstance(col_set, str):
+                select a set of meaningful columns.(e.g. features, columns)
+                if col_set == DataHandler.CS_RAW:
+                    the raw dataset will be returned.
+            - if isinstance(col_set, List[str]):
+                select several sets of meaningful columns, the returned data has multiple level
+        fetch_orig : bool
+            Return the original data instead of copy if possible.
+
+        Returns
+        -------
+        pd.DataFrame
+            the dataframe fetched
+        """
+        raise NotImplementedError("fetch is method not implemented!")
+
+
+class NaiveDFStorage(BaseHandlerStorage):
+    """Naive data storage for datahandler
+    - NaiveDFStorage is a naive data storage for datahandler
+    - NaiveDFStorage will input a pandas.DataFrame as and provide interface support for fetching data
+    """
+
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = DataHandler.CS_ALL,
+        fetch_orig: bool = True,
+    ) -> pd.DataFrame:
+        # Following conflicts may occur
+        # - Does [20200101", "20210101"] mean selecting this slice or these two days?
+        # To solve this issue
+        #   - slice have higher priorities (except when level is none)
+        if isinstance(selector, (tuple, list)) and level is not None:
+            # when level is None, the argument will be passed in directly
+            # we don't have to convert it into slice
+            try:
+                selector = slice(*selector)
+            except ValueError:
+                get_module_logger("DataHandlerLP").info(f"Fail to converting to query to slice. It will used directly")
+
+        data_df = self.df
+        data_df = fetch_df_by_col(data_df, col_set)
+        data_df = fetch_df_by_index(data_df, selector, level, fetch_orig=fetch_orig)
+        return data_df
+
+
+class HashingStockStorage(BaseHandlerStorage):
+    """Hashing data storage for datahanlder
+    - The default data storage pandas.DataFrame is too slow when randomly accessing one stock's data
+    - HashingStockStorage hashes the multiple stocks' data(pandas.DataFrame) by the key `stock_id`.
+    - HashingStockStorage hashes the pandas.DataFrame into a dict, whose key is the stock_id(str) and value this stock data(panda.DataFrame), it has the following format:
+        {
+            stock1_id: stock1_data,
+            stock2_id: stock2_data,
+            ...
+            stockn_id: stockn_data,
+        }
+    - By the `fetch` method, users can access any stock data with much lower time cost than default data storage
+    """
+
+    def __init__(self, df):
+        self.hash_df = dict()
+        self.stock_level = get_level_index(df, "instrument")
+        for k, v in df.groupby(level="instrument", group_keys=False):
+            self.hash_df[k] = v
+        self.columns = df.columns
+
+    @staticmethod
+    def from_df(df):
+        return HashingStockStorage(df)
+
+    def _fetch_hash_df_by_stock(self, selector, level):
+        """fetch the data with stock selector
+
+        Parameters
+        ----------
+        selector : Union[pd.Timestamp, slice, str]
+            describe how to select data by index
+        level : Union[str, int]
+            which index level to select the data
+            - if level is None, apply selector to df directly
+            - the `_fetch_hash_df_by_stock` will parse the stock selector in arg `selector`
+
+        Returns
+        -------
+        Dict
+            The dict whose key is stock_id, value is the stock's data
+        """
+
+        stock_selector = slice(None)
+        time_selector = slice(None)  # by default not filter by time.
+
+        if level is None:
+            # For directly applying.
+            if isinstance(selector, tuple) and self.stock_level < len(selector):
+                # full selector format
+                stock_selector = selector[self.stock_level]
+                time_selector = selector[1 - self.stock_level]
+            elif isinstance(selector, (list, str)) and self.stock_level == 0:
+                # only stock selector
+                stock_selector = selector
+        elif level in ("instrument", self.stock_level):
+            if isinstance(selector, tuple):
+                # NOTE: How could the stock level selector be a tuple?
+                stock_selector = selector[0]
+                raise TypeError(
+                    "I forget why would this case appear. But I think it does not make sense. So we raise a error for that case."
+                )
+            elif isinstance(selector, (list, str)):
+                stock_selector = selector
+
+        if not isinstance(stock_selector, (list, str)) and stock_selector != slice(None):
+            raise TypeError(f"stock selector must be type str|list, or slice(None), rather than {stock_selector}")
+
+        if stock_selector == slice(None):
+            return self.hash_df, time_selector
+
+        if isinstance(stock_selector, str):
+            stock_selector = [stock_selector]
+
+        select_dict = dict()
+        for each_stock in sorted(stock_selector):
+            if each_stock in self.hash_df:
+                select_dict[each_stock] = self.hash_df[each_stock]
+        return select_dict, time_selector
+
+    def fetch(
+        self,
+        selector: Union[pd.Timestamp, slice, str, pd.Index] = slice(None, None),
+        level: Union[str, int] = "datetime",
+        col_set: Union[str, List[str]] = DataHandler.CS_ALL,
+        fetch_orig: bool = True,
+    ) -> pd.DataFrame:
+        fetch_stock_df_list, time_selector = self._fetch_hash_df_by_stock(selector=selector, level=level)
+        fetch_stock_df_list = list(fetch_stock_df_list.values())
+        for _index, stock_df in enumerate(fetch_stock_df_list):
+            fetch_col_df = fetch_df_by_col(df=stock_df, col_set=col_set)
+            fetch_index_df = fetch_df_by_index(
+                df=fetch_col_df, selector=time_selector, level="datetime", fetch_orig=fetch_orig
+            )
+            fetch_stock_df_list[_index] = fetch_index_df
+        if len(fetch_stock_df_list) == 0:
+            index_names = ("instrument", "datetime") if self.stock_level == 0 else ("datetime", "instrument")
+            return pd.DataFrame(
+                index=pd.MultiIndex.from_arrays([[], []], names=index_names), columns=self.columns, dtype=np.float32
+            )
+        elif len(fetch_stock_df_list) == 1:
+            return fetch_stock_df_list[0]
+        else:
+            return pd.concat(fetch_stock_df_list, sort=False, copy=~fetch_orig)

Kronos/qlib/build/lib.linux-x86_64-cpython-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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-39/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