sw1pers-l 0.1.0__tar.gz

sw1pers_l-0.1.0/CHANGES.txt

@@ -0,0 +1,6 @@
+v0.1.0 - 03-17-2026
+-------------------
+Initial release
+- utils/ data_processing, diagrams, parameter_selection, sw1pers_scores, time_series, viualize, windows
+- core.py
+- test_pipeline.py

sw1pers_l-0.1.0/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (c) 2026 Miguel Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "sw1pers-l"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

sw1pers_l-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include LICENSE.txt
+include CHANGES.txt
+
+recursive-include utils *.py
+recursive-include utils *.json
+recursive-include utils *.yaml
+recursive-include utils *.txt

sw1pers_l-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: sw1pers_l
+Version: 0.1.0
+Summary: SW1Pers landscape for time series periodicity analysis
+Author: Miguel Almeida
+Author-email: Miguel Almeida <migpinalm@gmail.com>
+License: Copyright (c) 2026 Miguel Almeida
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "sw1pers-l"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software.
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: tqdm
+Requires-Dist: ripser
+Requires-Dist: plotly
+Dynamic: license-file
+
+The algorithm SW1PerS yields a scalar periodicity score for univariate time series.
+The aim of this project is to make extend the algorithm in order to correspond an array of periodicity scores to univariate time series:
+    The time series is divided into overlapping snippets (sub-time-series), to each of which we apply SW1PerS.
+    The size of the snippet and the overlapping size are hyper-parameters (dependent on the data)
+
+This is useful to locate periodic behaviour in general time series.
+On the other hand, this is useful to locate aperiodic behaviour in periodc time series.

sw1pers_l-0.1.0/README.md

@@ -0,0 +1,7 @@
+The algorithm SW1PerS yields a scalar periodicity score for univariate time series.
+The aim of this project is to make extend the algorithm in order to correspond an array of periodicity scores to univariate time series:
+    The time series is divided into overlapping snippets (sub-time-series), to each of which we apply SW1PerS.
+    The size of the snippet and the overlapping size are hyper-parameters (dependent on the data)
+
+This is useful to locate periodic behaviour in general time series.
+On the other hand, this is useful to locate aperiodic behaviour in periodc time series.

sw1pers_l-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sw1pers_l"
+version = "0.1.0"
+description = "SW1Pers landscape for time series periodicity analysis"
+readme = "README.md"
+license = { file = "LICENSE.txt" }
+authors = [
+    {name = "Miguel Almeida", email = "migpinalm@gmail.com"}
+]
+requires-python = ">=3.11"
+
+dependencies = [
+    "numpy",
+    "matplotlib",
+    "scipy",
+    "scikit-learn",
+    "tqdm",
+    "ripser",
+    "plotly"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["sw1pers_l*"]

sw1pers_l-0.1.0/setup.cfg

@@ -0,0 +1,33 @@
+[metadata]
+name = sw1pers_l
+version = 0.1.0
+description = SW1Pers landscape for time series periodicity analysis
+long_description = file: README.md
+long_description_content_type = text/markdown
+author = Miguel Almeida
+license = MIT
+license_files = LICENSE.txt
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.11
+include_package_data = True
+install_requires = 
+	numpy
+	matplotlib
+	scipy
+	scikit-learn
+	tqdm
+	ripser
+	plotly
+
+[options.packages.find]
+where = src
+include = sw1pers_l*
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sw1pers_l-0.1.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()

sw1pers_l-0.1.0/src/sw1pers_l/__init__.py

@@ -0,0 +1,5 @@
+# utils init
+
+from .core import SW1PerS, SW1PerS_L
+
+__all__ = ["SW1PerS, SW1PerS_L"]

sw1pers_l-0.1.0/src/sw1pers_l/core.py

@@ -0,0 +1,60 @@
+import numpy as np
+from .time_series import embed
+from .windows import make_embedded_windows, make_embedded_ts
+from .data_processing import moving_avg, make_spline
+from .visualize import attractor
+from .diagrams import make_pers_diagrams, make_pers_diagram
+from .sw1pers_scores import compute_scores, density, plot_score_landscape
+
+def SW1PerS(values, rolling_size=1, factor=2):
+    t_ma, ma = moving_avg(values, rolling_size)
+
+    t_fine, finer_spline = make_spline(t_ma, ma, factor*len(values))
+
+    emb_spline, _, _ = make_embedded_ts(finer_spline)
+
+    pers_dgm = make_pers_diagram(emb_spline)
+
+    score = compute_scores([pers_dgm])
+
+    return score
+
+
+#---------------------------------------------------------------------
+
+def SW1PerS_L(values, rolling_size=1, factor=2, choose_hyper_param=False):
+
+    t_ma, ma = moving_avg(values, rolling_size)
+
+    t_fine, finer_spline = make_spline(t_ma, ma, factor*len(values))
+
+    #-----------------------------------
+    if choose_hyper_param:
+        size_coeff = int(input("Window size = length of time series / __"))
+        stride_coeff = int(input("Window stride = window size / __"))
+        size = len(finer_spline)//size_coeff
+        stride = size//stride_coeff
+        print(f"window_size = len(time_series)/{size_coeff}")
+        print(f"window_stride = window_size/{stride_coeff}")
+        print()
+    else:
+        size = len(finer_spline)//8
+        stride = size//4
+
+    emb_windows, _, _ = make_embedded_windows(finer_spline, size, stride)
+
+    #-----------------------------------
+
+    pers_dgms = make_pers_diagrams(emb_windows)
+
+    scores = compute_scores(pers_dgms)
+
+    #-----------------------------------
+
+    rolling_size_scores = int(size/stride)
+                          
+    score_density = density(scores, rolling_size_scores)
+
+    plot_score_landscape(scores, score_density, finer_spline, size, stride, None, rolling_size_scores)
+
+    return scores

sw1pers_l-0.1.0/src/sw1pers_l/data_processing/__init__.py

@@ -0,0 +1,7 @@
+
+# data_processing
+
+from .cubic_spline import make_spline
+from .moving_average import moving_avg
+
+__all__ = ["make_spline", "moving_avg"]

sw1pers_l-0.1.0/src/sw1pers_l/data_processing/cubic_spline.py

@@ -0,0 +1,14 @@
+from scipy.interpolate import CubicSpline
+import numpy as np
+
+def make_spline(x, y, instances=2000,):
+    factor = round(instances/len(y))
+    print(f"Factor = {factor}\n")
+
+    t = np.arange(len(y) * factor)
+
+    cs = CubicSpline(x, y)
+
+    t_fine = np.linspace(x[0], x[-1], len(t))
+    finer_spline = cs(t_fine)
+    return t_fine, finer_spline

sw1pers_l-0.1.0/src/sw1pers_l/data_processing/moving_average.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+def moving_avg(ts, rolling_size=1):
+    ma = np.convolve(ts, np.ones(rolling_size)/rolling_size, mode='valid')
+    t_ma = np.arange(len(ma))  # adjusted time after convolution
+    return t_ma, ma
+

sw1pers_l-0.1.0/src/sw1pers_l/diagrams/__init__.py

@@ -0,0 +1,6 @@
+
+# diagrams
+
+from .make_diagrams import make_pers_diagram, make_pers_diagrams
+
+__all__=["make_pers_diagram","make_pers_diagrams"]

sw1pers_l-0.1.0/src/sw1pers_l/diagrams/make_diagrams.py

@@ -0,0 +1,15 @@
+from tqdm import tqdm
+from ripser import ripser
+
+def make_pers_diagram(data, thresh = 1):
+    result = ripser(data, maxdim=1, thresh=1, coeff=13)    # coeff must not divide window size!
+    return result['dgms']
+
+def make_pers_diagrams(emb_windows):
+    diagrams = []
+    print()
+    print("Forming persistence diagrams...\n")
+    for window in tqdm(emb_windows):
+        dgm = make_pers_diagram(window, thresh = 1)
+        diagrams.append(dgm)
+    return diagrams

sw1pers_l-0.1.0/src/sw1pers_l/parameter_selection/__init__.py

@@ -0,0 +1,10 @@
+
+# parameter_selection
+
+from .compute_delay import compute_optimal_delay, average_mutual_information
+from .compute_dim import compute_optimal_dim, false_nearest_neighbors
+
+__all__ = ["average_mutual_information", 
+           "compute_optimal_delay", 
+           "false_nearest_neighbors", 
+           "compute_optimal_dim"]

sw1pers_l-0.1.0/src/sw1pers_l/parameter_selection/compute_delay.py

@@ -0,0 +1,43 @@
+from sklearn.metrics import mutual_info_score
+import numpy as np
+
+def average_mutual_information(ts, max_lag=100, bins=64, plot=False):
+    max_lag = len(ts)//2
+    if ts.shape == (ts.shape[0], 1):
+        ts = ts.squeeze(1)
+
+    if np.max(ts) == np.min(ts):
+        return np.zeros(max_lag)
+
+    ts = (ts - np.min(ts)) / (np.max(ts) - np.min(ts))  # normalize
+    ami = []
+    for lag in range(1, max_lag + 1):
+        x = ts[:-lag]
+        y = ts[lag:]
+        # histogram binning
+        c_xy = np.histogram2d(x, y, bins)[0]
+        c_xy = c_xy[c_xy.sum(axis=1) > 0][:, c_xy.sum(axis=0) > 0]
+
+        if c_xy.size == 0:
+            ami.append(0.0)
+        else:
+            ami.append(mutual_info_score(None, None, contingency=c_xy))
+    # if plot:
+    #     plt.plot(range(1, max_lag+1), ami)
+    #     plt.xlabel("Lag")
+    #     plt.ylabel("AMI")
+    #     plt.title("Average Mutual Information")
+    #     plt.show()
+    return ami
+
+def compute_optimal_delay(ami, msg_bool=False):
+    ami = np.asarray(ami)
+
+    for i in range(1, len(ami) - 1):
+        if ami[i] < ami[i - 1] and ami[i] <= ami[i + 1]:
+            if msg_bool:
+                print(f"Optimal delay found at τ = {i+1}")
+            return i + 1
+    if msg_bool:
+        print("No local minimum found, using delay = 1")
+    return 1

sw1pers_l-0.1.0/src/sw1pers_l/parameter_selection/compute_dim.py

@@ -0,0 +1,48 @@
+from scipy.spatial.distance import cdist
+import numpy as np
+
+def false_nearest_neighbors(ts, max_dim, delay, R_thresh=10, A_thresh=2, plot=False):
+    if ts.shape == (ts.shape[0], 1):
+        ts = ts.squeeze(1)
+    # N = len(ts) - max_dim * delay
+    fnn_percentages = []
+    eps = 1e-10  # small value to avoid divide-by-zero
+
+    d = 1
+    N = len(ts) - (d) * delay
+    while d < max_dim+1 and N > len(ts)/3:    # ensure N is larger than one third the window size
+        embedded = np.array([ts[i:i + d * delay:delay] for i in range(N)])
+        dists = cdist(embedded, embedded)
+        np.fill_diagonal(dists, np.inf)
+        nearest_idx = np.argmin(dists, axis=1)
+        next_vals = ts[delay * d:N + delay * d]
+        next_vals_nn = ts[nearest_idx + delay * d]
+        dist_increase = np.abs(next_vals - next_vals_nn)
+        R = np.std(ts)
+        denom = dists[np.arange(N), nearest_idx] + eps
+        false_neighbors = ((dist_increase / denom) > R_thresh) | ((dist_increase / R) > A_thresh)
+        fnn_percentages.append(np.mean(false_neighbors) * 100)
+        d += 1
+        N = len(ts) - d * delay
+
+    # if plot:
+    #     plt.plot(range(1, d+1), fnn_percentages)
+    #     plt.xlabel("Embedding Dimension")
+    #     plt.ylabel("False Nearest Neighbors (%)")
+    #     plt.title("FNN vs Embedding Dimension")
+    #     plt.show()
+
+    return fnn_percentages
+
+def compute_optimal_dim(fnn, msg_bool = True):
+    optimal_dim = 0
+    threshhold = 3    # 5% by default
+    while optimal_dim==0:
+        for i, value in enumerate(fnn):
+            if value < threshhold:
+                optimal_dim = i + 1
+                if msg_bool:
+                    print(f"Found optimal dimension: {optimal_dim}\n")
+                break
+        threshhold += 1    # increase threshhold by 1% if no fnn value satisfies condition
+    return optimal_dim

sw1pers_l-0.1.0/src/sw1pers_l/sw1pers_scores/__init__.py

@@ -0,0 +1,9 @@
+
+# sw1pers_scores
+
+from .max_features import select_max_features
+from .score import compute_scores
+from .plot import plot_score_landscape, plot_scores_comparison
+from ._density import density
+
+__all__ = ["select_max_features", "compute_scores", "plot_score_landscape", "plot_scores_comparison", "density"]

sw1pers_l-0.1.0/src/sw1pers_l/sw1pers_scores/_density.py

@@ -0,0 +1,5 @@
+from scipy.ndimage import gaussian_filter1d
+
+def density(scores, rolling_size_scores):
+    sigma = rolling_size_scores/8  # adjust for desired smoothness
+    return gaussian_filter1d(scores, sigma=sigma)

sw1pers_l-0.1.0/src/sw1pers_l/sw1pers_scores/max_features.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+def select_max_features(diagrams):
+    max_feature_arr = []
+    for diagram in diagrams:
+        if len(diagram[1])==0:
+            max_feature_arr.append([0,0])
+        else:
+            max_feature = []
+            max = 0
+            for feature in diagram[1]:
+                if max < feature[1] - feature[0] and not np.isinf(feature[1]):
+                    max = feature[1] - feature[0]
+                    max_feature = [feature[0], feature[1]]
+                elif np.isinf(feature[1]) or max > np.sqrt(3):
+                    max = np.sqrt(3)
+                    max_feature = [feature[0], np.sqrt(3)]
+            max_feature_arr.append(max_feature)
+    return max_feature_arr

sw1pers_l-0.1.0/src/sw1pers_l/sw1pers_scores/plot.py

@@ -0,0 +1,115 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import matplotlib.dates as mdates
+from sw1pers_l.sw1pers_scores._density import density
+
+def plot_score_landscape(scores, score_density, finer_spline, window_size, window_stride, dates, rolling_size_scores):
+
+    offset = round(window_size/2)
+    scale_factor = np.max(finer_spline)/(np.max(scores))
+    fig, ax1 = plt.subplots(figsize=(11, 4))
+    x = range(0, len(finer_spline))
+
+    # Secondary y-axis (scores) ---------------------------------------------------
+    ax2 = ax1.twinx()
+    bar_y = scores
+    bar_x = np.arange(offset, offset + window_stride * len(scores), window_stride)
+    bar_width = window_size
+    ax2.bar(bar_x, bar_y, width=bar_width, alpha=0.15, label="Periodicity Score", color = "orange")
+    ax2.set_ylabel("Periodicity Score", color = "orange")
+    ax2.tick_params(axis='y', labelcolor = "orange")
+    ax2.set_ylim(0, np.max(bar_y)*1.05)
+
+    # Primary y-axis (time series) ------------------------------------------------
+    ax1.plot(x, finer_spline, label="Time Series Spline", color="C0", alpha=0.4)
+    ax1.set_ylabel("Time Series Spline", color="C0")
+    ax1.tick_params(axis='y', labelcolor='C0')
+    # ax1.set_ylim(np.min(finer_spline), np.max(finer_spline))
+
+    #Window indexing --------------------------------------------------------------
+    secax = ax1.secondary_xaxis("top")
+    step = 20
+    tick_positions = bar_x[::step]
+    tick_labels = [str(i) for i in range(0, len(bar_x), step)]
+    secax.set_xticks(tick_positions)
+    secax.set_xticklabels(tick_labels, rotation=45)
+    secax.set_xlabel("Windows")
+
+    # Date indexing (and primary time series) ---------------------------------------------------------------
+    if dates is not None:
+        n_ticks = int(len(finer_spline)/window_size/2)
+        tick_positions = np.linspace(0, len(finer_spline)-1, n_ticks, dtype=int)
+        tick_dates = pd.date_range(start=dates[0], end=dates[-1], periods=n_ticks)
+        ax1.set_xticks(tick_positions)
+        ax1.set_xticklabels(tick_dates.strftime("%Y-%m-%d"), rotation=45, ha="right")    #%Y-%m-%d [%H:%M]
+        ax1.set_xlabel("Date")
+        ax1.set_ylabel("Time Series Spline", color="C0")
+        ax1.tick_params(axis='y', labelcolor='C0')
+
+    # Density plot ----------------------------------------------------------------
+    ma_x = bar_x[rolling_size_scores//2 : -(rolling_size_scores//2)]  # center alignment
+    ma_y = score_density[rolling_size_scores//2 : -(rolling_size_scores//2)] #* scale_factor
+    ax2.plot(ma_x, ma_y, color="red", linewidth=2, label="Anomaly Density (MA)", alpha=0.6)
+
+    # Labels: combine from both axes-----------------------------------------------
+    lines_1, labels_1 = ax1.get_legend_handles_labels()
+    lines_2, labels_2 = ax2.get_legend_handles_labels()
+    ax1.legend(lines_1 + lines_2, labels_1 + labels_2, loc="lower right")
+    plt.tight_layout()
+    plt.grid()
+    plt.show()
+
+def plot_scores_comparison(scores, secondary_scores, window_size, window_stride, dates, factor=1, score_rolling_size=1, sec_score_rolling_size=1, is_score_windowed = False, show_bars = False, label_msg = "Alternative anomaly score"):
+    fig, ax1 = plt.subplots(figsize=(11, 4))
+    offset = round(window_size/2)
+
+    # Window x-axis set up -------------------------
+    windows_x = np.arange(offset, offset + window_stride * len(scores), window_stride)
+    
+    # Secondary scores plot ----------------
+    sec_score_density = density(secondary_scores, sec_score_rolling_size)
+    if is_score_windowed:
+        ax1.plot(windows_x, sec_score_density, color="C0", linewidth=1, label="Secondary Scores")
+        ax1.set_ylabel(label_msg, color = "C0")
+        ax1.tick_params(axis='y', labelcolor = 'C0')
+    else:
+        x = range(0, len(density(secondary_scores, sec_score_rolling_size)))
+        ax1.plot(x, sec_score_density, linewidth=1, label="Secondary Score Landscape", color="C0")
+        ax1.set_ylabel(label_msg, color="C0")
+        ax1.tick_params(axis='y', labelcolor='C0')
+
+    ax2 = ax1.twinx()
+
+    #sw1pers bars plot
+    if show_bars:
+        windows_y = scores
+        bar_width = window_size
+        ax2.bar(windows_x, windows_y, width=bar_width, alpha=0.15, label="Periodicity Scores", color = "orange")
+        ax2.set_ylabel("Periodicity Scores", color = "orange")
+        ax2.tick_params(axis='y', labelcolor = "orange")
+
+    # sw1pers plot -----------------
+    ma_x = windows_x[-int(-score_rolling_size//2) : int(-score_rolling_size//2)]  # center alignment
+    ma_y = density(scores, score_rolling_size)[-int(-score_rolling_size//2) : int(-score_rolling_size//2)]    # math.ceil(score_rolling_size//2)) also works here
+    ax2.plot(ma_x, ma_y, color="orange", linewidth=1, label="Periodicity Density")
+    ax2.set_ylabel("Periodicity score", color="orange")
+    ax2.tick_params(axis='y', labelcolor='orange')
+
+    #Window indexing -----------------------
+    secax = ax2.secondary_xaxis("top")
+    step = 20
+    tick_positions = windows_x[::step]
+    tick_labels = [str(i) for i in range(0, len(windows_x), step)]
+    secax.set_xticks(tick_positions)
+    secax.set_xticklabels(tick_labels, rotation=45)
+    secax.set_xlabel("Windows")
+
+    # Date indexing (and primary time series) ---------------------------------------------------------------
+    if dates is not None:
+        n_ticks = int(len(dates)*factor/(window_size))
+        tick_positions = np.linspace(0, len(dates)*factor-1, n_ticks, dtype=int)
+        tick_dates = pd.date_range(start=dates[0], end=dates[-1], periods=n_ticks)
+        ax1.set_xticks(tick_positions)
+        ax1.set_xticklabels(tick_dates.strftime("%Y-%m-%d"), rotation=45, ha="right")    #%Y-%m-%d [%H:%M]
+        ax1.set_xlabel("Date")

sw1pers_l-0.1.0/src/sw1pers_l/sw1pers_scores/score.py

@@ -0,0 +1,14 @@
+import numpy as np
+from .max_features import select_max_features
+
+def compute_scores(diagrams, n=2, m=2):    # n >= m
+    scores = []
+    max_feat = select_max_features(diagrams)
+    for feat in max_feat:
+        score = 1 - (feat[1]**n - feat[0]**m)/(np.sqrt(3))**n
+        if score < 0:
+            score = 0
+        if score > 1:
+            score = 1
+        scores.append(score)
+    return np.array(scores)

sw1pers_l-0.1.0/src/sw1pers_l/time_series/__init__.py

@@ -0,0 +1,8 @@
+
+# time_series
+
+from .sliding_windows import make_sliding_windows
+from .sw_embedding import embed
+
+__all__ = ["make_sliding_windows", 
+           "embed"]

sw1pers_l-0.1.0/src/sw1pers_l/time_series/sliding_windows.py

@@ -0,0 +1,4 @@
+import numpy as np
+
+def make_sliding_windows(ts, size, stride):
+    return np.array([ts[i:i+size] for i in range(0, len(ts) - size + 1, stride)])

sw1pers_l-0.1.0/src/sw1pers_l/time_series/sw_embedding.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+def embed(ts, dim, delay):
+    N = len(ts) - (dim - 1) * delay
+    return np.array([ts[i:i + dim * delay:delay] for i in range(N)])

sw1pers_l-0.1.0/src/sw1pers_l/visualize/__init__.py

@@ -0,0 +1,6 @@
+
+# visualize
+
+from .visualize import attractor
+
+__all__ = ["attractor"]

sw1pers_l-0.1.0/src/sw1pers_l/visualize/visualize.py

@@ -0,0 +1,33 @@
+import numpy as np
+import plotly.graph_objs as go
+
+def attractor(data, arr = [0,1,2], msg="Takens Embedding"):
+    print(f"Window shape:   {data.shape}")
+
+    if data.shape[1]>2:
+        x,y,z = data[:, arr[0]], data[:, arr[1]], data[:, arr[2]]
+    else:
+        x,y,z = data[:, 0], data[:, 1], np.zeros(len(data), )
+
+    print("Unique x:", len(np.unique(x)))
+    print("Unique y:", len(np.unique(y)))
+    print("Unique z:", len(np.unique(z)))
+
+    fig = go.Figure(data=[go.Scatter3d(
+            x=x, y=y, z=z,
+            mode='markers',
+            marker=dict(
+                size=5,
+                color=x,                # Set color to vary by Y value
+                colorscale='Viridis',   # Choose a colorscale
+                opacity=0.8
+            )
+        )])
+
+    fig.update_layout(
+        title=msg,
+        scene = dict(aspectmode = 'manual')
+    )
+
+    fig.show()
+

sw1pers_l-0.1.0/src/sw1pers_l/windows/__init__.py

@@ -0,0 +1,12 @@
+
+# windows
+
+from .make_emb_windows import make_embedded_windows
+from .make_emb_ts import make_embedded_ts
+from .point_cloud_tools import mean_center, normalize, meanshift_pointcloud
+
+__all__ = ["make_embedded_windows",
+           "make_embedded_ts",
+           "mean_center", 
+           "normalize", 
+           "meanshift_pointcloud"]

sw1pers_l-0.1.0/src/sw1pers_l/windows/make_emb_ts.py

@@ -0,0 +1,26 @@
+from tqdm import tqdm
+import numpy as np
+
+from sw1pers_l import parameter_selection
+from sw1pers_l import time_series
+
+from .point_cloud_tools import mean_center, normalize, meanshift_pointcloud
+
+def make_embedded_ts(X):
+
+    X = X.reshape(len(X), )
+
+    ami = parameter_selection.average_mutual_information(X, bins=int(np.sqrt(len(X)))+1)
+    delay = parameter_selection.compute_optimal_delay(ami, msg_bool=False)
+    fnn = parameter_selection.false_nearest_neighbors(X, max_dim=10, delay=delay)
+    dim = parameter_selection.compute_optimal_dim(fnn, msg_bool=False)
+
+    emb_cloud = time_series.embed(X, dim, delay)
+
+    emb_cloud = mean_center(emb_cloud)
+    emb_cloud = normalize(emb_cloud)
+
+    emb_cloud = meanshift_pointcloud(emb_cloud, np.pi/16)    # pi/16 is radius used in Perea's paper
+    emb_cloud = normalize(emb_cloud)
+
+    return emb_cloud, dim, delay

sw1pers_l-0.1.0/src/sw1pers_l/windows/make_emb_windows.py

@@ -0,0 +1,47 @@
+from tqdm import tqdm
+import numpy as np
+
+from sw1pers_l import parameter_selection
+from sw1pers_l import time_series
+
+from .point_cloud_tools import mean_center, normalize, meanshift_pointcloud
+
+
+def make_embedded_windows(X, window_size, window_stride):
+
+    X = X.reshape(len(X), )
+
+    windows = time_series.make_sliding_windows(X, window_size, window_stride)
+
+    emb_windows=[]
+    dim, delay = 1, 1
+    input_dimensions = []
+    input_delays = []
+
+    print("Finding best parameters...\n")
+    for i, window in enumerate(tqdm(windows)):
+        ami = parameter_selection.average_mutual_information(window, bins=int(np.sqrt(len(window)))+1)
+        delay = parameter_selection.compute_optimal_delay(ami, msg_bool=False)
+        input_delays.append(delay)
+        
+        fnn = parameter_selection.false_nearest_neighbors(window, max_dim=10, delay=delay)
+        dim = parameter_selection.compute_optimal_dim(fnn, msg_bool=False)
+        input_dimensions.append(dim)
+
+    print()
+    print("Forming point clouds...\n")
+    for i, window in enumerate(tqdm(windows)):
+        input_dim = input_dimensions[i]  #max(dim, 3)      # make this (dim + 1) to not squish some cycles trivial
+        input_delay = input_delays[i]
+        
+        emb_window = time_series.embed(window, input_dim, delay)
+
+        emb_window = mean_center(emb_window)
+        emb_window = normalize(emb_window)
+
+        emb_window = meanshift_pointcloud(emb_window, np.pi/16)    # pi/16 is radius used in Perea's paper
+        emb_window = normalize(emb_window)    # normalize again because meanshift changes this
+
+        emb_windows.append(emb_window)
+
+    return emb_windows, input_dimensions, input_delays

sw1pers_l-0.1.0/src/sw1pers_l/windows/point_cloud_tools.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+def mean_center(X):
+    return X - np.mean(X, axis = 0)
+
+def normalize(X):
+    return X/np.linalg.norm(X, axis = 1, keepdims=True)
+
+# def mean_center_normalize(X):
+#     return normalize(mean_center(X))
+
+
+from sklearn.metrics.pairwise import pairwise_distances
+
+def meanshift_pointcloud(SW_cloud, epsilon, metric='cosine'):
+
+    D = pairwise_distances(SW_cloud, metric=metric)
+    n_points, dim = SW_cloud.shape
+
+    threshhold = 1 - np.cos(epsilon)
+
+    cloud_denoised = np.zeros_like(SW_cloud)
+
+    for k in range(n_points):
+        mask = D[k] <= threshhold
+        cloud_denoised[k] = SW_cloud[mask].mean(axis=0)
+
+    return cloud_denoised

sw1pers_l-0.1.0/src/sw1pers_l.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: sw1pers_l
+Version: 0.1.0
+Summary: SW1Pers landscape for time series periodicity analysis
+Author: Miguel Almeida
+Author-email: Miguel Almeida <migpinalm@gmail.com>
+License: Copyright (c) 2026 Miguel Almeida
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "sw1pers-l"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software.
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: tqdm
+Requires-Dist: ripser
+Requires-Dist: plotly
+Dynamic: license-file
+
+The algorithm SW1PerS yields a scalar periodicity score for univariate time series.
+The aim of this project is to make extend the algorithm in order to correspond an array of periodicity scores to univariate time series:
+    The time series is divided into overlapping snippets (sub-time-series), to each of which we apply SW1PerS.
+    The size of the snippet and the overlapping size are hyper-parameters (dependent on the data)
+
+This is useful to locate periodic behaviour in general time series.
+On the other hand, this is useful to locate aperiodic behaviour in periodc time series.

sw1pers_l-0.1.0/src/sw1pers_l.egg-info/SOURCES.txt

@@ -0,0 +1,37 @@
+CHANGES.txt
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/sw1pers_l/__init__.py
+src/sw1pers_l/core.py
+src/sw1pers_l.egg-info/PKG-INFO
+src/sw1pers_l.egg-info/SOURCES.txt
+src/sw1pers_l.egg-info/dependency_links.txt
+src/sw1pers_l.egg-info/requires.txt
+src/sw1pers_l.egg-info/top_level.txt
+src/sw1pers_l/data_processing/__init__.py
+src/sw1pers_l/data_processing/cubic_spline.py
+src/sw1pers_l/data_processing/moving_average.py
+src/sw1pers_l/diagrams/__init__.py
+src/sw1pers_l/diagrams/make_diagrams.py
+src/sw1pers_l/parameter_selection/__init__.py
+src/sw1pers_l/parameter_selection/compute_delay.py
+src/sw1pers_l/parameter_selection/compute_dim.py
+src/sw1pers_l/sw1pers_scores/__init__.py
+src/sw1pers_l/sw1pers_scores/_density.py
+src/sw1pers_l/sw1pers_scores/max_features.py
+src/sw1pers_l/sw1pers_scores/plot.py
+src/sw1pers_l/sw1pers_scores/score.py
+src/sw1pers_l/time_series/__init__.py
+src/sw1pers_l/time_series/sliding_windows.py
+src/sw1pers_l/time_series/sw_embedding.py
+src/sw1pers_l/visualize/__init__.py
+src/sw1pers_l/visualize/visualize.py
+src/sw1pers_l/windows/__init__.py
+src/sw1pers_l/windows/make_emb_ts.py
+src/sw1pers_l/windows/make_emb_windows.py
+src/sw1pers_l/windows/point_cloud_tools.py
+tests/test_pipeline.py

sw1pers_l-0.1.0/src/sw1pers_l.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sw1pers_l-0.1.0/src/sw1pers_l.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+matplotlib
+scipy
+scikit-learn
+tqdm
+ripser
+plotly

sw1pers_l-0.1.0/src/sw1pers_l.egg-info/top_level.txt

@@ -0,0 +1 @@
+sw1pers_l

sw1pers_l-0.1.0/tests/test_pipeline.py

@@ -0,0 +1,16 @@
+
+# run this test: go to root directory -> python tests/test_pipeline.py
+
+#------------------------------------------------
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from sw1pers_l.core import SW1PerS, SW1PerS_L
+
+#------------------------------------------------
+
+x = np.arange(0, 10*2*np.pi, 0.1)
+test_ts = np.cos(x)
+
+scores = SW1PerS_L(test_ts)