PyDPEET 0.2.0__py3-none-any.whl

pydpeet/io/utils/formatter_utils.py

@@ -0,0 +1,429 @@
+import logging
+
+import numpy as np
+import pandas as pd
+
+
+def typecast(
+    df: pd.DataFrame,
+    column_name: str,
+    datatype,
+) -> pd.DataFrame:
+    """
+    Try to typecast a column in a DataFrame to a given type.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame to be modified
+    column_name : str
+        Name of the column to be typecast
+    datatype : type
+        datatype to which the column should be typecast
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    try:
+        if df is None:
+            raise ValueError(f"{df} is None")
+        if column_name is None:
+            raise ValueError(f"{column_name} is None")
+        if datatype is None:
+            raise ValueError(f"{datatype} is None")
+        if type(column_name) is not str:
+            raise ValueError(f"{column_name} is not a string")
+        if column_name not in df.columns:
+            raise ValueError(f"{column_name} is not in {df.columns}")
+        df[column_name] = df[column_name].astype(datatype)
+    except Exception:
+        logging.warning(f"Error converting column:{column_name} to {datatype.__name__}")
+
+    return df
+
+
+def testtime_hours_to_seconds_with_string_interpretation(
+    df: pd.DataFrame,
+    astype_string: bool,
+) -> pd.DataFrame:
+    """
+    Convert "Test_Time[s]" column from hours to seconds with string interpretation. (assumes hours are in "HH:MM:SS.MS" format)
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame to be modified
+    astype_string : bool, optional
+        Whether to convert the column to string type before applying the
+        conversion function. This is useful if the column contains both numeric
+        and string values.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    try:
+        if df is None:
+            raise ValueError(f"{df} is None")
+        if not isinstance(astype_string, bool):
+            raise ValueError(f"{astype_string} is not a boolean")
+        if "Test_Time[s]" not in df.columns:
+            raise ValueError(f"Test_Time[s] is not in {df.columns}")
+        if astype_string:
+            df["Test_Time[s]"] = df["Test_Time[s]"].astype(str).apply(_time_to_seconds)
+        else:
+            df["Test_Time[s]"] = df["Test_Time[s]"].apply(_time_to_seconds)
+    except Exception:
+        logging.warning("Error fixing Test_Time[s]")
+
+    return df
+
+
+def _time_to_seconds(time: str) -> float | None:
+    """
+    Convert a time string from the format "HH:MM:SS" to a total number of seconds.
+
+    Parameters
+    ----------
+    time : str
+        Time string to be converted, expected in the format "HH:MM:SS".
+        If the input is not in this format, attempts to convert it to a float.
+
+    Returns
+    -------
+    float
+        Total time in seconds. If the input is None or cannot be split into
+        hours, minutes, and seconds, returns the input as a float.
+
+    Raises
+    ------
+    ValueError
+        If the input time is None.
+    """
+    try:
+        if time is None:
+            raise ValueError(f"{time} is None")
+        h, m, s = time.split(":")
+        return float(s) + int(m) * 60 + int(h) * 3600
+    except Exception:
+        if time is None:
+            return time
+        return float(time)
+
+
+def apply_convert_to_float_if_possible(
+    df: pd.DataFrame,
+    column_name: str,
+) -> pd.DataFrame:
+    """
+    Apply a function to a DataFrame column that tries to convert its values to float if possible.
+
+    This function tries to convert the values to a float, and returns the value as a
+    float if successful. If not successful, the value is returned as is.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame containing the column to be modified.
+    column_name : str
+        Name of the column in the DataFrame to be modified.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame with the column converted to float if possible.
+    """
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if column_name is None:
+            raise ValueError("column_name is None")
+        if column_name not in df.columns:
+            raise ValueError(f"{column_name} is not in {df.columns}")
+        df[column_name] = df[column_name].apply(_convert_to_float_if_possible)
+    except Exception:
+        logging.warning(f"Error applying convert_to_float_if_possible for {column_name}")
+
+    return df
+
+
+def _convert_to_float_if_possible(x) -> float:
+    """
+    Try to convert a value to a float if possible.
+
+    This function takes a value, and tries to convert it to a float. If the
+    conversion is successful, the function returns the value as a float. If
+    not successful, the value is returned as is.
+
+    Parameters
+    ----------
+    x : any
+        Value to be converted to a float if possible.
+
+    Returns
+    -------
+    any
+        Value converted to a float if possible, otherwise the original value.
+
+    """
+    try:
+        return np.float64(x)
+    except (ValueError, TypeError):
+        return x
+
+
+def replace_empty_with_none_in_standard_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Replace empty strings with None in the columns specified in src.convert.STANDARD_COLUMNS.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame to be modified
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    from pydpeet.io.convert import STANDARD_COLUMNS
+
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if df.empty:
+            raise ValueError("dataframe is empty")
+        df[STANDARD_COLUMNS] = df[STANDARD_COLUMNS].replace("", None)
+    except Exception as e:
+        logging.warning(f"Error replacing empty with None. Reason: {e}")
+
+    return df
+
+
+def testtime_hours_to_seconds_direct(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Convert "Test_Time[s]" column from hours to seconds.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame to be modified
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame
+    """
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if "Test_Time[s]" not in df.columns:
+            raise ValueError("Test_Time[s] is not in dataFrame.columns")
+        df["Test_Time[s]"] = df["Test_Time[s]"].apply(_convert_to_hours_to_seconds_direct_if_possible)
+    except Exception as e:
+        logging.warning(f"Error fixing Test_Time[s] (converting hours to seconds). Reason: {e}")
+
+    return df
+
+
+def _convert_to_hours_to_seconds_direct_if_possible(x) -> float:
+    # TODO: Docstring
+    try:
+        return np.float64(x) * 3600
+    except (ValueError, TypeError):
+        return x
+
+
+def round_testtime(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Round the values in the "Test_Time[s]" column of the DataFrame to 5 decimal places.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame containing the "Test_Time[s]" column to be rounded.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame with rounded "Test_Time[s]" values.
+    """
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if df.empty:
+            raise ValueError("dataframe is empty")
+        if "Test_Time[s]" not in df.columns:
+            raise ValueError("Test_Time[s] is not in dataFrame.columns")
+
+        df["Test_Time[s]"] = round(df["Test_Time[s]"].astype(float), 5)
+    except Exception as e:
+        logging.warning(f"Error fixing Test_Time[s] (rounding). Reason: {e}")
+
+    return df
+
+
+def nan_to_none_in_column(
+    df: pd.DataFrame,
+    column_name: str,
+) -> pd.DataFrame:
+    """
+    Replace NaN values in a DataFrame column (column_name) with None.
+
+    Parameters
+    ----------
+    dataFrame : pandas.DataFrame
+        DataFrame containing the column to be modified.
+    column_name : str
+        Name of the column in the DataFrame to be modified.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame with NaN values replaced with None.
+    """
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if column_name is None:
+            raise ValueError("column_name is None")
+        if type(column_name) is not str:
+            raise ValueError("column_name is not a string")
+        if column_name not in df.columns:
+            raise ValueError(f"{column_name} is not in {df.columns}")
+        df[column_name] = df[column_name].replace({np.nan: None})
+    except Exception:
+        logging.warning(f"Error fixing {column_name} (replacing NaN with None)")
+
+    return df
+
+
+def move_strings_from_column_to_metadata(
+    df: pd.DataFrame,
+    column_name: str,
+) -> pd.DataFrame:
+    """
+    Move strings from a column into the "Meta_Data" column and replace them with None.
+
+    This function takes a DataFrame and a column name as input, and moves all strings in that column to the
+    "Meta_Data" column. The strings are joined together with a newline character and added to the existing
+    "Meta_Data" content. The original column is then replaced with None values.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame containing the column to be modified.
+    column_name : str
+        Name of the column in the DataFrame to be modified.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame with strings moved to "Meta_Data" and replaced with None in the original column.
+    """
+    concatenated_string = "\n"
+    try:
+        if df is None:
+            raise ValueError("dataFrame is None")
+        if not isinstance(column_name, str):
+            raise ValueError(f"column_name is not a string. Type is {type(column_name)}")
+        if column_name not in df.columns:
+            raise ValueError(f"{column_name} is not in {df.columns}")
+        if "Meta_Data" not in df.columns:
+            raise ValueError("Meta_Data Column doesn't exsist")
+
+        strings = df[column_name].apply(lambda x: x if isinstance(x, str) else None)
+        concatenated_string = concatenated_string.join(filter(None, strings))
+
+        df.loc[0, "Meta_Data"] = str(df.loc[0, "Meta_Data"]) + "\n\n" + concatenated_string
+        df[column_name] = df[column_name].apply(lambda x: None if isinstance(x, str) else x).astype(object)
+        df[column_name] = df[column_name].replace({np.nan: None})
+    except Exception:
+        logging.warning("Error adding Messages to Meta_Data")
+
+    return df
+
+
+def fix_time_format(
+    df: pd.DataFrame,
+    input_format: str = None,
+) -> pd.DataFrame:
+    """
+    Fix the format of the "Date_Time" column.
+
+    This function takes a DataFrame and an optional input format as input, and
+    attempts to convert the "Date_Time" column to a
+    datetime object using the given input format. If the input format is not
+    given, the function will try to infer the format from the data. The
+    resulting datetime object is then formatted as a string in the format
+    '%Y-%m-%d %H:%M:%S' and replaces the original column.
+    Fills empty parts with pandas.NaT.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame containing the column to be modified.
+    input_format : str, optional
+        Format string to use when converting the column to a datetime object.
+        If not given, the function will try to infer the format from the data.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Modified DataFrame with the "Date_Time" column
+        converted to the correct format.
+    """
+    column_name = "Date_Time"
+
+    try:
+        if df is None:
+            raise ValueError("data_frame is None")
+        if not isinstance(input_format, str):
+            raise ValueError(f"input_format is not a string. Type is {type(column_name)}")
+        if column_name not in df.columns:
+            raise ValueError(f"{column_name} is not in {df.columns}")
+        if "Date_Time" not in df.columns:
+            raise ValueError("Date_Time Column doesn't exsist")
+        try:
+            df[column_name] = pd.to_datetime(df[column_name], format=input_format, errors="coerce")
+        except Exception:
+            raise ValueError("Error changing to datetime") from None
+        try:
+            df[column_name] = df[column_name].dt.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            raise ValueError("Error changing to correct order in Timeformat") from None
+    except Exception:
+        logging.warning("Error fixing timeformat Date_Time")
+
+    return df
+
+
+def absolute_time_timedate_typecast(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Convert the "Date_Time" column in the DataFrame to a datetime object.
+
+    This function attempts to typecast the specified column in the DataFrame to a pandas datetime object.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        The DataFrame containing the column to be converted.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The DataFrame with the "Date_Time" column converted to datetime objects.
+    """
+    try:
+        if df is None:
+            raise ValueError("data_frame is None")
+        if "Date_Time" not in df.columns:
+            raise ValueError("Date_Time Column doesn't exsist")
+        df["Date_Time"] = pd.to_datetime(df["Date_Time"], errors="coerce")
+    except Exception:
+        logging.warning("Error typecasting Date_Time")
+
+    return df

pydpeet/io/utils/load_custom_module.py

@@ -0,0 +1,33 @@
+import os
+from importlib.util import (
+    module_from_spec,
+    spec_from_file_location,
+)
+from types import ModuleType
+
+
+def load_custom_module(
+    folder_path: str,
+    module_name: str,
+) -> ModuleType:
+    """
+    Loads a custom Python module from a specified folder.
+
+    Parameters:
+    folder_path (str): The path to the folder containing the module file.
+    module_name (str): The name of the module to load (without the .py extension).
+
+    Returns:
+    module: The loaded Python module object.
+
+    Raises:
+    FileNotFoundError: If the module file does not exist in the specified folder.
+    """
+    module_path = os.path.join(folder_path, f"{module_name}.py")
+    if not os.path.exists(module_path):
+        raise FileNotFoundError(f"Module {module_name}.py not found in the specified folder: {folder_path}")
+    spec = spec_from_file_location(module_name, module_path)
+    module = module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    return module

pydpeet/io/utils/timing.py

@@ -0,0 +1,36 @@
+import logging
+import time
+from typing import Any
+
+
+def measure_time(func) -> Any:
+    """
+    A decorator that measures the execution time of a function.
+
+    Args:
+        func (Callable): The function whose execution time is to be measured.
+
+    Returns:
+        Callable: A wrapped function that, when called, executes the original
+        function and prints the time taken to execute it.
+    """
+
+    def wrapper(*args, **kwargs) -> Any:
+        """
+        A wrapped function that, when called, executes the original function and prints the time taken to execute it.
+
+        Args:
+            *args (Any): The arguments to be passed to the original function.
+            **kwargs (Any): The keyword arguments to be passed to the original function.
+
+        Returns:
+            Any: The result of the original function.
+        """
+        start_time = time.perf_counter()
+        result = func(*args, **kwargs)
+        end_time = time.perf_counter()
+        logging.info(f"{func.__name__} executed in {end_time - start_time:.6f} seconds")
+
+        return result
+
+    return wrapper

pydpeet/io/write.py

@@ -0,0 +1,99 @@
+import logging
+import os
+
+import pandas as pd
+
+from pydpeet.io.configs.config import DataOutputFiletype
+
+
+# TODO:
+# Adjust to accept dataframes or lists of dataframes
+# or write dedicated wrapper for list inputs
+def write(
+    data_input: pd.DataFrame,
+    output_path: str,
+    output_file_name: str,
+    data_output_filetype: DataOutputFiletype = DataOutputFiletype.parquet,
+) -> None:
+    """
+    Export the given DataFrame to the given output path.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        DataFrame to be exported.
+    output_path : str
+        Path to the directory where the file will be saved. Must exist.
+    output_file_name : str
+        Name of the file to be saved.
+    data_output_filetype : DataOutputFiletype, optional
+        The file type to use when exporting the DataFrame. Defaults to
+        DataOutputFiletype.parquet.
+
+    Raises
+    ------
+    ValueError
+        If data_frame is None, or if output_path or output_file_name are None.
+    TypeError
+        If data_frame is not a pandas.DataFrame, or if data_output_filetype is not
+        a DataOutputFiletype.
+    """
+    if data_input is None:
+        raise ValueError("data_frame is None")
+    if not isinstance(data_input, pd.DataFrame):
+        raise TypeError(f"data_frame is not a pandas.DataFrame, but {type(data_input)}")
+    if output_path is None:
+        raise ValueError("output_path is None")
+    if not isinstance(output_path, str):
+        raise ValueError(f"output_path is not a string, but {type(output_path)}")
+    if output_file_name is None:
+        raise ValueError("output_file_name is None")
+    if not isinstance(output_file_name, str):
+        raise ValueError(f"output_file_name is not a string, but {type(output_file_name)}")
+    if data_output_filetype is None:
+        raise ValueError("data_output_filetype is None")
+    if not isinstance(data_output_filetype, DataOutputFiletype):
+        raise ValueError(f"data_output_filetype is not a DataOutputFiletype, but {type(data_output_filetype)}")
+
+    abs_path = os.path.abspath(output_path)
+
+    if not os.path.exists(abs_path):
+        os.makedirs(abs_path)
+
+    _do_export(data_input, os.path.join(abs_path, output_file_name), data_output_filetype)
+
+
+def _do_export(
+    df: pd.DataFrame,
+    output_path: str,
+    data_output_filetype: DataOutputFiletype,
+) -> None:
+    """
+    Export a DataFrame to a file in the specified format.
+
+    This function exports the given DataFrame to a file at the specified output
+    path in the format specified by data_output_filetype. The function supports
+    exporting to Parquet, CSV, and XLSX file formats.
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        The DataFrame to be exported.
+    output_path : str
+        The path (excluding file extension) where the file will be saved.
+    data_output_filetype : DataOutputFiletype
+        The format in which to export the DataFrame. Can be one of
+        DataOutputFiletype.parquet, DataOutputFiletype.csv, or
+        DataOutputFiletype.xlsx.
+    """
+    logging.info(f"exporting to {output_path}")
+    match data_output_filetype:
+        case DataOutputFiletype.parquet:
+            full_output_path = f"{output_path}_Data.parquet"
+            df.to_parquet(full_output_path, index=False, engine="pyarrow")
+        case DataOutputFiletype.csv:
+            full_output_path = f"{output_path}_Data.csv"
+            df.to_csv(full_output_path, index=False)
+        case DataOutputFiletype.xlsx:
+            full_output_path = f"{output_path}_Data.xlsx"
+            df.to_excel(full_output_path, index=False)

pydpeet/process/__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/analyze/__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__ = []