oafuncs 0.0.97.15__py3-none-any.whl → 0.0.97.17__py3-none-any.whl

oafuncs/oa_data.py

@@ -16,278 +16,217 @@ Python Version: 3.11
 import itertools
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
-
+from typing import Any, List, Union
 
 import numpy as np
 import salem
 import xarray as xr
+from rich import print
 from scipy.interpolate import griddata, interp1d
 
 __all__ = ["interp_along_dim", "interp_2d", "ensure_list", "mask_shapefile"]
 
 
-def ensure_list(input_data):
+def ensure_list(input_value: Any) -> List[str]:
     """
-    Ensures that the input is converted into a list.
+    Ensure the input is converted into a list.
 
-    If the input is already a list, it returns it directly.
-    If the input is a string, it wraps it in a list and returns.
-    For other types of input, it converts them to a string and then wraps in a list.
+    Args:
+        input_value (Any): The input which can be a list, a string, or any other type.
 
-    :param input_data: The input which can be a list, a string, or any other type.
-    :return: A list containing the input or the string representation of the input.
+    Returns:
+        List[str]: A list containing the input or the string representation of the input.
     """
-    if isinstance(input_data, list):
-        return input_data
-    elif isinstance(input_data, str):
-        return [input_data]
+    if isinstance(input_value, list):
+        return input_value
+    elif isinstance(input_value, str):
+        return [input_value]
     else:
-        # For non-list and non-string inputs, convert to string and wrap in a list
-        return [str(input_data)]
+        return [str(input_value)]
 
 
-def interp_along_dim(tgt_coords, src_coords, src_data, axis=-1, interp_method="linear", extrap_method="linear"):
+def interp_along_dim(
+    target_coordinates: np.ndarray,
+    source_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+    interpolation_axis: int = -1,
+    interpolation_method: str = "linear",
+    extrapolation_method: str = "linear",
+) -> np.ndarray:
     """
-    在指定维度上执行插值和外插操作。
-
-    Parameters:
-    -----------
-    tgt_coords: 1d array
-        目标坐标点数组，必须是一维数组。
-
-    src_coords: 1d or nd array
-        源坐标点数组。可以是一维数组（将被广播到与src_data匹配的形状）或与src_data相同形状的多维数组。
-
-    src_data: nd array
-        源数据数组，包含要从src_coords插值到tgt_coords的现象值。
-
-    axis: int (default -1)
-        要在src_data上执行插值的轴。默认为最后一个轴。
-
-    interp_method: str (default "linear")
-        核心插值方法。
-        可选值包括:
-        - "linear": 线性插值（默认）
-        - "nearest": 最近邻插值
-        - "zero": 零阶插值
-        - "slinear": 样条一阶插值
-        - "quadratic": 二阶插值
-        - "cubic": 三阶插值
-        - "previous": 使用前一个点的值
-        - "next": 使用后一个点的值
-        更多选项参考scipy.interpolate.interp1d的kind参数。
-
-    extrap_method: str (default "linear")
-        核心外插方法，用于处理超出源坐标范围的目标坐标点。
-        支持与interp_method相同的选项:
-        - "linear": 线性外插（默认）
-        - "nearest": 最近邻外插
-        - "zero": 零阶外插
-        - "slinear": 样条一阶外插
-        - "quadratic": 二阶外插
-        - "cubic": 三阶外插
-        - "previous": 使用最近的前一个点的值
-        - "next": 使用最近的后一个点的值
+    Perform interpolation and extrapolation along a specified dimension.
+
+    Args:
+        target_coordinates (np.ndarray): 1D array of target coordinate points.
+        source_coordinates (Union[np.ndarray, List[float]]): Source coordinate points (1D or ND array).
+        source_data (np.ndarray): Source data array to interpolate.
+        interpolation_axis (int, optional): Axis to perform interpolation on. Defaults to -1.
+        interpolation_method (str, optional): Interpolation method. Defaults to "linear".
+        extrapolation_method (str, optional): Extrapolation method. Defaults to "linear".
 
     Returns:
-    --------
-    array
-        插值后的数据数组，形状将与src_data相同，但在axis轴上长度为len(tgt_coords)。
+        np.ndarray: Interpolated data array.
+
+    Raises:
+        ValueError: If input dimensions or shapes are invalid.
 
     Examples:
-    ---------
-    1D插值示例:
-    >>> tgt_coords = np.array([1, 2, 3, 4])
-    >>> src_coords = np.array([0, 1, 2, 3, 4, 5])
-    >>> src_data = np.array([0, 1, 4, 9, 16, 25])
-    >>> interp_along_dim(tgt_coords, src_coords, src_data)
-    array([ 1.,  4.,  9., 16.])
-
-    多维插值示例:
-    >>> src_data = np.array([[0, 1, 4], [10, 20, 30]])
-    >>> interp_along_dim(np.array([0.5, 1.5]), np.array([0, 1, 2]), src_data, axis=1)
-    array([[ 0.5,  2.5],
-           [15. , 25. ]])
+        >>> target_coordinates = np.array([1, 2, 3])
+        >>> source_coordinates = np.array([0, 1, 2, 3])
+        >>> source_data = np.array([10, 20, 30, 40])
+        >>> result = interp_along_dim(target_coordinates, source_coordinates, source_data)
+        >>> print(result)  # Expected output: [20.0, 30.0]
     """
-    tgt_coords = np.asarray(tgt_coords)
-    if tgt_coords.ndim != 1:
-        raise ValueError("tgt_coords must be a 1d array.")
-
-    src_coords = np.asarray(src_coords)
-    src_data = np.asarray(src_data)
-
-    # 处理1维的简单情况
-    if src_data.ndim == 1 and src_coords.ndim == 1:
-        if len(src_coords) != len(src_data):
-            raise ValueError("For 1D data, src_coords and src_data must have the same length")
-
-        interpolator = interp1d(src_coords, src_data, kind=interp_method, fill_value="extrapolate", bounds_error=False)
-        return interpolator(tgt_coords)
-
-    # 多维情况的处理
-    if src_coords.ndim == 1:
-        # Expand src_coords to match src_data dimensions along the specified axis
-        shape = [1] * src_data.ndim
-        shape[axis] = src_coords.shape[0]
-        src_coords = np.reshape(src_coords, shape)
-        src_coords = np.broadcast_to(src_coords, src_data.shape)
-    elif src_coords.shape != src_data.shape:
-        raise ValueError("src_coords and src_data must have the same shape.")
-
-    def apply_interp_extrap(arr):
-        xp = np.moveaxis(src_coords, axis, 0)
-        # 根据维度正确获取坐标
-        if xp.ndim > 1:
-            xp = xp[:, 0]  # 多维情况
-        else:
-            xp = xp  # 1维情况
-
-        arr = np.moveaxis(arr, axis, 0)
-        interpolator = interp1d(xp, arr, kind=interp_method, fill_value="extrapolate", bounds_error=False)
-        interpolated = interpolator(tgt_coords)
-        if extrap_method != interp_method:
-            mask_extrap = (tgt_coords < xp.min()) | (tgt_coords > xp.max())
+    target_coordinates = np.asarray(target_coordinates)
+    if target_coordinates.ndim != 1:
+        raise ValueError("[red]target_coordinates must be a 1D array.[/red]")
+
+    source_coordinates = np.asarray(source_coordinates)
+    source_data = np.asarray(source_data)
+
+    if source_data.ndim == 1 and source_coordinates.ndim == 1:
+        if len(source_coordinates) != len(source_data):
+            raise ValueError("[red]For 1D data, source_coordinates and source_data must have the same length.[/red]")
+
+        interpolator = interp1d(source_coordinates, source_data, kind=interpolation_method, fill_value="extrapolate", bounds_error=False)
+        return interpolator(target_coordinates)
+
+    if source_coordinates.ndim == 1:
+        shape = [1] * source_data.ndim
+        shape[interpolation_axis] = source_coordinates.shape[0]
+        source_coordinates = np.reshape(source_coordinates, shape)
+        source_coordinates = np.broadcast_to(source_coordinates, source_data.shape)
+    elif source_coordinates.shape != source_data.shape:
+        raise ValueError("[red]source_coordinates and source_data must have the same shape.[/red]")
+
+    def apply_interp_extrap(arr: np.ndarray) -> np.ndarray:
+        xp = np.moveaxis(source_coordinates, interpolation_axis, 0)
+        xp = xp[:, 0] if xp.ndim > 1 else xp
+        arr = np.moveaxis(arr, interpolation_axis, 0)
+        interpolator = interp1d(xp, arr, kind=interpolation_method, fill_value="extrapolate", bounds_error=False)
+        interpolated = interpolator(target_coordinates)
+        if extrapolation_method != interpolation_method:
+            mask_extrap = (target_coordinates < xp.min()) | (target_coordinates > xp.max())
             if np.any(mask_extrap):
-                extrap_interpolator = interp1d(xp, arr, kind=extrap_method, fill_value="extrapolate", bounds_error=False)
-                interpolated[mask_extrap] = extrap_interpolator(tgt_coords[mask_extrap])
-        return np.moveaxis(interpolated, 0, axis)
-
-    result = np.apply_along_axis(apply_interp_extrap, axis, src_data)
-
-    return result
-
-
-def interp_2d(target_x, target_y, origin_x, origin_y, data, method="linear", parallel=True):
+                extrap_interpolator = interp1d(xp, arr, kind=extrapolation_method, fill_value="extrapolate", bounds_error=False)
+                interpolated[mask_extrap] = extrap_interpolator(target_coordinates[mask_extrap])
+        return np.moveaxis(interpolated, 0, interpolation_axis)
+
+    return np.apply_along_axis(apply_interp_extrap, interpolation_axis, source_data)
+
+
+def interp_2d(
+    target_x_coordinates: Union[np.ndarray, List[float]],
+    target_y_coordinates: Union[np.ndarray, List[float]],
+    source_x_coordinates: Union[np.ndarray, List[float]],
+    source_y_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+    interpolation_method: str = "linear",
+    use_parallel: bool = True,
+) -> np.ndarray:
     """
     Perform 2D interpolation on the last two dimensions of a multi-dimensional array.
 
-    Parameters:
-    - target_x (array-like): 1D or 2D array of target grid's x-coordinates.
-    - target_y (array-like): 1D or 2D array of target grid's y-coordinates.
-    - origin_x (array-like): 1D or 2D array of original grid's x-coordinates.
-    - origin_y (array-like): 1D or 2D array of original grid's y-coordinates.
-    - data (numpy.ndarray): Multi-dimensional array where the last two dimensions correspond to the original grid.
-    - method (str, optional): Interpolation method, default is 'linear'. Other options include 'nearest', 'cubic', etc.
-    - parallel (bool, optional): Flag to enable parallel processing. Default is True.
+    Args:
+        target_x_coordinates (Union[np.ndarray, List[float]]): Target grid's x-coordinates.
+        target_y_coordinates (Union[np.ndarray, List[float]]): Target grid's y-coordinates.
+        source_x_coordinates (Union[np.ndarray, List[float]]): Original grid's x-coordinates.
+        source_y_coordinates (Union[np.ndarray, List[float]]): Original grid's y-coordinates.
+        source_data (np.ndarray): Multi-dimensional array with the last two dimensions as spatial.
+        interpolation_method (str, optional): Interpolation method. Defaults to "linear".
+        use_parallel (bool, optional): Enable parallel processing. Defaults to True.
 
     Returns:
-    - interpolated_data (numpy.ndarray): Interpolated data with the same leading dimensions as the input data, but with the last two dimensions corresponding to the target grid.
+        np.ndarray: Interpolated data array.
 
     Raises:
-    - ValueError: If the shape of the data does not match the shape of the origin_x or origin_y grids.
-
-    Usage:
-    - Interpolate a 2D array:
-        result = interp_2d(target_x, target_y, origin_x, origin_y, data_2d)
-    - Interpolate a 3D array (where the last two dimensions are spatial):
-        result = interp_2d(target_x, target_y, origin_x, origin_y, data_3d)
-    - Interpolate a 4D array (where the last two dimensions are spatial):
-        result = interp_2d(target_x, target_y, origin_x, origin_y, data_4d)
+        ValueError: If input shapes are invalid.
+
+    Examples:
+        >>> target_x_coordinates = np.array([1, 2, 3])
+        >>> target_y_coordinates = np.array([4, 5, 6])
+        >>> source_x_coordinates = np.array([7, 8, 9])
+        >>> source_y_coordinates = np.array([10, 11, 12])
+        >>> source_data = np.random.rand(3, 3)
+        >>> result = interp_2d(target_x_coordinates, target_y_coordinates, source_x_coordinates, source_y_coordinates, source_data)
+        >>> print(result.shape)  # Expected output: (3, 3)
     """
 
-    def interp_single(data_slice, target_points, origin_points, method):
-        return griddata(origin_points, data_slice.ravel(), target_points, method=method).reshape(target_y.shape)
+    def interp_single(data_slice: np.ndarray, target_points: np.ndarray, origin_points: np.ndarray, method: str) -> np.ndarray:
+        return griddata(origin_points, data_slice.ravel(), target_points, method=method).reshape(target_y_coordinates.shape)
 
-    # 确保目标网格和初始网格都是二维的
-    if len(target_y.shape) == 1:
-        target_x, target_y = np.meshgrid(target_x, target_y)
-    if len(origin_y.shape) == 1:
-        origin_x, origin_y = np.meshgrid(origin_x, origin_y)
+    if len(target_y_coordinates.shape) == 1:
+        target_x_coordinates, target_y_coordinates = np.meshgrid(target_x_coordinates, target_y_coordinates)
+    if len(source_y_coordinates.shape) == 1:
+        source_x_coordinates, source_y_coordinates = np.meshgrid(source_x_coordinates, source_y_coordinates)
 
-    # 根据经纬度网格判断输入数据的形状是否匹配
-    if origin_x.shape != data.shape[-2:] or origin_y.shape != data.shape[-2:]:
-        raise ValueError("Shape of data does not match shape of origin_x or origin_y.")
+    if source_x_coordinates.shape != source_data.shape[-2:] or source_y_coordinates.shape != source_data.shape[-2:]:
+        raise ValueError("[red]Shape of source_data does not match shape of source_x_coordinates or source_y_coordinates.[/red]")
 
-    # 创建网格和展平数据
-    target_x, target_y = np.array(target_x), np.array(target_y)
-    origin_x, origin_y = np.array(origin_x), np.array(origin_y)
-    target_points = np.column_stack((target_y.ravel(), target_x.ravel()))
-    origin_points = np.column_stack((origin_y.ravel(), origin_x.ravel()))
+    target_points = np.column_stack((np.array(target_y_coordinates).ravel(), np.array(target_x_coordinates).ravel()))
+    origin_points = np.column_stack((np.array(source_y_coordinates).ravel(), np.array(source_x_coordinates).ravel()))
 
-    # 根据是否并行选择不同的执行方式
-    if parallel:
+    if use_parallel:
         with ThreadPoolExecutor(max_workers=mp.cpu_count() - 2) as executor:
-            if len(data.shape) == 2:
-                interpolated_data = list(executor.map(interp_single, [data], [target_points], [origin_points], [method]))
-            elif len(data.shape) == 3:
-                interpolated_data = list(executor.map(interp_single, [data[i] for i in range(data.shape[0])], [target_points] * data.shape[0], [origin_points] * data.shape[0], [method] * data.shape[0]))
-            elif len(data.shape) == 4:
-                index_combinations = list(itertools.product(range(data.shape[0]), range(data.shape[1])))
-                interpolated_data = list(executor.map(interp_single, [data[i, j] for i, j in index_combinations], [target_points] * len(index_combinations), [origin_points] * len(index_combinations), [method] * len(index_combinations)))
-                interpolated_data = np.array(interpolated_data).reshape(data.shape[0], data.shape[1], *target_y.shape)
+            if len(source_data.shape) == 2:
+                interpolated_data = list(executor.map(interp_single, [source_data], [target_points], [origin_points], [interpolation_method]))
+            elif len(source_data.shape) == 3:
+                interpolated_data = list(executor.map(interp_single, [source_data[i] for i in range(source_data.shape[0])], [target_points] * source_data.shape[0], [origin_points] * source_data.shape[0], [interpolation_method] * source_data.shape[0]))
+            elif len(source_data.shape) == 4:
+                index_combinations = list(itertools.product(range(source_data.shape[0]), range(source_data.shape[1])))
+                interpolated_data = list(executor.map(interp_single, [source_data[i, j] for i, j in index_combinations], [target_points] * len(index_combinations), [origin_points] * len(index_combinations), [interpolation_method] * len(index_combinations)))
+                interpolated_data = np.array(interpolated_data).reshape(source_data.shape[0], source_data.shape[1], *target_y_coordinates.shape)
     else:
-        if len(data.shape) == 2:
-            interpolated_data = interp_single(data, target_points, origin_points, method)
-        elif len(data.shape) == 3:
-            interpolated_data = np.stack([interp_single(data[i], target_points, origin_points, method) for i in range(data.shape[0])])
-        elif len(data.shape) == 4:
-            interpolated_data = np.stack([np.stack([interp_single(data[i, j], target_points, origin_points, method) for j in range(data.shape[1])]) for i in range(data.shape[0])])
+        if len(source_data.shape) == 2:
+            interpolated_data = interp_single(source_data, target_points, origin_points, interpolation_method)
+        elif len(source_data.shape) == 3:
+            interpolated_data = np.stack([interp_single(source_data[i], target_points, origin_points, interpolation_method) for i in range(source_data.shape[0])])
+        elif len(source_data.shape) == 4:
+            interpolated_data = np.stack([np.stack([interp_single(source_data[i, j], target_points, origin_points, interpolation_method) for j in range(source_data.shape[1])]) for i in range(source_data.shape[0])])
 
     return np.squeeze(np.array(interpolated_data))
 
 
-def mask_shapefile(data: np.ndarray, lons: np.ndarray, lats: np.ndarray, shapefile_path: str) -> xr.DataArray:
+def mask_shapefile(
+    data_array: np.ndarray,
+    longitudes: np.ndarray,
+    latitudes: np.ndarray,
+    shapefile_path: str,
+) -> Union[xr.DataArray, None]:
     """
-    Masks a 2D data array using a shapefile.
+    Mask a 2D data array using a shapefile.
 
-    Parameters:
-    - data: 2D numpy array of data to be masked.
-    - lons: 1D numpy array of longitudes.
-    - lats: 1D numpy array of latitudes.
-    - shapefile_path: Path to the shapefile used for masking.
+    Args:
+        data_array (np.ndarray): 2D array of data to be masked.
+        longitudes (np.ndarray): 1D array of longitudes.
+        latitudes (np.ndarray): 1D array of latitudes.
+        shapefile_path (str): Path to the shapefile used for masking.
 
     Returns:
-    - Masked xarray DataArray.
-    """
-    """
-    https://cloud.tencent.com/developer/article/1701896
+        Union[xr.DataArray, None]: Masked xarray DataArray or None if an error occurs.
+
+    Raises:
+        FileNotFoundError: If the shapefile does not exist.
+        ValueError: If the data dimensions do not match the coordinates.
+
+    Examples:
+        >>> data_array = np.random.rand(10, 10)
+        >>> longitudes = np.linspace(-180, 180, 10)
+        >>> latitudes = np.linspace(-90, 90, 10)
+        >>> shapefile_path = "path/to/shapefile.shp"
+        >>> masked_data = mask_shapefile(data_array, longitudes, latitudes, shapefile_path)
+        >>> print(masked_data)  # Expected output: Masked DataArray
+
     """
     try:
-        # import geopandas as gpd
-        # shp_f = gpd.read_file(shapefile_path)
         shp_f = salem.read_shapefile(shapefile_path)
-        data_da = xr.DataArray(data, coords=[("latitude", lats), ("longitude", lons)])
+        data_da = xr.DataArray(data_array, coords=[("latitude", latitudes), ("longitude", longitudes)])
         masked_data = data_da.salem.roi(shape=shp_f)
         return masked_data
     except Exception as e:
-        print(f"An error occurred: {e}")
+        print(f"[red]An error occurred: {e}[/red]")
         return None
 
 
 if __name__ == "__main__":
     pass
-    """ import time
-
-    import matplotlib.pyplot as plt
-
-    # 测试数据
-    origin_x = np.linspace(0, 10, 11)
-    origin_y = np.linspace(0, 10, 11)
-    target_x = np.linspace(0, 10, 101)
-    target_y = np.linspace(0, 10, 101)
-    data = np.random.rand(11, 11)
-
-    # 高维插值
-    origin_x = np.linspace(0, 10, 11)
-    origin_y = np.linspace(0, 10, 11)
-    target_x = np.linspace(0, 10, 101)
-    target_y = np.linspace(0, 10, 101)
-    data = np.random.rand(10, 10, 11, 11)
-
-    start = time.time()
-    interpolated_data = interp_2d(target_x, target_y, origin_x, origin_y, data, parallel=False)
-    print(f"Interpolation time: {time.time()-start:.2f}s")
-
-    print(interpolated_data.shape)
-
-    # 高维插值多线程
-    start = time.time()
-    interpolated_data = interp_2d(target_x, target_y, origin_x, origin_y, data)
-    print(f"Interpolation time: {time.time()-start:.2f}s")
-
-    print(interpolated_data.shape)
-    print(interpolated_data[0, 0, :, :].shape)
-    plt.figure()
-    plt.contourf(target_x, target_y, interpolated_data[0, 0, :, :])
-    plt.colorbar()
-    plt.show() """

oafuncs/oa_date.py

@@ -17,62 +17,90 @@ import calendar
 import datetime
 from typing import List, Optional
 
+from rich import print
+
 __all__ = ["month_days", "hour_range", "adjust_time", "timeit"]
 
 
 def month_days(year: int, month: int) -> int:
+    """
+    Calculate the number of days in a specific month of a year.
+
+    Args:
+        year (int): The year.
+        month (int): The month (1-12).
+
+    Returns:
+        int: Number of days in the specified month.
+
+    Example:
+        >>> month_days(2024, 2)
+        29
+    """
     return calendar.monthrange(year, month)[1]
 
 
-def hour_range(start: str, end: str, interval: int = 6) -> List[str]:
+def hour_range(start_time: str, end_time: str, hour_interval: int = 6) -> List[str]:
     """
     Generate a list of datetime strings with a specified interval in hours.
 
     Args:
-        start (str): Start date in the format "%Y%m%d%H".
-        end (str): End date in the format "%Y%m%d%H".
-        interval (int): Interval in hours between each datetime.
+        start_time (str): Start date in the format "%Y%m%d%H".
+        end_time (str): End date in the format "%Y%m%d%H".
+        hour_interval (int): Interval in hours between each datetime.
 
     Returns:
-        list: List of datetime strings in the format "%Y%m%d%H".
+        List[str]: List of datetime strings in the format "%Y%m%d%H".
+
+    Example:
+        >>> hour_range("2024010100", "2024010200", 6)
+        ['2024010100', '2024010106', '2024010112', '2024010118', '2024010124']
     """
-    date_s = datetime.datetime.strptime(start, "%Y%m%d%H")
-    date_e = datetime.datetime.strptime(end, "%Y%m%d%H")
+    date_s = datetime.datetime.strptime(start_time, "%Y%m%d%H")
+    date_e = datetime.datetime.strptime(end_time, "%Y%m%d%H")
     date_list = []
     while date_s <= date_e:
         date_list.append(date_s.strftime("%Y%m%d%H"))
-        date_s += datetime.timedelta(hours=interval)
+        date_s += datetime.timedelta(hours=hour_interval)
     return date_list
 
 
-def adjust_time(initial_time: str, amount: int, time_unit: str = "hours", output_format: Optional[str] = None) -> str:
+def adjust_time(base_time: str, time_delta: int, delta_unit: str = "hours", output_format: Optional[str] = None) -> str:
     """
-    Adjust a given initial time by adding a specified amount of time.
+    Adjust a given base time by adding a specified time delta.
 
     Args:
-        initial_time (str): Initial time in the format "yyyymmdd" to "yyyymmddHHMMSS".
-                            Missing parts are assumed to be "0".
-        amount (int): The amount of time to add.
-        time_unit (str): The unit of time to add ("seconds", "minutes", "hours", "days").
+        base_time (str): Base time in the format "yyyymmdd" to "yyyymmddHHMMSS".
+                         Missing parts are assumed to be "0".
+        time_delta (int): The amount of time to add.
+        delta_unit (str): The unit of time to add ("seconds", "minutes", "hours", "days").
         output_format (str, optional): Custom output format for the adjusted time. Defaults to None.
 
     Returns:
         str: The adjusted time as a string, formatted according to the output_format or time unit.
+
+    Example:
+        >>> adjust_time("20240101", 5, "days")
+        '20240106'
+        >>> adjust_time("20240101000000", 2, "hours", "%Y-%m-%d %H:%M:%S")
+        '2024-01-01 02:00:00'
+        >>> adjust_time("20240101000000", 30, "minutes")
+        '2024-01-01 00:30:00'
     """
     # Normalize the input time to "yyyymmddHHMMSS" format
     time_format = "%Y%m%d%H%M%S"
-    initial_time = initial_time.ljust(14, "0")
-    time_obj = datetime.datetime.strptime(initial_time, time_format)
+    base_time = base_time.ljust(14, "0")
+    time_obj = datetime.datetime.strptime(base_time, time_format)
 
     # Add the specified amount of time
-    if time_unit == "seconds":
-        time_obj += datetime.timedelta(seconds=amount)
-    elif time_unit == "minutes":
-        time_obj += datetime.timedelta(minutes=amount)
-    elif time_unit == "hours":
-        time_obj += datetime.timedelta(hours=amount)
-    elif time_unit == "days":
-        time_obj += datetime.timedelta(days=amount)
+    if delta_unit == "seconds":
+        time_obj += datetime.timedelta(seconds=time_delta)
+    elif delta_unit == "minutes":
+        time_obj += datetime.timedelta(minutes=time_delta)
+    elif delta_unit == "hours":
+        time_obj += datetime.timedelta(hours=time_delta)
+    elif delta_unit == "days":
+        time_obj += datetime.timedelta(days=time_delta)
     else:
         raise ValueError("Invalid time unit. Use 'seconds', 'minutes', 'hours', or 'days'.")
 
@@ -80,13 +108,13 @@ def adjust_time(initial_time: str, amount: int, time_unit: str = "hours", output
     if output_format:
         return time_obj.strftime(output_format)
     else:
-        if time_unit == "seconds":
+        if delta_unit == "seconds":
             default_format = "%Y%m%d%H%M%S"
-        elif time_unit == "minutes":
+        elif delta_unit == "minutes":
             default_format = "%Y%m%d%H%M"
-        elif time_unit == "hours":
+        elif delta_unit == "hours":
             default_format = "%Y%m%d%H"
-        elif time_unit == "days":
+        elif delta_unit == "days":
             default_format = "%Y%m%d"
         return time_obj.strftime(default_format)
 
@@ -96,19 +124,25 @@ class timeit:
     A decorator to measure the execution time of a function.
 
     Usage:
-        @timeit(log=True, print_time=True)
+        @timeit(log_to_file=True, display_time=True)
         def my_function():
             # Function code here
 
     Args:
-        log (bool): Whether to log the execution time to a file. Defaults to False.
-        print_time (bool): Whether to print the execution time to the console. Defaults to True.
+        log_to_file (bool): Whether to log the execution time to a file. Defaults to False.
+        display_time (bool): Whether to print the execution time to the console. Defaults to True.
+
+    Example:
+        @timeit(log_to_file=True, display_time=True)
+        def example_function():
+            # Simulate some work
+            time.sleep(2)
     """
 
-    def __init__(self, func, log: bool = False, print_time: bool = True):
+    def __init__(self, func, log_to_file: bool = False, display_time: bool = True):
         self.func = func
-        self.log = log
-        self.print_time = print_time
+        self.log_to_file = log_to_file
+        self.display_time = display_time
 
     def __call__(self, *args, **kwargs):
         start_time = datetime.datetime.now()
@@ -116,10 +150,10 @@ class timeit:
         end_time = datetime.datetime.now()
         elapsed_time = (end_time - start_time).total_seconds()
 
-        if self.print_time:
-            print(f"Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.")
+        if self.display_time:
+            print(f"[bold green]Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.[/bold green]")
 
-        if self.log:
+        if self.log_to_file:
             with open("execution_time.log", "a") as log_file:
                 log_file.write(f"{datetime.datetime.now()} - Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.\n")