ts-shape 0.0.0.19__tar.gz

ts-shape-0.0.0.19/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] Jakob Gabriel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), 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, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+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, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ts-shape-0.0.0.19/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: ts-shape
+Version: 0.0.0.19
+Summary: ts-shape filters, transforms and engineers your timeseries dataframe
+Home-page: https://jakobgabriel.github.io/ts-shape/
+Author: Jakob Gabriel
+Author-email: jakob.gabriel5@googlemail.com
+Project-URL: Bug Tracker, https://github.com/jakobgabriel/ts-shape
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# ts-shape | Timeseries Shaper
+
+[![pypi version](https://img.shields.io/pypi/v/timeseries-shaper.svg)](https://pypi.org/project/timeseries-shaper/)
+[![downloads](https://static.pepy.tech/badge/timeseries-shaper/week)](https://pepy.tech/projects/timeseries-shaper)
+![documentation workflow](https://github.com/jakobgabriel/ts-shape/actions/workflows/generate_docs.yml/badge.svg)
+[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://jakobgabriel.github.io/ts-shape/)
+
+----
+
+This repository contains the *ts-shape* python package. The abbreviation stands for
+
+*"Time Series shaping with rule based methods"*.
+
+ts-shape is a Python library for efficiently transforms, contextualizes and extracts events from time series data. It provides a set of tools to handle various transformations, making data preparation tasks easier and more intuitive.
+
+Besides that multiple engineering specific methods are utilized to make it fast and easy to work with time series data.
+
+## Features | Concept
+
+
+| **Category**  | **Feature**                                            | **Status** |
+|---------------|--------------------------------------------------------|------------|
+| **Transform** | Filters: Datatype-specific filters                     | ✔️         |
+|               | Functions: Lambda functions for transformations        | ✔️         |
+|               | Time Functions: Time-specific transformations          | ✔️         |
+|               | Calculator: Calculation-based transformations          | ✔️         |
+| **Features**  | Stats: Datatype-specific statistics                    | ✔️         |
+|               | Time Stats: Timestamp-specific statistics              | ✔️         |
+| **Context**   | Contextualize Timeseries datasets with foreign sources | ❌          |
+| **Events**    | Quality Events                                         | ❌          |
+|               | Maintenance Events                                     | ❌          |
+|               | Production Events                                      | ❌          |
+|               | Engineering Events                                     | ❌          |
+
+
+## Installation
+
+Install ts-shape using pip:
+
+```bash
+pip install timeseries-shaper
+```
+
+## Documentation
+
+For full documentation, visit GitHub Pages or check out the docstrings in the code.
+
+## Contributing
+
+Contributions are welcome! For major changes, please open an issue first to discuss what you would like to change.
+
+Please ensure to update tests as appropriate.
+
+## License
+
+Distributed under the MIT License. See LICENSE for more information.
+
+## Acknowledgements
+
+!TODO

ts-shape-0.0.0.19/README.md

@@ -0,0 +1,60 @@
+# ts-shape | Timeseries Shaper
+
+[![pypi version](https://img.shields.io/pypi/v/timeseries-shaper.svg)](https://pypi.org/project/timeseries-shaper/)
+[![downloads](https://static.pepy.tech/badge/timeseries-shaper/week)](https://pepy.tech/projects/timeseries-shaper)
+![documentation workflow](https://github.com/jakobgabriel/ts-shape/actions/workflows/generate_docs.yml/badge.svg)
+[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://jakobgabriel.github.io/ts-shape/)
+
+----
+
+This repository contains the *ts-shape* python package. The abbreviation stands for
+
+*"Time Series shaping with rule based methods"*.
+
+ts-shape is a Python library for efficiently transforms, contextualizes and extracts events from time series data. It provides a set of tools to handle various transformations, making data preparation tasks easier and more intuitive.
+
+Besides that multiple engineering specific methods are utilized to make it fast and easy to work with time series data.
+
+## Features | Concept
+
+
+| **Category**  | **Feature**                                            | **Status** |
+|---------------|--------------------------------------------------------|------------|
+| **Transform** | Filters: Datatype-specific filters                     | ✔️         |
+|               | Functions: Lambda functions for transformations        | ✔️         |
+|               | Time Functions: Time-specific transformations          | ✔️         |
+|               | Calculator: Calculation-based transformations          | ✔️         |
+| **Features**  | Stats: Datatype-specific statistics                    | ✔️         |
+|               | Time Stats: Timestamp-specific statistics              | ✔️         |
+| **Context**   | Contextualize Timeseries datasets with foreign sources | ❌          |
+| **Events**    | Quality Events                                         | ❌          |
+|               | Maintenance Events                                     | ❌          |
+|               | Production Events                                      | ❌          |
+|               | Engineering Events                                     | ❌          |
+
+
+## Installation
+
+Install ts-shape using pip:
+
+```bash
+pip install timeseries-shaper
+```
+
+## Documentation
+
+For full documentation, visit GitHub Pages or check out the docstrings in the code.
+
+## Contributing
+
+Contributions are welcome! For major changes, please open an issue first to discuss what you would like to change.
+
+Please ensure to update tests as appropriate.
+
+## License
+
+Distributed under the MIT License. See LICENSE for more information.
+
+## Acknowledgements
+
+!TODO

ts-shape-0.0.0.19/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ts-shape-0.0.0.19/setup.py

@@ -0,0 +1,26 @@
+import setuptools
+
+with open("README.md", "r", encoding = "utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name = "ts-shape",
+    version = "0.0.0.19",
+    author = "Jakob Gabriel",
+    author_email = "jakob.gabriel5@googlemail.com",
+    description = "ts-shape filters, transforms and engineers your timeseries dataframe",
+    long_description = long_description,
+    long_description_content_type = "text/markdown",
+    url = "https://jakobgabriel.github.io/ts-shape/",
+    project_urls = {
+        "Bug Tracker": "https://github.com/jakobgabriel/ts-shape",
+    },
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    package_dir = {"": "src"},
+    packages = setuptools.find_packages(where="src"),
+    python_requires = ">=3.10"
+)

ts-shape-0.0.0.19/src/ts_shape/context/__init__.py

@@ -0,0 +1 @@
+'''test'''

ts-shape-0.0.0.19/src/ts_shape/context/value_mapping.py

@@ -0,0 +1,89 @@
+import pandas as pd  # type: ignore
+from typing import Union
+from ts_shape.utils.base import Base
+
+class ValueMapper(Base):
+    """
+    A class to map values from specified columns of a DataFrame using a mapping table (CSV or JSON file),
+    inheriting from the Base class.
+    """
+    
+    def __init__(
+        self, 
+        dataframe: pd.DataFrame, 
+        mapping_file: str, 
+        map_column: str, 
+        mapping_key_column: str, 
+        mapping_value_column: str, 
+        file_type: str = 'csv', 
+        sep: str = ',', 
+        encoding: str = 'utf-8', 
+        column_name: str = 'systime'
+    ) -> None:
+        """
+        Initializes ValueMapper and the base DataFrame from the Base class.
+
+        Args:
+            dataframe (pd.DataFrame): The DataFrame to be processed and mapped.
+            mapping_file (str): The file path of the mapping table (CSV or JSON).
+            map_column (str): The name of the column in the DataFrame that needs to be mapped.
+            mapping_key_column (str): The column in the mapping table to match with values from the DataFrame.
+            mapping_value_column (str): The column in the mapping table containing the values to map to.
+            file_type (str): The type of the mapping file ('csv' or 'json'). Defaults to 'csv'.
+            sep (str): The separator for CSV files. Defaults to ','.
+            encoding (str): The encoding to use for reading the file. Defaults to 'utf-8'.
+            column_name (str): The name of the column to sort the DataFrame by in the base class. Defaults to 'systime'.
+        """
+        # Initialize the Base class with the sorted DataFrame
+        super().__init__(dataframe, column_name)
+        
+        # Additional attributes for ValueMapper
+        self.map_column: str = map_column
+        self.mapping_key_column: str = mapping_key_column
+        self.mapping_value_column: str = mapping_value_column
+        self.sep: str = sep
+        self.encoding: str = encoding
+        
+        # Load the mapping table based on file type
+        self.mapping_table: pd.DataFrame = self._load_mapping_table(mapping_file, file_type)
+    
+    def _load_mapping_table(self, mapping_file: str, file_type: str) -> pd.DataFrame:
+        """
+        Loads the mapping table from a CSV or JSON file.
+
+        Args:
+            mapping_file (str): The file path of the mapping table.
+            file_type (str): The type of the file ('csv' or 'json').
+
+        Returns:
+            pd.DataFrame: The loaded mapping table as a DataFrame.
+        """
+        if file_type == 'csv':
+            return pd.read_csv(mapping_file, sep=self.sep, encoding=self.encoding)
+        elif file_type == 'json':
+            return pd.read_json(mapping_file, encoding=self.encoding)
+        else:
+            raise ValueError("Unsupported file type. Please use 'csv' or 'json'.")
+    
+    def map_values(self) -> pd.DataFrame:
+        """
+        Maps values in the specified DataFrame column based on the mapping table.
+
+        Returns:
+            pd.DataFrame: A new DataFrame with the mapped values.
+        """
+        # Merge the mapping table with the DataFrame based on the map_column and mapping_key_column
+        mapped_df = self.dataframe.merge(
+            self.mapping_table[[self.mapping_key_column, self.mapping_value_column]],
+            left_on=self.map_column,
+            right_on=self.mapping_key_column,
+            how='left'
+        )
+        
+        # Replace the original column with the mapped values
+        mapped_df[self.map_column] = mapped_df[self.mapping_value_column]
+        
+        # Drop unnecessary columns
+        mapped_df = mapped_df.drop([self.mapping_key_column, self.mapping_value_column], axis=1)
+        
+        return mapped_df

ts-shape-0.0.0.19/src/ts_shape/events/quality/outlier_detection.py

@@ -0,0 +1,120 @@
+import pandas as pd  # type: ignore
+import numpy as np
+from scipy.stats import zscore
+from typing import Callable, Union
+from ts_shape.utils.base import Base
+
+
+class OutlierDetectionEvents(Base):
+    """
+    Processes time series data to detect outliers based on specified statistical methods.
+    """
+
+    def __init__(self, dataframe: pd.DataFrame, value_column: str, event_uuid: str = 'outlier_event', 
+                 time_threshold: str = '5min') -> None:
+        """
+        Initializes the OutlierDetectionEvents with specific attributes for outlier detection.
+
+        Args:
+            dataframe (pd.DataFrame): The input time series DataFrame.
+            value_column (str): The name of the column containing the values for outlier detection.
+            event_uuid (str): A UUID or identifier for detected outlier events.
+            time_threshold (str): The time threshold to group close events together.
+        """
+        super().__init__(dataframe)
+        self.value_column = value_column
+        self.event_uuid = event_uuid
+        self.time_threshold = time_threshold
+
+    def _group_outliers(self, outliers_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Groups detected outliers that are close in time and prepares the final events DataFrame.
+
+        Returns:
+            pd.DataFrame: A DataFrame of grouped outlier events.
+        """
+        # Grouping outliers that are close to each other in terms of time
+        outliers_df['group_id'] = (outliers_df['systime'].diff().abs() > pd.to_timedelta(self.time_threshold)).cumsum()
+
+        # Prepare events DataFrame
+        events_data = []
+
+        for group_id in outliers_df['group_id'].unique():
+            group_data = outliers_df[outliers_df['group_id'] == group_id]
+            if group_data.shape[0] > 1:  # Ensure there's more than one row to work with
+                first_row = group_data.nsmallest(1, 'systime')
+                last_row = group_data.nlargest(1, 'systime')
+                combined_rows = pd.concat([first_row, last_row])
+                events_data.append(combined_rows)
+
+        # Convert list of DataFrame slices to a single DataFrame
+        if events_data:
+            events_df = pd.concat(events_data)
+            events_df['uuid'] = self.event_uuid
+        else:
+            events_df = pd.DataFrame(columns=outliers_df.columns)  # Create empty DataFrame if no data
+
+        events_df[self.value_column] = np.nan
+        events_df['is_delta'] = True
+
+        return events_df.drop(['outlier', 'group_id'], axis=1)
+
+    def detect_outliers_zscore(self, threshold: float = 3.0) -> pd.DataFrame:
+        """
+        Detects outliers using the Z-score method.
+
+        Args:
+            threshold (float): The Z-score threshold for detecting outliers.
+
+        Returns:
+            pd.DataFrame: A DataFrame of detected outliers and grouped events.
+        """
+        df = self.dataframe.copy()
+
+        # Convert 'systime' to datetime and sort the DataFrame by 'systime' in descending order
+        df['systime'] = pd.to_datetime(df['systime'])
+        df = df.sort_values(by='systime', ascending=False)
+
+        # Detect outliers using the Z-score method
+        df['outlier'] = np.abs(zscore(df[self.value_column])) > threshold
+
+        # Filter to keep only outliers
+        outliers_df = df[df['outlier']]
+
+        # Group and return the outliers
+        return self._group_outliers(outliers_df)
+
+    def detect_outliers_iqr(self, threshold: tuple = (1.5, 1.5)) -> pd.DataFrame:
+        """
+        Detects outliers using the IQR method.
+
+        Args:
+            threshold (tuple): The multipliers for the IQR range for detecting outliers (lower, upper).
+
+        Returns:
+            pd.DataFrame: A DataFrame of detected outliers and grouped events.
+        """
+        df = self.dataframe.copy()
+
+        # Convert 'systime' to datetime and sort the DataFrame by 'systime' in descending order
+        df['systime'] = pd.to_datetime(df['systime'])
+        df = df.sort_values(by='systime', ascending=False)
+
+        # Detect outliers using the IQR method
+        Q1 = df[self.value_column].quantile(0.25)
+        Q3 = df[self.value_column].quantile(0.75)
+        IQR = Q3 - Q1
+        lower_bound = Q1 - threshold[0] * IQR
+        upper_bound = Q3 + threshold[1] * IQR
+        df['outlier'] = (df[self.value_column] < lower_bound) | (df[self.value_column] > upper_bound)
+
+        # Filter to keep only outliers
+        outliers_df = df[df['outlier']]
+
+        # Group and return the outliers
+        return self._group_outliers(outliers_df)
+
+# Example usage:
+# outlier_detector = OutlierDetectionEvents(dataframe=df, value_column='value')
+# detected_outliers_zscore = outlier_detector.detect_outliers_zscore(threshold=3.0)
+# detected_outliers_iqr = outlier_detector.detect_outliers_iqr(threshold=(1.5, 1.5))

ts-shape-0.0.0.19/src/ts_shape/events/quality/statistical_process_control.py

@@ -0,0 +1,191 @@
+import pandas as pd  # type: ignore
+import numpy as np
+from typing import Callable, List, Optional
+from ts_shape.utils.base import Base
+
+class StatisticalProcessControlRuleBased(Base):
+    """
+    Inherits from Base and applies SPC rules (Western Electric Rules) to a DataFrame for event detection.
+    Processes data based on control limit UUIDs, actual value UUIDs, and generates events with an event UUID.
+    """
+
+    def __init__(self, dataframe: pd.DataFrame, value_column: str, tolerance_uuid: str, actual_uuid: str, event_uuid: str) -> None:
+        """
+        Initializes the SPCMonitor with UUIDs for tolerance, actual, and event values.
+        Inherits the sorted dataframe from the Base class.
+        
+        Args:
+            dataframe (pd.DataFrame): The input DataFrame containing the data to be processed.
+            value_column (str): The column containing the values to monitor.
+            tolerance_uuid (str): UUID identifier for rows that set tolerance values.
+            actual_uuid (str): UUID identifier for rows containing actual values.
+            event_uuid (str): UUID to assign to generated events.
+        """
+        super().__init__(dataframe)  # Initialize the Base class
+        self.value_column: str = value_column
+        self.tolerance_uuid: str = tolerance_uuid
+        self.actual_uuid: str = actual_uuid
+        self.event_uuid: str = event_uuid
+    
+    def calculate_control_limits(self) -> pd.DataFrame:
+        """
+        Calculate the control limits (mean ± 1σ, 2σ, 3σ) for the tolerance values.
+        
+        Returns:
+            pd.DataFrame: DataFrame with control limits for each tolerance group.
+        """
+        df = self.dataframe[self.dataframe['uuid'] == self.tolerance_uuid]
+        mean = df[self.value_column].mean()
+        sigma = df[self.value_column].std()
+        
+        control_limits = {
+            'mean': mean,
+            '1sigma_upper': mean + sigma,
+            '1sigma_lower': mean - sigma,
+            '2sigma_upper': mean + 2 * sigma,
+            '2sigma_lower': mean - 2 * sigma,
+            '3sigma_upper': mean + 3 * sigma,
+            '3sigma_lower': mean - 3 * sigma,
+        }
+        
+        return pd.DataFrame([control_limits])
+    
+    def rule_1(self, df: pd.DataFrame, limits: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 1: One point beyond the 3σ control limits.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['rule_1'] = (df[self.value_column] > limits['3sigma_upper'].values[0]) | (df[self.value_column] < limits['3sigma_lower'].values[0])
+        return df[df['rule_1']]
+
+    def rule_2(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 2: Nine consecutive points on one side of the mean.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        mean = df[self.value_column].mean()
+        df['above_mean'] = df[self.value_column] > mean
+        df['below_mean'] = df[self.value_column] < mean
+        df['rule_2'] = (df['above_mean'].rolling(window=9).sum() == 9) | (df['below_mean'].rolling(window=9).sum() == 9)
+        return df[df['rule_2']]
+
+    def rule_3(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 3: Six consecutive points steadily increasing or decreasing.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['increasing'] = df[self.value_column].diff().gt(0)
+        df['decreasing'] = df[self.value_column].diff().lt(0)
+        df['rule_3'] = (df['increasing'].rolling(window=6).sum() == 6) | (df['decreasing'].rolling(window=6).sum() == 6)
+        return df[df['rule_3']]
+
+    def rule_4(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 4: Fourteen consecutive points alternating up and down.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['alternating'] = df[self.value_column].diff().apply(np.sign)
+        df['rule_4'] = df['alternating'].rolling(window=14).apply(lambda x: (x != x.shift()).sum() == 13, raw=True)
+        return df[df['rule_4']]
+
+    def rule_5(self, df: pd.DataFrame, limits: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 5: Two out of three consecutive points near the control limit (beyond 2σ but within 3σ).
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['rule_5'] = df[self.value_column].apply(
+            lambda x: 1 if ((x > limits['2sigma_upper'].values[0] and x < limits['3sigma_upper'].values[0]) or 
+                            (x < limits['2sigma_lower'].values[0] and x > limits['3sigma_lower'].values[0])) else 0
+        )
+        df['rule_5'] = df['rule_5'].rolling(window=3).sum() >= 2
+        return df[df['rule_5']]
+
+    def rule_6(self, df: pd.DataFrame, limits: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 6: Four out of five consecutive points near the control limit (beyond 1σ but within 2σ).
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['rule_6'] = df[self.value_column].apply(
+            lambda x: 1 if ((x > limits['1sigma_upper'].values[0] and x < limits['2sigma_upper'].values[0]) or 
+                            (x < limits['1sigma_lower'].values[0] and x > limits['2sigma_lower'].values[0])) else 0
+        )
+        df['rule_6'] = df['rule_6'].rolling(window=5).sum() >= 4
+        return df[df['rule_6']]
+
+    def rule_7(self, df: pd.DataFrame, limits: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 7: Fifteen consecutive points within 1σ of the centerline.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['rule_7'] = df[self.value_column].apply(
+            lambda x: 1 if (x < limits['1sigma_upper'].values[0] and x > limits['1sigma_lower'].values[0]) else 0
+        )
+        df['rule_7'] = df['rule_7'].rolling(window=15).sum() == 15
+        return df[df['rule_7']]
+
+    def rule_8(self, df: pd.DataFrame, limits: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rule 8: Eight consecutive points on both sides of the mean within 1σ.
+        
+        Returns:
+            pd.DataFrame: Filtered DataFrame with rule violations.
+        """
+        df['rule_8'] = df[self.value_column].apply(
+            lambda x: 1 if (x < limits['1sigma_upper'].values[0] and x > limits['1sigma_lower'].values[0]) else 0
+        )
+        df['rule_8'] = df['rule_8'].rolling(window=8).sum() == 8
+        return df[df['rule_8']]
+
+    def process(self, selected_rules: Optional[List[str]] = None) -> pd.DataFrame:
+        """
+        Applies the selected SPC rules and generates a DataFrame of events where any rules are violated.
+        
+        Args:
+            selected_rules (Optional[List[str]]): List of rule names (e.g., ['rule_1', 'rule_3']) to apply.
+        
+        Returns:
+            pd.DataFrame: DataFrame with rule violations and detected events.
+        """
+        df = self.dataframe[self.dataframe['uuid'] == self.actual_uuid]
+        df['systime'] = pd.to_datetime(df['systime'])
+        df = df.sort_values(by='systime')
+
+        limits = self.calculate_control_limits()
+
+        # Dictionary of rule functions
+        rules = {
+            'rule_1': lambda df: self.rule_1(df, limits),
+            'rule_2': lambda df: self.rule_2(df),
+            'rule_3': lambda df: self.rule_3(df),
+            'rule_4': lambda df: self.rule_4(df),
+            'rule_5': lambda df: self.rule_5(df, limits),
+            'rule_6': lambda df: self.rule_6(df, limits),
+            'rule_7': lambda df: self.rule_7(df, limits),
+            'rule_8': lambda df: self.rule_8(df, limits)
+        }
+
+        # If no specific rules are provided, use all rules
+        if selected_rules is None:
+            selected_rules = list(rules.keys())
+
+        # Apply selected rules and concatenate results
+        events = pd.concat([rules[rule](df) for rule in selected_rules if rule in rules]).drop_duplicates()
+
+        # Add the event UUID to the detected events
+        events['uuid'] = self.event_uuid
+
+        return events[['systime', self.value_column, 'uuid']].drop_duplicates()