wrfrun 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

wrfrun/extension/goos_sst/res/__init__.py

@@ -17,7 +17,6 @@ VTABLE_ERA_GOOS_SST
 
 from os.path import abspath, dirname
 
-
 _PATH = abspath(dirname(__file__))
 
 VTABLE_ERA_GOOS_SST = f"{_PATH}/Vtable.ERA_GOOS_SST"

wrfrun/extension/goos_sst/utils.py

@@ -6,22 +6,21 @@ Functions that are used by :doc:`/api/extension.goos_sst`.
 
 .. autosummary::
     :toctree: generated/
-    
+
     create_sst_grib
 """
 
-from cfgrib.xarray_to_grib import to_grib
 from numpy.dtypes import DateTime64DType
 from pandas import to_datetime
 from xarray import DataArray, Dataset
 
-from wrfrun.utils import logger
+from wrfrun.log import logger
 
 
 def create_sst_grib(data: DataArray, save_path: str):
     """
     Write SST data to a GRIB file.
-    
+
     This function creates GRIB file using ``cfgrib`` package.
     While GRIB write support is experimental in ``cfgrib``,
     this function may **FAIL TO CREATE GRIB FILE**.
@@ -31,13 +30,16 @@ def create_sst_grib(data: DataArray, save_path: str):
     :param save_path: Output GRIB file path.
     :type save_path: str
     """
+    # lazy import to fix sphinx build error
+    from cfgrib.xarray_to_grib import to_grib
+
     # check the data's dimensions.
     for _dim in ["time", "longitude", "latitude"]:
         if _dim not in data.dims:
             logger.error(f"Essential dimension '{_dim}' not found in data")
             raise KeyError
 
-    if not isinstance(data["time"].dtype, DateTime64DType):     # type: ignore
+    if not isinstance(data["time"].dtype, DateTime64DType):  # type: ignore
         data = data.assign_coords(time=to_datetime(data["time"].data))
 
     data = data.sortby(data["latitude"], ascending=False)
@@ -50,47 +52,51 @@ def create_sst_grib(data: DataArray, save_path: str):
     latitude_length = data["latitude"].size
     points_number = data.size
 
-    data = data.assign_attrs(**{
-        "units": "K",
-        "long_name": "Sea surface temperature",
-        "standard_name": "Sea surface temperature",
-        # The following keys and values will be used in GRIB.
-        "GRIB_paramId": 34,
-        "GRIB_shortName": "sst",
-        "GRIB_units": "K",
-        "GRIB_name": "Sea surface temperature",
-        "GRIB_stepUnits": 1,
-        "GRIB_stepType": "instant",
-        "GRIB_gridType": "regular_ll",
-        "GRIB_iDirectionIncrementInDegrees": delta_longitude,
-        "GRIB_iScanNegatively": 0,
-        "GRIB_jDirectionIncrementInDegrees": delta_latitude,
-        "GRIB_jScanPositively": 0,
-        "GRIB_latitudeOfFirstGridPointInDegrees": latitude_start,
-        "GRIB_latitudeOfLastGridPointInDegrees": latitude_stop,
-        "GRIB_longitudeOfFirstGridPointInDegrees": longitude_start,
-        "GRIB_longitudeOfLastGridPointInDegrees": longitude_stop,
-        "GRIB_Ny": latitude_length,
-        "GRIB_Nx": longitude_length,
-        "GRIB_typeOfLevel": "surface",
-        # The following keys and values can't be found at ECMWF websites.
-        "GRIB_cfName": "unknown",
-        "GRIB_cfVarName": "sst",
-        "GRIB_dataType": "an",  # Analysis data, defined at https://codes.ecmwf.int/grib/format/mars/type/
-        "GRIB_gridDefinitionDescription": "Latitude/Longitude Grid",
-        # "GRIB_missingValue": -9999,
-        "GRIB_numberOfPoints": points_number,
-        "GRIB_totalNumber": 0,
-        "GRIB_uvRelativeToGird": 0
-    })
+    data = data.assign_attrs(
+        **{
+            "units": "K",
+            "long_name": "Sea surface temperature",
+            "standard_name": "Sea surface temperature",
+            # The following keys and values will be used in GRIB.
+            "GRIB_paramId": 34,
+            "GRIB_shortName": "sst",
+            "GRIB_units": "K",
+            "GRIB_name": "Sea surface temperature",
+            "GRIB_stepUnits": 1,
+            "GRIB_stepType": "instant",
+            "GRIB_gridType": "regular_ll",
+            "GRIB_iDirectionIncrementInDegrees": delta_longitude,
+            "GRIB_iScanNegatively": 0,
+            "GRIB_jDirectionIncrementInDegrees": delta_latitude,
+            "GRIB_jScanPositively": 0,
+            "GRIB_latitudeOfFirstGridPointInDegrees": latitude_start,
+            "GRIB_latitudeOfLastGridPointInDegrees": latitude_stop,
+            "GRIB_longitudeOfFirstGridPointInDegrees": longitude_start,
+            "GRIB_longitudeOfLastGridPointInDegrees": longitude_stop,
+            "GRIB_Ny": latitude_length,
+            "GRIB_Nx": longitude_length,
+            "GRIB_typeOfLevel": "surface",
+            # The following keys and values can't be found at ECMWF websites.
+            "GRIB_cfName": "unknown",
+            "GRIB_cfVarName": "sst",
+            "GRIB_dataType": "an",  # Analysis data, defined at https://codes.ecmwf.int/grib/format/mars/type/
+            "GRIB_gridDefinitionDescription": "Latitude/Longitude Grid",
+            # "GRIB_missingValue": -9999,
+            "GRIB_numberOfPoints": points_number,
+            "GRIB_totalNumber": 0,
+            "GRIB_uvRelativeToGird": 0,
+        }
+    )
 
     to_grib(
-        Dataset({
-            "sst": data
-        }, attrs={
-            "GRIB_centre": "ecmf",
-            "GRIB_edition": 1,
-        }), save_path
+        Dataset(
+            {"sst": data},
+            attrs={
+                "GRIB_centre": "ecmf",
+                "GRIB_edition": 1,
+            },
+        ),
+        save_path,
     )
 
 

wrfrun/extension/littler/core.py

@@ -13,15 +13,15 @@ Implementation of ``extension.littler``'s core functionality.
     LittleR
 """
 
-from json import loads, dumps
-from typing import Union, Tuple, Iterable
+from json import dumps, loads
+from typing import Iterable, Tuple, Union
 from zipfile import ZipFile
 
-from pandas import DataFrame, read_csv
 import numpy as np
+from pandas import DataFrame, read_csv
 
-from wrfrun.core import get_wrfrun_config
-from wrfrun.utils import logger
+from wrfrun.core import WRFRUN
+from wrfrun.log import logger
 
 
 def to_fstring(var: Union[int, float, bool, str], length: Union[int, Tuple[int, int]]) -> str:
@@ -52,23 +52,15 @@ def to_fstring(var: Union[int, float, bool, str], length: Union[int, Tuple[int,
     """
     if isinstance(var, float):
         if not isinstance(length, tuple):
-            logger.error(
-                "`length` must be a tuple contain two values `(total length, decimal length)` when `var` is `float`"
-            )
-            raise ValueError(
-                "`length` must be a tuple contain two values `(total length, decimal length)` when `var` is `float`"
-            )
+            logger.error("`length` must be a tuple contain two values `(total length, decimal length)` when `var` is `float`")
+            raise ValueError("`length` must be a tuple contain two values `(total length, decimal length)` when `var` is `float`")
 
         res = f"{var:{length[0]}.{length[1]}f}"
 
     else:
         if not isinstance(length, int):
-            logger.error(
-                "`length` must be an int value when `var` is not `float`"
-            )
-            raise ValueError(
-                "`length` must be an int value when `var` is not `float`"
-            )
+            logger.error("`length` must be an int value when `var` is not `float`")
+            raise ValueError("`length` must be an int value when `var` is not `float`")
 
         if isinstance(var, bool):
             res = "T" if var else "F"
@@ -84,6 +76,7 @@ class LittleRHead(dict):
     """
     Headers of LITTLE_R observation data.
     """
+
     def __init__(
         self,
         longitude: float,
@@ -102,7 +95,7 @@ class LittleRHead(dict):
         cloud_cover=-888888,
         precipitable_water=-888888,
         quality_control: Union[dict, int] = 0,
-        **kwargs
+        **kwargs,
     ) -> None:
         """
         Headers of LITTLE_R observation data.
@@ -125,7 +118,8 @@ class LittleRHead(dict):
         :type name: str
         :param source: Data source, defaults to "Created by wrfrun package".
         :type source: str
-        :param num_sequence: Sequence number which is used to merge multiple record data, the less the num is, the newer the data is. Defaults to 0.
+        :param num_sequence: Sequence number which is used to merge multiple record data,
+                             the less the num is, the newer the data is. Defaults to 0.
         :type num_sequence: int
         :param sea_level_pressure: Sea level pressure. Defaults to -888,888.
         :type sea_level_pressure: int
@@ -220,24 +214,26 @@ class LittleRHead(dict):
     #     return self._convert_to_fstring()
 
     def _convert_to_fstring(self) -> str:
-        return f"{self.latitude:20.5f}" \
-               f"{self.longitude:20.5f}" \
-               f"{self.ID.rjust(40, ' ')}" \
-               f"{self.name.rjust(40, ' ')}" \
-               f"{self.fm.rjust(40, ' ')}" \
-               f"{self.source.rjust(40, ' ')}" \
-               f"{self.elevation:20.5f}" \
-               f"{self.num_valid_field:10d}" \
-               f"{self.num_error:10d}" \
-               f"{self.num_warning:10d}" \
-               f"{self.num_sequence:10d}" \
-               f"{self.num_duplicate:10d}" \
-               f"{to_fstring(self.is_sounding, 10)}" \
-               f"{to_fstring(self.is_bogus, 10)}" \
-               f"{to_fstring(self.discard, 10)}" \
-               f"{self.time:10d}" \
-               f"{self.julian_day:10d}" \
-               f"{self.date.rjust(20, ' ')}" + self._generate_data_qc()
+        return (
+            f"{self.latitude:20.5f}"
+            f"{self.longitude:20.5f}"
+            f"{self.ID.rjust(40, ' ')}"
+            f"{self.name.rjust(40, ' ')}"
+            f"{self.fm.rjust(40, ' ')}"
+            f"{self.source.rjust(40, ' ')}"
+            f"{self.elevation:20.5f}"
+            f"{self.num_valid_field:10d}"
+            f"{self.num_error:10d}"
+            f"{self.num_warning:10d}"
+            f"{self.num_sequence:10d}"
+            f"{self.num_duplicate:10d}"
+            f"{to_fstring(self.is_sounding, 10)}"
+            f"{to_fstring(self.is_bogus, 10)}"
+            f"{to_fstring(self.discard, 10)}"
+            f"{self.time:10d}"
+            f"{self.julian_day:10d}"
+            f"{self.date.rjust(20, ' ')}" + self._generate_data_qc()
+        )
 
     def _generate_data_qc(self) -> str:
         field = [
@@ -270,16 +266,26 @@ class LittleRHead(dict):
 
 
 LITTLE_R_DATA_FIELD = [
-    "pressure", "pressure_qc",
-    "height", "height_qc",
-    "temperature", "temperature_qc",
-    "dew_point", "dew_point_qc",
-    "wind_speed", "wind_speed_qc",
-    "wind_direction", "wind_direction_qc",
-    "wind_u", "wind_u_qc",
-    "wind_v", "wind_v_qc",
-    "relative_humidity", "relative_humidity_qc",
-    "thickness", "thickness_qc",
+    "pressure",
+    "pressure_qc",
+    "height",
+    "height_qc",
+    "temperature",
+    "temperature_qc",
+    "dew_point",
+    "dew_point_qc",
+    "wind_speed",
+    "wind_speed_qc",
+    "wind_direction",
+    "wind_direction_qc",
+    "wind_u",
+    "wind_u_qc",
+    "wind_v",
+    "wind_v_qc",
+    "relative_humidity",
+    "relative_humidity_qc",
+    "thickness",
+    "thickness_qc",
 ]
 
 
@@ -287,23 +293,24 @@ class LittleRData(DataFrame):
     """
     LITTLE_R observation data without headers.
     """
+
     def __init__(
         self,
         data=None,
         index=None,
         columns=None,
-        pressure: Union[Iterable, float] = 100000.,
-        height: Union[Iterable, float] = -888888.,
-        temperature: Union[Iterable, float] = 264.,
-        dew_point: Union[Iterable, float] = 263.,
-        wind_speed: Union[Iterable, float] = -888888.,
-        wind_direction: Union[Iterable, float] = -888888.,
-        wind_u: Union[Iterable, float] = -888888.,
-        wind_v: Union[Iterable, float] = -888888.,
-        relative_humidity: Union[Iterable, float] = -888888.,
-        thickness: Union[Iterable, float] = -888888.,
+        pressure: Union[Iterable, float] = 100000.0,
+        height: Union[Iterable, float] = -888888.0,
+        temperature: Union[Iterable, float] = 264.0,
+        dew_point: Union[Iterable, float] = 263.0,
+        wind_speed: Union[Iterable, float] = -888888.0,
+        wind_direction: Union[Iterable, float] = -888888.0,
+        wind_u: Union[Iterable, float] = -888888.0,
+        wind_v: Union[Iterable, float] = -888888.0,
+        relative_humidity: Union[Iterable, float] = -888888.0,
+        thickness: Union[Iterable, float] = -888888.0,
         quality_control_flag: Union[Iterable, dict, int] = 0,
-        **kwargs
+        **kwargs,
     ) -> None:
         """
         LITTLE_R observation data without headers.
@@ -411,9 +418,7 @@ class LittleRData(DataFrame):
                 wind_v = np.array([wind_v]).astype(float)
                 relative_humidity = np.array([relative_humidity]).astype(float)
                 thickness = np.array([thickness]).astype(float)
-                quality_control_flag = np.array(
-                    [quality_control_flag]
-                ).astype(int)
+                quality_control_flag = np.array([quality_control_flag]).astype(int)
             else:
                 pressure = np.asarray(pressure).astype(float)
                 height = np.asarray(height).astype(float)
@@ -425,9 +430,7 @@ class LittleRData(DataFrame):
                 wind_v = np.asarray(wind_v).astype(float)
                 relative_humidity = np.asarray(relative_humidity).astype(float)
                 thickness = np.asarray(thickness).astype(float)
-                quality_control_flag = np.asarray(
-                    quality_control_flag
-                ).astype(int)
+                quality_control_flag = np.asarray(quality_control_flag).astype(int)
 
             # construct data
             if isinstance(quality_control_flag, dict):
@@ -493,7 +496,7 @@ class LittleRData(DataFrame):
         return cls.from_dict(data_dict)
 
     @classmethod
-    def from_dict(cls, data: dict, orient='columns', dtype=None, columns=None):
+    def from_dict(cls, data: dict, orient="columns", dtype=None, columns=None):
         """
         Create ``LittleRData`` instance from a dict.
         This method inspects all fields in ``data`` and supplements any missing fields with invalid value (-888888).
@@ -517,7 +520,7 @@ class LittleRData(DataFrame):
                 if field.endswith("_qc"):
                     data[field] = np.zeros_like(temp_data).astype(int)
                 else:
-                    data[field] = np.zeros_like(temp_data) - 888888.
+                    data[field] = np.zeros_like(temp_data) - 888888.0
 
         return super().from_dict(data, orient, dtype, columns)  # type: ignore
 
@@ -553,7 +556,7 @@ class LittleRData(DataFrame):
         res = ""
         valid_field_num = 0
         for row in self.index:
-            for (key, qc_key) in zip(fields, qc_fields):
+            for key, qc_key in zip(fields, qc_fields):
                 _field = self.loc[row, key]
                 _field_qc = self.loc[row, qc_key]
 
@@ -564,7 +567,7 @@ class LittleRData(DataFrame):
             res += "\n"
 
         # add ending record
-        for (_, _) in zip(fields, qc_fields):
+        for _, _ in zip(fields, qc_fields):
             res += f"{-777777:13.5f}{0:7d}"
         res += "\n"
 
@@ -587,18 +590,18 @@ class LittleR(LittleRData):
         index=None,
         columns=None,
         data_header: Union[dict, None] = None,
-        pressure: Union[Iterable, float] = 100000.,
-        height: Union[Iterable, float] = -888888.,
-        temperature: Union[Iterable, float] = 264.,
-        dew_point: Union[Iterable, float] = 263.,
-        wind_speed: Union[Iterable, float] = -888888.,
-        wind_direction: Union[Iterable, float] = -888888.,
-        wind_u: Union[Iterable, float] = -888888.,
-        wind_v: Union[Iterable, float] = -888888.,
-        relative_humidity: Union[Iterable, float] = -888888.,
-        thickness: Union[Iterable, float] = -888888.,
+        pressure: Union[Iterable, float] = 100000.0,
+        height: Union[Iterable, float] = -888888.0,
+        temperature: Union[Iterable, float] = 264.0,
+        dew_point: Union[Iterable, float] = 263.0,
+        wind_speed: Union[Iterable, float] = -888888.0,
+        wind_direction: Union[Iterable, float] = -888888.0,
+        wind_u: Union[Iterable, float] = -888888.0,
+        wind_v: Union[Iterable, float] = -888888.0,
+        relative_humidity: Union[Iterable, float] = -888888.0,
+        thickness: Union[Iterable, float] = -888888.0,
         quality_control_flag: Union[Iterable, dict, int] = 0,
-        **kwargs
+        **kwargs,
     ) -> None:
         """
         ``LittleR`` class helps you manage LITTLE_R data easily.
@@ -751,7 +754,7 @@ class LittleR(LittleRData):
             quality_control_flag=quality_control_flag,
             index=index,
             columns=columns,
-            **kwargs
+            **kwargs,
         )
 
         if data_header is None:
@@ -777,7 +780,7 @@ class LittleR(LittleRData):
         cloud_cover=-888888,
         precipitable_water=-888888,
         quality_control: Union[dict, int] = 0,
-        **kwargs
+        **kwargs,
     ):
         """
         Set headers of LITTLE_R observation data.
@@ -801,7 +804,8 @@ class LittleR(LittleRData):
         :type name: str, optional
         :param source: Data source, defaults to "Created by wrfrun package".
         :type source: str, optional
-        :param num_sequence: Sequence number, used to merge multiple record data, the less the num is, the newer the data is, defaults to 0
+        :param num_sequence: Sequence number, used to merge multiple record data,
+                             the less the num is, the newer the data is, defaults to 0
         :type num_sequence: int, optional
         :param sea_level_pressure: Sea level pressure, defaults to -888888
         :type sea_level_pressure: int, optional
@@ -817,10 +821,23 @@ class LittleR(LittleRData):
         :type quality_control: Union[dict, int], optional
         """
         self.little_r_head = LittleRHead(
-            longitude, latitude, fm, elevation, is_bogus, date, ID,
-            name=name, source=source, num_sequence=num_sequence, sea_level_pressure=sea_level_pressure, reference_pressure=reference_pressure,
-            surface_pressure=surface_pressure, cloud_cover=cloud_cover, precipitable_water=precipitable_water, quality_control=quality_control,
-            **kwargs
+            longitude,
+            latitude,
+            fm,
+            elevation,
+            is_bogus,
+            date,
+            ID,
+            name=name,
+            source=source,
+            num_sequence=num_sequence,
+            sea_level_pressure=sea_level_pressure,
+            reference_pressure=reference_pressure,
+            surface_pressure=surface_pressure,
+            cloud_cover=cloud_cover,
+            precipitable_water=precipitable_water,
+            quality_control=quality_control,
+            **kwargs,
         )
 
     def __str__(self) -> str:
@@ -849,7 +866,7 @@ class LittleR(LittleRData):
         if not file_path.endswith(".zlr"):
             file_path = f"{file_path}.zlr"
 
-        file_path = get_wrfrun_config().parse_resource_uri(file_path)
+        file_path = WRFRUN.config.parse_resource_uri(file_path)
 
         with ZipFile(file_path, "w") as zip_file:
             with zip_file.open("header", "w") as header_file:
@@ -868,7 +885,7 @@ class LittleR(LittleRData):
         :return: ``LittleR`` instance.
         :rtype: LittleR
         """
-        file_path = get_wrfrun_config().parse_resource_uri(file_path)
+        file_path = WRFRUN.config.parse_resource_uri(file_path)
 
         with ZipFile(file_path, "r") as zip_file:
             with zip_file.open("header", "r") as header_file:

wrfrun/extension/utils.py

@@ -15,8 +15,9 @@ from os.path import exists
 from shutil import copyfile
 from typing import List, Optional
 
-from wrfrun.core import get_wrfrun_config
-from wrfrun.utils import check_path, logger
+from wrfrun.core import WRFRUN
+from wrfrun.log import logger
+from wrfrun.utils import check_path
 
 
 def extension_postprocess(output_dir: str, extension_id: str, outputs: Optional[List[str]] = None):
@@ -37,7 +38,7 @@ def extension_postprocess(output_dir: str, extension_id: str, outputs: Optional[
     :param outputs: A list contains multiple filenames. Files in this will be treated as outputs.
     :type outputs: list
     """
-    WRFRUNConfig = get_wrfrun_config()
+    WRFRUNConfig = WRFRUN.config
     output_path = WRFRUNConfig.WRFRUN_OUTPUT_PATH
     output_save_path = f"{output_path}/{extension_id}"
     log_save_path = f"{output_path}/{extension_id}/logs"

wrfrun/log.py

@@ -0,0 +1,117 @@
+"""
+wrfrun.log
+##########
+
+.. autosummary::
+    :toctree: generated/
+
+    get_wrfrun_rich_console
+    logger_add_file_handler
+    set_logger
+    unify_logger_format
+
+``wrfrun`` submodule to manage logs. This submodule only take care of ``wrfrun``'s log.
+
+For functions and classes which parse numerical models' log, please check :doc:`model </api/model>`.
+"""
+
+import logging
+from datetime import datetime
+from os import environ
+from time import time
+from typing import Dict, List, Optional
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+from .utils import check_path
+
+WRFRUN_RICH_CONSOLE = Console()
+
+
+def set_logger(logger_list: List[str], logger_level: Optional[Dict] = None):
+    """
+    This function will replace all handlers of each logger in ``logger_list`` with RichHandler.
+
+    If there are some custom handlers in logger, they will be replaced too.
+
+    :param logger_list: A list contains loggers.
+    :type logger_list: list
+    :param logger_level: You can specify the log level in ``logger_level``, with the name of logger is the key,
+                         and the level of logger is the value.
+                         Default if None, with which all loggers' level will be set to ``logging.WARNING``.
+    :type logger_level: list | None
+    """
+    formatter = logging.Formatter("%(name)s :: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    # use rich handler
+    handler = RichHandler(console=WRFRUN_RICH_CONSOLE)
+    handler.setFormatter(formatter)
+
+    for logger_name in logger_list:
+        if logger_name in logging.root.manager.loggerDict:
+            _logger = logging.getLogger(logger_name)
+            for _handler in _logger.handlers:
+                _logger.removeHandler(_handler)
+            _logger.addHandler(handler)
+
+            if logger_level is not None and logger_name in logger_level:
+                _logger.setLevel(logger_level[logger_name])
+            else:
+                _logger.setLevel(logging.WARNING)
+
+
+def unify_logger_format():
+    """
+    This function is only supposed to be used internally.
+
+    This function will replace all handlers of each logger with ``rich.logging.RichHandler``.
+    Use this carefully.
+    """
+    set_logger(
+        ["cdsapi", "cfgrib", "datapi"],
+        {"cdsapi": logging.INFO, "cfgrib": logging.ERROR, "datapi": logging.INFO},
+    )
+
+
+# init wrfrun logger
+logger = logging.getLogger("wrfrun")
+# check environment variables and set logger level
+if "WRFRUN_DEBUG_MODE" in environ and environ["WRFRUN_DEBUG_MODE"]:
+    _logger_level = logging.DEBUG
+    _debug_mode = True
+else:
+    _logger_level = logging.INFO
+    _debug_mode = False
+set_logger(["wrfrun"], {"wrfrun": _logger_level})
+logger.debug(f"DEBUG MODE: {_debug_mode}")
+
+
+def logger_add_file_handler(log_path: str):
+    """
+    Set log file of logger.
+
+    :param log_path: Log file path.
+    :type log_path: str
+    """
+    # check log save path
+    check_path(log_path)
+
+    # add file handler
+    file_handler = logging.FileHandler(f"{log_path}/{datetime.fromtimestamp(time()).strftime('%Y-%m-%d %H:%M:%S')}.log")
+    file_handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s :: %(message)s", datefmt="%m-%d %H:%M:%S")
+    )
+    logger.addHandler(file_handler)
+
+
+def get_wrfrun_rich_console() -> Console:
+    """
+    Get ``rich.console.Console`` instance used in wrfrun.
+
+    :return: Console instance.
+    :rtype: Console
+    """
+    return WRFRUN_RICH_CONSOLE
+
+
+__all__ = ["set_logger", "unify_logger_format", "logger_add_file_handler", "logger", "get_wrfrun_rich_console"]