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

oafuncs/_script/netcdf_merge.py

@@ -48,7 +48,7 @@ def merge_nc(file_list: Union[str, List[str]], var_name: Optional[Union[str, Lis
     # 初始化合并数据字典
     merged_data = {}
 
-    for i, file in pbar(enumerate(file_list),description="Reading files", color="green",total=len(file_list)):
+    for i, file in pbar(enumerate(file_list), description="Reading files", color="#f8bbd0", total=len(file_list)):
         with xr.open_dataset(file) as ds:
             for var in var_names:
                 data_var = ds[var]

oafuncs/_script/netcdf_modify.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2025-04-05 14:00:50
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2025-04-05 14:00:50
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\_script\\netcdf_modify.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.12
+"""
+
+import os
+
+import netCDF4 as nc
+import numpy as np
+from rich import print
+
+
+def _is_valid_netcdf_file(file_path):
+    """
+    Check if the file is a valid NetCDF file.
+    """
+    try:
+        with nc.Dataset(file_path, "r") as _:
+            pass
+        return True
+    except Exception:
+        return False
+
+
+def _modify_var(nc_file_path, variable_name, new_value):
+    """
+    Modify the value of a variable in a NetCDF file.
+    """
+    if not os.path.exists(nc_file_path):
+        raise FileNotFoundError(f"NetCDF file '{nc_file_path}' does not exist.")
+    if not _is_valid_netcdf_file(nc_file_path):
+        raise ValueError(f"File '{nc_file_path}' is not a valid NetCDF file.")
+    if not variable_name:
+        raise ValueError("Variable name cannot be empty or None.")
+    if not isinstance(new_value, np.ndarray):
+        raise TypeError("New value must be a numpy.ndarray.")
+
+    try:
+        with nc.Dataset(nc_file_path, "r+") as dataset:
+            if variable_name not in dataset.variables:
+                raise ValueError(f"Variable '{variable_name}' not found in the NetCDF file.")
+            variable = dataset.variables[variable_name]
+            if variable.shape != new_value.shape:
+                raise ValueError(f"Shape mismatch: Variable '{variable_name}' has shape {variable.shape}, but new value has shape {new_value.shape}.")
+            variable[:] = new_value
+        print(f"[green]Successfully modified variable '{variable_name}' in '{nc_file_path}'.[/green]")
+        return True
+    except (FileNotFoundError, ValueError, TypeError) as e:
+        print(f"[red]Error:[/red] {e}")
+        return False
+    except Exception as e:
+        print(f"[red]Unexpected Error:[/red] Failed to modify variable '{variable_name}' in '{nc_file_path}'. [bold]Details:[/bold] {e}")
+        return False
+
+
+def _modify_attr(nc_file_path, variable_name, attribute_name, attribute_value):
+    """
+    Add or modify an attribute of a variable in a NetCDF file.
+    """
+    if not os.path.exists(nc_file_path):
+        raise FileNotFoundError(f"NetCDF file '{nc_file_path}' does not exist.")
+    if not _is_valid_netcdf_file(nc_file_path):
+        raise ValueError(f"File '{nc_file_path}' is not a valid NetCDF file.")
+    if not variable_name:
+        raise ValueError("Variable name cannot be empty or None.")
+    if not attribute_name:
+        raise ValueError("Attribute name cannot be empty or None.")
+
+    try:
+        with nc.Dataset(nc_file_path, "r+") as ds:
+            if variable_name not in ds.variables:
+                raise ValueError(f"Variable '{variable_name}' not found in the NetCDF file.")
+            variable = ds.variables[variable_name]
+            variable.setncattr(attribute_name, attribute_value)
+        print(f"[green]Successfully modified attribute '{attribute_name}' of variable '{variable_name}' in '{nc_file_path}'.[/green]")
+        return True
+    except (FileNotFoundError, ValueError) as e:
+        print(f"[red]Error:[/red] {e}")
+        return False
+    except Exception as e:
+        print(f"[red]Unexpected Error:[/red] Failed to modify attribute '{attribute_name}' of variable '{variable_name}' in file '{nc_file_path}'. [bold]Details:[/bold] {e}")
+        return False
+
+
+def modify_nc(nc_file, var_name, attr_name=None, new_value=None):
+    """
+    Modify the value of a variable or the value of an attribute in a NetCDF file.
+    """
+    try:
+        if attr_name is None:
+            return _modify_var(nc_file, var_name, new_value)
+        else:
+            return _modify_attr(nc_file, var_name, attr_name, new_value)
+    except Exception as e:
+        print(f"[red]Error:[/red] An error occurred while modifying '{var_name}' in '{nc_file}'. [bold]Details:[/bold] {e}")
+        return False

oafuncs/_script/netcdf_write.py

@@ -0,0 +1,125 @@
+import numpy as np
+import os
+import netCDF4 as nc
+import xarray as xr
+
+
+def _numpy_to_nc_type(numpy_type):
+    """将NumPy数据类型映射到NetCDF数据类型"""
+    numpy_to_nc = {
+        "float32": "f4",
+        "float64": "f8",
+        "int8": "i1",
+        "int16": "i2",
+        "int32": "i4",
+        "int64": "i8",
+        "uint8": "u1",
+        "uint16": "u2",
+        "uint32": "u4",
+        "uint64": "u8",
+    }
+    # 确保传入的是字符串类型，如果不是，则转换为字符串
+    numpy_type_str = str(numpy_type) if not isinstance(numpy_type, str) else numpy_type
+    return numpy_to_nc.get(numpy_type_str, "f4")  # 默认使用 'float32'
+
+
+def _calculate_scale_and_offset(data, n=16):
+    if not isinstance(data, np.ndarray):
+        raise ValueError("Input data must be a NumPy array.")
+
+    # 使用 nan_to_num 来避免 NaN 值对 min 和 max 的影响
+    data_min = np.nanmin(data)
+    data_max = np.nanmax(data)
+
+    if np.isnan(data_min) or np.isnan(data_max):
+        raise ValueError("Input data contains NaN values, which are not allowed.")
+
+    scale_factor = (data_max - data_min) / (2**n - 1)
+    add_offset = data_min + 2 ** (n - 1) * scale_factor
+
+    return scale_factor, add_offset
+
+
+def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_switch=True, compile_switch=True):
+    """
+    Description:
+        Write data to NetCDF file
+    Parameters:
+        file: str, file path
+        data: data
+        varname: str, variable name
+        coords: dict, coordinates, key is the dimension name, value is the coordinate data
+        mode: str, write mode, 'w' for write, 'a' for append
+        scale_offset_switch: bool, whether to use scale_factor and add_offset, default is True
+        compile_switch: bool, whether to use compression parameters, default is True
+    Example:
+        save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'a')
+    """
+    # 设置压缩参数
+    kwargs = {"zlib": True, "complevel": 4} if compile_switch else {}
+
+    # 检查文件存在性并根据模式决定操作
+    if mode == "w" and os.path.exists(file):
+        os.remove(file)
+    elif mode == "a" and not os.path.exists(file):
+        mode = "w"
+
+    # 打开 NetCDF 文件
+    with nc.Dataset(file, mode, format="NETCDF4") as ncfile:
+        # 如果 data 是 DataArray 并且没有提供 varname 和 coords
+        if varname is None and coords is None and isinstance(data, xr.DataArray):
+            encoding = {}
+            for var in data.data_vars:
+                scale_factor, add_offset = _calculate_scale_and_offset(data[var].values)
+                encoding[var] = {
+                    "zlib": True,
+                    "complevel": 4,
+                    "dtype": "int16",
+                    "scale_factor": scale_factor,
+                    "add_offset": add_offset,
+                    "_FillValue": -32767,
+                }
+            data.to_netcdf(file, mode=mode, encoding=encoding)
+            return
+
+        # 添加坐标
+        for dim, coord_data in coords.items():
+            if dim in ncfile.dimensions:
+                if len(coord_data) != len(ncfile.dimensions[dim]):
+                    raise ValueError(f"Length of coordinate '{dim}' does not match the dimension length.")
+                else:
+                    ncfile.variables[dim][:] = np.array(coord_data)
+            else:
+                ncfile.createDimension(dim, len(coord_data))
+                var = ncfile.createVariable(dim, _numpy_to_nc_type(coord_data.dtype), (dim,), **kwargs)
+                var[:] = np.array(coord_data)
+
+                # 如果坐标数据有属性，则添加到 NetCDF 变量
+                if isinstance(coord_data, xr.DataArray) and coord_data.attrs:
+                    for attr_name, attr_value in coord_data.attrs.items():
+                        var.setncattr(attr_name, attr_value)
+
+        # 添加或更新变量
+        if varname in ncfile.variables:
+            if data.shape != ncfile.variables[varname].shape:
+                raise ValueError(f"Shape of data does not match the variable shape for '{varname}'.")
+            ncfile.variables[varname][:] = np.array(data)
+        else:
+            # 创建变量
+            dim_names = tuple(coords.keys())
+            if scale_offset_switch:
+                scale_factor, add_offset = _calculate_scale_and_offset(np.array(data))
+                dtype = "i2"
+                var = ncfile.createVariable(varname, dtype, dim_names, fill_value=-32767, **kwargs)
+                var.setncattr("scale_factor", scale_factor)
+                var.setncattr("add_offset", add_offset)
+            else:
+                dtype = _numpy_to_nc_type(data.dtype)
+                var = ncfile.createVariable(varname, dtype, dim_names, **kwargs)
+            var[:] = np.array(data)
+
+        # 添加属性
+        if isinstance(data, xr.DataArray) and data.attrs:
+            for key, value in data.attrs.items():
+                if key not in ["scale_factor", "add_offset", "_FillValue", "missing_value"] or not scale_offset_switch:
+                    var.setncattr(key, value)

oafuncs/oa_cmap.py

@@ -1,27 +1,15 @@
-#!/usr/bin/env python
-# coding=utf-8
-"""
-Author: Liu Kun && 16031215@qq.com
-Date: 2024-09-17 16:55:11
-LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-11-21 13:14:24
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_cmap.py
-Description:
-EditPlatform: vscode
-ComputerInfo: XPS 15 9510
-SystemInfo: Windows 11
-Python Version: 3.11
-"""
+from typing import List, Optional, Union
 
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
 from rich import print
 
-__all__ = ["show", "to_color", "create", "create_rgbtxt", "get"]
+__all__ = ["show", "to_color", "create", "get"]
+
 
 # ** 将cmap用填色图可视化（官网摘抄函数）
-def show(colormaps):
+def show(colormaps: Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]) -> None:
     """
     Description:
         Helper function to plot data with associated colormap.
@@ -31,107 +19,84 @@ def show(colormaps):
         cmap = ListedColormap(["darkorange", "gold", "lawngreen", "lightseagreen"])
         show([cmap]); show("viridis"); show(["viridis", "cividis"])
     """
-    if isinstance(colormaps, str) or isinstance(colormaps, mpl.colors.Colormap):
+    if not isinstance(colormaps, list):
         colormaps = [colormaps]
     np.random.seed(19680801)
     data = np.random.randn(30, 30)
     n = len(colormaps)
     fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3), constrained_layout=True, squeeze=False)
-    for [ax, cmap] in zip(axs.flat, colormaps):
+    for ax, cmap in zip(axs.flat, colormaps):
         psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)
         fig.colorbar(psm, ax=ax)
     plt.show()
 
 
 # ** 将cmap转为list，即多个颜色的列表
-def to_color(cmap, n=256):
+def to_color(cmap_name: str, n: int = 256) -> List[tuple]:
     """
     Description:
         Convert a colormap to a list of colors
     Parameters:
-        cmap : str; the name of the colormap
-        n    : int, optional; the number of colors
+        cmap_name : str; the name of the colormap
+        n         : int, optional; the number of colors
     Return:
         out_colors : list of colors
     Example:
         out_colors = to_color('viridis', 256)
     """
-    c_map = mpl.colormaps.get_cmap(cmap)
-    out_colors = [c_map(i) for i in np.linspace(0, 1, n)]
-    return out_colors
+    cmap = mpl.colormaps.get_cmap(cmap_name)
+    return [cmap(i) for i in np.linspace(0, 1, n)]
 
 
 # ** 自制cmap，多色，可带位置
-def create(colors: list, nodes=None, under=None, over=None):  # 利用颜色快速配色
+def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file_path: Optional[str] = None, positions: Optional[List[float]] = None, under_color: Optional[Union[str, tuple]] = None, over_color: Optional[Union[str, tuple]] = None, delimiter: str = ",") -> mpl.colors.Colormap:
     """
     Description:
-        Create a custom colormap
+        Create a custom colormap from a list of colors or an RGB txt document.
     Parameters:
-        colors : list of colors
-        nodes  : list of positions
-        under  : color
-        over   : color
+        color_list  : list of colors (optional, required if rgb_file_path is None)
+        rgb_file_path : str, the path of txt file (optional, required if color_list is None)
+        positions   : list of positions (optional, for color_list)
+        under_color : color (optional)
+        over_color  : color (optional)
+        delimiter   : str, optional, default is ','; the delimiter of RGB values in txt file
     Return:
         cmap : colormap
     Example:
-        cmap = create(['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
-        cmap = create(['aliceblue','skyblue','deepskyblue'],[0.0,0.5,1.0])
+        cmap = create(color_list=['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
+        cmap = create(color_list=['aliceblue','skyblue','deepskyblue'], positions=[0.0,0.5,1.0])
+        cmap = create(rgb_file_path='path/to/file.txt', delimiter=',')
     """
+    if rgb_file_path:
+        with open(rgb_file_path) as fid:
+            data = fid.readlines()
+        n = len(data)
+        rgb = np.zeros((n, 3))
+        for i in np.arange(n):
+            rgb[i][0] = data[i].split(delimiter)[0]
+            rgb[i][1] = data[i].split(delimiter)[1]
+            rgb[i][2] = data[i].split(delimiter)[2]
+        max_rgb = np.max(rgb)
+        if max_rgb > 2:  # if the value is greater than 2, it is normalized to 0-1
+            rgb = rgb / 255.0
+        cmap_color = mpl.colors.ListedColormap(rgb, name="my_color")
+    elif color_list:
+        if positions is None:  # 自动分配比例
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", color_list)
+        else:  # 按提供比例分配
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(positions, color_list)))
+    else:
+        raise ValueError("Either 'color_list' or 'rgb_file_path' must be provided.")
 
-    if nodes is None:  # 采取自动分配比例
-        cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", colors)
-    else:  # 按照提供比例分配
-        cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(nodes, colors)))
-    if under is not None:
-        cmap_color.set_under(under)
-    if over is not None:
-        cmap_color.set_over(over)
+    if under_color is not None:
+        cmap_color.set_under(under_color)
+    if over_color is not None:
+        cmap_color.set_over(over_color)
     return cmap_color
 
 
-# ** 根据RGB的txt文档制作色卡（利用Grads调色盘）
-def create_rgbtxt(rgbtxt_file,split_mark=','):  # 根据RGB的txt文档制作色卡/根据rgb值制作
-    """
-    Description
-    -----------
-    Make a color card according to the RGB txt document, each line in the txt file is an RGB value, separated by commas, such as: 251,251,253
-    
-    Parameters
-    ----------
-    rgbtxt_file : str, the path of txt file
-    split_mark  : str, optional, default is ','; the split mark of rgb value
-
-    Returns
-    -------
-    cmap : colormap
-
-    Example
-    -------
-    cmap=create_rgbtxt(path,split_mark=',')
-    
-    txt example
-    -----------
-    251,251,253
-    225,125,25
-    250,205,255
-    """
-    with open(rgbtxt_file) as fid:
-        data = fid.readlines()
-    n = len(data)
-    rgb = np.zeros((n, 3))
-    for i in np.arange(n):
-        rgb[i][0] = data[i].split(split_mark)[0]
-        rgb[i][1] = data[i].split(split_mark)[1]
-        rgb[i][2] = data[i].split(split_mark)[2]
-    max_rgb = np.max(rgb)
-    if max_rgb > 2:  # if the value is greater than 2, it is normalized to 0-1
-        rgb = rgb / 255.0
-    my_cmap = mpl.colors.ListedColormap(rgb, name="my_color")
-    return my_cmap
-
-
 # ** 选择cmap
-def get(cmap_name=None, query=False):
+def get(cmap_name: Optional[str] = None, query: bool = False) -> Optional[mpl.colors.Colormap]:
     """
     Description:
         Choosing a colormap from the list of available colormaps or a custom colormap
@@ -147,43 +112,26 @@ def get(cmap_name=None, query=False):
         cmap = get('warm_1')
         cmap = get('colorful_1')
     """
-
     my_cmap_dict = {
         "diverging_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
         "cool_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
         "warm_1": create(["#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
-        # "land_1": create_custom(["#3E6436", "#678A59", "#91A176", "#B8A87D", "#D9CBB2"], under="#A6CEE3", over="#FFFFFF"),
-        # "ocean_1": create_custom(["#126697", "#2D88B3", "#4EA1C9", "#78B9D8", "#A6CEE3"], under="#8470FF", over="#3E6436"), 
-        # "ocean_land_1": create_custom(
-        #     [
-        #         "#126697",  # 深蓝（深海）
-        #         "#2D88B3",  # 蓝
-        #         "#4EA1C9",  # 蓝绿
-        #         "#78B9D8",  # 浅蓝（浅海）
-        #         "#A6CEE3",  # 浅蓝（近岸）
-        #         "#AAAAAA",  # 灰色（0值，海平面）
-        #         "#D9CBB2",  # 沙质土壤色（陆地开始）
-        #         "#B8A87D",  # 浅棕
-        #         "#91A176",  # 浅绿
-        #         "#678A59",  # 中绿
-        #         "#3E6436",  # 深绿（高山）
-        #     ]
-        # ),
         "colorful_1": create(["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"]),
     }
+
     if query:
         print("Available cmap names:")
-        print('-' * 20)
-        print('Defined by myself:')
-        for key, _ in my_cmap_dict.items():
-            print(key)
-        print('-' * 20)
-        print('Matplotlib built-in:')
-        print(mpl.colormaps())
         print("-" * 20)
-    
+        print("Defined by myself:")
+        print("\n".join(my_cmap_dict.keys()))
+        print("-" * 20)
+        print("Matplotlib built-in:")
+        print("\n".join(mpl.colormaps.keys()))
+        print("-" * 20)
+        return None
+
     if cmap_name is None:
-        return
+        return None
 
     if cmap_name in my_cmap_dict:
         return my_cmap_dict[cmap_name]
@@ -191,9 +139,8 @@ def get(cmap_name=None, query=False):
         try:
             return mpl.colormaps.get_cmap(cmap_name)
         except ValueError:
-            # raise ValueError(f"Unknown cmap name: {cmap_name}")
             print(f"Unknown cmap name: {cmap_name}\nNow return 'rainbow' as default.")
-            return mpl.colormaps.get_cmap("rainbow")
+            return mpl.colormaps.get_cmap("rainbow")  # 默认返回 'rainbow'
 
 
 if __name__ == "__main__":
@@ -209,7 +156,7 @@ if __name__ == "__main__":
 
     # ** 测试根据RGB的txt文档制作色卡
     file_path = "E:/python/colorbar/test.txt"
-    cmap_rgb = create_rgbtxt(file_path)
+    cmap_rgb = create(rgb_file_path=file_path)
 
     # ** 测试将cmap转为list
     out_colors = to_color("viridis", 256)

oafuncs/oa_date.py

@@ -13,40 +13,39 @@ SystemInfo: Windows 11
 Python Version: 3.12
 """
 
-
-
 import calendar
 import datetime
+from typing import List, Optional
 
-__all__ = ["get_days_in_month", "generate_hour_list", "adjust_time", "timeit"]
+__all__ = ["month_days", "hour_range", "adjust_time", "timeit"]
 
 
-def get_days_in_month(year, month):
+def month_days(year: int, month: int) -> int:
     return calendar.monthrange(year, month)[1]
 
 
-def generate_hour_list(start_date, end_date, interval_hours=6):
+def hour_range(start: str, end: str, interval: int = 6) -> List[str]:
     """
     Generate a list of datetime strings with a specified interval in hours.
 
     Args:
-        start_date (str): Start date in the format "%Y%m%d%H".
-        end_date (str): End date in the format "%Y%m%d%H".
-        interval_hours (int): Interval in hours between each datetime.
+        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.
 
     Returns:
         list: List of datetime strings in the format "%Y%m%d%H".
     """
-    date_s = datetime.datetime.strptime(start_date, "%Y%m%d%H")
-    date_e = datetime.datetime.strptime(end_date, "%Y%m%d%H")
+    date_s = datetime.datetime.strptime(start, "%Y%m%d%H")
+    date_e = datetime.datetime.strptime(end, "%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_hours)
+        date_s += datetime.timedelta(hours=interval)
     return date_list
 
 
-def adjust_time(initial_time, amount, time_unit="hours", output_format=None):
+def adjust_time(initial_time: str, amount: int, time_unit: str = "hours", output_format: Optional[str] = None) -> str:
     """
     Adjust a given initial time by adding a specified amount of time.
 
@@ -91,22 +90,37 @@ def adjust_time(initial_time, amount, time_unit="hours", output_format=None):
             default_format = "%Y%m%d"
         return time_obj.strftime(default_format)
 
+
 class timeit:
     """
     A decorator to measure the execution time of a function.
 
     Usage:
-        @timeit
+        @timeit(log=True, print_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.
     """
-    def __init__(self, func):
+
+    def __init__(self, func, log: bool = False, print_time: bool = True):
         self.func = func
+        self.log = log
+        self.print_time = print_time
 
     def __call__(self, *args, **kwargs):
         start_time = datetime.datetime.now()
         result = self.func(*args, **kwargs)
         end_time = datetime.datetime.now()
         elapsed_time = (end_time - start_time).total_seconds()
-        print(f"Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.")
-        return result
+
+        if self.print_time:
+            print(f"Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.")
+
+        if self.log:
+            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")
+
+        return result