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

oafuncs/oa_help.py

@@ -116,6 +116,16 @@ def log():
         log()
     """
     print("更新日志：")
+    print(
+        """
+        2025-04-06
+        1. 给所有函数使用Python标准的docstring格式(英文)添加/修改说明
+        2. 同时给所有参数添加类型声明
+        3. 逻辑检查,优化
+        4. 使用rich库的print函数，增加颜色
+        5. 所有输出,如果是中文,改成英文
+        """
+    )
     print(
         """
         2025-01-15

oafuncs/oa_nc.py

@@ -1,20 +1,5 @@
-#!/usr/bin/env python
-# coding=utf-8
-"""
-Author: Liu Kun && 16031215@qq.com
-Date: 2024-09-17 14:58:50
-LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-12-06 14:16:56
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_nc.py
-Description:
-EditPlatform: vscode
-ComputerInfo: XPS 15 9510
-SystemInfo: Windows 11
-Python Version: 3.11
-"""
-
 import os
-from typing import List, Optional, Union, Tuple
+from typing import List, Optional, Tuple, Union
 
 import netCDF4 as nc
 import numpy as np
@@ -24,225 +9,273 @@ from rich import print
 __all__ = ["save", "merge", "modify", "rename", "check", "convert_longitude", "isel", "draw"]
 
 
-def save(file: str, data: Union[np.ndarray, xr.DataArray], varname: Optional[str] = None, coords: Optional[dict] = None, mode: str = "w", scale_offset_switch: bool = True, compile_switch: bool = True) -> None:
+def save(
+    file_path: str,
+    data: Union[np.ndarray, xr.DataArray],
+    variable_name: Optional[str] = None,
+    coordinates: Optional[dict] = None,
+    write_mode: str = "w",
+    use_scale_offset: bool = True,
+    use_compression: bool = True,
+) -> None:
     """
-    Description:
-        Write data to NetCDF file
-    Parameters:
-        file: str, file path
-        data: np.ndarray or xr.DataArray, data to be written
-        varname: Optional[str], variable name
-        coords: Optional[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
+    Write data to a NetCDF file.
+
+    Args:
+        file_path (str): File path to save the NetCDF file.
+        data (Union[np.ndarray, xr.DataArray]): Data to be written.
+        variable_name (Optional[str]): Variable name for the data.
+        coordinates (Optional[dict]): Coordinates, where keys are dimension names and values are coordinate data.
+        write_mode (str): Write mode, 'w' for write, 'a' for append. Default is 'w'.
+        use_scale_offset (bool): Whether to use scale_factor and add_offset. Default is True.
+        use_compression (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')
+        >>> save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'a')
+        >>> save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'w')
+        >>> save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'w', use_scale_offset=False, use_compression=False)
+        >>> save(r'test.nc', data)
     """
     from ._script.netcdf_write import save_to_nc
 
-    save_to_nc(file, data, varname, coords, mode, scale_offset_switch, compile_switch)
+    save_to_nc(file_path, data, variable_name, coordinates, write_mode, use_scale_offset, use_compression)
+    print(f"[green]Data successfully saved to {file_path}[/green]")
 
 
-def merge(file_list: Union[str, List[str]], var_name: Optional[Union[str, List[str]]] = None, dim_name: Optional[str] = None, target_filename: Optional[str] = None) -> None:
+def merge(
+    file_paths: Union[str, List[str]],
+    variable_names: Optional[Union[str, List[str]]] = None,
+    merge_dimension: Optional[str] = None,
+    output_file: Optional[str] = None,
+) -> None:
     """
-    Description:
-        Merge multiple NetCDF files into one.
-    Parameters:
-        file_list: Union[str, List[str]], list of file paths or a single file path
-        var_name: Optional[Union[str, List[str]]], variable names to merge
-        dim_name: Optional[str], dimension name to merge along
-        target_filename: Optional[str], output file name
+    Merge multiple NetCDF files into one.
+
+    Args:
+        file_paths (Union[str, List[str]]): List of file paths or a single file path.
+        variable_names (Optional[Union[str, List[str]]]): Variable names to merge.
+        merge_dimension (Optional[str]): Dimension name to merge along.
+        output_file (Optional[str]): Output file name.
+
+    Example:
+        merge(['file1.nc', 'file2.nc'], variable_names='temperature', merge_dimension='time', output_file='merged.nc')
     """
     from ._script.netcdf_merge import merge_nc
 
-    merge_nc(file_list, var_name, dim_name, target_filename)
+    merge_nc(file_paths, variable_names, merge_dimension, output_file)
+    print(f"[green]Files successfully merged into {output_file}[/green]")
 
 
-def modify(nc_file: str, var_name: str, attr_name: Optional[str] = None, new_value: Optional[Union[str, float, int, np.ndarray]] = None) -> None:
+def modify(
+    file_path: str,
+    variable_name: str,
+    attribute_name: Optional[str] = None,
+    new_value: Optional[Union[str, float, int, np.ndarray]] = None,
+) -> None:
     """
-    Description:
-        Modify the value of a variable or the value of an attribute in a NetCDF file.
-    Parameters:
-        nc_file: str, the path to the NetCDF file
-        var_name: str, the name of the variable to be modified
-        attr_name: Optional[str], the name of the attribute to be modified. If None, the variable value will be modified
-        new_value: Optional[Union[str, float, int, np.ndarray]], the new value of the variable or attribute
+    Modify the value of a variable or an attribute in a NetCDF file.
+
+    Args:
+        file_path (str): Path to the NetCDF file.
+        variable_name (str): Name of the variable to be modified.
+        attribute_name (Optional[str]): Name of the attribute to be modified. If None, the variable value will be modified.
+        new_value (Optional[Union[str, float, int, np.ndarray]]): New value for the variable or attribute.
+
+    Example:
+        >>> modify('file.nc', 'temperature', 'units', 'Celsius')
+        >>> modify('file.nc', 'temperature', new_value=np.array([1, 2, 3]))
     """
     from ._script.netcdf_modify import modify_nc
 
-    modify_nc(nc_file, var_name, attr_name, new_value)
+    modify_nc(file_path, variable_name, attribute_name, new_value)
+    print(f"[green]Successfully modified {variable_name} in {file_path}[/green]")
 
 
-def rename(ncfile_path: str, old_name: str, new_name: str) -> None:
+def rename(
+    file_path: str,
+    old_name: str,
+    new_name: str,
+) -> None:
     """
-    Description:
-        Rename a variable and/or dimension in a NetCDF file.
-    Parameters:
-        ncfile_path: str, the path to the NetCDF file
-        old_name: str, the current name of the variable or dimension
-        new_name: str, the new name to assign to the variable or dimension
+    Rename a variable or dimension in a NetCDF file.
+
+    Args:
+        file_path (str): Path to the NetCDF file.
+        old_name (str): Current name of the variable or dimension.
+        new_name (str): New name to assign to the variable or dimension.
+
+    Example:
+        >>> rename('file.nc', 'old_var', 'new_var')
     """
     try:
-        with nc.Dataset(ncfile_path, "r+") as dataset:
-            # If the old name is not found as a variable or dimension, print a message
+        with nc.Dataset(file_path, "r+") as dataset:
             if old_name not in dataset.variables and old_name not in dataset.dimensions:
-                print(f"Variable or dimension {old_name} not found in the file.")
+                print(f"[yellow]Variable or dimension {old_name} not found in the file.[/yellow]")
+                return
 
-            # Attempt to rename the variable
             if old_name in dataset.variables:
                 dataset.renameVariable(old_name, new_name)
-                print(f"Successfully renamed variable {old_name} to {new_name}.")
+                print(f"[green]Successfully renamed variable {old_name} to {new_name}.[/green]")
 
-            # Attempt to rename the dimension
             if old_name in dataset.dimensions:
-                # Check if the new dimension name already exists
                 if new_name in dataset.dimensions:
                     raise ValueError(f"Dimension name {new_name} already exists in the file.")
                 dataset.renameDimension(old_name, new_name)
-                print(f"Successfully renamed dimension {old_name} to {new_name}.")
+                print(f"[green]Successfully renamed dimension {old_name} to {new_name}.[/green]")
 
     except Exception as e:
-        print(f"An error occurred: {e}")
+        print(f"[red]An error occurred: {e}[/red]")
 
 
-def check(ncfile: str, delete_switch: bool = False, print_switch: bool = True) -> bool:
+def check(
+    file_path: str,
+    delete_if_invalid: bool = False,
+    print_messages: bool = True,
+) -> bool:
     """
-    Description:
-        Check if a NetCDF file is corrupted with enhanced error handling.
-    Parameters:
-        ncfile: str, the path to the NetCDF file
-        delete_switch: bool, whether to delete the file if it is corrupted
-        print_switch: bool, whether to print messages during the check
+    Check if a NetCDF file is corrupted.
+
+    Args:
+        file_path (str): Path to the NetCDF file.
+        delete_if_invalid (bool): Whether to delete the file if it is corrupted. Default is False.
+        print_messages (bool): Whether to print messages during the check. Default is True.
+
     Returns:
-        bool: True if the file is valid, False otherwise
+        bool: True if the file is valid, False otherwise.
+
+    Example:
+        >>> is_valid = check('file.nc', delete_if_invalid=True)
     """
     is_valid = False
 
-    if not os.path.exists(ncfile):
-        if print_switch:
-            print(f"[#ffeac5]Local file missing: [#009d88]{ncfile}")
-            # 提示：提示文件缺失也许是正常的，这只是检查文件是否存在于本地
-            print("[#d6d9fd]Note: File missing may be normal, this is just to check if the file exists locally.")
+    if not os.path.exists(file_path):
+        if print_messages:
+            print(f"[yellow]File not found: {file_path}[/yellow]")
         return False
 
     try:
-        # # 深度验证文件结构
-        # with nc.Dataset(ncfile, "r") as ds:
-        #     # 显式检查文件结构完整性
-        #     ds.sync()  # 强制刷新缓冲区
-        #     ds.close()  # 显式关闭后重新打开验证
-
-        # 二次验证确保变量可访问
-        with nc.Dataset(ncfile, "r") as ds_verify:
+        with nc.Dataset(file_path, "r") as ds_verify:
             if not ds_verify.variables:
-                if print_switch:
-                    print(f"[red]Empty variables: {ncfile}[/red]")
+                if print_messages:
+                    print(f"[red]Empty variables in file: {file_path}[/red]")
             else:
-                # 尝试访问元数据
                 _ = ds_verify.__dict__
-                # 抽样检查第一个变量
                 for var in ds_verify.variables.values():
-                    _ = var.shape  # 触发实际数据访问
+                    _ = var.shape
                     break
                 is_valid = True
 
-    except Exception as e:  # 捕获所有异常类型
-        if print_switch:
-            print(f"[red]HDF5 validation failed for {ncfile}: {str(e)}[/red]")
-        error_type = type(e).__name__
-        if "HDF5" in error_type or "h5" in error_type.lower():
-            if print_switch:
-                print(f"[red]Critical HDF5 structure error detected in {ncfile}[/red]")
-
-    # 安全删除流程
-    if not is_valid:
-        if delete_switch:
-            try:
-                os.remove(ncfile)
-                if print_switch:
-                    print(f"[red]Removed corrupted file: {ncfile}[/red]")
-            except Exception as del_error:
-                if print_switch:
-                    print(f"[red]Failed to delete corrupted file: {ncfile} - {str(del_error)}[/red]")
-        return False
-
-    return True
+    except Exception as e:
+        if print_messages:
+            print(f"[red]File validation failed: {file_path} - {str(e)}[/red]")
+
+    if not is_valid and delete_if_invalid:
+        try:
+            os.remove(file_path)
+            if print_messages:
+                print(f"[red]Deleted corrupted file: {file_path}[/red]")
+        except Exception as del_error:
+            if print_messages:
+                print(f"[red]Failed to delete file: {file_path} - {str(del_error)}[/red]")
+
+    return is_valid
+
+
+def convert_longitude(
+    dataset: xr.Dataset,
+    longitude_name: str = "longitude",
+    target_range: int = 180,
+) -> xr.Dataset:
+    """
+    Convert the longitude array to a specified range.
 
+    Args:
+        dataset (xr.Dataset): The xarray dataset containing the longitude data.
+        longitude_name (str): Name of the longitude variable. Default is "longitude".
+        target_range (int): Target range to convert to, either 180 or 360. Default is 180.
 
-def convert_longitude(ds: xr.Dataset, lon_name: str = "longitude", convert: int = 180) -> xr.Dataset:
-    """
-    Description:
-        Convert the longitude array to a specified range.
-    Parameters:
-        ds: xr.Dataset, the xarray dataset containing the longitude data
-        lon_name: str, the name of the longitude variable, default is "longitude"
-        convert: int, the target range to convert to, can be 180 or 360, default is 180
     Returns:
-        xr.Dataset: The xarray dataset with the converted longitude
+        xr.Dataset: Dataset with converted longitude.
+
+    Example:
+        >>> dataset = convert_longitude(dataset, longitude_name="lon", target_range=360)
     """
-    to_which = int(convert)
-    if to_which not in [180, 360]:
-        raise ValueError("convert value must be '180' or '360'")
+    if target_range not in [180, 360]:
+        raise ValueError("target_range value must be 180 or 360")
 
-    if to_which == 180:
-        ds = ds.assign_coords({lon_name: (ds[lon_name] + 180) % 360 - 180})
-    elif to_which == 360:
-        ds = ds.assign_coords({lon_name: (ds[lon_name] + 360) % 360})
+    if target_range == 180:
+        dataset = dataset.assign_coords({longitude_name: (dataset[longitude_name] + 180) % 360 - 180})
+    else:
+        dataset = dataset.assign_coords({longitude_name: (dataset[longitude_name] + 360) % 360})
 
-    return ds.sortby(lon_name)
+    return dataset.sortby(longitude_name)
 
 
-def isel(ncfile: str, dim_name: str, slice_list: List[int]) -> xr.Dataset:
+def isel(
+    file_path: str,
+    dimension_name: str,
+    indices: List[int],
+) -> xr.Dataset:
     """
-    Description:
-        Choose the data by the index of the dimension.
-    Parameters:
-        ncfile: str, the path of the netCDF file
-        dim_name: str, the name of the dimension
-        slice_list: List[int], the indices of the dimension
+    Select data by the index of a dimension.
+
+    Args:
+        file_path (str): Path to the NetCDF file.
+        dimension_name (str): Name of the dimension.
+        indices (List[int]): Indices of the dimension to select.
+
     Returns:
-        xr.Dataset: The subset dataset
+        xr.Dataset: Subset dataset.
+
+    Example:
+        >>> subset = isel('file.nc', 'time', [0, 1, 2])
     """
-    ds = xr.open_dataset(ncfile)
-    slice_list = np.array(slice_list).flatten()
-    slice_list = [int(i) for i in slice_list]
-    ds_new = ds.isel(**{dim_name: slice_list})
+    ds = xr.open_dataset(file_path)
+    indices = [int(i) for i in np.array(indices).flatten()]
+    ds_new = ds.isel(**{dimension_name: indices})
     ds.close()
     return ds_new
 
 
-def draw(output_dir: Optional[str] = None, dataset: Optional[xr.Dataset] = None, ncfile: Optional[str] = None, xyzt_dims: Union[List[str], Tuple[str, str, str, str]] = ("longitude", "latitude", "level", "time"), plot_type: str = "contourf", fixed_colorscale: bool = False) -> None:
+def draw(
+    output_directory: Optional[str] = None,
+    dataset: Optional[xr.Dataset] = None,
+    file_path: Optional[str] = None,
+    dimensions: Union[List[str], Tuple[str, str, str, str]] = ("longitude", "latitude", "level", "time"),
+    plot_style: str = "contourf",
+    use_fixed_colorscale: bool = False,
+) -> None:
     """
-    Description:
-        Draw the data in the netCDF file.
-    Parameters:
-        output_dir: Optional[str], the path of the output directory
-        dataset: Optional[xr.Dataset], the xarray dataset to plot
-        ncfile: Optional[str], the path of the netCDF file
-        xyzt_dims: Union[List[str], Tuple[str, str, str, str]], the dimensions for plotting
-        plot_type: str, the type of the plot, default is "contourf" (contourf, contour)
-        fixed_colorscale: bool, whether to use fixed colorscale, default is False
+    Draw data from a NetCDF file.
+
+    Args:
+        output_directory (Optional[str]): Path of the output directory.
+        dataset (Optional[xr.Dataset]): Xarray dataset to plot.
+        file_path (Optional[str]): Path to the NetCDF file.
+        dimensions (Union[List[str], Tuple[str, str, str, str]]): Dimensions for plotting.
+        plot_style (str): Type of the plot, e.g., "contourf" or "contour". Default is "contourf".
+        use_fixed_colorscale (bool): Whether to use a fixed colorscale. Default is False.
+
+    Example:
+        >>> draw(output_directory="plots", file_path="file.nc", plot_style="contour")
     """
     from ._script.plot_dataset import func_plot_dataset
 
-    if output_dir is None:
-        output_dir = str(os.getcwd())
-    if isinstance(xyzt_dims, (list, tuple)):
-        xyzt_dims = tuple(xyzt_dims)
-    else:
-        raise ValueError("xyzt_dims must be a list or tuple")
+    if output_directory is None:
+        output_directory = os.getcwd()
+    if not isinstance(dimensions, (list, tuple)):
+        raise ValueError("dimensions must be a list or tuple")
+
     if dataset is not None:
-        func_plot_dataset(dataset, output_dir, xyzt_dims, plot_type, fixed_colorscale)
-    else:
-        if ncfile is not None:
-            if check(ncfile):
-                ds = xr.open_dataset(ncfile)
-                func_plot_dataset(ds, output_dir, xyzt_dims, plot_type, fixed_colorscale)
-            else:
-                print(f"Invalid file: {ncfile}")
+        func_plot_dataset(dataset, output_directory, tuple(dimensions), plot_style, use_fixed_colorscale)
+    elif file_path is not None:
+        if check(file_path):
+            ds = xr.open_dataset(file_path)
+            func_plot_dataset(ds, output_directory, tuple(dimensions), plot_style, use_fixed_colorscale)
         else:
-            print("No dataset or file provided.")
+            print(f"[red]Invalid file: {file_path}[/red]")
+    else:
+        print("[red]No dataset or file provided.[/red]")
 
 
 if __name__ == "__main__":

oafuncs/oa_python.py

@@ -14,23 +14,37 @@ Python Version: 3.12
 """
 
 import os
+from typing import List, Optional
 
 from rich import print
 
 __all__ = ["install_packages", "upgrade_packages"]
 
 
-def install_packages(packages=None, python_executable="python", package_manager="pip"):
+def install_packages(
+    packages: Optional[List[str]] = None,
+    python_executable: str = "python",
+    package_manager: str = "pip",
+) -> None:
     """
-    packages: list, libraries to be installed
-    python_executable: str, Python version; for example, on Windows, copy python.exe to python312.exe, then set python_executable='python312'
-    package_manager: str, the package manager to use ('pip' or 'conda')
+    Install the specified Python packages using the given package manager.
+
+    Args:
+        packages (Optional[List[str]]): A list of libraries to be installed. If None, no packages will be installed.
+        python_executable (str): The Python executable to use (e.g., 'python312').
+        package_manager (str): The package manager to use ('pip' or 'conda').
+
+    Raises:
+        ValueError: If 'packages' is not a list or None, or if 'package_manager' is not 'pip' or 'conda'.
+    
+    Example:
+        >>> install_packages(packages=["numpy", "pandas"], python_executable="python", package_manager="pip")
     """
     if not isinstance(packages, (list, type(None))):
-        raise ValueError("The 'packages' parameter must be a list or None")
+        raise ValueError("[red]The 'packages' parameter must be a list or None[/red]")
 
     if package_manager not in ["pip", "conda"]:
-        raise ValueError("The 'package_manager' parameter must be either 'pip' or 'conda'")
+        raise ValueError("[red]The 'package_manager' parameter must be either 'pip' or 'conda'[/red]")
 
     if package_manager == "conda":
         if not packages:
@@ -39,11 +53,11 @@ def install_packages(packages=None, python_executable="python", package_manager=
             package_count = len(packages)
             for i, package in enumerate(packages):
                 os.system(f"conda install -c conda-forge {package} -y")
-                print("-" * 100)
-                print(f"Successfully installed {package} ({i + 1}/{package_count})")
-                print("-" * 100)
+                print(f"[green]{'-' * 100}[/green]")
+                print(f"[green]Successfully installed {package} ({i + 1}/{package_count})[/green]")
+                print(f"[green]{'-' * 100}[/green]")
         except Exception as e:
-            print(f"Installation failed: {str(e)}")
+            print(f"[red]Installation failed: {str(e)}[/red]")
         return
 
     os.system(f"{python_executable} -m ensurepip")
@@ -55,29 +69,41 @@ def install_packages(packages=None, python_executable="python", package_manager=
         installed_packages = {pkg.split("==")[0].lower() for pkg in installed_packages}
         package_count = len(packages)
         for i, package in enumerate(packages):
-            # Check if the library is already installed, skip if installed
             if package.lower() in installed_packages:
-                print(f"{package} is already installed")
+                print(f"[yellow]{package} is already installed[/yellow]")
                 continue
             os.system(f"{python_executable} -m pip install {package}")
-            print("-" * 100)
-            print(f"Successfully installed {package} ({i + 1}/{package_count})")
-            print("-" * 100)
+            print(f"[green]{'-' * 100}[/green]")
+            print(f"[green]Successfully installed {package} ({i + 1}/{package_count})[/green]")
+            print(f"[green]{'-' * 100}[/green]")
     except Exception as e:
-        print(f"Installation failed: {str(e)}")
+        print(f"[red]Installation failed: {str(e)}[/red]")
 
 
-def upgrade_packages(packages=None, python_executable="python", package_manager="pip"):
+def upgrade_packages(
+    packages: Optional[List[str]] = None,
+    python_executable: str = "python",
+    package_manager: str = "pip",
+) -> None:
     """
-    packages: list, libraries to be upgraded
-    python_executable: str, Python version; for example, on Windows, copy python.exe to python312.exe, then set python_executable='python312'
-    package_manager: str, the package manager to use ('pip' or 'conda')
+    Upgrade the specified Python packages using the given package manager.
+
+    Args:
+        packages (Optional[List[str]]): A list of libraries to be upgraded. If None, all installed packages will be upgraded.
+        python_executable (str): The Python executable to use (e.g., 'python312').
+        package_manager (str): The package manager to use ('pip' or 'conda').
+
+    Raises:
+        ValueError: If 'packages' is not a list or None, or if 'package_manager' is not 'pip' or 'conda'.
+    
+    Example:
+        >>> upgrade_packages(packages=["numpy", "pandas"], python_executable="python", package_manager="pip")
     """
     if not isinstance(packages, (list, type(None))):
-        raise ValueError("The 'packages' parameter must be a list or None")
+        raise ValueError("[red]The 'packages' parameter must be a list or None[/red]")
 
     if package_manager not in ["pip", "conda"]:
-        raise ValueError("The 'package_manager' parameter must be either 'pip' or 'conda'")
+        raise ValueError("[red]The 'package_manager' parameter must be either 'pip' or 'conda'[/red]")
 
     try:
         if package_manager == "conda":
@@ -86,13 +112,13 @@ def upgrade_packages(packages=None, python_executable="python", package_manager=
                 packages = [pkg.split("=")[0] for pkg in installed_packages if not pkg.startswith("#")]
             for package in packages:
                 os.system(f"conda update -c conda-forge {package} -y")
-            print("Upgrade successful")
+            print("[green]Upgrade successful[/green]")
         else:
             if not packages:
                 installed_packages = os.popen(f"{python_executable} -m pip list --format=freeze").read().splitlines()
                 packages = [pkg.split("==")[0] for pkg in installed_packages]
             for package in packages:
                 os.system(f"{python_executable} -m pip install --upgrade {package}")
-            print("Upgrade successful")
+            print("[green]Upgrade successful[/green]")
     except Exception as e:
-        print(f"Upgrade failed: {str(e)}")
+        print(f"[red]Upgrade failed: {str(e)}[/red]")