PyDPEET 0.2.0__py3-none-any.whl

pydpeet/io/device/zahner/formatter.py

@@ -0,0 +1,73 @@
+import pandas as pd
+
+from pydpeet.io.utils.formatter_utils import nan_to_none_in_column, round_testtime, typecast
+
+
+def get_data_into_format_zahner_1(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Format a DataFrame in the format of a Zahner EIS file, type 1.
+
+    The DataFrame is modified in-place.
+
+    The modifications are as follows:
+
+    - The "Test_Time[s]" column is rounded to 5 decimal places.
+    - NaN values in the "Test_Time[s]" column are replaced with None.
+    - The "Step_Count" column is typecast to int.
+    - The "EIS_f[Hz]" column is typecast to float.
+    - The "EIS_Z_Real[Ohm]" column is typecast to float.
+    - The "EIS_Z_Imag[Ohm]" column is typecast to float.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame to be modified.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame.
+    """
+    df = round_testtime(df)
+    df = nan_to_none_in_column(df, "Test_Time[s]")
+    typecast(df, "Step_Count", int)
+    typecast(df, "EIS_f[Hz]", float)
+    typecast(df, "EIS_Z_Real[Ohm]", float)
+    typecast(df, "EIS_Z_Imag[Ohm]", float)
+
+    return df
+
+
+def get_data_into_format_zahner_2(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Format a DataFrame in the format of a Zahner EIS file, type 2.
+
+    The DataFrame is modified in-place.
+
+    The modifications are as follows:
+
+    - The "Test_Time[s]" column is rounded to 5 decimal places.
+    - NaN values in the "Test_Time[s]" column are replaced with None.
+    - The "Step_Count" column is typecast to int.
+    - The "Voltage[V]" column is typecast to float.
+    - The "Current[A]" column is typecast to float.
+    - The "Test_Time[s]" column is typecast to float.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame to be modified.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame.
+    """
+    df = round_testtime(df)
+    df = nan_to_none_in_column(df, "Test_Time[s]")
+    typecast(df, "Step_Count", int)
+    typecast(df, "Voltage[V]", float)
+    typecast(df, "Current[A]", float)
+    typecast(df, "Test_Time[s]", float)
+
+    return df

pydpeet/io/device/zahner/mapper.py

@@ -0,0 +1,34 @@
+# Map raw-data column names (left) to standardized column names (right)
+COLUMN_MAP_1 = {
+    "Frequency/Hz": "EIS_f[Hz]",
+    "Number": "Step_Count",
+    r"R/": "EIS_Z_Real[Ohm]",
+    r"I/": "EIS_Z_Imag[Ohm]",
+}
+
+COLUMN_MAP_2 = {
+    "step": "Step_Count",
+    "voltage V": "Voltage[V]",
+    "time s": "Test_Time[s]",
+    "current A": "Current[A]",
+}
+
+# Default columns of the standardized format
+# which are not present in the raw data files.
+MISSING_REQUIRED_COLUMNS_1 = [
+    "Test_Time[s]",
+    "Voltage[V]",
+    "Current[A]",
+    "Date_Time",
+    "Temperature[°C]",
+    "EIS_DC[A]",
+]
+
+MISSING_REQUIRED_COLUMNS_2 = [
+    "EIS_DC[A]",
+    "Temperature[°C]",
+    "Date_Time",
+    "EIS_f[Hz]",
+    "EIS_Z_Real[Ohm]",
+    "EIS_Z_Imag[Ohm]",
+]

pydpeet/io/device/zahner/reader.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+
+def to_dataframe(input_path: str) -> tuple[pd.DataFrame, str]:
+    """
+    Parses the input file from the new Zahner Cycler into a pandas DataFrame.
+
+    Parameters:
+    input_path (str): Path to the input file.
+
+    Returns:
+    (pd.DataFrame, str): A tuple containing the DataFrame with data and metadata as a string.
+    """
+    metadata = []
+
+    # Open the file and process lines
+    with open(input_path, encoding="us-ascii") as file:
+        # Read metadata until a data header line is detected
+        line = file.readline()
+        while not (line.strip().startswith("time") or line.strip().startswith("Number")):
+            metadata.append(line.strip())
+            line = file.readline()
+
+        # Detect delimiter and process the header
+        if ";" in line:
+            delimiter = ";"
+        elif "," in line:
+            delimiter = ","
+        else:
+            delimiter = None  # Whitespace-delimited
+
+        # Read and parse data lines
+        if delimiter:
+            headers = line.strip().split(delimiter)
+            data_lines = [row.strip().split(delimiter) for row in file if row.strip()]
+        else:
+            headers = line.strip().split()
+            data_lines = [row.strip().split() for row in file if row.strip()]
+
+    # Join metadata into a single string
+    metadata_str = "\n".join(metadata)
+
+    # Create DataFrame
+    df = pd.DataFrame(data_lines, columns=headers)
+
+    return df, metadata_str

pydpeet/io/device/zahner_new/__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/io/device/zahner_new/formatter.py

@@ -0,0 +1,72 @@
+import pandas as pd
+
+from pydpeet.io.utils.formatter_utils import nan_to_none_in_column, round_testtime, typecast
+
+
+def get_data_into_format_zahner_1(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Rounds the values in the "Test_Time[s]" column of the DataFrame to 5 decimal places, replaces NaN values with None, and typecasts the "Step_Count" and "EIS_f[Hz]" columns to int and float, respectively.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame to be modified
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    round_testtime(df)
+    nan_to_none_in_column(df, "Test_Time[s]")
+    typecast(df, "Step_Count", int)
+    typecast(df, "EIS_f[Hz]", float)
+
+    return df
+
+
+def get_data_into_format_zahner_2(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Rounds the values in the "Test_Time[s]" column of the DataFrame to 5 decimal places, replaces NaN values with None, and typecasts the "Step_Count", "Voltage[V]", and "Current[A]" columns to int, float, and float, respectively.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame to be modified
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    df = round_testtime(df)
+    df = nan_to_none_in_column(df, "Test_Time[s]")
+    typecast(df, "Step_Count", int)
+    typecast(df, "Voltage[V]", float)
+    typecast(df, "Current[A]", float)
+
+    return df
+
+
+def get_data_into_format_zahner_3(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Rounds the values in the "Test_Time[s]" column of the DataFrame to 5 decimal places, replaces NaN values with None, and typecasts the "Step_Count", "Voltage[V]", "Current[A]", and "EIS_f[Hz]" columns to int, float, float, and float, respectively.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame to be modified
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    df = round_testtime(df)
+    df = nan_to_none_in_column(df, "Test_Time[s]")
+    typecast(df, "Step_Count", int)
+    typecast(df, "Voltage[V]", float)
+    typecast(df, "Current[A]", float)
+    typecast(df, "EIS_f[Hz]", float)
+
+    return df

pydpeet/io/device/zahner_new/mapper.py

@@ -0,0 +1,50 @@
+# Map raw-data column names (left) to standardized column names (right)
+COLUMN_MAP_1 = {
+    r"Frequency/Hz": "EIS_f[Hz]",
+    "Number": "Step_Count",
+}
+
+COLUMN_MAP_2 = {
+    "step": "Step_Count",
+    "voltage V": "Voltage[V]",
+    "time s": "Test_Time[s]",
+    "current A": "Current[A]",
+}
+
+COLUMN_MAP_3 = {
+    "Number": "Step_Count",
+    "Voltage/V": "Voltage[V]",
+    "Current/A": "Current[A]",
+    "Time/s": "Test_Time[s]",
+    "Frequency/Hz": "EIS_f[Hz]",
+}
+
+# Default columns of the standardized format
+# which are not present in the raw data files.
+MISSING_REQUIRED_COLUMNS_1 = [
+    "Test_Time[s]",
+    "Voltage[V]",
+    "Current[A]",
+    "Date_Time",
+    "Temperature[°C]",
+    "EIS_DC[A]",
+    "EIS_Z_Real[Ohm]",
+    "EIS_Z_Imag[Ohm]",
+]
+
+MISSING_REQUIRED_COLUMNS_2 = [
+    "EIS_DC[A]",
+    "Temperature[°C]",
+    "Date_Time",
+    "EIS_f[Hz]",
+    "EIS_Z_Real[Ohm]",
+    "EIS_Z_Imag[Ohm]",
+]
+
+MISSING_REQUIRED_COLUMNS_3 = [
+    "Temperature[°C]",
+    "Date_Time",
+    "EIS_Z_Real[Ohm]",
+    "EIS_Z_Imag[Ohm]",
+    "EIS_DC[A]",
+]

pydpeet/io/device/zahner_new/reader.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+
+def to_dataframe(input_path: str) -> tuple[pd.DataFrame, str]:
+    """
+    Parses the input file from the Zahner Cycler into a pandas DataFrame.
+
+    Parameters:
+    input_path (str): Path to the input file.
+
+    Returns:
+    (pd.DataFrame, str): A tuple containing the DataFrame with data and metadata as a string.
+    """
+    metadata = []
+
+    # Open the file and process lines
+    with open(input_path, encoding="us-ascii") as file:
+        # Read metadata until a data header line is detected
+        line = file.readline()
+        while not (line.strip().startswith("time") or line.strip().startswith("Number")):
+            metadata.append(line.strip())
+            line = file.readline()
+
+        # Detect delimiter and process the header
+        if ";" in line:
+            delimiter = ";"
+        elif "," in line:
+            delimiter = ","
+        else:
+            delimiter = None  # Whitespace-delimited
+
+        # Read and parse data lines
+        if delimiter:
+            headers = line.strip().split(delimiter)
+            data_lines = [row.strip().split(delimiter) for row in file if row.strip()]
+        else:
+            headers = line.strip().split()
+            data_lines = [row.strip().split() for row in file if row.strip()]
+
+    # Join metadata into a single string
+    metadata_str = "\n".join(metadata)
+
+    # Create DataFrame
+    df = pd.DataFrame(data_lines, columns=headers)
+
+    return df, metadata_str

pydpeet/io/map.py

@@ -0,0 +1,69 @@
+import logging
+
+import pandas as pd
+
+from pydpeet.io.configs.config import STANDARD_COLUMNS
+
+
+def mapping(
+    df: pd.DataFrame,
+    column_map: dict,
+    missing_columns: list,
+) -> pd.DataFrame:
+    """
+    Renames and maps specific columns in the DataFrame to standardized names.
+    If a standardized column doesn't exist in the DataFrame, it is added with default None values.
+    Non-mapped columns will remain unchanged in the resulting DataFrame.
+
+    Parameters:
+    dataFrame (pandas.DataFrame): The input DataFrame to be processed.
+    column_map (dict): A dictionary mapping existing column names to new standardized names.
+    missing_columns (list): A list of column names to ensure their existence in the DataFrame.
+
+    Returns:
+    pandas.DataFrame: The updated DataFrame with standardized column names.
+
+    Assumptions:
+    column_map and missing_columns contain all standard columns
+    (If you want to rename more or add more columns do it after the conversion)
+    """
+    if df is None:
+        raise ValueError("dataFrame is None")
+    if column_map is None:
+        raise ValueError("column_map is None")
+    if missing_columns is None:
+        raise ValueError("missing_columns is None")
+    if type(df) is not pd.DataFrame:
+        raise ValueError("dataFrame is not a DataFrame")
+    if type(column_map) is not dict:
+        raise ValueError("column_map is not a dictionary")
+    if type(missing_columns) is not list:
+        raise ValueError("missing_columns is not a list")
+    standard_columns_excluding_metadata = [col for col in STANDARD_COLUMNS if not col.startswith("Meta_Data")]
+    if not all(col in list(column_map.values()) + missing_columns for col in standard_columns_excluding_metadata):
+        raise ValueError("column_map and missing_columns do not contain all standard columns")
+    if any(col not in STANDARD_COLUMNS for col in list(column_map.values()) + missing_columns):
+        raise ValueError("column_map and missing_columns contain columns that are not standard columns")
+
+    # Create a copy of the DataFrame to avoid modifying the original
+    df_copy = df.copy()
+
+    # Add missing columns with None values if they do not exist, and issue warnings
+    for missing in missing_columns:
+        if missing not in df_copy.columns:
+            logging.warning(f"Missing column: '{missing}'. Adding Collumn (with None values) named: '{missing}'.")
+            df_copy[missing] = None
+
+    # Warn if a column that should be mapped is missing and add it with None values
+    for original_col in column_map.keys():
+        if original_col not in df_copy.columns:
+            logging.warning(
+                f"Column to be mapped '{original_col}' does not exist in DataFrame. Adding it with None values."
+            )
+            df_copy[original_col] = None
+
+    # Rename the existing columns as per the column_map
+    # Columns not in the column_map will remain unchanged
+    df_copy.rename(columns=column_map, inplace=True)
+
+    return df_copy

pydpeet/io/read.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pandas as pd
+
+from pydpeet.io.configs.config import Config
+from pydpeet.io.convert import (
+    convert_file,
+    convert_files_in_directory,
+)
+
+ConfigLike = Config | str
+PathLike = str | Path
+
+
+def read(
+    config: ConfigLike,
+    input_path: object,
+    keep_all_additional_data: bool = False,
+    custom_folder_path: str = None,
+) -> pd.DataFrame | list[pd.DataFrame]:
+    # TODO: Docstring
+    if isinstance(input_path, str):
+        if os.path.isfile(input_path):
+            return convert_file(config, input_path, None, keep_all_additional_data, custom_folder_path)
+        elif os.path.isdir(input_path):
+            return convert_files_in_directory(config, input_path, None, keep_all_additional_data, custom_folder_path)
+        else:
+            raise ValueError("Input path is invalid!")
+    elif isinstance(input_path, list):
+        dfs = []
+        for input_item in input_path:
+            if isinstance(input_item, str):
+                if os.path.isfile(input_item):
+                    dfs.append(convert_file(config, input_item, None, keep_all_additional_data, custom_folder_path))
+                elif os.path.isdir(input_item):
+                    dfs.append(
+                        convert_files_in_directory(
+                            config, input_item, None, keep_all_additional_data, custom_folder_path
+                        )
+                    )
+                else:
+                    raise ValueError("Input path item is invalid!")
+            else:
+                raise ValueError("Input path item is of invalid type!")
+        return dfs
+    else:
+        raise ValueError("Input path is of invalid type!")

pydpeet/io/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/io/utils/ext_path.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+
+class ExtPath(Path):
+    @staticmethod
+    def is_not_valid(path: str | None) -> bool:
+        """
+        Checks if a given path is not valid.
+
+        Args:
+            path (str | None): The path to check.
+
+        Returns:
+            bool: True if the path is not valid; False otherwise.
+        """
+        return not ExtPath.is_valid(path)
+
+    @staticmethod
+    def is_valid(path: str | None) -> bool:
+        """
+        Checks if a given path is valid.
+
+        A path is valid if it is not None or empty and if it exists.
+
+        Args:
+            path (str | None): The path to check.
+
+        Returns:
+            bool: True if the path is valid; False otherwise.
+        """
+        return bool(path) and Path(path).exists()
+
+    def is_excel_file(self) -> bool:
+        return self.exists() and self.is_file() and self.suffix in (".xlsx", ".xls")