pattern-detector 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

pattern_detector/__init__.py

@@ -0,0 +1,36 @@
+try:
+    from .aoi_finder import run_area_of_interest_finder
+except ImportError:
+    raise ImportError("The PatternDetector module could not be imported. Ensure all dependencies are installed.")
+
+__version__ = "0.2.1"
+
+def pattern_detector(data, pattern, column_pattern):
+    """
+    A simplified interface for using the PatternDetector class.
+
+    Parameters:
+    - data (pd.DataFrame): The main data.
+    - pattern (pd.DataFrame): The pattern data.
+    - column_pattern (str): The column name for pattern matching.
+
+    Returns:
+    - pd.DataFrame: The resulting DataFrame with detected cycles.
+    """
+    detector = run_area_of_interest_finder(data, pattern, column_pattern)
+    return detector
+
+# Replace the module with a callable version
+import sys
+from types import ModuleType
+
+class CallableModule(ModuleType):
+    def __init__(self, name):
+        super().__init__(name)
+        self.__version__ = __version__
+
+    def __call__(self, data, pattern, column_pattern):
+        return pattern_detector(data, pattern, column_pattern)
+
+# Replace the current module in sys.modules with the callable version
+sys.modules[__name__] = CallableModule(__name__)

pattern_detector/aoi_finder.py

@@ -0,0 +1,185 @@
+import numpy as np
+import pandas as pd
+
+import warnings
+warnings.filterwarnings("ignore")
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+#import warnings
+from scipy.stats import skew, kurtosis
+#warnings.filterwarnings("ignore")
+from scipy.fft import fft
+from scipy.interpolate import interp1d
+
+
+def compute_cosine_sim(data1, window_size,len_iter,pattern1,  i, j):
+
+    window = data1[i:i + window_size - (len_iter//2) + j ,:]
+
+
+    max_pos = np.max(pattern1) +  0.1 * np.ptp(pattern1) # np.ptp : calculates max-min difference
+    min_pos = np.min(pattern1) - 0.1 * np.ptp(pattern1)
+    mean_pos_upper = np.mean(pattern1) + 0.1 * np.ptp(pattern1)
+    mean_pos_lower = np.mean(pattern1) - 0.1 * np.ptp(pattern1)
+    pattern_skewness = skew(pattern1.flatten())
+    pattern_kurtosis = kurtosis(pattern1.flatten())
+    pattern_std = np.std( pattern1.flatten() )
+    cross_correlation_threshold = 0.5  # Set a threshold for cross-correlation
+
+    starting_point_lower = pattern1[0] - 0.2 * np.ptp(pattern1)
+    starting_point_upper = pattern1[0] + 0.2 * np.ptp(pattern1)
+
+    ending_point_lower = pattern1[-1] - 0.2 * np.ptp(pattern1)
+    ending_point_upper = pattern1[-1] + 0.2 * np.ptp(pattern1)
+
+
+    x_original = np.linspace(0, 1, len(window))
+    x_target = np.linspace(0, 1, len(pattern1))
+
+    window = window.reshape(-1 ,)
+
+    interpolator = interp1d(x_original, window, kind='cubic')  # Linear interpolation
+
+    window2 = interpolator(x_target)
+
+    corr_coef = np.corrcoef(window2, pattern1)[0][1]
+
+    sliding_window_max = np.max(window2)
+    sliding_window_min = np.min(window2)
+    sliding_window_skewness = skew(window2)
+    sliding_window_kurtosis = kurtosis(window2)
+    sliding_window_mean = np.mean(window2)
+    sliding_window_std = np.std(window2)
+
+
+    if ( sliding_window_max <= max_pos and sliding_window_min >= min_pos and
+            mean_pos_upper >= sliding_window_mean >= mean_pos_lower and
+            abs(sliding_window_skewness - pattern_skewness) < 0.5 and
+            abs(sliding_window_kurtosis - pattern_kurtosis) < 1.0 and
+            pattern_std * 0.9 <= sliding_window_std <= pattern_std * 1.1 and
+            corr_coef >= cross_correlation_threshold
+            and starting_point_lower<= window2[0] <= starting_point_upper and
+            ending_point_lower<= window2[-1] <= ending_point_upper ):
+
+        fft_pattern = fft(pattern1)
+        fft_window = fft(window2)
+
+        magnitude_pattern = np.abs(fft_pattern)
+        magnitude_window = np.abs(fft_window)
+
+        dot_product = np.dot(magnitude_pattern, magnitude_window)
+        norm_1 = np.linalg.norm(magnitude_pattern)
+        norm_2 = np.linalg.norm(magnitude_window)
+
+        cosine_similarity = dot_product / (norm_1 * norm_2)
+
+
+        return i, j, cosine_similarity
+
+    else:
+        return i, j, 0
+
+
+def sliding_window_cosine_similarity(data, pattern,  column_pattern ):
+
+    len_iter = 400 if len(pattern) >= 400 else 200
+    bin_parser = 3 if len_iter == 400 else 2
+
+    pattern[column_pattern] = pattern[column_pattern].astype(float)
+    pattern.reset_index(drop=True, inplace=True)
+    pattern['bin'] = pattern.index // bin_parser
+    pattern1 = pattern.groupby('bin').agg({column_pattern: 'mean'}).reset_index()
+    pattern1 = np.array(pattern1[column_pattern]).reshape(-1, )
+
+    # Prepare data
+    data.reset_index(drop=True, inplace=True)
+    data[column_pattern] = data[column_pattern].astype(float)
+    data['bin'] = data.index // bin_parser
+    data1 = data.groupby('bin').agg({column_pattern: 'mean'}).reset_index()
+    data1 = np.array(data1[column_pattern]).reshape(-1, 1)
+
+    window_size = len(pattern1)
+    step_size = 2
+
+    similarity_dict = {}
+
+
+    with ThreadPoolExecutor() as executor:  # Adjust max_workers based on your CPU cores
+        futures = [executor.submit(compute_cosine_sim, data1, window_size, len_iter, pattern1, i, j)
+                   for i in range(0, len(data1) - window_size, step_size)
+                   for j in range(0, len_iter, (len_iter // 40))]
+        for future in as_completed(futures):
+            i, j, similarity = future.result()
+            if i not in similarity_dict:
+                similarity_dict[i] = {}
+            similarity_dict[i][j] = similarity
+
+    return similarity_dict, pattern1, window_size, bin_parser, len_iter
+
+
+def run_area_of_interest_finder(df,pattern,column_pattern):
+
+    similarity_dict, pattern1, window_size, bin_parser, len_iter  = sliding_window_cosine_similarity(df, pattern, column_pattern)
+
+    approx_cycle_length = len(pattern1)*0.95
+
+    results = []
+    for key1, value in similarity_dict.items():
+
+        max_key = max(value, key=value.get)
+        max_value = value[max_key]
+        results.append({'key': key1, 'max_key': max_key, 'max_value': max_value})
+
+    df_dist = pd.DataFrame(results)
+
+    df_dist.reset_index(inplace=True)
+    df_dist['app_cycle'] = df_dist["key"] // approx_cycle_length
+    df_dist["app_cycle"] = df_dist["app_cycle"].astype(int)
+
+    yig = tuple(df_dist.groupby("app_cycle"))
+    cyc_dict = {x: y for x, y in yig}
+
+    idx_cyc = 0
+    cyc_concat_df = pd.DataFrame()
+
+    for k in cyc_dict.keys():
+        df_cyc = cyc_dict[k]
+        df_cyc = df_cyc[ df_cyc["max_value"] != 0 ]
+
+        key_min_df =  df_cyc[["key","max_key","max_value"]][  df_cyc["max_value"] == np.max(df_cyc['max_value'])]
+        key_min_df["cycle"] = idx_cyc
+        if len(key_min_df) != 0:
+            cyc_concat_df = pd.concat([cyc_concat_df,key_min_df],ignore_index=True,axis="index")
+            idx_cyc += 1
+        else:
+            continue
+
+    cyc_concat_df["start_index"] = cyc_concat_df["key"]
+    cyc_concat_df["end_index"] = cyc_concat_df["start_index"] + window_size + cyc_concat_df["max_key"] - (len_iter//2)
+    cyc_concat_df["shift_start"] = cyc_concat_df["start_index"].shift(1)
+
+    cyc_concat_df["diff"] = cyc_concat_df["shift_start"] - cyc_concat_df["start_index"]
+    cyc_concat_df["shift_start"].iloc[0] = len(pattern1)
+    cyc_concat_df["diff"].iloc[0] = -len(pattern1)
+    limit = len(pattern1)*.7
+    cyc_concat_df = cyc_concat_df[ cyc_concat_df["diff"] < -limit ]
+    cyc_concat_df.reset_index(inplace=True, drop=True)
+    cyc_concat_df["cycle"] = cyc_concat_df.index
+
+    cyc_concat_df["shift_end"] = cyc_concat_df["end_index"].shift(1)
+    ######## Çakışmaları önlemek için yapıldı
+    cyc_concat_df["shift_end"].iloc[0] = cyc_concat_df["diff"].iloc[0]
+    cyc_concat_df["diff_end"] = cyc_concat_df["shift_end"] - cyc_concat_df["start_index"]
+    cyc_concat_df["start_index"][ cyc_concat_df["diff_end"] > 0 ] =  cyc_concat_df["start_index"][ cyc_concat_df["diff_end"] > 0 ] + cyc_concat_df["diff_end"] + 1
+
+
+    #df = data.copy()
+    df.reset_index(drop=True,inplace=True)
+    for i in cyc_concat_df["cycle"].unique():
+        start = cyc_concat_df["start_index"][cyc_concat_df["cycle"] == i].values[0]*bin_parser
+        stop = cyc_concat_df["end_index"][cyc_concat_df["cycle"] == i].values[0]*bin_parser
+        #print(start, stop, i, stop-start)
+        df.loc[start:stop,"cycle"] = int(i)
+
+
+    return df

pattern_detector/cosine_similarity_function.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pandas as pd
+#import warnings
+from scipy.stats import skew, kurtosis
+#warnings.filterwarnings("ignore")
+from scipy.fft import fft
+from scipy.interpolate import interp1d
+
+
+def compute_cosine_sim(data1, window_size,len_iter,pattern1,  i, j):
+
+    window = data1[i:i + window_size - (len_iter//2) + j ,:]
+
+
+    max_pos = np.max(pattern1) +  0.1 * np.ptp(pattern1) # np.ptp : calculates max-min difference
+    min_pos = np.min(pattern1) - 0.1 * np.ptp(pattern1)
+    mean_pos_upper = np.mean(pattern1) + 0.1 * np.ptp(pattern1)
+    mean_pos_lower = np.mean(pattern1) - 0.1 * np.ptp(pattern1)
+    pattern_skewness = skew(pattern1.flatten())
+    pattern_kurtosis = kurtosis(pattern1.flatten())
+    pattern_std = np.std( pattern1.flatten() )
+    cross_correlation_threshold = 0.5  # Set a threshold for cross-correlation
+
+    starting_point_lower = pattern1[0] - 0.2 * np.ptp(pattern1)
+    starting_point_upper = pattern1[0] + 0.2 * np.ptp(pattern1)
+
+    ending_point_lower = pattern1[-1] - 0.2 * np.ptp(pattern1)
+    ending_point_upper = pattern1[-1] + 0.2 * np.ptp(pattern1)
+
+
+    x_original = np.linspace(0, 1, len(window))
+    x_target = np.linspace(0, 1, len(pattern1))
+
+    window = window.reshape(-1 ,)
+
+    interpolator = interp1d(x_original, window, kind='cubic')  # Linear interpolation
+
+    window2 = interpolator(x_target)
+
+    corr_coef = np.corrcoef(window2, pattern1)[0][1]
+
+    sliding_window_max = np.max(window2)
+    sliding_window_min = np.min(window2)
+    sliding_window_skewness = skew(window2)
+    sliding_window_kurtosis = kurtosis(window2)
+    sliding_window_mean = np.mean(window2)
+    sliding_window_std = np.std(window2)
+
+
+    if ( sliding_window_max <= max_pos and sliding_window_min >= min_pos and
+            mean_pos_upper >= sliding_window_mean >= mean_pos_lower and
+            abs(sliding_window_skewness - pattern_skewness) < 0.5 and
+            abs(sliding_window_kurtosis - pattern_kurtosis) < 1.0 and
+            pattern_std * 0.9 <= sliding_window_std <= pattern_std * 1.1 and
+            corr_coef >= cross_correlation_threshold
+            and starting_point_lower<= window2[0] <= starting_point_upper and
+            ending_point_lower<= window2[-1] <= ending_point_upper ):
+
+        fft_pattern = fft(pattern1)
+        fft_window = fft(window2)
+
+        magnitude_pattern = np.abs(fft_pattern)
+        magnitude_window = np.abs(fft_window)
+
+        dot_product = np.dot(magnitude_pattern, magnitude_window)
+        norm_1 = np.linalg.norm(magnitude_pattern)
+        norm_2 = np.linalg.norm(magnitude_window)
+
+        cosine_similarity = dot_product / (norm_1 * norm_2)
+
+
+        return i, j, cosine_similarity
+
+    else:
+        return i, j, 0

pattern_detector/sliding_window_cosine_similarity.py

@@ -0,0 +1,45 @@
+import numpy as np
+import pandas as pd
+from Functions.cosine_similarity_function import compute_cosine_sim
+import warnings
+warnings.filterwarnings("ignore")
+from concurrent.futures import ThreadPoolExecutor, as_completed, ProcessPoolExecutor
+
+
+
+def sliding_window_cosine_similarity(data, pattern,  column_pattern ):
+
+    len_iter = 400 if len(pattern) >= 400 else 200
+    bin_parser = 3 if len_iter == 400 else 2
+
+    pattern[column_pattern] = pattern[column_pattern].astype(float)
+    pattern.reset_index(drop=True, inplace=True)
+    pattern['bin'] = pattern.index // bin_parser
+    pattern1 = pattern.groupby('bin').agg({column_pattern: 'mean'}).reset_index()
+    pattern1 = np.array(pattern1[column_pattern]).reshape(-1, )
+
+    # Prepare data
+    data.reset_index(drop=True, inplace=True)
+    data[column_pattern] = data[column_pattern].astype(float)
+    data['bin'] = data.index // bin_parser
+    data1 = data.groupby('bin').agg({column_pattern: 'mean'}).reset_index()
+    data1 = np.array(data1[column_pattern]).reshape(-1, 1)
+
+    window_size = len(pattern1)
+    step_size = 2
+
+    similarity_dict = {}
+
+
+    with ThreadPoolExecutor() as executor:  # Adjust max_workers based on your CPU cores
+        futures = [executor.submit(compute_cosine_sim, data1, window_size, len_iter, pattern1, i, j)
+                   for i in range(0, len(data1) - window_size, step_size)
+                   for j in range(0, len_iter, (len_iter // 40))]
+        for future in as_completed(futures):
+            i, j, similarity = future.result()
+            if i not in similarity_dict:
+                similarity_dict[i] = {}
+            similarity_dict[i][j] = similarity
+
+    return similarity_dict, pattern1, window_size, bin_parser, len_iter
+

{pattern_detector-0.1.0.dist-info → pattern_detector-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pattern_detector
-Version: 0.1.0
+Version: 0.2.1
 Summary: A library for detecting patterns in time-series data.
 Author: Yigit Utku Bulut and Ahmet Faruk Minareci
 Author-email: yigit.utku.bulut@gmail.com, ahmetfaruk.minareci@gmail.com

pattern_detector-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+pattern_detector/__init__.py,sha256=Fuk6OrcI-ryoFxzIqFQEM2F6L3R0vZYSX7y_hHxHufI,1159
+pattern_detector/aoi_finder.py,sha256=TwlXN54UWVdWl2tC-E48enCPiDvnkmFm_rwFhZkkS7c,7069
+pattern_detector/cosine_similarity_function.py,sha256=Vgh6Blm6kji54JfXLVoiesYYwO0qDAyCv6W--YBlU3o,2704
+pattern_detector/sliding_window_cosine_similarity.py,sha256=B-Zs0fHDCXlFcWlzEhKuTquavIWzUlMgc1dd3x2gkBk,1735
+pattern_detector/utils.py,sha256=jqkfeTqWEnrnvzKBxr_UdKj9cj7zPF15UhHPr9sBSa0,2646
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_detector.py,sha256=mSNuqaHEkRiGcFnvvwNWa1UWKjhF6l8xBrFhGHQ1S0A,1021
+pattern_detector-0.2.1.dist-info/LICENSE,sha256=RslT26mCGxF9nQEyEQL8kFMFUgmYvCA0UivIWefxWmU,1098
+pattern_detector-0.2.1.dist-info/METADATA,sha256=5VuZn23JkdZryRW5UKPGpJFJ_lnKs6_fqObUBn-0Dd8,536
+pattern_detector-0.2.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+pattern_detector-0.2.1.dist-info/top_level.txt,sha256=zYjRoeMq6DYEzeVTU-JZKbeooXspQwn8M0uCF-naRww,23
+pattern_detector-0.2.1.dist-info/RECORD,,

pattern_detector-0.2.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pattern_detector
+tests

tests/test_detector.py

@@ -1,11 +1,11 @@
 import pytest
 import numpy as np
 import pandas as pd
-from pattern_detection.detector import PatternDetector
+from pattern_detector.aoi_finder import run_area_of_interest_finder
 
 def test_preprocess_pattern():
     pattern = pd.DataFrame({"value": range(10)})
-    detector = PatternDetector(None, pattern, "value")
+    detector = run_area_of_interest_finder(None, pattern, "value")
     detector.preprocess_pattern()
     assert detector.pattern1 is not None
     assert len(detector.pattern1) > 0
@@ -13,7 +13,7 @@ def test_preprocess_pattern():
 def test_calculate_similarity():
     data = pd.DataFrame({"value": range(100)})
     pattern = pd.DataFrame({"value": range(10)})
-    detector = PatternDetector(data, pattern, "value")
+    detector = run_area_of_interest_finder(data, pattern, "value")
     detector.preprocess_pattern()
     detector.calculate_similarity()
     assert len(detector.similarity_dict) > 0
@@ -21,7 +21,7 @@ def test_calculate_similarity():
 def test_find_area_of_interest():
     data = pd.DataFrame({"value": range(100)})
     pattern = pd.DataFrame({"value": range(10)})
-    detector = PatternDetector(data, pattern, "value")
+    detector = run_area_of_interest_finder(data, pattern, "value")
     result = detector.find_area_of_interest()
     assert "cycle" in result.columns
     assert not result["cycle"].isnull().all()

pattern_detection/__init__.py

@@ -1,3 +0,0 @@
-from .detector import PatternDetector
-
-__all__ = ["PatternDetector"]

pattern_detection/detector.py

@@ -1,152 +0,0 @@
-import numpy as np
-import pandas as pd
-from scipy.stats import skew, kurtosis
-from joblib import Parallel, delayed
-
-class PatternDetector:
-    def __init__(self, df, pattern, column_pattern):
-        self.df = df.copy()
-        self.pattern = pattern
-        self.column_pattern = column_pattern
-        self.similarity_dict = {}
-        self.pattern1 = None
-        self.window_size = None
-        self.bin_parser = None
-        self.len_iter = None
-        self.pattern_constraints = {}
-
-    def preprocess_pattern(self):
-        """Preprocess the pattern data."""
-        len_iter = 400 if len(self.pattern) >= 400 else 200
-        bin_parser = 3 if len_iter == 400 else 2
-
-        self.pattern['bin'] = self.pattern.index // bin_parser
-        self.pattern1 = self.pattern.groupby('bin')[self.column_pattern].mean().to_numpy()
-        self.len_iter = len_iter
-        self.bin_parser = bin_parser
-        self.window_size = len(self.pattern1)
-
-        # Compute constraints
-        self.pattern_constraints = {
-            "max_pos": np.max(self.pattern1) + 0.1 * np.ptp(self.pattern1),
-            "min_pos": np.min(self.pattern1) - 0.1 * np.ptp(self.pattern1),
-            "mean_pos_upper": np.mean(self.pattern1) + 0.1 * np.ptp(self.pattern1),
-            "mean_pos_lower": np.mean(self.pattern1) - 0.1 * np.ptp(self.pattern1),
-            "pattern_skewness": skew(self.pattern1),
-            "pattern_kurtosis": kurtosis(self.pattern1),
-            "pattern_std": np.std(self.pattern1),
-            "starting_point_lower": self.pattern1[0] - 0.2 * np.ptp(self.pattern1),
-            "starting_point_upper": self.pattern1[0] + 0.2 * np.ptp(self.pattern1),
-            "ending_point_lower": self.pattern1[-1] - 0.2 * np.ptp(self.pattern1),
-            "ending_point_upper": self.pattern1[-1] + 0.2 * np.ptp(self.pattern1),
-            "cross_correlation_threshold": 0.5,
-        }
-
-    def preprocess_data(self):
-        """Preprocess the main data."""
-        self.df['bin'] = self.df.index // self.bin_parser
-        return self.df.groupby('bin')[self.column_pattern].mean().to_numpy().reshape(-1, 1)
-
-    def apply_constraints(self, window):
-        """Apply constraints to filter valid windows."""
-        pc = self.pattern_constraints
-        corr_coef = np.corrcoef(window, self.pattern1)[0][1]
-
-        if (
-            np.max(window) <= pc["max_pos"]
-            and np.min(window) >= pc["min_pos"]
-            and pc["mean_pos_upper"] >= np.mean(window) >= pc["mean_pos_lower"]
-            and abs(skew(window) - pc["pattern_skewness"]) < 0.5
-            and abs(kurtosis(window) - pc["pattern_kurtosis"]) < 1.0
-            and pc["pattern_std"] * 0.9 <= np.std(window) <= pc["pattern_std"] * 1.1
-            and corr_coef >= pc["cross_correlation_threshold"]
-            and pc["starting_point_lower"] <= window[0] <= pc["starting_point_upper"]
-            and pc["ending_point_lower"] <= window[-1] <= pc["ending_point_upper"]
-        ):
-            return True
-        return False
-
-    def compute_cosine_sim(self, data1, i, j):
-        """Compute cosine similarity for a given sliding window."""
-        window = data1[i:i + self.window_size - (self.len_iter // 2) + j, :].reshape(-1,)
-
-        if len(window) != len(self.pattern1):  # Ensure dimensions match
-            return i, j, 0
-
-        # Apply constraints
-        if not self.apply_constraints(window):
-            return i, j, 0
-
-        fft_pattern = np.fft.fft(self.pattern1)
-        fft_window = np.fft.fft(window)
-
-        dot_product = np.dot(np.abs(fft_pattern), np.abs(fft_window))
-        norm_pattern = np.linalg.norm(np.abs(fft_pattern))
-        norm_window = np.linalg.norm(np.abs(fft_window))
-        similarity = dot_product / (norm_pattern * norm_window)
-
-        return i, j, similarity
-
-    def calculate_similarity(self):
-        """Calculate sliding window cosine similarity."""
-        data1 = self.preprocess_data()
-
-        results = Parallel(n_jobs=-1)(
-            delayed(self.compute_cosine_sim)(data1, i, j)
-            for i in range(0, len(data1) - self.window_size, 2)
-            for j in range(0, self.len_iter, self.len_iter // 40)
-        )
-
-        for i, j, similarity in results:
-            if similarity > 0:
-                self.similarity_dict.setdefault(i, {})[j] = similarity
-
-    def get_top_similarities(self):
-        """Extract top similarities from the similarity dictionary."""
-        results = [
-            {'key': key1, 'max_key': max(value, key=value.get), 'max_value': max(value.values())}
-            for key1, value in self.similarity_dict.items()
-        ]
-        return pd.DataFrame(results)
-
-    def find_area_of_interest(self):
-        """Find areas of interest in the data."""
-        self.preprocess_pattern()
-        self.calculate_similarity()
-        df_dist = self.get_top_similarities()
-
-        approx_cycle_length = len(self.pattern1) * 0.95
-        df_dist['app_cycle'] = (df_dist['key'] // approx_cycle_length).astype(int)
-        grouped = df_dist.groupby('app_cycle')
-
-        cyc_concat_df = pd.concat(
-            [
-                group.loc[group['max_value'].idxmax()].assign(cycle=idx_cyc)
-                for idx_cyc, (_, group) in enumerate(grouped)
-                if not group.empty and group['max_value'].max() != 0
-            ],
-            ignore_index=True
-        )
-
-        cyc_concat_df['start_index'] = cyc_concat_df['key']
-        cyc_concat_df['end_index'] = (
-            cyc_concat_df['start_index'] + self.window_size +
-            cyc_concat_df['max_key'] - (self.len_iter // 2)
-        )
-        cyc_concat_df['shift_start'] = cyc_concat_df['start_index'].shift(1, fill_value=len(self.pattern1))
-        cyc_concat_df['diff'] = cyc_concat_df['shift_start'] - cyc_concat_df['start_index']
-        limit = len(self.pattern1) * 0.7
-        cyc_concat_df = cyc_concat_df[cyc_concat_df['diff'] < -limit].reset_index(drop=True)
-        cyc_concat_df['cycle'] = cyc_concat_df.index
-
-        cyc_concat_df['shift_end'] = cyc_concat_df['end_index'].shift(1, fill_value=cyc_concat_df['diff'].iloc[0])
-        cyc_concat_df['diff_end'] = cyc_concat_df['shift_end'] - cyc_concat_df['start_index']
-        overlap = cyc_concat_df['diff_end'] > 0
-        cyc_concat_df.loc[overlap, 'start_index'] += cyc_concat_df.loc[overlap, 'diff_end'] + 1
-
-        self.df['cycle'] = np.nan
-        for _, row in cyc_concat_df.iterrows():
-            start, stop = int(row['start_index'] * self.bin_parser), int(row['end_index'] * self.bin_parser)
-            self.df.loc[start:stop, 'cycle'] = row['cycle']
-
-        return self.df

pattern_detector-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-pattern_detection/__init__.py,sha256=hzZhj16aof1dhcIOAI9Tfo5EoPJgexGChsnCLgXq-68,68
-pattern_detection/detector.py,sha256=XaYYRledSolgTPTYLRSWhjZhmnAAvZT2pD3h5g9kP9k,6585
-pattern_detection/utils.py,sha256=jqkfeTqWEnrnvzKBxr_UdKj9cj7zPF15UhHPr9sBSa0,2646
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_detector.py,sha256=biHGbqd6Uc8dFTtyK-BxYeqFYtJOO9lk_6rQMeQCbQs,972
-pattern_detector-0.1.0.dist-info/LICENSE,sha256=RslT26mCGxF9nQEyEQL8kFMFUgmYvCA0UivIWefxWmU,1098
-pattern_detector-0.1.0.dist-info/METADATA,sha256=9pgMSSHwImJHjA1AOAOJm-ou2MsYnNFwPa6AGvl-fow,536
-pattern_detector-0.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-pattern_detector-0.1.0.dist-info/top_level.txt,sha256=W_tzR9Ah3_TgQsiGDs46ELePkuxfcPmFOosXSYw2hl0,24
-pattern_detector-0.1.0.dist-info/RECORD,,

pattern_detector-0.1.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-pattern_detection
-tests