PyDPEET 0.2.0__py3-none-any.whl

pydpeet/process/sequence/utils/processing/widen_constant_segments.py

@@ -0,0 +1,185 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from numba import njit
+
+
+# TODO: Typing correct?
+@njit(cache=True)
+def _widen_segments_numba(
+    Data_arr: np.ndarray,
+    ID_arr: np.ndarray,
+    thresholds: np.array,
+) -> np.array:
+    """
+    Widen constant segments in a DataFrame by identifying contiguous segments in each column,
+    and then widening each segment by extending it to the left and right until the
+    average of the segment exceeds the threshold.
+
+    Parameters:
+    Data_arr (numpy array): Input DataFrame with Segment columns.
+    ID_arr (numpy array): IDs of the segments in the DataFrame.
+    thresholds (numpy array): Threshold values per column.
+
+    Returns:
+    numpy array: The original DataFrame with widened segments.
+    """
+    n_rows, n_cols = Data_arr.shape
+    new_ID_arr = ID_arr.copy()
+
+    for col_idx in range(n_cols):
+        thresh = thresholds[col_idx]
+        col_data = Data_arr[:, col_idx]
+        col_ids = new_ID_arr[:, col_idx]
+
+        i = 0
+        while i < n_rows:
+            col_id = col_ids[i]
+            if col_id == -1:
+                i += 1
+                continue
+
+            # Identify start and end of contiguous segment
+            start = i
+            while i + 1 < n_rows and col_ids[i + 1] == col_id:
+                i += 1
+            end = i
+
+            # Compute mean and check validity in one pass
+            seg_sum = 0.0
+            segment_length = end - start + 1
+            is_valid = True
+            for j in range(start, end + 1):
+                seg_sum += col_data[j]
+            avg = seg_sum / segment_length
+
+            for j in range(start, end + 1):
+                if abs(col_data[j] - avg) > thresh:
+                    is_valid = False
+                    break
+            if not is_valid:
+                i += 1
+                continue
+
+            # Extend to the right
+            extend_r = end
+            j = end + 1
+            while j < n_rows:
+                v = col_data[j]
+                cid_j = new_ID_arr[j, col_idx]
+                if abs(v - avg) > thresh or (cid_j != -1 and cid_j != col_id):
+                    break
+                extend_r = j
+                j += 1
+
+            # Extend to the left
+            extend_l = start
+            j = start - 1
+            while j >= 0:
+                v = col_data[j]
+                cid_j = new_ID_arr[j, col_idx]
+                if abs(v - avg) > thresh or (cid_j != -1 and cid_j != col_id):
+                    break
+                extend_l = j
+                j -= 1
+
+            # Assign widened ID to extended ranges
+            for j in range(extend_l, start):
+                new_ID_arr[j, col_idx] = col_id
+            for j in range(end + 1, extend_r + 1):
+                new_ID_arr[j, col_idx] = col_id
+
+            # Invalidate other columns only once for the widened areas
+            if extend_l < start or extend_r > end:
+                for other_col_idx in range(n_cols):
+                    if other_col_idx == col_idx:
+                        continue
+                    for j in range(extend_l, start):
+                        new_ID_arr[j, other_col_idx] = -1
+                    for j in range(end + 1, extend_r + 1):
+                        new_ID_arr[j, other_col_idx] = -1
+
+            i += 1
+
+    return new_ID_arr
+
+
+def _widen_constant_segments(
+    df: pd.DataFrame,
+    adjust_segments_config: list[tuple[str, float]],
+    Threshold_segments_to_print: int,
+    supress_IO_warnings: bool,
+) -> pd.DataFrame:
+    """
+    Widen constant segments in a DataFrame by identifying contiguous segments in each column,
+    and then widening each segment by extending it to the left and right until the
+    average of the segment exceeds the threshold.
+
+    Parameters:
+    df (pd.DataFrame): Input DataFrame with Segment columns.
+    adjust_segments_config (list of tuples): List of tuples containing column name and threshold value.
+        Example: [("Voltage[V]", 0.1), ("Current[A]", 0.1), ("Power[W]", 0.1)]
+    Threshold_segments_to_print (int): The maximum number of removed segments to print in the warning message.
+    supress_IO_warnings (bool): Whether to suppress warning messages.
+
+    Returns:
+    pd.DataFrame: The original DataFrame with widened segments.
+    """
+    Data_columns_name_list = [name for name, _ in adjust_segments_config]
+    thresholds = np.array([thresh for _, thresh in adjust_segments_config], dtype=np.float64)
+    ID_columns_name_list = ["Segment_" + name for name, _ in adjust_segments_config]
+
+    Data_arr = df[Data_columns_name_list].to_numpy(dtype=np.float64)
+    ID_arr = df[ID_columns_name_list].to_numpy(dtype=np.int32)
+
+    n_rows = ID_arr.shape[0]
+
+    # Store start and end indices of original segments per column
+    original_segments = {col: [] for col in ID_columns_name_list}
+    for i, col in enumerate(ID_columns_name_list):
+        ids = ID_arr[:, i]
+        current_id = ids[0]
+        start_idx = 0 if current_id != -1 else None
+        for row in range(1, n_rows):
+            if ids[row] != current_id:
+                if current_id != -1:
+                    original_segments[col].append((start_idx, row - 1))
+                current_id = ids[row]
+                start_idx = row if current_id != -1 else None
+        if current_id != -1:
+            original_segments[col].append((start_idx, n_rows - 1))
+
+    # Run widening
+    new_ID_arr = _widen_segments_numba(Data_arr, ID_arr, thresholds)
+
+    # Check removed segments and print one-line warning
+    for i, col in enumerate(ID_columns_name_list):
+        updated_ids = new_ID_arr[:, i]
+        removed_ranges = [
+            f"{start}:{end}" for start, end in original_segments[col] if np.all(updated_ids[start : end + 1] == -1)
+        ]
+        if removed_ranges:
+            if not supress_IO_warnings:
+                if Threshold_segments_to_print:
+                    if Threshold_segments_to_print < len(removed_ranges):
+                        logging.warning(
+                            f"Removed segments during finetuning of the width in '{col}': "
+                            + ", ".join(removed_ranges[:Threshold_segments_to_print])
+                            + " ..."
+                        )
+                    else:
+                        logging.warning(
+                            f"Removed segments during finetuning of the width in '{col}': "
+                            + ", ".join(removed_ranges[:Threshold_segments_to_print])
+                        )
+                else:
+                    logging.warning(
+                        f"Removed segments during finetuning of the width in '{col}': " + ", ".join(removed_ranges)
+                    )
+
+    # Update DataFrame
+    for i, col in enumerate(ID_columns_name_list):
+        df[col] = new_ID_arr[:, i]
+
+    return df

pydpeet/process/sequence/utils/visualize/__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/visualize/visualize_data.py

@@ -0,0 +1,288 @@
+import logging
+import tkinter as tk
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from pydpeet.process.sequence.utils.console_prints.log_time import log_time
+
+# -------------------------------------------------------------------
+# Compute screen dimensions once
+# -------------------------------------------------------------------
+_root = tk.Tk()
+_root.withdraw()
+_root.update_idletasks()
+_SCREEN_DIMS = (_root.winfo_screenwidth(), _root.winfo_screenheight())
+try:
+    _root.destroy()
+except tk.TclError:
+    pass
+
+
+def _visualize_phases(
+    dataframe: pd.DataFrame,
+    start_time: float = 0.0,
+    end_time: float = 1e50,
+    segment_id_cols: list[str] = None,
+    segment_colors: (dict[str, str] | list[str]) = None,
+    segment_alpha: float = 0.3,
+    columns_to_visualize: list[str] = None,
+    line_colors: dict[str, str] = None,
+    y_axis_ranges: dict[str, tuple[float, float]] = None,
+    use_lines_for_segments: bool = True,
+    show_column_names: bool = True,
+    show_time: bool = True,
+    show_id: bool = True,
+    width_height_ratio: list[float, float] = None,
+    show_runtime: bool = True,
+    show_grid: bool = False,
+) -> None:
+    """
+    Visualizes the given dataframe by plotting all columns over time.
+
+    Parameters:
+        dataframe (pd.DataFrame): The dataframe to be visualized.
+        start_time (float, optional): The start time of the visualization. Defaults to 0.0.
+        end_time (float, optional): The end time of the visualization. Defaults to 1e50.
+        segment_id_cols (list[str], optional): The columns of the dataframe to be used as segment IDs. Defaults to None.
+        segment_colors (dict[str, str] | list[str], optional): The colors to be used for the segments. Defaults to None.
+        segment_alpha (float, optional): The alpha value of the segment backgrounds. Defaults to 0.3.
+        columns_to_visualize (list[str], optional): The columns of the dataframe to be visualized. Defaults to ['Voltage[V]', 'Current[A]', 'Power[W]'].
+        line_colors (dict[str, str], optional): The colors to be used for the lines. Defaults to None.
+        y_axis_ranges (dict[str, tuple[float, float]], optional): The ranges of the y-axis. Defaults to None.
+        use_lines_for_segments (bool, optional): Whether to use lines for the segments. Defaults to True.
+        show_column_names (bool, optional): Whether to show the column names. Defaults to True.
+        show_time (bool, optional): Whether to show the time. Defaults to True.
+        show_id (bool, optional): Whether to show the ID. Defaults to True.
+        width_height_ratio (list[float, float], optional): The ratio of the width to the height of the figure. Defaults to [1.0, 0.3].
+        show_runtime (bool, optional): Whether to show the runtime. Defaults to True.
+        show_grid (bool, optional): Whether to show the grid. Defaults to False.
+
+    Returns:
+        None
+    """
+    # Set default values for mutable data structures
+    if columns_to_visualize is None:
+        columns_to_visualize = ["Voltage[V]", "Current[A]", "Power[W]"]
+    if width_height_ratio is None:
+        width_height_ratio = [1.0, 0.3]
+
+    # 1) Filter by time
+    with log_time("filtering by time", show_runtime):
+        mask = pd.Series(True, index=dataframe.index)
+        if start_time is not None:
+            mask &= dataframe["Test_Time[s]"] >= start_time
+        if end_time is not None:
+            mask &= dataframe["Test_Time[s]"] <= end_time
+        df = dataframe.loc[mask]
+
+    # 2) Normalize line colors and y-axis ranges
+    with log_time("normalizing colors and y-axis ranges", show_runtime):
+        line_colors = line_colors or {}
+        y_axis_ranges = y_axis_ranges or {}
+
+    # 3) Map segment colors to `Variable` values
+    with log_time("mapping segment colors", show_runtime):
+        segment_colors = {var: col for var, col in zip(segment_id_cols, segment_colors, strict=False)}
+
+    # 4) Set up figure
+    with log_time("setting up figure", show_runtime):
+        screen_w, screen_h = _SCREEN_DIMS
+        dpi = plt.rcParams["figure.dpi"]
+        fig_w, fig_h = (screen_w * width_height_ratio[0]) / dpi, (screen_h * width_height_ratio[1]) / dpi
+
+        plt.ioff()
+        fig, ax_base = plt.subplots(figsize=(fig_w, fig_h))
+        axes = {}
+        offset = 0.02
+
+        for idx, col in enumerate(columns_to_visualize):
+            if idx == 0:
+                ax = ax_base
+            elif idx == 1:
+                ax = ax_base.twinx()
+            else:
+                ax = ax_base.twinx()
+                ax.spines["right"].set_position(("axes", 1 + offset))
+                ax.spines["right"].set_visible(True)
+                ax.yaxis.set_label_position("right")
+                ax.yaxis.set_ticks_position("right")
+                offset += 0.05
+
+            ax.set_ylabel(col, color=line_colors.get(col))
+            ax.tick_params(axis="y", labelcolor=line_colors.get(col))
+            if col in y_axis_ranges:
+                ax.set_ylim(*y_axis_ranges[col])
+            axes[col] = ax
+            fig.subplots_adjust(right=1 + offset + 0.05)
+
+    # 5) Plot data
+    with log_time("plotting data", show_runtime):
+        t = df["Test_Time[s]"]
+        for col in columns_to_visualize:
+            if col in df.columns:
+                axes[col].plot(t, df[col], label=col, color=line_colors.get(col))
+
+    # 6) Group segments by ID + Variable
+    with log_time("grouping segments by ID + Variable", show_runtime):
+        stats = df.groupby(["ID", "Variable"])["Test_Time[s]"].agg(tmin="min", tmax="max").reset_index()
+
+    y0, y1 = ax_base.get_ylim()
+    height = y1 - y0
+
+    # 7) Draw segment backgrounds and labels
+    with log_time("drawing segment backgrounds and labels", show_runtime):
+        intervals = []
+        colors = []
+        vline_positions = []
+        mid_y = (y0 + y1) / 2
+
+        for _, row in stats.iterrows():
+            tmin, tmax = row["tmin"], row["tmax"]
+            duration = tmax - tmin
+            variable = row["Variable"]
+            color = segment_colors.get(variable, "gray")
+
+            intervals.append((tmin, duration))
+            colors.append(color)
+
+            if use_lines_for_segments:
+                vline_positions.append(tmin)
+
+        # Draw all backgrounds at once
+        ax_base.broken_barh(intervals, (y0, height), facecolors=colors, alpha=segment_alpha)
+
+        # Draw all vertical lines at once
+        if use_lines_for_segments and vline_positions:
+            ax_base.vlines(vline_positions, y0, y1, colors="k", alpha=segment_alpha)
+
+        # Draw text labels (still per segment, this is usually okay)
+        for _, row in stats.iterrows():
+            tmin, tmax = row["tmin"], row["tmax"]
+            duration = tmax - tmin
+            x_center = tmin + duration / 2
+            variable = row["Variable"]
+            id = row["ID"]
+
+            label_parts = []
+            if show_id:
+                label_parts.append(f"ID:{id}")
+            if show_column_names:
+                label_parts.append(f"{variable}")
+            if show_time:
+                label_parts.append(f"{duration:.1f}s")
+
+            label = "  ".join(label_parts)
+
+            ax_base.text(x_center, mid_y, label, ha="center", va="center", rotation=90, size=10)
+
+    # 8) Adding grid and legend
+    with log_time("adding grid and legend", show_runtime):
+        # TODO power labels multiple times shown fix?
+        ax_base.set_xlabel("Testtime [s]")
+        legend_handles, legend_labels = [], []
+        for ax in axes.values():
+            handles, labels = ax.get_legend_handles_labels()
+            legend_handles += handles
+            legend_labels += labels
+        if handles:
+            ax_base.legend(legend_handles, legend_labels, loc="upper left")
+        if show_grid:
+            ax_base.grid()
+        plt.tight_layout()
+
+
+# TODO: Docstring
+def visualize_phases(
+    dataframe: pd.DataFrame,
+    start_time: float = None,
+    end_time: float = None,
+    visualize_phases_config: list[tuple[str, str]] = None,
+    segment_alpha: float = 0.3,
+    line_visualization_config: list[tuple[str, str, tuple[float, float]]] = None,
+    use_lines_for_segments: bool = True,
+    show_column_names: bool = True,
+    show_time: bool = True,
+    show_id: bool = True,
+    width_height_ratio: tuple[float, float] | list[float] = None,
+    show_runtime: bool = True,
+) -> None:
+    # Set default values for mutable data structures
+    if visualize_phases_config is None:
+        visualize_phases_config = [
+            ("V", "blue"),
+            ("I", "red"),
+            ("P", "green"),
+        ]
+    if line_visualization_config is None:
+        line_visualization_config = [
+            ("Voltage[V]", "blue", (2.3, 4.3)),
+            ("Current[A]", "red", (-10, 10)),
+            # ("Power[W]", "green", (-40, 40)),
+        ]
+    if width_height_ratio is None:
+        width_height_ratio: float = [1.0, 0.3]
+
+    if start_time is None:
+        logging.warning("start_time is None - setting it to 0.0")
+        start_time = 0.0
+    if end_time is None:
+        logging.warning("end_time is None - setting it to the biggest possible float")
+        end_time = float("inf")
+    if dataframe is None:
+        raise ValueError("dataframe is None")
+    if not isinstance(dataframe, pd.DataFrame):
+        raise TypeError("dataframe must be a pandas DataFrame")
+    if not (isinstance(width_height_ratio, list | tuple) and len(width_height_ratio) == 2):
+        raise ValueError("width_height_ratio must be a list or tuple of length 2")
+    if "Test_Time[s]" not in dataframe.columns:
+        raise ValueError("dataframe needs to have at least column 'Test_Time[s]'")
+    if "ID" not in dataframe.columns:
+        raise ValueError("dataframe needs to have at least column 'ID'")
+    if not isinstance(visualize_phases_config, list):
+        raise TypeError("visualize_phases_config must be a list")
+    if not isinstance(line_visualization_config, list):
+        raise TypeError("line_visualization_config must be a list")
+    if start_time >= end_time:
+        raise ValueError(f"start_time ({start_time}) must be less than end_time ({end_time})")
+    if not (0 <= segment_alpha <= 1):
+        logging.warning("segment_alpha must be between 0 and 1 - resetting it now to 0.3")
+        segment_alpha = 0.3
+
+    if start_time is None:
+        start_time = dataframe["Test_Time[s]"].min()
+    if end_time is None:
+        end_time = dataframe["Test_Time[s]"].max()
+
+    segment_id_cols = [col for col, _ in visualize_phases_config]
+    segment_colors = [color for _, color in visualize_phases_config]
+    columns_to_visualize = [col for col, _, _ in line_visualization_config]
+    line_colors = {col: color for col, color, _ in line_visualization_config}
+    y_axis_ranges = {col: y_range for col, _, y_range in line_visualization_config}
+
+    if not isinstance(segment_id_cols, list):
+        raise TypeError("segment_id_cols must be a list of strings")
+    if not isinstance(segment_colors, list | dict):
+        raise TypeError("segment_colors must be a list or dict")
+    if isinstance(segment_colors, list) and len(segment_id_cols) != len(segment_colors):
+        raise ValueError("segment_id_cols and segment_colors must have the same length")
+    if not isinstance(columns_to_visualize, list):
+        raise TypeError("columns_to_visualize must be a list")
+
+    _visualize_phases(
+        dataframe=dataframe,
+        start_time=start_time,
+        end_time=end_time,
+        segment_id_cols=segment_id_cols,
+        segment_colors=segment_colors,
+        segment_alpha=segment_alpha,
+        columns_to_visualize=columns_to_visualize,
+        line_colors=line_colors,
+        y_axis_ranges=y_axis_ranges,
+        use_lines_for_segments=use_lines_for_segments,
+        show_column_names=show_column_names,
+        show_time=show_time,
+        show_id=show_id,
+        width_height_ratio=width_height_ratio,
+        show_runtime=show_runtime,
+    )

pydpeet/res/__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/utils/__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/utils/logging_style.py

@@ -0,0 +1,28 @@
+import logging
+
+
+def set_logging_style(
+    level="WARNING", formatting_string="%(levelname)s | %(pathname)s:%(lineno)d | %(message)s"
+) -> None:
+    """
+    Sets up on import the logging configuration to use the specified level and a custom format.
+
+    The logging configuration is set to use the specified level. The format of the
+    messages is set to '<levelname> | <pathname>:<lineno> | <message>'.
+
+    Parameters
+    ----------
+    level : int, optional
+        The logging level to use. Defaults to logging.WARNING.
+    formatting_string : str, optional
+        The formatting string to use for the log messages. Defaults to
+        '%(levelname)s | %(pathname)s:%(lineno)d | %(message)s'.
+
+    Returns
+    -------
+    None
+    """
+    if isinstance(level, str):
+        level = getattr(logging, level)
+
+    logging.basicConfig(level=level, format=formatting_string, force=True)

pydpeet-0.2.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: PyDPEET
+Version: 0.2.0
+Summary: Python package to read, unify, and convert battery measurement data from arbitrary battery cyclers to Parquet files. This package also provides functions to process, evaluate, and visualise the standardised data.
+Author: Alexander Günter Hinrichsen, Jan Kalisch, Daniel Schröder, Cataldo De Simone
+Author-email: Anton Schlösser <a.schloesser@tu-berlin.de>, Martin Otto <m.otto.1@tu-berlin.de>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+License-File: AUTHORS.md
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: pyarrow
+Requires-Dist: python-calamine
+Requires-Dist: numba
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: bibtexparser
+Requires-Dist: scikit-learn
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: pydata-sphinx-theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: bibtexparser; extra == "docs"
+Dynamic: license-file
+
+# PyDPEET - Fast and Easy Battery Data Unification, Processing, and Analysis
+
+[[_TOC_]]
+
+## Disclaimer
+
+This README is still under (re-)construction due to changes in the codebase.
+
+## Description
+
+<!-- This project enables you to convert battery measurement data to a standardized format.
+
+Cycler output their measurement data in different formats and different file types, like for example .csv and .xslx. Each has to be handled differently which makes it difficult to work with the data and that's the reason why we created a standardized format.
+The standardized Data and Metadata can be used inside of the code and can be output as a .csv (Data), .xlsx (Data) or parquet(Data) to a output_path of your choosing.
+
+Keeping additional data outside of our definition of the standardized columns and custom cycler handling is also possible. -->
+
+
+## Standardised Format
+
+The standard columns are defined as follows:
+
+```python
+STANDARD_COLUMNS = [
+    "Meta_Data",
+    "Step_Count",
+    "Voltage[V]",
+    "Current[A]",
+    "Temperature[°C]",
+    "Test_Time[s]",
+    "Date_Time",
+    "EIS_f[Hz]",
+    "EIS_Z_Real[Ohm]",
+    "EIS_Z_Imag[Ohm]",
+    "EIS_DC[A]"
+]
+```
+
+## Meta data
+
+## Supported Cyclers
+
+## Installation
+
+### For Developers
+
+#### Rebuild package for "pip"
+
+#### How to renew the documentation after implementing new functions
+
+### For Users
+
+## Usage
+
+## Custom Handling of Cycler
+
+## How to add a Custom Handling to the Project