PyDPEET 0.2.0__py3-none-any.whl

pydpeet/process/sequence/utils/configs/CONFIG_preprocessing.py

@@ -0,0 +1,243 @@
+from pydpeet.process.sequence.configs import config
+from pydpeet.process.sequence.utils.preprocessing.calculate_thresholds import calculate_minimum_definitive_differences
+
+THRESHOLD_DICT_Custom = [  # ARBIN_OLD
+    0.0005,  # ACCURACY_VOLTAGE_SIGNAL
+    0.01,  # ACCURACY_CURRENT_SIGNAL
+    0.0005,  # ACCURACY_VOLTAGE_MEASUREMENT
+    0.01,  # ACCURACY_CURRENT_MEASUREMENT
+    5,  # FS_VOLTAGE
+    3,  # FS_CURRENT
+]
+# use THRESHOLD_DICT = THRESHOLD_DICT_Custom if you don't want to use a predefined dictionary
+THRESHOLD_DICT = config.NEWARE_CT_4008Q_5V12A_S1
+MIN_DEFINITIVE_VOLTAGE_DIFFERENCE, MIN_DEFINITIVE_CURRENT_DIFFERENCE = calculate_minimum_definitive_differences(
+    *THRESHOLD_DICT
+)
+
+####### depending on the Noise needs to be adjusted even for measurements of the same device #######
+SEGMENTS_TO_DETECT_CONFIG = [
+    # devide threshold by 2 because it's looking above and below the target line
+    ("Voltage[V]", MIN_DEFINITIVE_VOLTAGE_DIFFERENCE / 2),
+    ("Current[A]", MIN_DEFINITIVE_CURRENT_DIFFERENCE / 2),
+    ("Power[W]", (MIN_DEFINITIVE_VOLTAGE_DIFFERENCE + MIN_DEFINITIVE_CURRENT_DIFFERENCE) / 2),
+]
+####### depending on the Noise needs to be adjusted even for measurements of the same device #######
+# ORDER IS IMPORTANT!
+ADJUST_SEGMENTS_CONFIG = [
+    ("Voltage[V]", MIN_DEFINITIVE_VOLTAGE_DIFFERENCE),
+    ("Current[A]", MIN_DEFINITIVE_CURRENT_DIFFERENCE),
+    ("Power[W]", (MIN_DEFINITIVE_VOLTAGE_DIFFERENCE + MIN_DEFINITIVE_CURRENT_DIFFERENCE)),
+]
+
+THRESHOLD_CV_SEGMENTS_0A_END = MIN_DEFINITIVE_CURRENT_DIFFERENCE
+
+####### HAS TO USE SAME KEY AS DATA_COLUMNS! only change the values of thresholds! ########
+THRESHOLDS_PRIMITIVE_ANNOTATION = {
+    "V": MIN_DEFINITIVE_VOLTAGE_DIFFERENCE,
+    "I": MIN_DEFINITIVE_CURRENT_DIFFERENCE,
+    "P": MIN_DEFINITIVE_VOLTAGE_DIFFERENCE + MIN_DEFINITIVE_CURRENT_DIFFERENCE,
+}
+
+########################################################################################################################
+SHOW_RUNTIME = True
+SHOW_RUNTIME_ANNOTATION = True
+SHOW_RUNTIME_ANALYZE = True
+SHOW_RUNTIME_VISUALIZATION = True
+THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK = 2
+THRESHOLD_CONSOLE_PRINTS_CV_CHECK = 2
+THRESHOLD_CONSOLE_PRINTS_FINETUNING_WIDTH = 2
+THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK = 10
+########################################################################################################################
+# Visualize Data
+VISUALIZE_PHASES_CONFIG = [
+    ("V", "blue"),
+    ("I", "red"),
+    ("P", "green"),
+]
+LINE_VISUALIZATION_CONFIG = [
+    ("Voltage[V]", "blue", (2.4, 4.3)),
+    ("Current[A]", "red", (-10, 10)),
+    ("Power[W]", "green", (-40, 20)),
+]
+START = 0
+END = 1e100
+USE_LINES_FOR_SEGMENTS = True
+SHOW_COLUMN_NAMES = True
+SHOW_TIME = True
+SHOW_ID = True
+SEGMENT_ALPHA = 0.3
+WIDTH_HEIGHT_RATIO = [1, 0.3]
+########################################################################################################################
+# Generate Instructions
+END_CONDITION_MAP_GENERATE_INSTRUCTIONS = {
+    "CC": "voltage",
+    "CV": "current",
+    "CP": "voltage",
+    "Pause": "time",
+}
+########################################################################################################################
+SEQUENCES_CONFIG: dict[str, dict] = {
+    # Complex Sequences
+    # Loop rules: "loop": True, "exact_loops": 2, "min_loops": 2, "max_loops": 2, "minimum_IDs": 6
+    "Discharge_iOCV": {"loop": True, "minimum_IDs": 4, "sequence": ["CC_Discharge", "Pause"]},
+    "Charge_iOCV": {"loop": True, "min_loops": 2, "sequence": ["Pause", "CC_Charge"]},
+    "CCCV_Charge": {"loop": False, "sequence": ["CC_Charge", "CV_Charge"]},
+}
+SEGMENTS_CONFIG_SIMPLE: dict[str, dict] = {
+    # Primitive segments
+    # I, V, P,
+    # Charging, Discharging
+    "I": {
+        "rules": {
+            "variable": "I",
+        }
+    },
+    "V": {
+        "rules": {
+            "variable": "V",
+        }
+    },
+    "P": {
+        "rules": {
+            "variable": "P",
+        }
+    },
+    "Charging": {
+        "rules": {
+            "direction": "Charge",
+        }
+    },
+    "Discharging": {
+        "rules": {
+            "direction": "Discharge",
+        }
+    },
+}
+SEGMENTS_CONFIG_STANDARD: dict[str, dict] = {
+    # Primitive segments
+    # Pause
+    # CC_Charge, CV_Charge, CP_Charge
+    # CC_Discharge, CV_Discharge, CP_Discharge
+    # Ramp_Current_Charge, Ramp_Voltage_Charge, Ramp_Power_Charge
+    # Ramp_Current_Discharge, Ramp_Voltage_Discharge, Ramp_Power_Discharge
+    "Pause": {
+        "rules": {
+            "type": "Rest",
+        }
+    },
+    "CC_Charge": {
+        "rules": {
+            "variable": "I",
+            "type": "Constant",
+            "direction": "Charge",
+        }
+    },
+    "CV_Charge": {
+        "rules": {
+            "variable": "V",
+            "type": "Constant",
+            "direction": "Charge",
+        }
+    },
+    "CP_Charge": {
+        "rules": {
+            "variable": "P",
+            "type": "Constant",
+            "direction": "Charge",
+        }
+    },
+    "CC_Discharge": {
+        "rules": {
+            "variable": "I",
+            "type": "Constant",
+            "direction": "Discharge",
+        }
+    },
+    "CV_Discharge": {
+        "rules": {
+            "variable": "V",
+            "type": "Constant",
+            "direction": "Discharge",
+        }
+    },
+    "CP_Discharge": {
+        "rules": {
+            "variable": "P",
+            "type": "Constant",
+            "direction": "Discharge",
+        }
+    },
+    "CRamp_Charge": {
+        "rules": {
+            "variable": "I",
+            "type": "Ramp",
+            "direction": "Up",
+        }
+    },
+    "VRamp_Charge": {
+        "rules": {
+            "variable": "V",
+            "type": "Ramp",
+            "direction": "Up",
+        }
+    },
+    "PRamp_Charge": {
+        "rules": {
+            "variable": "P",
+            "type": "Ramp",
+            "direction": "Up",
+        }
+    },
+    "CRamp_Discharge": {
+        "rules": {
+            "variable": "I",
+            "type": "Ramp",
+            "direction": "Down",
+        }
+    },
+    "VRamp_Discharge": {
+        "rules": {
+            "variable": "V",
+            "type": "Ramp",
+            "direction": "Down",
+        }
+    },
+    "PRamp_Discharge": {
+        "rules": {
+            "variable": "P",
+            "type": "Ramp",
+            "direction": "Down",
+        }
+    },
+}
+
+
+SEGMENT_SEQUENCE_CONFIG = {
+    **SEQUENCES_CONFIG,
+    **SEGMENTS_CONFIG_STANDARD,
+    **SEGMENTS_CONFIG_SIMPLE,
+}
+########################################################################################################################
+#### These shouldn't be changed when using ppb Dataframes ####
+DATA_COLUMNS = {
+    "V": "Voltage[V]",
+    "I": "Current[A]",
+    "P": "Power[W]",
+}
+#### These shouldn't be changed when using ppb Dataframes ####
+
+STEP_ANALYZER_PRIMITIVES_CONFIG_PRECOMPILE = {
+    "SEGMENTS_TO_DETECT_CONFIG": SEGMENTS_TO_DETECT_CONFIG,
+    "ADJUST_SEGMENTS_CONFIG": ADJUST_SEGMENTS_CONFIG,
+    "THRESHOLDS_PRIMITIVE_ANNOTATION": THRESHOLDS_PRIMITIVE_ANNOTATION,
+    "SHOW_RUNTIME": SHOW_RUNTIME,
+    "SHOW_RUNTIME_ANNOTATION": SHOW_RUNTIME_ANNOTATION,
+    "DATA_COLUMNS": DATA_COLUMNS,
+    "MIN_DEFINITIVE_CURRENT_DIFFERENCE": MIN_DEFINITIVE_CURRENT_DIFFERENCE,
+    "THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK": THRESHOLD_CONSOLE_PRINTS_ZERO_LENGTH_CHECK,
+    "THRESHOLD_CONSOLE_PRINTS_CV_CHECK": THRESHOLD_CONSOLE_PRINTS_CV_CHECK,
+    "THRESHOLD_CONSOLE_PRINTS_FINETUNING_WIDTH": THRESHOLD_CONSOLE_PRINTS_FINETUNING_WIDTH,
+    "THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK": THRESHOLD_CONSOLE_PRINTS_POWER_ZERO_WATT_CHECK,
+    "THRESHOLD_CV_SEGMENTS_0A_END": THRESHOLD_CV_SEGMENTS_0A_END,
+}

pydpeet/process/sequence/utils/configs/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []

pydpeet/process/sequence/utils/console_prints/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []

pydpeet/process/sequence/utils/console_prints/log_time.py

@@ -0,0 +1,30 @@
+import logging
+from contextlib import contextmanager
+from time import perf_counter
+
+
+@contextmanager
+def log_time(
+    description: str = "",
+    SHOW_RUNTIME: bool = True,
+):
+    """
+    Context manager to log the time taken by a block of code.
+
+    The log message will show the time taken in seconds with 4 decimal places,
+    and the description passed as argument.
+
+    Parameters:
+        description: str
+            The description of the block of code.
+        SHOW_RUNTIME: bool
+            Whether to print the time taken.
+
+    Returns:
+        None
+    """
+    start = perf_counter()
+    yield
+    end = perf_counter()
+    if SHOW_RUNTIME:
+        logging.info(f"    {end - start:.4f}s {description}")

pydpeet/process/sequence/utils/postprocessing/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []

pydpeet/process/sequence/utils/postprocessing/df_primitives_correction.py

@@ -0,0 +1,166 @@
+import pandas as pd
+
+from pydpeet.process.sequence.utils.annotate.annotate_primitives import _merged_annotations
+
+
+def df_primitives_correction(
+    df_primitives: pd.DataFrame,
+    correction_config: dict,
+    data_columns: dict[str, str],
+    thresholds: dict[str, float],
+    reindex: bool = True,
+    reannotate: bool = True,
+) -> pd.DataFrame:
+    """
+    Corrects the primitives in the dataframe based on the given configuration.
+
+    Parameters:
+    df_primitives (pd.DataFrame): Input dataframe containing the primitives.
+    correction_config (dict): Configuration for the correction, containing the following keys:
+        - replace_ID (dict): Mapping of old IDs to new IDs.
+        - replace_time (dict): Mapping of time ranges and the new labels for variable.
+        - replace_time_and_merge (dict): Mapping of time ranges  and the new labels for variable + merges all into one segment.
+        - merge_left (list): List of IDs to merge with the previous segment.
+        - merge_right (list): List of IDs to merge with the next segment.
+        - merge_range (list): List of tuples of start and end IDs to merge. Keeping left Variable
+        Example: {'replace_time': {(0.0, 10.0): 'I', (10.0, 20.0): 'P'}, ...}
+    data_columns (dict): Mapping of column names to their respective short names.
+        Example: data_columns = {"I": "Current[A]", "P": "Power[W]", "V": "Voltage[V]"}
+    thresholds (dict): Threshold values for each type of annotation.
+        Example: {"V": 0.1, "I": 0.1, "P": 0.1}
+    reindex (bool): Whether to reindex the IDs to be consecutive, by default True.
+    reannotate (bool): Whether to reannotate the primitives after the correction, by default True.
+
+    Returns:
+    pd.DataFrame: The corrected dataframe with the added columns for annotated primitives.
+    """
+
+    df = df_primitives.copy()
+    max_id = df["ID"].max() + 1  # for new IDs
+
+    # --- REPLACE by ID ---
+    if "replace_ID" in correction_config:
+        for id_, new_label in correction_config["replace_ID"].items():
+            df.loc[df["ID"] == id_, "Variable"] = new_label
+
+    # --- REPLACE by TIME with splitting ---
+    if "replace_time" in correction_config:
+        for (start, end), new_label in correction_config["replace_time"].items():
+            overlapping_idx = df[(df["Test_Time[s]"] >= start) & (df["Test_Time[s]"] <= end)].index
+            if overlapping_idx.empty:
+                continue
+
+            overlapping_ids = df.loc[overlapping_idx, "ID"].unique()
+            for seg_id in overlapping_ids:
+                segment_rows = df[df["ID"] == seg_id]
+                seg_start_time = segment_rows["Test_Time[s]"].min()
+                seg_end_time = segment_rows["Test_Time[s]"].max()
+
+                if start <= seg_start_time and end >= seg_end_time:
+                    mask = df["ID"] == seg_id
+                    df.loc[mask, "Variable"] = new_label
+                else:
+                    if seg_start_time < start:
+                        mask_before = (df["ID"] == seg_id) & (df["Test_Time[s]"] < start)
+                        df.loc[mask_before, "ID"] = max_id
+                        max_id += 1
+
+                    mask_overlap = (df["ID"] == seg_id) & (df["Test_Time[s]"] >= start) & (df["Test_Time[s]"] <= end)
+                    df.loc[mask_overlap, "Variable"] = new_label
+                    df.loc[mask_overlap, "ID"] = max_id
+                    max_id += 1
+
+                    if seg_end_time > end:
+                        mask_after = (df["ID"] == seg_id) & (df["Test_Time[s]"] > end)
+                        df.loc[mask_after, "ID"] = max_id
+                        max_id += 1
+
+    # --- REPLACE by TIME and MERGE ---
+    if "replace_time_and_merge" in correction_config:
+        for (start, end), new_label in correction_config["replace_time_and_merge"].items():
+            overlapping_idx = df[(df["Test_Time[s]"] >= start) & (df["Test_Time[s]"] <= end)].index
+            if overlapping_idx.empty:
+                continue
+
+            overlapping_ids = df.loc[overlapping_idx, "ID"].unique()
+            new_id_for_merge = max_id
+            max_id += 1
+
+            for seg_id in overlapping_ids:
+                segment_rows = df[df["ID"] == seg_id]
+                seg_start_time = segment_rows["Test_Time[s]"].min()
+                seg_end_time = segment_rows["Test_Time[s]"].max()
+
+                if start <= seg_start_time and end >= seg_end_time:
+                    mask = df["ID"] == seg_id
+                    df.loc[mask, "Variable"] = new_label
+                    df.loc[mask, "ID"] = new_id_for_merge
+                else:
+                    if seg_start_time < start:
+                        mask_before = (df["ID"] == seg_id) & (df["Test_Time[s]"] < start)
+                        df.loc[mask_before, "ID"] = max_id
+                        max_id += 1
+
+                    mask_overlap = (df["ID"] == seg_id) & (df["Test_Time[s]"] >= start) & (df["Test_Time[s]"] <= end)
+                    df.loc[mask_overlap, "Variable"] = new_label
+                    df.loc[mask_overlap, "ID"] = new_id_for_merge
+
+                    if seg_end_time > end:
+                        mask_after = (df["ID"] == seg_id) & (df["Test_Time[s]"] > end)
+                        df.loc[mask_after, "ID"] = max_id
+                        max_id += 1
+
+    # --- MERGE LEFT ---
+    if "merge_left" in correction_config:
+        for id_ in correction_config["merge_left"]:
+            segment_rows = df[df["ID"] == id_]
+            if segment_rows.empty:
+                continue
+            first_pos = df.index.get_loc(segment_rows.index[0])
+            if first_pos == 0:
+                continue
+            left_id = df.iloc[first_pos - 1]["ID"]
+            left_variable = df.iloc[first_pos - 1]["Variable"]
+            df.loc[segment_rows.index, "ID"] = left_id
+            df.loc[segment_rows.index, "Variable"] = left_variable
+
+    # --- MERGE RIGHT ---
+    if "merge_right" in correction_config:
+        for id_ in correction_config["merge_right"]:
+            segment_rows = df[df["ID"] == id_]
+            if segment_rows.empty:
+                continue
+
+            first_pos = df.index.get_loc(segment_rows.index[0])
+            last_pos = df.index.get_loc(segment_rows.index[-1])
+
+            right_pos = last_pos + 1
+            if right_pos >= len(df):
+                continue
+
+            right_id = df.iloc[right_pos]["ID"]
+            right_variable = df.iloc[right_pos]["Variable"]
+            df.loc[segment_rows.index, "ID"] = right_id
+            df.loc[segment_rows.index, "Variable"] = right_variable
+
+    # --- MERGE RANGES ---
+    if "merge_range" in correction_config:
+        for start_id, end_id in correction_config["merge_range"]:
+            mask = (df["ID"] >= start_id) & (df["ID"] <= end_id)
+            if not mask.any():
+                continue
+            target_id = start_id
+            target_variable = df.loc[df["ID"] == target_id, "Variable"].iloc[0]
+            df.loc[mask, "ID"] = target_id
+            df.loc[mask, "Variable"] = target_variable
+
+    # --- REINDEX IDs to be consecutive ---
+    if reindex:
+        unique_ids = df["ID"].drop_duplicates().reset_index(drop=True)
+        id_mapping = {old_id: new_id for new_id, old_id in enumerate(unique_ids, start=1)}
+        df["ID"] = df["ID"].map(id_mapping)
+
+    if reannotate:
+        df = _merged_annotations(df, data_columns, thresholds)
+
+    return df

pydpeet/process/sequence/utils/postprocessing/filter_df.py

@@ -0,0 +1,168 @@
+import logging
+import operator
+from functools import reduce
+
+import pandas as pd
+from pandas import DataFrame
+
+
+# TODO: Docstring
+def filter_df(
+    df_segments_and_sequences: pd.DataFrame,
+    df_primitives: pd.DataFrame,
+    rules: list[str],
+    standard_columns: list[str],
+    combine_op: str = "xor",
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    # Map string to actual function
+    comb_funcs = {"and": operator.and_, "or": operator.or_, "xor": operator.xor, "not": operator.not_}
+    if combine_op not in comb_funcs:
+        raise ValueError(f"combine_op must be one of {list(comb_funcs)}")
+
+    if not rules:
+        # No filtering, use all IDs
+        df_filtered_IDs = df_segments_and_sequences["ID"].values
+    else:
+        # build list of boolean Series for each rule
+        masks = []
+        for col in rules:
+            if col not in df_segments_and_sequences:
+                raise KeyError(f"column {col!r} not in DataFrame")
+            masks.append(operator.ne(df_segments_and_sequences[col], 0))
+
+        # combine masks with selected operator
+        combined_mask = reduce(comb_funcs[combine_op], masks)
+        df_filtered_IDs = df_segments_and_sequences[combined_mask]["ID"].values
+
+    # Create standard and non-standard dataframes
+    df_standard = df_primitives[standard_columns + ["ID", "Power[W]"]]
+    df_non_standard = df_primitives[
+        [col for col in df_primitives.columns if col not in standard_columns + ["Power[W]"]]
+    ]
+
+    # Nullify non-standard rows not in filtered IDs
+    mask = ~df_non_standard["ID"].isin(df_filtered_IDs)
+    cols_to_null = [col for col in df_non_standard.columns if col != "ID"]
+    df_non_standard.loc[mask, cols_to_null] = None
+    df_non_standard.loc[mask, "Variable"] = "Filtered"
+
+    # Combine standard and non-standard
+    df_filtered = pd.concat([df_standard, df_non_standard.drop(columns="ID")], axis=1)
+
+    return df_filtered, df_filtered_IDs
+
+
+# TODO: Docstring
+def return_or_print_blocks(
+    df_filtered: pd.DataFrame,
+    filtered_IDs: pd.Series | list | set | tuple,
+    print_blocks: bool = True,
+) -> None | list[dict]:
+    import numpy as np
+
+    # Ensure IDs are in a fast lookup structure
+    filtered_IDs_set = set(filtered_IDs)
+
+    # Convert necessary columns to arrays
+    ids = df_filtered["ID"].values
+    testtimes = df_filtered["Test_Time[s]"].values
+    is_filtered = df_filtered["Variable"].values == "Filtered"
+
+    # Boolean mask for unfiltered rows
+    unfiltered_mask = np.isin(ids, list(filtered_IDs_set)) & ~is_filtered
+
+    # Find block boundaries (diff between 0/1 in mask)
+    block_edges = np.diff(unfiltered_mask.astype(int))
+    starts = np.where(block_edges == 1)[0] + 1
+    ends = np.where(block_edges == -1)[0]
+
+    # Edge case: starts/ends at beginning or end
+    if unfiltered_mask[0]:
+        starts = np.insert(starts, 0, 0)
+    if unfiltered_mask[-1]:
+        ends = np.append(ends, len(unfiltered_mask) - 1)
+
+    blocks = []
+    for i, (start_idx, end_idx) in enumerate(zip(starts, ends, strict=False), start=-1):
+        start_id = ids[start_idx]
+        end_id = ids[end_idx]
+        start_time = testtimes[start_idx]
+        end_time = testtimes[end_idx]
+        if print_blocks:
+            logging.info("-" * 40)
+            logging.info(f"Block {i + 1}:")
+            logging.info(f"  Start ID: {start_id}, Test_Time[s]: {start_time}")
+            logging.info(f"  End ID:   {end_id}, Test_Time[s]: {end_time}")
+            logging.info("-" * 40)
+
+        blocks.append(
+            {
+                "start_id": start_id,
+                "end_id": end_id,
+                "start_time": start_time,
+                "end_time": end_time,
+            }
+        )
+
+    return blocks
+
+
+def split_df_by_blocks(
+    df_filtered: pd.DataFrame,
+    blocks: list[dict],
+) -> list[pd.DataFrame]:
+    """
+    Split df_filtered into multiple DataFrames per block.
+    Each block includes all rows from start_id to end_id (inclusive), even if IDs repeat.
+    """
+    dfs_per_block = []
+    ids = df_filtered["ID"].values
+
+    for block in blocks:
+        start_id = block["start_id"]
+        end_id = block["end_id"]
+
+        # Find ALL positions of start_id and end_id
+        start_positions = (ids == start_id).nonzero()[0]
+        end_positions = (ids == end_id).nonzero()[0]
+
+        if len(start_positions) == 0 or len(end_positions) == 0:
+            continue  # skip if not found
+
+        start_idx = start_positions[0]
+        end_idx = end_positions[-1]
+
+        df_block = df_filtered.iloc[start_idx : end_idx + 1].copy()
+        dfs_per_block.append(df_block)
+
+    return dfs_per_block
+
+
+def filter_and_split_df_by_blocks(
+    df_segments_and_sequences: pd.DataFrame,
+    df_primitives: pd.DataFrame,
+    rules: list[str],
+    combine_op: str = "or",
+    print_blocks: bool = False,
+    also_return_filtered_df: bool = True,
+) -> tuple[list[DataFrame], DataFrame] | list[DataFrame]:
+    standard_columns = ["Test_Time[s]", "Voltage[V]", "Current[A]", "Power[W]"]
+    logging.warning("Using default standard columns:")
+    logging.warning(standard_columns)
+
+    df_filtered, df_filtered_IDs = filter_df(
+        df_segments_and_sequences=df_segments_and_sequences,
+        df_primitives=df_primitives,
+        rules=rules,
+        combine_op=combine_op,
+        standard_columns=standard_columns,
+    )
+
+    blocks = return_or_print_blocks(df_filtered=df_filtered, filtered_IDs=df_filtered_IDs, print_blocks=print_blocks)
+
+    dfs_per_block = split_df_by_blocks(df_filtered=df_filtered, blocks=blocks)
+
+    if also_return_filtered_df:
+        return dfs_per_block, df_filtered
+
+    return dfs_per_block