zigzag-reload 0.3.3__tar.gz

zigzag_reload-0.3.3/CHANGES.txt

@@ -0,0 +1,12 @@
+v0.1.0, 2014-02-21 -- Initial Release, refactored version of my poorly
+                      executed TSGeom package.
+v0.1.1, 2014-02-25 -- Change README.txt to README.rst so that Github will 
+                      process it correctly.
+v0.1.2, 2014-03-20 -- FIX bug that caused install error due to changed README
+                      file name. 
+v0.1.3, 2014-03-20 -- FIX of previous FIX. Apparently, I don't understand the 
+                      README.rst usage pattern.
+v0.1.4, 2017-05-09 -- Refactor for Cython instead of numba
+v0.3.0, 2022-07-31 -- Switch to poetry for package management. Drop support
+                      for Python below 3.8. Add plotting package helpers.
+                      Add support for Pandas.

zigzag_reload-0.3.3/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2014, John Bjorn Nelson
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

zigzag_reload-0.3.3/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: zigzag-reload
+Version: 0.3.3
+Summary: Package for finding peaks and valleys of time series.
+Home-page: https://github.com/jbn/ZigZag
+License: BSD-3-Clause
+Author: generativist
+Author-email: jbn@abreka.com
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: Cython (>=0.29,<0.30)
+Requires-Dist: numpy (>=1.21.1)
+Project-URL: Repository, https://github.com/jbn/ZigZag
+Description-Content-Type: text/markdown
+
+![build-and-test-python](https://github.com/jbn/ZigZag/actions/workflows/build-and-test-python.yml/badge.svg)
+[![PyPI version](https://badge.fury.io/py/ZigZag.svg)](https://badge.fury.io/py/ZigZag)
+[![GitHub stars](https://img.shields.io/github/stars/jbn/ZigZag)](https://github.com/jbn/ZigZag/stargazers)
+[![GitHub license](https://img.shields.io/github/license/jbn/ZigZag)](https://github.com/jbn/ZigZag/blob/main/LICENSE.txt)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/ZigZag)
+
+
+# ZigZag
+
+ZigZag provides functions for identifying the peaks and valleys of a time
+series. Additionally, it provides a function for computing the maximum drawdown.
+
+For fastest understanding, [view the IPython notebook demo tutorial](https://github.com/jbn/ZigZag/blob/master/zigzag_demo.ipynb>).
+
+## Contributing
+
+This is an admittedly small project. Still, if you have any contributions, 
+please [fork this project on github](https://github.com/jbn/ZigZag) and
+send me a pull request.
+

zigzag_reload-0.3.3/README.md

@@ -0,0 +1,19 @@
+![build-and-test-python](https://github.com/jbn/ZigZag/actions/workflows/build-and-test-python.yml/badge.svg)
+[![PyPI version](https://badge.fury.io/py/ZigZag.svg)](https://badge.fury.io/py/ZigZag)
+[![GitHub stars](https://img.shields.io/github/stars/jbn/ZigZag)](https://github.com/jbn/ZigZag/stargazers)
+[![GitHub license](https://img.shields.io/github/license/jbn/ZigZag)](https://github.com/jbn/ZigZag/blob/main/LICENSE.txt)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/ZigZag)
+
+
+# ZigZag
+
+ZigZag provides functions for identifying the peaks and valleys of a time
+series. Additionally, it provides a function for computing the maximum drawdown.
+
+For fastest understanding, [view the IPython notebook demo tutorial](https://github.com/jbn/ZigZag/blob/master/zigzag_demo.ipynb>).
+
+## Contributing
+
+This is an admittedly small project. Still, if you have any contributions, 
+please [fork this project on github](https://github.com/jbn/ZigZag) and
+send me a pull request.

zigzag_reload-0.3.3/build.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+import sys
+from distutils.command.build_ext import build_ext
+from distutils.core import Distribution, Extension
+
+from Cython.Build import cythonize
+import numpy as np
+
+compile_args = ["-O3"]
+link_args = []
+include_dirs = [np.get_include()]
+libraries = ["m"]
+
+
+def build():
+    debug_mode_on = '1' if 'debug_mode_on' in os.environ else '0'
+    extensions = [
+        Extension(
+            "*",
+            ["zigzag/*.pyx"],
+            extra_compile_args=compile_args,
+            extra_link_args=link_args,
+            include_dirs=include_dirs,
+            libraries=libraries if os.name != 'nt' else [],
+            define_macros=[('CYTHON_TRACE', debug_mode_on),
+                           ('CYTHON_TRACE_NOGIL', debug_mode_on),
+                           ('CYTHON_BINDING', debug_mode_on),
+                           ('CYTHON_FAST_PYCCALL', '1')],
+        )
+    ]
+    ext_modules = cythonize(
+        extensions,
+        include_path=include_dirs,
+        compiler_directives={"binding": True, "language_level": sys.version_info.major},
+    )
+
+    distribution = Distribution({"name": "extended", "ext_modules": ext_modules})
+    distribution.package_dir = "extended"
+
+    cmd = build_ext(distribution)
+    cmd.ensure_finalized()
+    cmd.run()
+
+    # Copy built extensions back to the project
+    for output in cmd.get_outputs():
+        relative_extension = os.path.relpath(output, cmd.build_lib)
+        shutil.copyfile(output, relative_extension)
+        mode = os.stat(relative_extension).st_mode
+        mode |= (mode & 0o444) >> 2
+        os.chmod(relative_extension, mode)
+
+
+if __name__ == "__main__":
+    build()

zigzag_reload-0.3.3/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = [
+    "poetry-core>=1.0.0",
+    "Cython>=0.29",
+    "numpy >=1.21.1",
+]
+build-backend = "poetry.core.masonry.api"
+
+[[tool.poetry.source]]
+name = "tsinghua"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+default = true
+
+[tool.poetry]
+name = "zigzag-reload"
+version = "0.3.3"
+readme = "README.md"
+homepage = "https://github.com/jbn/ZigZag"
+repository = "https://github.com/jbn/ZigZag"
+description = "Package for finding peaks and valleys of time series."
+authors = ["generativist <jbn@abreka.com>"]
+license = "BSD-3-Clause"
+packages = [{ include = "zigzag" }]
+include = [
+    { path = "zigzag/**/*.so", format = "wheel" },
+    { path = "zigzag/**/*.pyx" },
+    { path = "zigzag/**/*.pyd" },
+    "CHANGES.txt"
+]
+
+[tool.poetry.dependencies]
+python = ">=3.8"
+numpy = ">=1.21.1"
+Cython = "^0.29"
+
+[tool.poetry.build]
+generate-setup-file = false
+script = "build.py"
+
+[tool.poetry.dev-dependencies]
+pytest = "^7.1.2"
+pandas = ">=0.22,<2.0"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests",
+]

zigzag_reload-0.3.3/zigzag/__init__.py

@@ -0,0 +1,4 @@
+from zigzag.core import *
+
+PEAK = 1
+VALLEY = -1

zigzag_reload-0.3.3/zigzag/core.pyx

@@ -0,0 +1,234 @@
+cimport cython
+import numpy as np
+from numpy cimport ndarray, int_t
+
+DEF PEAK = 1
+DEF VALLEY = -1
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef int_t identify_initial_pivot(double [:] X,
+                                   double up_thresh,
+                                   double down_thresh):
+    cdef:
+        double x_0 = X[0]
+        double x_t = x_0
+
+        double max_x = x_0
+        double min_x = x_0
+
+        int_t max_t = 0
+        int_t min_t = 0
+
+    up_thresh += 1
+    down_thresh += 1
+
+    for t in range(1, len(X)):
+        x_t = X[t]
+
+        if x_t / min_x >= up_thresh:
+            return VALLEY if min_t == 0 else PEAK
+
+        if x_t / max_x <= down_thresh:
+            return PEAK if max_t == 0 else VALLEY
+
+        if x_t > max_x:
+            max_x = x_t
+            max_t = t
+
+        if x_t < min_x:
+            min_x = x_t
+            min_t = t
+
+    t_n = len(X)-1
+    return VALLEY if x_0 < X[t_n] else PEAK
+
+def _to_ndarray(X):
+    # The type signature in peak_valley_pivots_detailed does not work for
+    # pandas series because as of 0.13.0 it no longer sub-classes ndarray.
+    # The workaround everyone used was to call `.values` directly before
+    # calling the function. Which is fine but a little annoying.
+    t = type(X)
+    if t.__name__ == 'ndarray':
+        pass  # Check for ndarray first for historical reasons
+    elif f"{t.__module__}.{t.__name__}" == 'pandas.core.series.Series':
+        X = X.values
+    elif isinstance(X, (list, tuple)):
+        X = np.array(X)
+
+    return X
+
+
+def peak_valley_pivots(X, up_thresh, down_thresh):
+    X = _to_ndarray(X)
+
+    # Ensure float for correct signature
+    if not str(X.dtype).startswith('float'):
+        X = X.astype(np.float64)
+
+    return peak_valley_pivots_detailed(X, up_thresh, down_thresh, True, False)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef peak_valley_pivots_detailed(double [:] X,
+                                  double up_thresh,
+                                  double down_thresh,
+                                  bint limit_to_finalized_segments,
+                                  bint use_eager_switching_for_non_final):
+    """
+    Find the peaks and valleys of a series.
+
+    :param X: the series to analyze
+    :param up_thresh: minimum relative change necessary to define a peak
+    :param down_thesh: minimum relative change necessary to define a valley
+    :return: an array with 0 indicating no pivot and -1 and 1 indicating
+        valley and peak
+
+
+    The First and Last Elements
+    ---------------------------
+    The first and last elements are guaranteed to be annotated as peak or
+    valley even if the segments formed do not have the necessary relative
+    changes. This is a tradeoff between technical correctness and the
+    propensity to make mistakes in data analysis. The possible mistake is
+    ignoring data outside the fully realized segments, which may bias
+    analysis.
+    """
+    if down_thresh > 0:
+        raise ValueError('The down_thresh must be negative.')
+
+    cdef:
+        int_t initial_pivot = identify_initial_pivot(X,
+                                                     up_thresh,
+                                                     down_thresh)
+        int_t t_n = len(X)
+        ndarray[int_t, ndim=1] pivots = np.zeros(t_n, dtype=np.int_)
+        int_t trend = -initial_pivot
+        int_t last_pivot_t = 0
+        double last_pivot_x = X[0]
+        double x, r
+
+    pivots[0] = initial_pivot
+
+    # Adding one to the relative change thresholds saves operations. Instead
+    # of computing relative change at each point as x_j / x_i - 1, it is
+    # computed as x_j / x_1. Then, this value is compared to the threshold + 1.
+    # This saves (t_n - 1) subtractions.
+    up_thresh += 1
+    down_thresh += 1
+
+    for t in range(1, t_n):
+        x = X[t]
+        r = x / last_pivot_x
+
+        if trend == -1:
+            if r >= up_thresh:
+                pivots[last_pivot_t] = trend
+                trend = PEAK
+                last_pivot_x = x
+                last_pivot_t = t
+            elif x < last_pivot_x:
+                last_pivot_x = x
+                last_pivot_t = t
+        else:
+            if r <= down_thresh:
+                pivots[last_pivot_t] = trend
+                trend = VALLEY
+                last_pivot_x = x
+                last_pivot_t = t
+            elif x > last_pivot_x:
+                last_pivot_x = x
+                last_pivot_t = t
+
+
+    if limit_to_finalized_segments:
+        if use_eager_switching_for_non_final:
+            if last_pivot_t > 0 and last_pivot_t < t_n-1:
+                pivots[last_pivot_t] = trend
+                pivots[t_n-1] = -trend
+            else:
+                pivots[t_n-1] = trend
+        else:
+            if last_pivot_t == t_n-1:
+                pivots[last_pivot_t] = trend
+            elif pivots[t_n-1] == 0:
+                pivots[t_n-1] = -trend
+
+    return pivots
+
+
+def max_drawdown(X) -> float:
+    X = _to_ndarray(X)
+
+    # Ensure float for correct signature
+    if not str(X.dtype).startswith('float'):
+        X = X.astype(np.float64)
+
+    return max_drawdown_c(X)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef double max_drawdown_c(ndarray[double, ndim=1] X):
+    """
+    Compute the maximum drawdown of some sequence.
+
+    :return: 0 if the sequence is strictly increasing.
+        otherwise the abs value of the maximum drawdown
+        of sequence X
+    """
+    cdef:
+        double mdd = 0
+        double peak = X[0]
+        double x, dd
+
+    for x in X:
+        if x > peak:
+            peak = x
+
+        dd = (peak - x) / peak
+
+        if dd > mdd:
+            mdd = dd
+
+    return mdd if mdd != 0.0 else 0.0
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def pivots_to_modes(int_t [:] pivots):
+    """
+    Translate pivots into trend modes.
+
+    :param pivots: the result of calling ``peak_valley_pivots``
+    :return: numpy array of trend modes. That is, between (VALLEY, PEAK] it
+    is 1 and between (PEAK, VALLEY] it is -1.
+    """
+
+    cdef:
+        int_t x, t
+        ndarray[int_t, ndim=1] modes = np.zeros(len(pivots),
+                                                dtype=np.int_)
+        int_t mode = -pivots[0]
+
+    modes[0] = pivots[0]
+
+    for t in range(1, len(pivots)):
+        x = pivots[t]
+        if x != 0:
+            modes[t] = mode
+            mode = -x
+        else:
+            modes[t] = mode
+
+    return modes
+
+
+def compute_segment_returns(X, pivots):
+    """
+    :return: numpy array of the pivot-to-pivot returns for each segment."""
+    X = _to_ndarray(X)
+    pivot_points = X[pivots != 0]
+    return pivot_points[1:] / pivot_points[:-1] - 1.0

zigzag_reload-0.3.3/zigzag/plotting.py

@@ -0,0 +1,18 @@
+"""
+The package requirements do not enforce matplotlib as a requirement so this
+package is optional. However, it's useful.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def plot_pivots(X, pivots, ax=None):
+    if ax is None:
+        ax = plt.subplots(1, 1)[1]
+
+    ax.set_xlim(0, len(X))
+    ax.set_ylim(X.min()*0.99, X.max()*1.01)
+    ax.plot(np.arange(len(X)), X, 'k:', alpha=0.5)
+    ax.plot(np.arange(len(X))[pivots != 0], X[pivots != 0], 'k-')
+    ax.scatter(np.arange(len(X))[pivots == 1], X[pivots == 1], color='g')
+    ax.scatter(np.arange(len(X))[pivots == -1], X[pivots == -1], color='r')