fynance 2.1.0__py3-none-any.whl

fynance/__init__.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# @Author: ArthurBernard
+# @Email: arthur.bernard.92@gmail.com
+# @Date: 2019-02-15 12:50:12
+# @Last modified by: ArthurBernard
+# @Last modified time: 2019-11-05 16:55:36
+
+"""
+Fynance : A Python package for quant financial research
+=======================================================
+
+Documentation is available at
+https://fynance.readthedocs.io/en/latest/index.html.
+
+Contents
+--------
+Fynance is a python/cython project that includes several machine learning,
+econometric and statistical subpackages specialy adapted for financial
+analysis, portfolio allocation, and backtest trading strategies.
+
+Subpackages
+-----------
+portfolio       --- Portfolio allocation & sizing
+backtest        --- Backtest strategy tools
+estimator       --- Parameter estimation (Cython ARMA/GARCH)
+features        --- Features extraction
+models          --- Econometric and Neural Network models (using PyTorch)
+
+Utility tools
+-------------
+_exceptions --- Fynance exceptions
+tests       --- Run fynance unittests
+_wrappers   --- Fynance wrapper functions
+
+API stability policy (1.x series)
+---------------------------------
+The symbols re-exported below from :mod:`fynance.models`,
+:mod:`fynance.portfolio.allocation`, :mod:`fynance.features` and
+:mod:`fynance.estimator` form the **public, stable API** for the 1.x
+release line. Within 1.x:
+
+- public function and class signatures are frozen — no removals, no
+  backward-incompatible signature changes;
+- behavioural changes that would break user code go through one
+  release of :class:`DeprecationWarning` before becoming the new
+  default (see ``CONTRIBUTING.md``);
+- :mod:`fynance.backtest` and :mod:`fynance.models` *internal* helpers
+  (names prefixed with ``_``) remain free to evolve.
+
+Breaking changes are reserved for the 2.x line and tracked in
+``CHANGELOG.md``.
+
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("fynance")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ['__version__']
+
+import sys as _sys
+
+from .backtest import *
+from .core import *
+from .data import *
+from .estimator import *
+from .features import *
+from .metrics import *
+from .models import *
+from .plot import *
+from .portfolio import *
+from .signal import *
+from .strategy import *
+
+# Aggregate each subpackage's public surface. Use ``sys.modules`` rather than the
+# package attributes, which a star import may have shadowed with a name that
+# collides with a submodule (e.g. the ``backtest`` engine function).
+for _name in ("core", "data", "models", "estimator", "features", "metrics",
+              "plot", "signal", "backtest", "portfolio", "strategy"):
+    __all__ += _sys.modules[f"{__name__}.{_name}"].__all__
+
+# Restore the subpackage attribute shadowed by such a collision so that
+# ``fynance.backtest`` resolves to the package (``fynance.backtest.backtest``
+# stays the engine function).
+backtest = _sys.modules[__name__ + ".backtest"]
+
+del _sys, _name

fynance/_exceptions.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# @Author: ArthurBernard
+# @Email: arthur.bernard.92@gmail.com
+# @Date: 2019-10-23 17:01:36
+# @Last modified by: ArthurBernard
+# @Last modified time: 2019-10-23 17:17:32
+
+""" Define some various richly-typed exceptions. """
+
+# Built-in packages
+
+# Third party packages
+
+# Local packages
+
+
+class ArraySizeError(ValueError, IndexError):
+    """ Size of the array was invalid. """
+
+    def __init__(self, size, axis=None, min_size=None, msg_prefix=None):
+        """ Initialize the array size error. """
+        msg = 'array of size {}'.format(size)
+
+        if axis is not None:
+            msg += ' in axis {}'.format(axis)
+
+        msg += ' is not allowed'
+
+        if min_size is not None:
+            msg += ', minimum size is {}'.format(min_size)
+
+        if msg_prefix is not None:
+            msg = '{}: {}'.format(msg_prefix, msg)
+
+        super().__init__(msg)

fynance/_wrappers.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# @Author: ArthurBernard
+# @Email: arthur.bernard.92@gmail.com
+# @Date: 2019-10-11 10:10:43
+# @Last modified by: ArthurBernard
+# @Last modified time: 2019-11-08 11:11:54
+
+""" Some wrappers functions. """
+
+# Built-in packages
+from functools import wraps
+from warnings import warn
+
+# Third party packages
+import numpy as np
+
+# Local packages
+from fynance._exceptions import ArraySizeError
+
+
+def _check_dtype(X, dtype):
+    if dtype is None:
+        dtype = X.dtype
+
+    if X.dtype != np.float64:
+        X = X.astype(np.float64)
+
+    return X, dtype
+
+
+def wrap_dtype(func):
+    """ Check the dtype of the `X` array.
+
+    Convert dtype of X to np.float64 before to pass to cython function and
+    convert to specified dtype at the end.
+
+    """
+    @wraps(func)
+    def check_dtype(X, *args, dtype=None, **kwargs):
+        X, dtype = _check_dtype(X, dtype)
+
+        if dtype != np.float64:
+            return func(X, *args, dtype=dtype, **kwargs).astype(dtype)
+
+        return func(X, *args, dtype=dtype, **kwargs)
+
+    return check_dtype
+
+
+def wrap_axis(func):
+    """ Check if computation on `axis` of `X` array is available. """
+    @wraps(func)
+    def check_axis(X, *args, axis=0, min_size=0, **kwargs):
+        shape = X.shape
+        if X.ndim > 2:
+            warn(
+                'currently, array of dimensions larger than 2 are not '
+                'supported, it may lead to some issues',
+                category=UserWarning,
+                stacklevel=2,
+            )
+
+        if shape[axis] < min_size:
+
+            raise ArraySizeError(shape[axis], axis=axis, min_size=min_size)
+
+        elif X.ndim <= axis:
+
+            raise np.AxisError(axis, len(X.shape))
+
+        elif axis == 1 and X.ndim == 2:
+
+            return func(X.T, *args, axis=0, **kwargs).T
+
+        return func(X, *args, axis=axis, **kwargs)
+
+    return check_axis
+
+
+def wrap_lags(func):
+    # Not clean, may lead to undesirable behavior
+    """ Check the max available lag for `X` array. """
+    @wraps(func)
+    def check_lags(X, k, *args, axis=0, **kwargs):
+        if k <= 0:
+            raise ValueError('lag {} must be greater than 0.'.format(k))
+
+        elif X.shape[axis] < k:
+            warn(
+                '{} lags is out of bounds for axis {} with size {}'.format(
+                    k, axis, X.shape[axis]
+                ),
+                category=UserWarning,
+                stacklevel=2,
+            )
+            k = X.shape[axis]
+
+        return func(X, k, *args, axis=axis, **kwargs)
+
+    return check_lags
+
+
+def wrap_window(func):
+    """ Check if the lagged window `w` is available for `X` array. """
+    @wraps(func)
+    def check_window(X, w=None, **kwargs):
+        if w == 0 or w is None:
+            w = X.shape[0]
+
+        elif 'min_size' in kwargs.keys() and w < kwargs['min_size']:
+
+            raise ValueError('lagged window of size {} is not available, \
+                must be greater than {}'.format(w, kwargs['min_size']))
+
+        elif w < 0:
+
+            raise ValueError('lagged window of size {} is not available, \
+                must be positive.'.format(w))
+
+        elif w > X.shape[0]:
+            warn(
+                'lagged window of size {} is out of bounds with time axis '
+                'of size {}'.format(w, X.shape[0]),
+                category=UserWarning,
+                stacklevel=2,
+            )
+            w = X.shape[0]
+
+        return func(X, w=int(w), **kwargs)
+
+    return check_window
+
+
+def wrap_expo(func):
+    # Not clean, may lead to undesirable behavior
+    """ Check if parameters is allowed by the `kind` of moving avg/std. """
+    @wraps(func)
+    def check_expo(X, *args, w=None, kind=None, **kwargs):
+        if kind == 'e':
+            w = 1 - 2 / (1 + w)
+
+        return func(X, *args, w=w, kind=kind, **kwargs)
+
+    return check_expo
+
+
+def wrap_null(func):
+    """ Check if there is any null value and raise an exception. """
+    @wraps(func)
+    def check_null(X, *args, **kwargs):
+        if (X == 0).any():
+
+            raise ValueError('null value in X is not allowed.')
+
+        return func(X, *args, **kwargs)
+
+    return check_null
+
+
+def wrap_ddof(func):
+    """ Check if ddof is not greater than the number of timeframe. """
+    @wraps(func)
+    def check_ddof(X, *args, ddof=0, **kwargs):
+        if ddof >= X.shape[0]:
+            msg_prefix = 'with degree of freedom {}'.format(ddof)
+
+            raise ArraySizeError(X.shape[0], msg_prefix=msg_prefix)
+
+        elif ddof < 0:
+
+            raise ValueError('ddof must be a positive value')
+
+        return func(X, *args, ddof=ddof, **kwargs)
+
+    return check_ddof
+
+
+def wrap_keepdims(func):
+    """ Check that output have same dimensions as input. """
+    @wraps(func)
+    def check_keepdims(X, *args, keepdims=False, **kwargs):
+        if keepdims:
+            out = func(X, *args, **kwargs)
+
+            return out.reshape(out.shape + (1,))
+
+        return func(X, *args, **kwargs)
+
+    return check_keepdims
+
+
+class WrapperArray:
+    """ Object to wrap function that handle numpy arrays.
+
+    This object mix several wrapper functions.
+
+    Parameters
+    ----------
+    *args : {'dtype', 'axis', 'lags', 'window', 'null', 'ddof', 'keepdims'}
+        Wrapper functions.
+    **kwargs
+        Keyword arguments to pass to wrapper functions.
+
+    """
+
+    handler = {
+        'dtype': wrap_dtype,
+        'axis': wrap_axis,
+        'lags': wrap_lags,
+        'window': wrap_window,
+        'null': wrap_null,
+        'ddof': wrap_ddof,
+    }
+
+    def __init__(self, *args, **kwargs):
+        """ Initialize wrapper functions. """
+        self.wrappers = {key: self.handler[key] for key in args}
+        self.kw = kwargs
+
+    def __call__(self, func):
+        """ Wrap `func`.
+
+        Parameters
+        ----------
+        func : function
+            Function to wrap.
+
+        Returns
+        -------
+        function
+            Wrapped function.
+
+        """
+        @wraps(func)
+        def wrap(X, *args, **kwargs):
+            wrap_func = None
+            kwargs = {**kwargs, **self.kw}
+
+            for k, w in self.wrappers.items():
+
+                if wrap_func is None:
+                    wrap_func = w(func)
+
+                else:
+                    wrap_func = w(wrap_func)
+
+            return wrap_func(X, *args, **kwargs)
+
+        return wrap

fynance/backtest/__init__.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+
+Some tools to backtest strategies
+
+.. currentmodule:: fynance.backtest
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Contents:
+
+   backtest.tools
+   backtest.plot_object
+
+"""
+
+from . import (
+    backtest_neural_net,
+    cost,
+    dynamic_plot_backtest,
+    engine,
+    plot_backtest,
+    plot_tools,
+    print_stats,
+    result,
+)
+from .backtest_neural_net import *
+from .cost import *
+from .dynamic_plot_backtest import *
+from .engine import *
+from .plot_backtest import *
+from .plot_tools import *
+from .print_stats import *
+from .result import *
+
+__all__ = print_stats.__all__
+__all__ += cost.__all__
+__all__ += engine.__all__
+__all__ += result.__all__
+__all__ += plot_tools.__all__
+__all__ += plot_backtest.__all__
+__all__ += dynamic_plot_backtest.__all__
+__all__ += backtest_neural_net.__all__

fynance/backtest/_basis_plot.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# @Author: ArthurBernard
+# @Email: arthur.bernard.92@gmail.com
+# @Date: 2020-10-24 09:03:49
+# @Last modified by: ArthurBernard
+# @Last modified time: 2020-11-20 09:09:02
+
+""" Description. """
+
+# Built-in packages
+from abc import ABCMeta
+
+# Third party packages
+# import numpy as np
+import matplotlib.pyplot as plt
+
+# import seaborn as sns
+
+# Local packages
+
+__all__ = []
+
+
+class _BasisAxes(metaclass=ABCMeta):
+    def __call__(self, fig, n_rows, n_cols, n_axes):
+        self.fig = fig
+        self.n_axes = n_axes
+        self.ax = self.fig.add_subplot(n_rows, n_cols, n_axes)
+
+    # @abstractmethod
+    def plot(self, y, x=None):
+        if x is None:
+            self.ax.plot(y)
+
+        else:
+            self.ax.plot(x, y)
+
+
+class _BasisPlot:
+    def __init__(self, **kwargs):
+        self.fig = plt.figure(**kwargs)
+        self._n_axes = 0
+        self._n_cols = 1
+        self._n_rows = 0
+        self.axes = {}
+        self.keys = []
+
+    def __setitem__(self, key, value: _BasisAxes):
+        # Set optimal number of axes on figure plot
+        self._n_axes += 1
+        sqrt_n_axes = self._n_axes ** 0.5
+        if self._n_cols * self._n_rows < self._n_axes:
+            if self._n_rows > self._n_cols and self._n_rows >= sqrt_n_axes:
+                self._n_cols += 1
+
+            else:
+                self._n_rows += 1
+
+        print(self._n_rows, self._n_cols)
+        self.axes[key] = value
+        self.keys.append(key)
+
+    def __delitem__(self, key):
+        # Set optimal number of axes on figure plot
+        self._n_axes -= 1
+        n_cols = self._n_cols
+        n_rows = self._n_rows
+        if (n_cols - 1) * n_rows >= self._n_axes:
+            self._n_cols -= 1
+
+        elif (n_rows - 1) * n_cols >= self._n_axes:
+            self._n_rows -= 1
+
+        if self._n_axes < 1:
+            self.fig = None
+            print("destruct fig")
+
+        del self.axes[key]
+        self.keys.remove(key)
+
+    def __getitem__(self, key):
+        return self.axes[key]
+
+    def set_axes(self):
+        for i, key in enumerate(self.keys, 1):
+            self.axes[key](self.fig, self._n_rows, self._n_cols, i)
+
+        return self
+
+
+if __name__ == "__main__":
+    pass

fynance/backtest/backtest_neural_net.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# coding: utf-8
+
+""" Live multi-panel backtest figure for neural-network training.
+
+Provides :class:`BacktestNeuralNet`, which composes the dynamic
+loss / accuracy / performance plots from
+:mod:`fynance.backtest.dynamic_plot_backtest` into a single updating figure.
+"""
+
+# Third-party packages
+from matplotlib import pyplot as plt
+
+# Local packages
+from fynance.backtest.dynamic_plot_backtest import (
+    DynaPlotAccuracy,
+    DynaPlotLoss,
+    DynaPlotPerf,
+)
+
+__all__ = ['BacktestNeuralNet']
+
+
+class BacktestNeuralNet:
+
+    def __init__(self, figsize=(9, 6), loss_xlim=None, perf_xlim=None,
+                 accu_xlim=None, plot_accuracy=False, plot_loss=True,
+                 plot_perf=False, **subplot_kw):
+        # Set dynamic plot object
+        n_rows = plot_accuracy + plot_loss + plot_perf
+        self.f, self.axes = plt.subplots(n_rows, 1, figsize=figsize,
+                                         **subplot_kw)
+
+        if n_rows == 1:
+            self.axes = [self.axes]
+
+        plt.ion()
+        self.accu_is_plot = False
+        self.loss_is_plot = False
+        self.perf_is_plot = False
+
+        if plot_accuracy:
+            self.set_plot_accuracy(self.axes[0], accu_xlim=accu_xlim)
+
+        if plot_loss:
+            self.set_plot_loss(self.axes[int(plot_accuracy)],
+                               loss_xlim=loss_xlim)
+
+        if plot_perf:
+            self.set_plot_perf(self.axes[int(plot_accuracy + plot_loss)],
+                               perf_xlim=perf_xlim)
+
+    def set_plot_accuracy(self, ax, accu_xlim=None):
+        """ Set plot accuracy object. """
+        self.dp_accu = DynaPlotAccuracy(self.f, ax)
+        self.dp_accu.ax.grid()
+        self.dp_accu.ax.set_autoscaley_on(True)
+
+        if accu_xlim is not None:
+            self.dp_accu.ax.set_xlim(*accu_xlim, auto=False)
+            print("setup xlim:", accu_xlim)
+            self.dp_accu.ax.set_autoscalex_on(False)
+
+        else:
+            self.dp_accu.ax.set_autoscalex_on(True)
+
+    def plot_accuracy(self, test, eval, train=None, clear=True):
+        """ Plot accuracy scores for test and evaluate set. """
+        self.dp_accu.plot(test=test, eval=eval, train=train, clear=clear)
+        self.accu_is_plot = True
+
+    def update_accuracy(self, test, eval, train=None):
+        """ Plot accuracy scores for test and evaluate set. """
+        self.dp_accu.update(test=test, eval=eval, train=train)
+
+    def set_plot_loss(self, ax, loss_xlim=None):
+        """ Set plot loss object. """
+        self.dp_loss = DynaPlotLoss(self.f, ax)
+        self.dp_loss.ax.grid()
+        self.dp_loss.ax.set_autoscaley_on(True)
+
+        if loss_xlim is not None:
+            self.dp_loss.ax.set_xlim(*loss_xlim, auto=False)
+            print("setup xlim:", loss_xlim)
+            self.dp_loss.ax.set_autoscalex_on(False)
+
+        else:
+            self.dp_loss.ax.set_autoscalex_on(True)
+
+    def plot_loss(self, test, eval, train=None, clear=True):
+        """ Plot loss function values for test and evaluate set. """
+        self.dp_loss.plot(test=test, eval=eval, train=train, clear=clear)
+        self.loss_is_plot = True
+
+    def update_loss(self, test, eval, train=None):
+        """ Plot loss function values for test and evaluate set. """
+        self.dp_loss.update(test=test, eval=eval, train=train)
+
+    def set_plot_perf(self, ax, perf_xlim=None):
+        # set perf plot
+        self.dp_perf = DynaPlotPerf(self.f, ax)
+        self.dp_perf.ax.grid()
+        self.dp_perf.ax.set_autoscaley_on(True)
+        if perf_xlim is not None:
+            self.dp_perf.ax.set_xlim(*perf_xlim, auto=False)
+            print("setup xlim:", perf_xlim)
+            self.dp_perf.ax.set_autoscalex_on(False)
+
+        else:
+            self.dp_perf.ax.set_autoscalex_on(True)
+
+    def plot_perf(self, test, eval, underlying=None, index=None, clear=True):
+        """ Plot performance values for test and eval set. """
+        self.dp_perf.plot(test=test, eval=eval, underlying=underlying,
+                          index=index, clear=clear)
+        self.perf_is_plot = True
+
+    def update_perf(self, test, eval, underlying=None, index=None, clear=True):
+        """ Update performance values for test and eval set. """
+        self.dp_perf.update(test=test, eval=eval, underlying=underlying,
+                            index=index, clear=clear)

fynance/backtest/cost.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# coding: utf-8
+
+""" Transaction cost models for the vectorized backtest engine.
+
+Concretizes the :class:`~fynance.core.protocols.CostModel` seam. Only the
+proportional (turnover-based) model ships in 2.0; non-linear slippage is a
+documented extension point.
+
+"""
+
+from __future__ import annotations
+
+# Third-party packages
+import numpy as np
+from numpy.typing import NDArray
+
+# Local packages
+from fynance.portfolio.sizing import transaction_cost
+
+__all__ = ['ProportionalCost']
+
+
+class ProportionalCost:
+    """ Proportional transaction cost: ``(fee + slippage) * turnover``.
+
+    Turnover at each step is the absolute traded weight
+    :math:`\\sum_i |w_{t,i} - w_{t-1,i}|` (the first step charges the initial
+    position). Conforms to :class:`~fynance.core.protocols.CostModel`.
+
+    Parameters
+    ----------
+    fee : float
+        Proportional fee per unit traded (e.g. ``0.001`` = 10 bps).
+    slippage : float
+        Additional proportional slippage per unit traded.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> cost = ProportionalCost(fee=0.01)
+    >>> cost(np.array([[1.0, 0.0], [0.5, 0.5], [0.5, 0.5]]))
+    array([0.01, 0.01, 0.  ])
+
+    """
+
+    def __init__(self, fee: float = 0.0, slippage: float = 0.0):
+        """ Store the cost rates. """
+        self.fee = fee
+        self.slippage = slippage
+
+    def __call__(self, weights: NDArray) -> NDArray[np.float64]:
+        """ Return the per-step proportional cost of a weight book. """
+        rate = self.fee + self.slippage
+
+        if rate == 0.0:
+            w = np.asarray(weights, dtype=np.float64)
+
+            return np.zeros(w.shape[0], dtype=np.float64)
+
+        return transaction_cost(weights, fee=rate)