potato-util 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

potato_util/__init__.py

@@ -1,6 +1,4 @@
-from .__version__ import __version__
-
+# flake8: noqa
 
-__all__ = [
-    "__version__",
-]
+from .__version__ import __version__
+from ._base import *

potato_util/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.2"
+__version__ = "0.0.3"

potato_util/_base.py

@@ -51,67 +51,7 @@ def camel_to_snake(val: str) -> str:
     return val
 
 
-@validate_call
-def clean_obj_dict(obj_dict: dict, cls_name: str) -> dict:
-    """Clean class name from object.__dict__ for str(object).
-
-    Args:
-        obj_dict (dict, required): Object dictionary by object.__dict__.
-        cls_name (str , required): Class name by cls.__name__.
-
-    Returns:
-        dict: Clean object dictionary.
-    """
-
-    try:
-        if not obj_dict:
-            raise ValueError("'obj_dict' argument value is empty!")
-
-        if not cls_name:
-            raise ValueError("'cls_name' argument value is empty!")
-    except ValueError as err:
-        logger.error(err)
-        raise
-
-    _self_dict = obj_dict.copy()
-    for _key in _self_dict.copy():
-        _class_prefix = f"_{cls_name}__"
-        if _key.startswith(_class_prefix):
-            _new_key = _key.replace(_class_prefix, "")
-            _self_dict[_new_key] = _self_dict.pop(_key)
-    return _self_dict
-
-
-@validate_call(config={"arbitrary_types_allowed": True})
-def obj_to_repr(obj: object) -> str:
-    """Modifying object default repr() to custom info.
-
-    Args:
-        obj (object, required): Any python object.
-
-    Returns:
-        str: String for repr() method.
-    """
-
-    try:
-        if not obj:
-            raise ValueError("'obj' argument value is empty!")
-    except ValueError as err:
-        logger.error(err)
-        raise
-
-    _self_repr = (
-        f"<{obj.__class__.__module__}.{obj.__class__.__name__} object at {hex(id(obj))}: "
-        + "{"
-        + f"{str(dir(obj)).replace('[', '').replace(']', '')}"
-        + "}>"
-    )
-    return _self_repr
-
-
 __all__ = [
     "deep_merge",
     "camel_to_snake",
-    "clean_obj_dict",
-    "obj_to_repr",
 ]

potato_util/dt.py

@@ -11,13 +11,55 @@ from .constants import WarnEnum, TSUnitEnum
 logger = logging.getLogger(__name__)
 
 
+def now_local_dt() -> datetime:
+    """Get current datetime in local timezone with tzinfo.
+
+    Returns:
+        datetime: Current datetime in local timezone with tzinfo.
+    """
+
+    _local_dt = datetime.now().astimezone()
+    return _local_dt
+
+
+def now_utc_dt() -> datetime:
+    """Get current datetime in UTC timezone with tzinfo.
+
+    Returns:
+        datetime: Current datetime in UTC timezone with tzinfo.
+    """
+
+    _utc_dt = datetime.now(tz=timezone.utc)
+    return _utc_dt
+
+
+@validate_call(config={"arbitrary_types_allowed": True})
+def now_dt(tz: ZoneInfo | tzinfo | str | None = None) -> datetime:
+    """Get current datetime in specified timezone with tzinfo.
+
+    Args:
+        tz (ZoneInfo | tzinfo | str | None, optional): Timezone info. Defaults to None (UTC timezone).
+
+    Returns:
+        datetime: Current datetime in specified timezone with tzinfo.
+    """
+
+    _dt = now_utc_dt()
+    if tz:
+        _dt = convert_tz(dt=_dt, tz=tz)
+    return _dt
+
+
 @validate_call(config={"arbitrary_types_allowed": True})
-def add_tzinfo(dt: datetime, tz: ZoneInfo | tzinfo | str) -> datetime:
+def replace_tz(dt: datetime, tz: ZoneInfo | tzinfo | str) -> datetime:
     """Add or replace timezone info to datetime object.
 
     Args:
-        dt (datetime                    , required): Datetime object.
-        tz (Union[ZoneInfo, tzinfo, str], required): Timezone info.
+        dt (datetime               , required): Datetime object.
+        tz (ZoneInfo | tzinfo | str, required): Timezone info.
+
+    Raises:
+        ZoneInfoNotFoundError: If `tz` argument value is invalid.
 
     Returns:
         datetime: Datetime object with timezone info.
@@ -30,30 +72,29 @@ def add_tzinfo(dt: datetime, tz: ZoneInfo | tzinfo | str) -> datetime:
     return dt
 
 
-@validate_call
-def datetime_to_iso(
-    dt: datetime, sep: str = "T", warn_mode: WarnEnum = WarnEnum.IGNORE
-) -> str:
-    """Convert datetime object to ISO 8601 format.
+@validate_call(config={"arbitrary_types_allowed": True})
+def convert_tz(
+    dt: datetime,
+    tz: ZoneInfo | tzinfo | str,
+    warn_mode: WarnEnum | str = WarnEnum.ALWAYS,
+) -> datetime:
+    """Convert datetime object to another timezone.
 
     Args:
-        dt        (datetime, required): Datetime object.
-        sep       (str     , optional): Separator between date and time. Defaults to "T".
-        warn_mode (WarnEnum, optional): Warning mode. Defaults to WarnEnum.IGNORE.
+        dt        (datetime               , required): Datetime object to convert.
+        tz        (ZoneInfo | tzinfo | str, required): Timezone info to convert.
+        warn_mode (WarnEnum | str         , optional): Warning mode. Defaults to WarnEnum.ALWAYS.
 
     Raises:
-        ValueError: If `sep` argument length is greater than 8.
         ValueError: If `dt` argument doesn't have any timezone info and `warn_mode` is set to WarnEnum.ERROR.
+        ValueError: If `warn_mode` argument value is invalid.
 
     Returns:
-        str: Datetime string in ISO 8601 format.
+        datetime: Datetime object which has been converted to another timezone.
     """
 
-    sep = sep.strip()
-    if 8 < len(sep):
-        raise ValueError(
-            f"`sep` argument length '{len(sep)}' is too long, must be less than or equal to 8!"
-        )
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
 
     if not dt.tzinfo:
         _message = "Not found any timezone info in `dt` argument, assuming it's UTC timezone..."
@@ -66,30 +107,44 @@ def datetime_to_iso(
             logger.error(_message)
             raise ValueError(_message)
 
-        dt = add_tzinfo(dt=dt, tz="UTC")
+        dt = replace_tz(dt=dt, tz="UTC")
 
-    _dt_str = dt.isoformat(sep=sep, timespec="milliseconds")
-    return _dt_str
+    if isinstance(tz, str):
+        tz = ZoneInfo(tz)
 
+    dt = dt.astimezone(tz=tz)
+    return dt
 
-@validate_call(config={"arbitrary_types_allowed": True})
-def convert_tz(
-    dt: datetime, tz: ZoneInfo | tzinfo | str, warn_mode: WarnEnum = WarnEnum.ALWAYS
-) -> datetime:
-    """Convert datetime object to another timezone.
+
+@validate_call
+def dt_to_iso(
+    dt: datetime, sep: str = "T", warn_mode: WarnEnum | str = WarnEnum.IGNORE
+) -> str:
+    """Convert datetime object to ISO 8601 format.
 
     Args:
-        dt        (datetime                    , required): Datetime object to convert.
-        tz        (Union[ZoneInfo, tzinfo, str], required): Timezone info to convert.
-        warn_mode (WarnEnum                    , optional): Warning mode. Defaults to WarnEnum.ALWAYS.
+        dt        (datetime      , required): Datetime object.
+        sep       (str           , optional): Separator between date and time. Defaults to "T".
+        warn_mode (WarnEnum | str, optional): Warning mode. Defaults to WarnEnum.IGNORE.
 
     Raises:
         ValueError: If `dt` argument doesn't have any timezone info and `warn_mode` is set to WarnEnum.ERROR.
+        ValueError: If `sep` argument length is greater than 8.
+        ValueError: If `warn_mode` argument value is invalid.
 
     Returns:
-        datetime: Datetime object which has been converted to another timezone.
+        str: Datetime string in ISO 8601 format.
     """
 
+    sep = sep.strip()
+    if 8 < len(sep):
+        raise ValueError(
+            f"`sep` argument length '{len(sep)}' is too long, must be less than or equal to 8!"
+        )
+
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if not dt.tzinfo:
         _message = "Not found any timezone info in `dt` argument, assuming it's UTC timezone..."
         if warn_mode == WarnEnum.ALWAYS:
@@ -101,59 +156,51 @@ def convert_tz(
             logger.error(_message)
             raise ValueError(_message)
 
-        dt = add_tzinfo(dt=dt, tz="UTC")
+        dt = replace_tz(dt=dt, tz="UTC")
 
-    if isinstance(tz, str):
-        tz = ZoneInfo(tz)
-
-    dt = dt.astimezone(tz=tz)
-    return dt
-
-
-def now_utc_dt() -> datetime:
-    """Get current datetime in UTC timezone with tzinfo.
-
-    Returns:
-        datetime: Current datetime in UTC timezone with tzinfo.
-    """
+    _dt_str = dt.isoformat(sep=sep, timespec="milliseconds")
+    return _dt_str
 
-    _utc_dt = datetime.now(tz=timezone.utc)
-    return _utc_dt
 
+@validate_call(config={"arbitrary_types_allowed": True})
+def calc_future_dt(
+    delta: timedelta | int,
+    dt: datetime | None = None,
+    tz: ZoneInfo | tzinfo | str | None = None,
+) -> datetime:
+    """Calculate future datetime by adding delta time to current or specified datetime.
 
-def now_local_dt() -> datetime:
-    """Get current datetime in local timezone with tzinfo.
+    Args:
+        delta (timedelta | int             , required): Delta time to add to current or specified datetime.
+        dt    (datetime | None             , optional): Datetime before adding delta time. Defaults to None.
+        tz    (ZoneInfo | tzinfo, str, None, optional): Timezone info. Defaults to None.
 
     Returns:
-        datetime: Current datetime in local timezone with tzinfo.
+        datetime: Calculated future datetime.
     """
 
-    _local_dt = datetime.now().astimezone()
-    return _local_dt
-
-
-@validate_call(config={"arbitrary_types_allowed": True})
-def now_dt(tz: ZoneInfo | tzinfo | str) -> datetime:
-    """Get current datetime in specified timezone with tzinfo.
+    if not dt:
+        dt = now_utc_dt()
 
-    Args:
-        tz (Union[ZoneInfo, tzinfo, str], required): Timezone info.
+    if tz:
+        dt = convert_tz(dt=dt, tz=tz)
 
-    Returns:
-        datetime: Current datetime in specified timezone with tzinfo.
-    """
+    if isinstance(delta, int):
+        delta = timedelta(seconds=delta)
 
-    _dt = now_utc_dt()
-    _dt = convert_tz(dt=_dt, tz=tz)
-    return _dt
+    _future_dt = dt + delta
+    return _future_dt
 
 
 @validate_call
-def now_ts(unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int:
+def now_ts(unit: TSUnitEnum | str = TSUnitEnum.SECONDS) -> int:
     """Get current timestamp in UTC timezone.
 
     Args:
-        unit (TSUnitEnum, optional): Type of timestamp unit. Defaults to `TSUnitEnum.SECONDS`.
+        unit (TSUnitEnum | str, optional): Type of timestamp unit. Defaults to TSUnitEnum.SECONDS.
+
+    Raises:
+        ValueError: If `unit` argument value is invalid.
 
     Returns:
         int: Current timestamp.
@@ -168,17 +215,22 @@ def now_ts(unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int:
         _now_ts = int(time.time_ns() / 1000)
     elif unit == TSUnitEnum.NANOSECONDS:
         _now_ts = int(time.time_ns())
+    else:
+        raise ValueError(f"`unit` argument value '{unit}' is invalid!")
 
     return _now_ts
 
 
 @validate_call
-def convert_ts(dt: datetime, unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int:
+def dt_to_ts(dt: datetime, unit: TSUnitEnum | str = TSUnitEnum.SECONDS) -> int:
     """Convert datetime to timestamp.
 
     Args:
-        dt   (datetime  , required): Datetime object to convert.
-        unit (TSUnitEnum, optional): Type of timestamp unit. Defaults to `TSUnitEnum.SECONDS`.
+        dt   (datetime        , required): Datetime object to convert.
+        unit (TSUnitEnum | str, optional): Type of timestamp unit. Defaults to `TSUnitEnum.SECONDS`.
+
+    Raises:
+        ValueError: If `unit` argument value is invalid.
 
     Returns:
         int: Converted timestamp.
@@ -193,48 +245,20 @@ def convert_ts(dt: datetime, unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int:
         _ts = int(dt.timestamp() * 1000000)
     elif unit == TSUnitEnum.NANOSECONDS:
         _ts = int(dt.timestamp() * 1000000000)
+    else:
+        raise ValueError(f"`unit` argument value '{unit}' is invalid!")
 
     return _ts
 
 
-@validate_call(config={"arbitrary_types_allowed": True})
-def calc_future_dt(
-    delta: timedelta | int,
-    dt: datetime | None = None,
-    tz: ZoneInfo | tzinfo | str | None = None,
-) -> datetime:
-    """Calculate future datetime by adding delta time to current or specified datetime.
-
-    Args:
-        delta (Union[timedelta, int]             , required): Delta time to add to current or specified datetime.
-        dt    (Optional[datetime]                , optional): Datetime before adding delta time. Defaults to None.
-        tz    (Union[ZoneInfo, tzinfo, str, None], optional): Timezone info. Defaults to None.
-
-    Returns:
-        datetime: Calculated future datetime.
-    """
-
-    if not dt:
-        dt = now_utc_dt()
-
-    if tz:
-        dt = convert_tz(dt=dt, tz=tz)
-
-    if isinstance(delta, int):
-        delta = timedelta(seconds=delta)
-
-    _future_dt = dt + delta
-    return _future_dt
-
-
 __all__ = [
-    "add_tzinfo",
-    "datetime_to_iso",
-    "convert_tz",
     "now_utc_dt",
     "now_local_dt",
     "now_dt",
-    "now_ts",
-    "convert_ts",
+    "replace_tz",
+    "convert_tz",
+    "dt_to_iso",
     "calc_future_dt",
+    "now_ts",
+    "dt_to_ts",
 ]

potato_util/generator.py

@@ -0,0 +1,65 @@
+import uuid
+import string
+import secrets
+
+from pydantic import validate_call
+
+from .dt import now_ts
+
+
+@validate_call
+def gen_unique_id(prefix: str = "") -> str:
+    """Generate unique ID. Format: '{prefix}{datetime}_{uuid4}'.
+
+    Args:
+        prefix (str, optional): Prefix of ID. Defaults to ''.
+
+    Raises:
+        ValueError: If `prefix` length is greater than 32.
+
+    Returns:
+        str: Unique ID.
+    """
+
+    prefix = prefix.strip()
+    if 32 < len(prefix):
+        raise ValueError(
+            f"`prefix` argument length {len(prefix)} is too long, must be less than or equal to 32!",
+        )
+
+    _id = str(f"{prefix}{now_ts()}_{uuid.uuid4().hex}").lower()
+    return _id
+
+
+@validate_call
+def gen_random_string(length: int = 16, is_alphanum: bool = True) -> str:
+    """Generate secure random string.
+
+    Args:
+        length      (int , optional): Length of random string. Defaults to 16.
+        is_alphanum (bool, optional): If True, generate only alphanumeric string. Defaults to True.
+
+    Raises:
+        ValueError: If `length` is less than 1.
+
+    Returns:
+        str: Generated random string.
+    """
+
+    if length < 1:
+        raise ValueError(
+            f"`length` argument value {length} is too small, must be greater than or equal to 1!",
+        )
+
+    _base_chars = string.ascii_letters + string.digits
+    if not is_alphanum:
+        _base_chars += string.punctuation
+
+    _random_str = "".join(secrets.choice(_base_chars) for _i in range(length))
+    return _random_str
+
+
+__all__ = [
+    "gen_unique_id",
+    "gen_random_string",
+]

potato_util/http/_base.py

@@ -34,7 +34,9 @@ def get_http_status(status_code: int) -> tuple[HTTPStatus, bool]:
         elif (500 <= status_code) and (status_code < 600):
             status_code = 500
         else:
-            raise ValueError(f"Invalid HTTP status code: '{status_code}'!")
+            raise ValueError(
+                f"`status_code` argument value '{status_code}' is invalid, must be in range 100-599!",
+            )
 
         _http_status = HTTPStatus(status_code)
 

potato_util/http/fastapi.py

@@ -8,7 +8,7 @@ def get_relative_url(val: Request | URL) -> str:
     """Get relative url only path with query params from request object or URL object.
 
     Args:
-        val (Union[Request, URL]): Request object or URL object to extract relative url.
+        val (Request | URL, required): Request object or URL object to extract relative url.
 
     Returns:
         str: Relative url only path with query params.

potato_util/io/_async.py

@@ -14,14 +14,14 @@ logger = logging.getLogger(__name__)
 
 @validate_call
 async def async_create_dir(
-    create_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG
+    create_dir: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG
 ) -> None:
     """Asynchronous create directory if `create_dir` doesn't exist.
 
     Args:
-        create_dir (str, required): Create directory path.
-        warn_mode  (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
-                                        Defaults to 'DEBUG'.
+        create_dir (str           , required): Create directory path.
+        warn_mode  (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+                                                Defaults to 'DEBUG'.
 
     Raises:
         ValueError: If `create_dir` argument length is out of range.
@@ -36,6 +36,9 @@ async def async_create_dir(
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if not await aiofiles.os.path.isdir(create_dir):
         try:
             _message = f"Creating '{create_dir}' directory..."
@@ -66,14 +69,14 @@ async def async_create_dir(
 
 @validate_call
 async def async_remove_dir(
-    remove_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG
+    remove_dir: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG
 ) -> None:
     """Asynchronous remove directory if `remove_dir` exists.
 
     Args:
-        remove_dir (str, required): Remove directory path.
-        warn_mode  (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
-                                        Defaults to 'DEBUG'.
+        remove_dir (str           , required): Remove directory path.
+        warn_mode  (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+                                                Defaults to 'DEBUG'.
 
     Raises:
         ValueError: If `remove_dir` argument length is out of range.
@@ -88,6 +91,9 @@ async def async_remove_dir(
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if await aiofiles.os.path.isdir(remove_dir):
         try:
             _message = f"Removing '{remove_dir}' directory..."
@@ -118,14 +124,14 @@ async def async_remove_dir(
 
 @validate_call
 async def async_remove_dirs(
-    remove_dirs: list[str], warn_mode: WarnEnum = WarnEnum.DEBUG
+    remove_dirs: list[str], warn_mode: WarnEnum | str = WarnEnum.DEBUG
 ) -> None:
     """Asynchronous remove directories if `remove_dirs` exists.
 
     Args:
-        remove_dirs (List[str], required): Remove directories paths as list.
-        warn_mode   (str      , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
-                                                Defaults to 'DEBUG'.
+        remove_dirs (list[str]     , required): Remove directories paths as list.
+        warn_mode   (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+                                                    Defaults to 'DEBUG'.
     """
 
     for _remove_dir in remove_dirs:
@@ -136,14 +142,14 @@ async def async_remove_dirs(
 
 @validate_call
 async def async_remove_file(
-    file_path: str, warn_mode: WarnEnum = WarnEnum.DEBUG
+    file_path: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG
 ) -> None:
     """Asynchronous remove file if `file_path` exists.
 
     Args:
-        file_path (str, required): Remove file path.
-        warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
-                                        Defaults to 'DEBUG'.
+        file_path (str           , required): Remove file path.
+        warn_mode (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+                                                Defaults to 'DEBUG'.
 
     Raises:
         ValueError: If `file_path` argument length is out of range.
@@ -158,6 +164,9 @@ async def async_remove_file(
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if await aiofiles.os.path.isfile(file_path):
         try:
             _message = f"Removing '{file_path}' file..."
@@ -188,13 +197,13 @@ async def async_remove_file(
 
 @validate_call
 async def async_remove_files(
-    file_paths: list[str], warn_mode: WarnEnum = WarnEnum.DEBUG
+    file_paths: list[str], warn_mode: WarnEnum | str = WarnEnum.DEBUG
 ) -> None:
     """Asynchronous remove files if `file_paths` exists.
 
     Args:
-        file_paths (List[str], required): Remove file paths as list.
-        warn_mode  (str      , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+        file_paths (list[str]     , required): Remove file paths as list.
+        warn_mode  (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
                                                 Defaults to 'DEBUG'.
     """
 
@@ -209,15 +218,15 @@ async def async_get_file_checksum(
     file_path: str,
     hash_method: HashAlgoEnum = HashAlgoEnum.md5,
     chunk_size: int = 4096,
-    warn_mode: WarnEnum = WarnEnum.DEBUG,
+    warn_mode: WarnEnum | str = WarnEnum.DEBUG,
 ) -> str | None:
     """Asynchronous get file checksum.
 
     Args:
-        file_path   (str         , required): Target file path.
-        hash_method (HashAlgoEnum, optional): Hash method. Defaults to `HashAlgoEnum.md5`.
-        chunk_size  (int         , optional): Chunk size. Defaults to 4096.
-        warn_mode   (str         , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+        file_path   (str           , required): Target file path.
+        hash_method (HashAlgoEnum  , optional): Hash method. Defaults to `HashAlgoEnum.md5`.
+        chunk_size  (int           , optional): Chunk size. Defaults to 4096.
+        warn_mode   (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
                                                     Defaults to 'DEBUG'.
 
     Raises:
@@ -241,6 +250,9 @@ async def async_get_file_checksum(
             f"`chunk_size` argument value {chunk_size} is invalid, must be greater than 10!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     _file_checksum: str | None = None
     if await aiofiles.os.path.isfile(file_path):
         _file_hash = hashlib.new(hash_method.value)