oafuncs 0.0.97.14__tar.gz → 0.0.97.16__tar.gz

{oafuncs-0.0.97.14/oafuncs.egg-info → oafuncs-0.0.97.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.97.14
+Version: 0.0.97.16
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu

{oafuncs-0.0.97.14 → oafuncs-0.0.97.16}/oafuncs/_script/cprogressbar.py

@@ -153,6 +153,7 @@ class ColorProgressBar:
         update_interval: float = 0.1,
         bar_length: int = None,
         speed_estimate_period: float = 30.0,
+        next_line: bool = False,
     ):
         self.iterable = iterable
         self.description = description
@@ -161,7 +162,7 @@ class ColorProgressBar:
         self.update_interval = update_interval
         self.bar_length = bar_length
         self.speed_estimate_period = speed_estimate_period
-        self.mark_num = random.randint(0, 13)  # 随机选择填充字符的数量
+        self.next_line = next_line
 
         # 线程安全锁
         self._lock = threading.RLock()
@@ -187,6 +188,10 @@ class ColorProgressBar:
         self._is_terminal = hasattr(self._file, "isatty") and self._file.isatty()
         self._is_jupyter = "ipykernel" in sys.modules
 
+        # 输出样式
+        filled_list = ["▊", "█", "▓", "▒", "░", "#", "=", ">", "▌", "▍", "▎", "▏", "*"]
+        self.filled = random.choice(filled_list)
+
     def _generate_gradient(self) -> Optional[List[str]]:
         """生成渐变色列表（修复内置colormap支持）"""
         try:
@@ -253,11 +258,7 @@ class ColorProgressBar:
 
     def _format_bar(self, progress: float, width: int) -> str:
         """格式化进度条显示"""
-        filled_list = ["▊", "█", "▓", "▒", "░", "#", "=", ">", "▌", "▍", "▎", "▏", "*"]
-        # filled = "░"
-        # filled = filled_list[2]  # 选择中间的填充字符
-        # filled = random.choice(filled_list)  # 随机选择填充字符
-        filled = filled_list[min(self.mark_num, len(filled_list) - 1)]  # 随机选择填充字符
+        filled = self.filled
         empty = " "
         # 为其他信息保留更多空间
         max_width = max(10, width - 60)  # 至少保留10个字符的进度条
@@ -363,7 +364,10 @@ class ColorProgressBar:
                 self._file.write(f"{line}\n")
             elif self._is_terminal:
                 # 标准终端环境，覆盖同一行
-                self._file.write(f"\r{line}")
+                if self.next_line:
+                    self._file.write(f"\r{line}\n")
+                else:
+                    self._file.write(f"\r{line}")
             else:
                 # 非交互式环境，仅在完成时输出
                 if self.task.finished:
@@ -395,7 +399,7 @@ class ColorProgressBar:
 
         finally:
             # 完成后进行清理
-            if self._is_terminal and not self._is_jupyter:
+            if self._is_terminal and not self._is_jupyter and not self.next_line:
                 self._file.write("\n")
                 self._file.flush()
 
@@ -406,28 +410,46 @@ class ColorProgressBar:
         return [to_hex(cmap(i)) for i in np.linspace(0, 1, n)]
 
 
+def cpbar(
+    iterable,
+    description="Working...",
+    total=None,
+    completed=0,
+    color="cyan",
+    cmap=None,
+    update_interval=0.1,
+    bar_length=None,
+    speed_estimate_period=30.0,
+    next_line=False,
+):
+    """便捷函数，返回 ColorProgressBar 对象"""
+    return ColorProgressBar(
+        iterable=iterable,
+        description=description,
+        total=total,
+        completed=completed,
+        color=color,
+        cmap=cmap,
+        update_interval=update_interval,
+        bar_length=bar_length,
+        speed_estimate_period=speed_estimate_period,
+        next_line=next_line,
+    )
+
+
 # 验证示例
 if __name__ == "__main__":
-    for _ in ColorProgressBar(range(100), description="Diverging:", cmap="diverging_1"):
-        # print("\rTesting...", end="")
+    for _ in cpbar(range(20), description="Diverging:", cmap="diverging_1", next_line=True):
+        print("Processing...")
         time.sleep(0.1)
 
-    for _ in ColorProgressBar(range(100), description="Colorful:", cmap="colorful_1"):
-        time.sleep(0.1)
-
-    for _ in ColorProgressBar(range(100), description="Viridis:", cmap="viridis"):
+    for _ in ColorProgressBar(range(20), description="Viridis:", cmap="viridis"):
         time.sleep(0.1)
 
     # 使用自定义渐变色
     for _ in ColorProgressBar(range(50), description="Custom_cmap:", cmap=["#FF0000", "#0000FF"]):
         time.sleep(0.1)
 
-    for _ in ColorProgressBar(range(50), description="Default:"):
-        time.sleep(0.1)
-
-    for _ in ColorProgressBar(range(50), description="Custom_color:", color="#FF00FF"):
-        time.sleep(0.1)
-
     # 测试无法获取长度的迭代器
     def infinite_generator():
         i = 0

{oafuncs-0.0.97.14 → oafuncs-0.0.97.16}/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-0.0.97.16/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-0.0.97.16/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-0.0.97.16/oafuncs/oa_cmap.py

@@ -0,0 +1,162 @@
+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", "get"]
+
+
+# ** 将cmap用填色图可视化（官网摘抄函数）
+def show(colormaps: Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]) -> None:
+    """
+    Description:
+        Helper function to plot data with associated colormap.
+    Parameters:
+        colormaps : list of colormaps, or a single colormap; can be a string or a colormap object.
+    Example:
+        cmap = ListedColormap(["darkorange", "gold", "lawngreen", "lightseagreen"])
+        show([cmap]); show("viridis"); show(["viridis", "cividis"])
+    """
+    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):
+        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_name: str, n: int = 256) -> List[tuple]:
+    """
+    Description:
+        Convert a colormap to a list of colors
+    Parameters:
+        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)
+    """
+    cmap = mpl.colormaps.get_cmap(cmap_name)
+    return [cmap(i) for i in np.linspace(0, 1, n)]
+
+
+# ** 自制cmap，多色，可带位置
+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 from a list of colors or an RGB txt document.
+    Parameters:
+        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(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 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
+
+
+# ** 选择cmap
+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
+    Parameters:
+        cmap_name : str, optional; the name of the colormap
+        query     : bool, optional; whether to query the available colormap names
+    Return:
+        cmap : colormap
+    Example:
+        cmap = get('viridis')
+        cmap = get('diverging_1')
+        cmap = get('cool_1')
+        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"]),
+        "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:")
+        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 None
+
+    if cmap_name in my_cmap_dict:
+        return my_cmap_dict[cmap_name]
+    else:
+        try:
+            return mpl.colormaps.get_cmap(cmap_name)
+        except ValueError:
+            print(f"Unknown cmap name: {cmap_name}\nNow return 'rainbow' as default.")
+            return mpl.colormaps.get_cmap("rainbow")  # 默认返回 'rainbow'
+
+
+if __name__ == "__main__":
+    # ** 测试自制cmap
+    colors = ["#C2B7F3", "#B3BBF2", "#B0CBF1", "#ACDCF0", "#A8EEED"]
+    nodes = [0.0, 0.2, 0.4, 0.6, 1.0]
+    c_map = create(colors, nodes)
+    show([c_map])
+
+    # ** 测试自制diverging型cmap
+    diverging_cmap = create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
+    show([diverging_cmap])
+
+    # ** 测试根据RGB的txt文档制作色卡
+    file_path = "E:/python/colorbar/test.txt"
+    cmap_rgb = create(rgb_file_path=file_path)
+
+    # ** 测试将cmap转为list
+    out_colors = to_color("viridis", 256)

{oafuncs-0.0.97.14 → oafuncs-0.0.97.16}/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