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

potato_util/io/_sync.py

@@ -13,13 +13,13 @@ logger = logging.getLogger(__name__)
 
 
 @validate_call
-def create_dir(create_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
+def create_dir(create_dir: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG) -> None:
     """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.
@@ -34,6 +34,9 @@ def create_dir(create_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if not os.path.isdir(create_dir):
         try:
             _message = f"Creating '{create_dir}' directory..."
@@ -63,13 +66,13 @@ def create_dir(create_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
 
 
 @validate_call
-def remove_dir(remove_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
+def remove_dir(remove_dir: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG) -> None:
     """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.
@@ -84,6 +87,9 @@ def remove_dir(remove_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if os.path.isdir(remove_dir):
         try:
             _message = f"Removing '{remove_dir}' directory..."
@@ -113,12 +119,14 @@ def remove_dir(remove_dir: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
 
 
 @validate_call
-def remove_dirs(remove_dirs: list[str], warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
+def remove_dirs(
+    remove_dirs: list[str], warn_mode: WarnEnum | str = WarnEnum.DEBUG
+) -> None:
     """Remove directories if `remove_dirs` exist.
 
     Args:
-        remove_dirs (List[str], required): Remove directory paths as list.
-        warn_mode   (str      , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
+        remove_dirs (list[str]     , required): Remove directory paths as list.
+        warn_mode   (WarnEnum | str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'.
                                                 Defaults to 'DEBUG'.
     """
 
@@ -129,13 +137,13 @@ def remove_dirs(remove_dirs: list[str], warn_mode: WarnEnum = WarnEnum.DEBUG) ->
 
 
 @validate_call
-def remove_file(file_path: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
+def remove_file(file_path: str, warn_mode: WarnEnum | str = WarnEnum.DEBUG) -> None:
     """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.
@@ -150,6 +158,9 @@ def remove_file(file_path: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
             f"must be between 1 and {MAX_PATH_LENGTH} characters!"
         )
 
+    if isinstance(warn_mode, str):
+        warn_mode = WarnEnum(warn_mode.strip().upper())
+
     if os.path.isfile(file_path):
         try:
             _message = f"Removing '{file_path}' file..."
@@ -179,12 +190,14 @@ def remove_file(file_path: str, warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
 
 
 @validate_call
-def remove_files(file_paths: list[str], warn_mode: WarnEnum = WarnEnum.DEBUG) -> None:
+def remove_files(
+    file_paths: list[str], warn_mode: WarnEnum | str = WarnEnum.DEBUG
+) -> None:
     """Remove files if `file_paths` exist.
 
     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'.
     """
 
@@ -199,16 +212,16 @@ def 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:
     """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'.
-                                                Defaults to 'DEBUG'.
+        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:
         ValueError: If `file_path` argument length is out of range.
@@ -231,6 +244,9 @@ def 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 os.path.isfile(file_path):
         _file_hash = hashlib.new(hash_method.value)

potato_util/sanitizer.py

@@ -30,7 +30,7 @@ def escape_html(val: str) -> str:
 
 
 @validate_call
-def escape_url(val: AnyHttpUrl) -> str:
+def escape_url(val: AnyHttpUrl | str) -> str:
     """Escape URL characters.
 
     Args:
@@ -40,6 +40,9 @@ def escape_url(val: AnyHttpUrl) -> str:
         str: Escaped string.
     """
 
+    if isinstance(val, str):
+        val = AnyHttpUrl(val)
+
     _escaped = quote(str(val))
     return _escaped
 
@@ -47,13 +50,19 @@ def escape_url(val: AnyHttpUrl) -> str:
 @validate_call
 def sanitize_special_chars(val: str, mode: str = "LOW") -> str:
     """Sanitize special characters.
+    Available modes:
+        - "BASE" or "HTML": Basic HTML special characters.
+        - "LOW": Low-risk special characters.
+        - "MEDIUM": Medium-risk special characters.
+        - "HIGH", "SCRIPT", or "SQL": High-risk special characters.
+        - "STRICT": Strict mode, removes most special characters.
 
     Args:
         val  (str, required): String to sanitize.
         mode (str, optional): Sanitization mode. Defaults to "LOW".
 
     Raises:
-        ValueError: If `mode` is unsupported.
+        ValueError: If `mode` argument value is invalid.
 
     Returns:
         str: Sanitized string.
@@ -72,7 +81,7 @@ def sanitize_special_chars(val: str, mode: str = "LOW") -> str:
     elif mode == "STRICT":
         _pattern = SPECIAL_CHARS_STRICT_REGEX
     else:
-        raise ValueError(f"Unsupported mode: {mode}")
+        raise ValueError(f"`mode` argument value '{mode}' is invalid!")
 
     _sanitized = re.sub(pattern=_pattern, repl="", string=val)
     return _sanitized

potato_util/secure.py

@@ -1,73 +1,19 @@
-import uuid
-import string
-import secrets
 import hashlib
 
 from pydantic import validate_call
 
 from .constants import HashAlgoEnum
-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
-
-
-@validate_call
-def hash_str(val: str | bytes, algorithm: HashAlgoEnum = HashAlgoEnum.sha256) -> str:
+def hash_str(
+    val: str | bytes, algorithm: HashAlgoEnum | str = HashAlgoEnum.sha256
+) -> str:
     """Hash a string using a specified hash algorithm.
 
     Args:
-        val       (str | bytes , required): The value to be hashed.
-        algorithm (HashAlgoEnum, required): The hash algorithm to use. Defaults to `HashAlgoEnum.sha256`.
+        val       (str | bytes       , required): The value to be hashed.
+        algorithm (HashAlgoEnum | str, optional): The hash algorithm to use. Defaults to `HashAlgoEnum.sha256`.
 
     Returns:
         str: The hexadecimal representation of the digest.
@@ -76,6 +22,9 @@ def hash_str(val: str | bytes, algorithm: HashAlgoEnum = HashAlgoEnum.sha256) ->
     if isinstance(val, str):
         val = val.encode("utf-8")
 
+    if isinstance(algorithm, str):
+        algorithm = HashAlgoEnum(algorithm.strip().lower())
+
     _hash = hashlib.new(algorithm.value)
     _hash.update(val)
 
@@ -84,7 +33,5 @@ def hash_str(val: str | bytes, algorithm: HashAlgoEnum = HashAlgoEnum.sha256) ->
 
 
 __all__ = [
-    "gen_unique_id",
-    "gen_random_string",
     "hash_str",
 ]

potato_util/validator.py

@@ -18,7 +18,7 @@ def is_truthy(val: str | bool | int | float | None) -> bool:
     """Check if the value is truthy.
 
     Args:
-        val (Union[str, bool, int, float, None], required): Value to check.
+        val (str | bool | int | float | None, required): Value to check.
 
     Raises:
         ValueError: If `val` argument type is string and value is invalid.
@@ -45,7 +45,7 @@ def is_falsy(val: str | bool | int | float | None) -> bool:
     """Check if the value is falsy.
 
     Args:
-        val (Union[str, bool, int, float, None], required): Value to check.
+        val (str | bool | int | float | None, required): Value to check.
 
     Returns:
         bool: True if the value is falsy, False otherwise.
@@ -93,8 +93,8 @@ def is_valid(val: str, pattern: Pattern | str) -> bool:
     """Check if the string is valid with given pattern.
 
     Args:
-        val     (str                , required): String to check.
-        pattern (Union[Pattern, str], required): Pattern regex to check.
+        val     (str          , required): String to check.
+        pattern (Pattern | str, required): Pattern regex to check.
 
     Returns:
         bool: True if the string is valid with given pattern, False otherwise.
@@ -107,13 +107,19 @@ def is_valid(val: str, pattern: Pattern | str) -> bool:
 @validate_call
 def has_special_chars(val: str, mode: str = "LOW") -> bool:
     """Check if the string has special characters.
+    Available modes:
+        - "BASE" or "HTML": Basic HTML special characters.
+        - "LOW": Low-risk special characters.
+        - "MEDIUM": Medium-risk special characters.
+        - "HIGH", "SCRIPT", or "SQL": High-risk special characters.
+        - "STRICT": Strict mode, checks for most special characters.
 
     Args:
         val  (str, required): String to check.
         mode (str, optional): Check mode. Defaults to "LOW".
 
     Raises:
-        ValueError: If `mode` is unsupported.
+        ValueError: If `mode` argument value is invalid.
 
     Returns:
         bool: True if the string has special characters, False otherwise.
@@ -134,7 +140,7 @@ def has_special_chars(val: str, mode: str = "LOW") -> bool:
     elif mode == "STRICT":
         _pattern = SPECIAL_CHARS_STRICT_REGEX
     else:
-        raise ValueError(f"Unsupported mode: {mode}")
+        raise ValueError(f"`mode` argument value '{mode}' is invalid!")
 
     _has_special_chars = bool(re.search(pattern=_pattern, string=val))
     return _has_special_chars

{potato_util-0.0.2.dist-info → potato_util-0.0.4.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: potato_util
-Version: 0.0.2
+Version: 0.0.4
 Summary: 'potato_util' is collection of simple useful utils package for python.
 Author-email: Batkhuu Byambajav <batkhuu10@gmail.com>
-Project-URL: Homepage, https://github.com/bybatkhuu/module.python-utils
+Project-URL: Homepage, https://github.com/bybatkhuu/module-python-utils
 Project-URL: Documentation, https://pyutils-docs.bybatkhuu.dev
-Project-URL: Repository, https://github.com/bybatkhuu/module.python-utils.git
-Project-URL: Issues, https://github.com/bybatkhuu/module.python-utils/issues
-Project-URL: Changelog, https://github.com/bybatkhuu/module.python-utils/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/bybatkhuu/module-python-utils.git
+Project-URL: Issues, https://github.com/bybatkhuu/module-python-utils/issues
+Project-URL: Changelog, https://github.com/bybatkhuu/module-python-utils/blob/main/CHANGELOG.md
 Keywords: potato_util,utils,utilities,tools,helpers
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -77,11 +77,13 @@ Requires-Dist: pyright<2.0.0,>=1.1.392; extra == "dev"
 Requires-Dist: pre-commit<5.0.0,>=4.0.1; extra == "dev"
 Dynamic: license-file
 
-# Potato Utils (Python Utils)
+# Python Utils (potato-util)
 
 [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit)
-[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bybatkhuu/module.python-utils/2.build-publish.yml?logo=GitHub)](https://github.com/bybatkhuu/module.python-utils/actions/workflows/2.build-publish.yml)
-[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/bybatkhuu/module.python-utils?logo=GitHub&color=blue)](https://github.com/bybatkhuu/module.python-utils/releases)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bybatkhuu/module-python-utils/2.build-publish.yml?logo=GitHub)](https://github.com/bybatkhuu/module-python-utils/actions/workflows/2.build-publish.yml)
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/bybatkhuu/module-python-utils?logo=GitHub&color=blue)](https://github.com/bybatkhuu/module-python-utils/releases)
+[![PyPI](https://img.shields.io/pypi/v/potato-util?logo=PyPi)](https://pypi.org/project/potato-util)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/potato-util?logo=Python)](https://docs.conda.io/en/latest/miniconda.html)
 
 'potato_util' is collection of simple useful utils package for python.
 
@@ -89,11 +91,13 @@ Dynamic: license-file
 
 - Python utilities
 - Datetime utilities
-- File I/O utilities
-- HTTP utilities
-- Security utilities
+- Generator utilities
 - Sanitation utilities
+- Security utilities
 - Validation utilities
+- HTTP utilities
+- File I/O utilities
+- And more...
 
 ---
 
@@ -109,7 +113,7 @@ Dynamic: license-file
 [OPTIONAL] For **DEVELOPMENT** environment:
 
 - Install [**git**](https://git-scm.com/downloads)
-- Setup an [**SSH key**](https://docs.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh) ([video tutorial](https://www.youtube.com/watch?v=snCP3c7wXw0))
+- Setup an [**SSH key**](https://docs.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh)
 
 ### 2. 📥 Download or clone the repository
 
@@ -130,20 +134,20 @@ cd ~/workspaces/projects
 **OPTION A.** Clone the repository:
 
 ```sh
-git clone https://github.com/bybatkhuu/module.python-utils.git && \
-    cd module.python-utils
+git clone https://github.com/bybatkhuu/module-python-utils.git && \
+    cd module-python-utils
 ```
 
 **OPTION B.** Clone the repository (for **DEVELOPMENT**: git + ssh key):
 
 ```sh
-git clone git@github.com:bybatkhuu/module.python-utils.git && \
-    cd module.python-utils
+git clone git@github.com:bybatkhuu/module-python-utils.git && \
+    cd module-python-utils
 ```
 
 **OPTION C.** Download source code:
 
-1. Download archived **zip** file from [**releases**](https://github.com/bybatkhuu/module.python-utils/releases).
+1. Download archived **zip** file from [**releases**](https://github.com/bybatkhuu/module-python-utils/releases).
 2. Extract it into the projects directory.
 
 ### 3. 📦 Install the package
@@ -159,7 +163,7 @@ pip install -U potato-util
 **OPTION B.** Install latest version directly from **GitHub** repository:
 
 ```sh
-pip install git+https://github.com/bybatkhuu/module.python-utils.git
+pip install git+https://github.com/bybatkhuu/module-python-utils.git
 ```
 
 **OPTION C.** Install from the downloaded **source code**:
@@ -176,11 +180,14 @@ pip install -e .
 
 ```sh
 pip install -e .[dev]
+
+# Install pre-commit hooks:
+pre-commit install
 ```
 
 **OPTION E.** Install from **pre-built release** files:
 
-1. Download **`.whl`** or **`.tar.gz`** file from [**releases**](https://github.com/bybatkhuu/module.python-utils/releases)
+1. Download **`.whl`** or **`.tar.gz`** file from [**releases**](https://github.com/bybatkhuu/module-python-utils/releases)
 2. Install with pip:
 
 ```sh
@@ -210,6 +217,177 @@ cp -r ./src/potato_util /some/path/project/
 [**`examples/simple/main.py`**](./examples/simple/main.py):
 
 ```python
+#!/usr/bin/env python
+
+# Standard libraries
+import os
+import sys
+import logging
+
+# Third-party libraries
+from pydantic import AnyHttpUrl
+
+# Internal modules
+import potato_util
+import potato_util.dt as dt_utils
+import potato_util.generator as gen_utils
+import potato_util.sanitizer as sanitizer_utils
+import potato_util.secure as secure_utils
+import potato_util.validator as validator_utils
+import potato_util.http as http_utils
+
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    _log_level = logging.INFO
+    if str(os.getenv("DEBUG", "0")).lower() in ("1", "true", "t", "yes", "y"):
+        _log_level = logging.DEBUG
+
+    logging.basicConfig(
+        stream=sys.stdout,
+        level=_log_level,
+        datefmt="%Y-%m-%d %H:%M:%S %z",
+        format="[%(asctime)s | %(levelname)s | %(filename)s:%(lineno)d]: %(message)s",
+    )
+
+    # Base utils:
+    logger.info("[BASE UTILITIES]")
+    _dict1 = {"a": 1, "b": {"c": 2, "d": 3}, "g": [2, 3, 4]}
+    _dict2 = {"b": {"c": 20, "e": 30}, "f": 40, "g": [5, 6, 7]}
+    _merged_dict = potato_util.deep_merge(_dict1, _dict2)
+    logger.info(f"Merged dict: {_merged_dict}")
+
+    _camel_str = "CamelCaseString"
+    _snake_str = potato_util.camel_to_snake(_camel_str)
+    logger.info(f"Converted '{_camel_str}' to '{_snake_str}'")
+    logger.info("-" * 80)
+
+    # Datetime utils:
+    logger.info("[DATETIME UTILITIES]")
+    _now_local_dt = dt_utils.now_local_dt()
+    logger.info(f"Current local datetime: {_now_local_dt}")
+
+    _now_utc_dt = dt_utils.now_utc_dt()
+    logger.info(f"Current UTC datetime: {_now_utc_dt}")
+
+    _now_ny_dt = dt_utils.now_dt(tz="America/New_York")
+    logger.info(f"Current New York datetime: {_now_ny_dt}")
+
+    _now_ts = dt_utils.now_ts()
+    logger.info(f"Current UTC timestamp (seconds): {_now_ts}")
+
+    _now_ts_ms = dt_utils.now_ts(unit="MILLISECONDS")
+    logger.info(f"Current UTC timestamp (ms): {_now_ts_ms}")
+
+    _now_ts_micro = dt_utils.now_ts(unit="MICROSECONDS")
+    logger.info(f"Current UTC timestamp (microseconds): {_now_ts_micro}")
+
+    _now_ts_ns = dt_utils.now_ts(unit="NANOSECONDS")
+    logger.info(f"Current UTC timestamp (nanoseconds): {_now_ts_ns}")
+
+    _dt_ts = dt_utils.dt_to_ts(dt=_now_local_dt)
+    logger.info(f"Converted local datetime to UTC timestamp (seconds): {_dt_ts}")
+
+    _replaced_tz_dt = dt_utils.replace_tz(dt=_now_local_dt, tz="Asia/Ulaanbaatar")
+    logger.info(f"Add or replace timezone with Asia/Ulaanbaatar: {_replaced_tz_dt}")
+
+    _converted_dt = dt_utils.convert_tz(dt=_now_ny_dt, tz="Asia/Seoul")
+    logger.info(
+        f"Calculated and converted timezone from New York to Seoul: {_converted_dt}"
+    )
+
+    _dt_iso = dt_utils.dt_to_iso(dt=_now_local_dt)
+    logger.info(f"Parsing datetime to ISO 8601 format string: {_dt_iso}")
+
+    _future_dt = dt_utils.calc_future_dt(delta=3600, dt=_now_local_dt, tz="Asia/Tokyo")
+    logger.info(f"Calculated future datetime after 3600 seconds in Tokyo: {_future_dt}")
+    logger.info("-" * 80)
+
+    # Generator utils:
+    logger.info("[GENERATOR UTILITIES]")
+    _unique_id = gen_utils.gen_unique_id(prefix="item_")
+    logger.info(f"Generated unique ID based on datetime and UUIDv4: {_unique_id}")
+
+    _random_str = gen_utils.gen_random_string(length=32, is_alphanum=False)
+    logger.info(f"Generated secure random string: {_random_str}")
+    logger.info("-" * 80)
+
+    # Sanitizer utils:
+    logger.info("[SANITIZER UTILITIES]")
+    _raw_html = '  <script>alert("XSS Attack!");</script>  '
+    _escaped_html = sanitizer_utils.escape_html(val=_raw_html)
+    logger.info(f"Escaped HTML: {_escaped_html}")
+
+    _raw_url = "https://www.example.com/search?q=potato util&body=<script>alert('Attack!')</script>&lang=한국어"
+    _escaped_url = sanitizer_utils.escape_url(val=_raw_url)
+    logger.info(f"Escaped URL: {_escaped_url}")
+
+    _raw_str = "Hello@World! This is a test_string with special#chars$%&*()[]{};:'\",.<>?/\\|`~"
+    _sanitized_str = sanitizer_utils.sanitize_special_chars(val=_raw_str, mode="STRICT")
+    logger.info(f"Sanitized string: {_sanitized_str}")
+    logger.info("-" * 80)
+
+    # Secure utils:
+    logger.info("[SECURE UTILITIES]")
+    _input_str = "SensitiveInformation123!"
+    _hashed_str_sha256 = secure_utils.hash_str(val=_input_str, algorithm="sha256")
+    logger.info(f"SHA-256 hashed string: {_hashed_str_sha256}")
+    logger.info("-" * 80)
+
+    # Validator utils:
+    logger.info("[VALIDATOR UTILITIES]")
+    _is_yes_truthy = validator_utils.is_truthy(val="Yes")
+    logger.info(f"Is 'Yes' truthy: {_is_yes_truthy}")
+    _is_off_truthy = validator_utils.is_truthy(val="OFF")
+    logger.info(f"Is 'OFF' truthy: {_is_off_truthy}")
+
+    _is_no_falsy = validator_utils.is_falsy(val="f")
+    logger.info(f"Is 'f' falsy: {_is_no_falsy}")
+    _is_1_falsy = validator_utils.is_falsy(val="1")
+    logger.info(f"Is '1' falsy: {_is_1_falsy}")
+
+    _request_id = "f058ebd6-02f7-4d3f-942e-904344e8cde5"
+    _is_valid_request_id = validator_utils.is_request_id(val=_request_id)
+    logger.info(f"Is '{_request_id}' a valid request ID: {_is_valid_request_id}")
+
+    _blacklist = ["hacker", "guest"]
+    _input_username = "hacker"
+    _is_blacklisted = validator_utils.is_blacklisted(
+        val=_input_username, blacklist=_blacklist
+    )
+    logger.info(f"Is '{_input_username}' blacklisted: {_is_blacklisted}")
+
+    _pattern = r"^[a-zA-Z0-9_]{3,16}$"  # Alphanumeric and underscores, 3-16 chars
+    _test_username = "valid_user123"
+    _is_valid_username = validator_utils.is_valid(val=_test_username, pattern=_pattern)
+    logger.info(f"Is '{_test_username}' a valid username: {_is_valid_username}")
+
+    _string_with_special_chars = "Hello@World!"
+    _has_special_chars = validator_utils.has_special_chars(
+        val=_string_with_special_chars, mode="STRICT"
+    )
+    logger.info(
+        f"Does '{_string_with_special_chars}' have special chars: {_has_special_chars}"
+    )
+    logger.info("-" * 80)
+
+    # HTTP utils:
+    logger.info("[HTTP UTILITIES]")
+    _http_status_tuple = http_utils.get_http_status(status_code=403)
+    logger.info(f"HTTP status and known: {_http_status_tuple}")
+
+    _url = AnyHttpUrl("https://www.google.com")
+    _is_connectable = http_utils.is_connectable(url=_url, timeout=3, check_status=True)
+    logger.info(f"Is '{_url}' connectable: {_is_connectable}")
+    logger.info("-" * 80)
+
+    return
+
+
+if __name__ == "__main__":
+    main()
 ```
 
 👍

potato_util-0.0.4.dist-info/RECORD

@@ -0,0 +1,25 @@
+potato_util/__init__.py,sha256=xl4th2Z_OmTk-3aO1w05Vh8ob0BnX4RcY1fT9tGX61c,74
+potato_util/__version__.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
+potato_util/_base.py,sha256=557Dj7eYmPIPE2s5yNtCKbJPOEj3lieHY4ZE1roxvFQ,1315
+potato_util/dt.py,sha256=DatLzuXOxdanplBv-Kf3qOaomrTCUUBSYv_QgTtQB6U,7635
+potato_util/generator.py,sha256=vdvHj1UrCOQI2WXQHQ2H63PMLQ6yOXAZPNl0m-6BgtY,1572
+potato_util/sanitizer.py,sha256=pZuMDvZxKKIdwFKTcqfmHb9ji-UefSgRgJ8ynHG6UFs,2267
+potato_util/secure.py,sha256=HxlUGyJl15qiL5WFrTZOJLgBZzuEr3Eu--qvBPmj2So,848
+potato_util/validator.py,sha256=TANw7uWHi0PANPkrNDOFFvRcYL9Ge75b4xGSf3PTW1A,4083
+potato_util/constants/__init__.py,sha256=lhxZ2k-QotMR_w9w-Gv-9pCEFrQSKxe1YEIvV83pf8E,80
+potato_util/constants/_base.py,sha256=J1i611erzcrPRZ6USkVgnNZ_IvvN9YLbcltvyIngpcg,61
+potato_util/constants/_enum.py,sha256=tThmf7lFsGfFUNNQE0hOUZ0JKc821ZGZnSyJIj2jVTQ,515
+potato_util/constants/_regex.py,sha256=T7SSsqD0y8jXJJPURwAK2uA59AjLt1uqGfqqUd1a22o,710
+potato_util/http/__init__.py,sha256=qWOzScMVJEHjzClEqOYmGtfkZyU8f8Hz8nT054Dbblo,229
+potato_util/http/_async.py,sha256=dfs-ynchPKdnMNQXqyoqhcz-jhtQ7g_4JnNfVr3bXk0,1178
+potato_util/http/_base.py,sha256=qoW5U8gxihVMx3v1gSLLmptMjScVsDS9PowvJ6tTc9c,1436
+potato_util/http/_sync.py,sha256=i8oyRmh-WraOzotaUbssIjOPvBh1pvLPupdoCvyHTK0,1169
+potato_util/http/fastapi.py,sha256=iqCxZcQDIVtcqCN9dZ4itcoUs6KzsfRGgK7sRd5EmOA,675
+potato_util/io/__init__.py,sha256=FoGcN7t0uArQV4hbMR1X5aeC8Yq-h_ds4xooNpkmgG0,209
+potato_util/io/_async.py,sha256=XVNFDCRII-ib32tksxj5G3nDLsV-ylTW2Hw3_seIY-k,10012
+potato_util/io/_sync.py,sha256=ZVRukOYWWvXtVlU_Gf8GoKnQZqSI2LISHPMmxXi4-2U,9644
+potato_util-0.0.4.dist-info/licenses/LICENSE.txt,sha256=CUTK-r0BWIg1r0bBiemAcMhakgV0N7HuRhw6rQ-A9A4,1074
+potato_util-0.0.4.dist-info/METADATA,sha256=GE6OpxAvbyH4Bd7psAp9p9Q6qyUGPouja2jKzgTnVM4,15634
+potato_util-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+potato_util-0.0.4.dist-info/top_level.txt,sha256=pLMnSfT6rhlYBpo2Gnd8kKMDxcuvxdVizqsv1dd1frw,12
+potato_util-0.0.4.dist-info/RECORD,,