v0.11.0 Release

list_helpers:
convert to list, any input, output is always a list
compare to lists, check what elements from A are not in B, type safe

string helpers
add is_int, is_float checker
add string to bool converter for true/True/false/False strings

config reader with parsing and checking
The simple config reader is now in the corelibs with the basic content check, convert to list for entries, convert to value for entries, etc

log updates:
Add Log type Enum for better log level checks and convert
Add a get int for requested log level, and return default if not found
Make the validate log level a static function

Add tests for list helpers and new string helpers

.gitignore

@@ -3,3 +3,4 @@
 **/*.egg-info
 .mypy_cache/
 **/.env
+.coverage

README.md

@@ -12,16 +12,21 @@ This is a pip package that can be installed into any project and covers the foll
 
 ## Current list
 
+- config_handling: simple INI config file data loader with check/convert/etc
 - csv_handling: csv dict writer helper
 - debug_handling: various debug helpers like data dumper, timer, utilization, etc
 - file_handling: crc handling for file content and file names, progress bar
 - json_handling: jmespath support and json date support
-- list_dict_handling: list and dictionary handling support (search, fingerprinting, etc)
+- iterator_handling: list and dictionary handling support (search, fingerprinting, etc)
 - logging_handling: extend log and also error message handling
 - requests_handling: requests wrapper for better calls with auth headers
 - script_handling: pid lock file handling, abort timer
 - string_handling: byte format, datetime format, hashing, string formats for numbrers, double byte string format, etc
 
+## UV setup
+
+uv must be [installed](https://docs.astral.sh/uv/getting-started/installation/)
+
 ## How to publish
 
 Have the following setup in `project.toml`
@@ -35,8 +40,8 @@ explicit = true
 ```
 
 ```sh
-uv build --native-tls
-uv publish --index egra-gitea --token <gitea token> --native-tls
+uv build
+uv publish --index egra-gitea --token <gitea token>
 ```
 
 ## Test package
@@ -44,21 +49,55 @@ uv publish --index egra-gitea --token <gitea token> --native-tls
 We must set the full index URL here because we run with "--no-project"
 
 ```sh
-uv run --with corelibs --index egra-gitea=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/ --no-project --native-tls -- python -c "import corelibs"
+uv run --with corelibs --index egra-gitea=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/ --no-project -- python -c "import corelibs"
+```
+
+### Python tests
+
+All python tests are the tests/ folder. They are structured by the source folder layout
+
+run them with
+
+```sh
+uv run pytest
+```
+
+Get a coverate report
+
+```sh
+uv run pytest --cov=corelibs
 ```
 
 ### Other tests
 
-In the test folder other tests are located.
+In the test-run folder usage and run tests are located
 
-At the moment only a small test for the "progress" and the "double byte string format" module is set
+#### Progress
 
 ```sh
-uv run --native-tls tests/progress/progress_test.py
+uv run test-run/progress/progress_test.py
+```
+
+#### Double byte string format
+
+```sh
+uv run test-run/double_byte_string_format/double_byte_string_format.py
+```
+
+#### Strings helpers
+
+```sh
+uv run test-run/timestamp_strings/timestamp_strings.py
 ```
 
 ```sh
-uv run --native-tls tests/double_byte_string_format/double_byte_string_format.py
+uv run test-run/string_handling/string_helpers.py
+```
+
+#### Log
+
+```sh
+uv run test-run/logging_handling/log.py
 ```
 
 ## How to install in another project
@@ -66,19 +105,23 @@ uv run --native-tls tests/double_byte_string_format/double_byte_string_format.py
 This will also add the index entry
 
 ```sh
-uv add corelibs --index egra-gitea=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/ --native-tls
+uv add corelibs --index egra-gitea=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/
 ```
 
 ## Python venv setup
 
-In the folder where the script will be located
-
-```sh
-uv venv --python 3.13
-```
-
-Install all neded dependencies
+After clone, run the command below to install all dependenciss
 
 ```sh
 uv sync
 ```
+
+## NOTE on TLS problems
+
+> [!warning] TLS problems with Netskope
+
+If the Netskope service is running all uv runs will fail unless either --native-tls is set or the enviroment variable SSL_CERT_FILE is set, see blow
+
+```sh
+export SSL_CERT_FILE='/Library/Application Support/Netskope/STAgent/data/nscacert_combined.pem'
+```

pyproject.toml

@@ -1,9 +1,9 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.5.0"
+version = "0.11.0"
 description = "Collection of utils for Python scripts"
-readme = "ReadMe.md"
+readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "jmespath>=1.0.1",
@@ -25,6 +25,12 @@ explicit = true
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-cov>=6.2.1",
+]
+
 # MARK: Python linting
 [tool.pyright]
 typeCheckingMode = "strict"

src/CoreLibs/logging_handling/log.py

@@ -1,120 +0,0 @@
-"""
-A log handler wrapper
-"""
-
-import logging.handlers
-import logging
-from pathlib import Path
-from typing import Mapping
-
-
-class Log:
-    """
-    logger setup
-    """
-
-    EXCEPTION: int = 60
-
-    def __init__(
-        self,
-        log_path: Path,
-        log_name: str,
-        log_level_console: str = 'WARNING',
-        log_level_file: str = 'DEBUG',
-        add_start_info: bool = True
-    ):
-        logging.addLevelName(Log.EXCEPTION, 'EXCEPTION')
-        if not log_name.endswith('.log'):
-            log_path = log_path.with_suffix('.log')
-        # overall logger settings
-        self.logger = logging.getLogger(log_name)
-        # set maximum logging level for all logging output
-        self.logger.setLevel(logging.DEBUG)
-        # console logger
-        self.__console_handler(log_level_console)
-        # file logger
-        self.__file_handler(log_level_file, log_path)
-        # if requests set a start log
-        if add_start_info is True:
-            self.break_line('START')
-
-    def __filter_exceptions(self, record: logging.LogRecord) -> bool:
-        return record.levelname != "EXCEPTION"
-
-    def __console_handler(self, log_level_console: str = 'WARNING'):
-        # console logger
-        if not isinstance(getattr(logging, log_level_console.upper(), None), int):
-            log_level_console = 'WARNING'
-        console_handler = logging.StreamHandler()
-        formatter_console = logging.Formatter(
-            (
-                '[%(asctime)s.%(msecs)03d] '
-                '[%(filename)s:%(funcName)s:%(lineno)d] '
-                '<%(levelname)s> '
-                '%(message)s'
-            ),
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
-        console_handler.setLevel(log_level_console)
-        # do not show exceptions logs on console
-        console_handler.addFilter(self.__filter_exceptions)
-        console_handler.setFormatter(formatter_console)
-        self.logger.addHandler(console_handler)
-
-    def __file_handler(self, log_level_file: str, log_path: Path) -> None:
-        # file logger
-        if not isinstance(getattr(logging, log_level_file.upper(), None), int):
-            log_level_file = 'DEBUG'
-        file_handler = logging.handlers.TimedRotatingFileHandler(
-            filename=log_path,
-            encoding="utf-8",
-            when="D",
-            interval=1
-        )
-        formatter_file_handler = logging.Formatter(
-            (
-                '[%(asctime)s.%(msecs)03d] '
-                '[%(pathname)s:%(funcName)s:%(lineno)d] '
-                '[%(name)s:%(process)d] '
-                '<%(levelname)s> '
-                '%(message)s'
-            ),
-            datefmt="%Y-%m-%dT%H:%M:%S",
-        )
-        file_handler.setLevel(log_level_file)
-        file_handler.setFormatter(formatter_file_handler)
-        self.logger.addHandler(file_handler)
-
-    def break_line(self, info: str = "BREAK"):
-        """
-        add a break line as info level
-
-        Keyword Arguments:
-            info {str} -- _description_ (default: {"BREAK"})
-        """
-        self.logger.info("[%s] ================================>", info)
-
-    def exception(self, msg: object, *args: object, extra: Mapping[str, object] | None = None) -> None:
-        """
-        log on exceotion level
-
-        Args:
-            msg (object): _description_
-            *args (object): arguments for msg
-            extra: Mapping[str, object] | None: extra arguments for the formatting if needed
-        """
-        self.logger.log(Log.EXCEPTION, msg, *args, exc_info=True, extra=extra)
-
-    def validate_log_level(self, log_level: str) -> bool:
-        """
-        if the log level is invalid, will erturn false
-
-        Args:
-            log_level (str): _description_
-
-        Returns:
-            bool: _description_
-        """
-        return isinstance(getattr(logging, log_level.upper(), None), int)
-
-# __END__

src/CoreLibs/string_handling/string_helpers.py

@@ -1,86 +0,0 @@
-"""
-String helpers
-"""
-
-from textwrap import shorten
-
-
-def shorten_string(string: str, length: int, hard_shorten: bool = False, placeholder: str = " [~]") -> str:
-    """
-    check if entry is too long and cut it, but only for console output
-    Note that if there are no spaces in the string, it will automatically use the hard split mode
-
-    Args:
-        string (str): _description_
-        length (int): _description_
-        hard_shorten (bool): if shorte should be done on fixed string lenght. Default: False
-        placeholder (str): placeholder string. Default: " [~]"
-
-    Returns:
-        str: _description_
-    """
-    length = int(length)
-    string = str(string)
-    if len(string) > length:
-        if hard_shorten is True or " " not in string:
-            short_string = f"{string[:(length - len(placeholder))]}{placeholder}"
-        else:
-            short_string = shorten(string, width=length, placeholder=placeholder)
-    else:
-        short_string = string
-
-    return short_string
-
-
-def left_fill(string: str, width: int, char: str = " ") -> str:
-    """
-    left fill for a certain length to fill a max size
-    string is the original string to left padd, width is the maximum width
-    that needs to be filled, char is the filler character
-
-    Arguments:
-        string {str} -- _description_
-        width {int} -- _description_
-
-    Keyword Arguments:
-        char {str} -- _description_ (default: {" "})
-
-    Returns:
-        str -- _description_
-    """
-    # the width needs to be string
-    if width < 0:
-        width = len(string)
-    # char can only be one length long
-    if len(char) != 1:
-        char = " "
-    return (
-        "{:"
-        f"{char}>{width}"
-        "}"
-    ).format(string)
-
-
-def format_number(number: float, precision: int = 0) -> str:
-    """
-    format numbers, current trailing zeros does not work
-    use {:,} or {:,.f} or {:,.<N>f} <N> = number instead of this
-
-    Arguments:
-        number {float} -- _description_
-
-    Keyword Arguments:
-        precision {int} -- _description_ (default: {0})
-
-    Returns:
-        str -- _description_
-    """
-    if precision < 0 and precision > 100:
-        precision = 0
-    return (
-        "{:,."
-        f"{str(precision)}"
-        "f}"
-    ).format(number)
-
-# __END__

src/corelibs/config_handling/settings_loader.py

@@ -0,0 +1,507 @@
+"""
+Load settings file for a certain group
+Check data for existing and valid
+Additional check for override settings as arguments
+"""
+
+import re
+import sys
+import configparser
+from typing import Any, Tuple, Sequence, cast
+from pathlib import Path
+from corelibs.logging_handling.log import Log
+from corelibs.iterator_handling.list_helpers import convert_to_list, is_list_in_list
+from corelibs.string_handling.string_helpers import is_int, is_float, str_to_bool
+from corelibs.config_handling.settings_loader_handling.settings_loader_check import SettingsLoaderCheck
+
+
+class SettingsLoader:
+    """
+    Settings Loader with Argument parser
+    """
+
+    # split char
+    DEFAULT_ELEMENT_SPLIT_CHAR: str = ','
+
+    CONVERT_TO_LIST: list[str] = ['str', 'int', 'float', 'bool', 'auto']
+
+    def __init__(
+        self,
+        args: dict[str, Any],
+        config_file: Path,
+        log: 'Log | None' = None,
+        always_print: bool = False
+    ) -> None:
+        """
+        init the Settings loader
+
+        Args:
+            args (dict): Script Arguments
+            config_file (Path): config file including path
+            log (Log | None): Lop class, if set errors are written to this
+            always_print (bool): Set to true to always print errors, even if Log is available
+            element_split_char (str): Split character, default is ','
+
+        Raises:
+            ValueError: _description_
+        """
+        self.args = args
+        self.config_file = config_file
+        self.log = log
+        self.always_print = always_print
+        # entries that have to be split
+        self.entry_split_char: dict[str, str] = {}
+        self.entry_convert: dict[str, str] = {}
+        # config parser
+        self.config_parser: configparser.ConfigParser | None = self.__load_config_file()
+        # all settings
+        self.settings: dict[str, dict[str, Any]] | None = None
+        # remove file name and get base path and check
+        if not self.config_file.parent.is_dir():
+            raise ValueError(f"Cannot find the config folder: {self.config_file.parent}")
+        # load the config file before we parse anything
+
+    def load_settings(self, config_id: str, config_validate: dict[str, list[str]]) -> dict[str, str]:
+        """
+        neutral settings loader
+
+        The settings values on the right side are seen as a list if they have "," inside (see ELEMENT SPLIT CHAR)
+        but only if the "check:list." is set
+
+        for the allowe entries set, each set is "key => checks", check set is "check type:settings"
+        key: the key name in the settings file
+        check: check set with the following allowed entries on the left side for type
+        - mandatory: must be set as "mandatory:yes", if the key entry is missing or empty throws error
+        - check: see __check_settings for the settings currently available
+        - matching: a | list of entries where the value has to match too
+        - in: the right side is another KEY value from the settings where this value must be inside
+        - split: character to split entries, if set check:list+ must be set if checks are needed
+        - convert: convert to int, float -> if element is number convert, else leave as is
+
+        Args:
+            config_id (str): what block to load
+            config_allowed (list[str]): list of allowed entries sets
+
+        Returns:
+            dict[str, str]: key = value list
+        """
+        settings: dict[str, dict[str, Any]] = {
+            config_id: {},
+        }
+        if self.config_parser is not None:
+            try:
+                # load all data as is, validation is done afterwards
+                settings[config_id] = dict(self.config_parser[config_id])
+                for key, checks in config_validate.items():
+                    skip = True
+                    split_char = self.DEFAULT_ELEMENT_SPLIT_CHAR
+                    # if one is set as list in check -> do not skip, but add to list
+                    for check in checks:
+                        if check.startswith("convert:"):
+                            try:
+                                [_, convert_to] = check.split(":")
+                                if convert_to not in self.CONVERT_TO_LIST:
+                                    self.__print(
+                                        f"[!] In [{config_id}] the convert type is invalid {check}: {convert_to}",
+                                        'CRITICAL',
+                                        raise_exception=True
+                                    )
+                            except ValueError as e:
+                                self.__print(
+                                    f"[!] In [{config_id}] the convert type setup for entry failed: {check}: {e}",
+                                    'CRITICAL',
+                                    raise_exception=True
+                                )
+                                sys.exit(1)
+                        # split char, also check to not set it twice, first one only
+                        if check.startswith("split:") and not self.entry_split_char.get(key):
+                            try:
+                                [_, split_char] = check.split(":")
+                                if len(split_char) == 0:
+                                    self.__print(
+                                        (
+                                            f"[*] In [{config_id}] the [{key}] split char character is empty, "
+                                            f"fallback to: {self.DEFAULT_ELEMENT_SPLIT_CHAR}"
+                                        ),
+                                        "WARNING"
+                                    )
+                                    split_char = self.DEFAULT_ELEMENT_SPLIT_CHAR
+                                self.entry_split_char[key] = split_char
+                                skip = False
+                            except ValueError as e:
+                                self.__print(
+                                    f"[!] In [{config_id}] the split character setup for entry failed: {check}: {e}",
+                                    'CRITICAL',
+                                    raise_exception=True
+                                )
+                                sys.exit(1)
+                    if skip:
+                        continue
+                    settings[config_id][key] = [
+                        __value.replace(" ", "")
+                        for __value in settings[config_id][key].split(split_char)
+                    ]
+            except KeyError as e:
+                self.__print(
+                    f"[!] Cannot read [{config_id}] block in the {self.config_file}: {e}",
+                    'CRITICAL', raise_exception=True
+                )
+                sys.exit(1)
+        else:
+            # ignore error if arguments are set
+            if not self.__check_arguments(config_validate, True):
+                self.__print(f"[!] Cannot find file: {self.config_file}", 'CRITICAL', raise_exception=True)
+                sys.exit(1)
+            else:
+                # base set
+                settings[config_id] = {}
+        # make sure all are set
+        # if we have arguments set, this override config settings
+        error: bool = False
+        for entry, validate in config_validate.items():
+            # if we have command line option set, this one overrides config
+            if self.__get_arg(entry):
+                self.__print(f"[*] Command line option override for: {entry}", 'WARNING')
+                settings[config_id][entry] = self.args.get(entry)
+            # validate checks
+            for check in validate:
+                # CHECKS
+                # - mandatory
+                # - check: regex check (see SettingsLoaderCheck class for entries)
+                # - matching: entry in given list
+                # - in: entry in other setting entry list
+                # - length: for string length
+                # - range: for int/float range check
+                # mandatory check
+                if check == "mandatory:yes" and not settings[config_id].get(entry):
+                    error = True
+                    self.__print(f"[!] Missing content entry for: {entry}", 'ERROR')
+                # skip if empty none
+                if settings[config_id].get(entry) is None:
+                    continue
+                if check.startswith("check:"):
+                    # replace the check and run normal checks
+                    settings[config_id][entry] = self.__check_settings(
+                        check, entry, settings[config_id][entry]
+                    )
+                elif check.startswith("matching:"):
+                    checks = check.replace("matching:", "").split("|")
+                    if __result := is_list_in_list(convert_to_list(settings[config_id][entry]), list(checks)):
+                        error = True
+                        self.__print(f"[!] [{entry}] '{__result}' not matching {checks}", 'ERROR')
+                elif check.startswith("in:"):
+                    check = check.replace("in:", "")
+                    # skip if check does not exist, and set error
+                    if settings[config_id].get(check) is None:
+                        error = True
+                        self.__print(f"[!] [{entry}] '{check}' target does not exist", 'ERROR')
+                        continue
+                    # entry must be in check entry
+                    # in for list, else equal with convert to string
+                    if (
+                        __result := is_list_in_list(
+                            convert_to_list(settings[config_id][entry]),
+                            __checks := convert_to_list(settings[config_id][check])
+                        )
+                    ):
+                        self.__print(f"[!] [{entry}] '{__result}' must be in the '{__checks}' values list", 'ERROR')
+                        error = True
+                elif check.startswith('length:'):
+                    check = check.replace("length:", "")
+                    # length can be: n, n-, n-m, -m
+                    # as: equal, >= >=< =<
+                    self.__build_from_to_equal(entry, check)
+                    if not self.__length_range_validate(
+                        entry,
+                        'length',
+                        cast(list[str], convert_to_list(settings[config_id][entry])),
+                        self.__build_from_to_equal(entry, check, convert_to_int=True)
+                    ):
+                        error = True
+                elif check.startswith('range:'):
+                    check = check.replace("range:", "")
+                    if not self.__length_range_validate(
+                        entry,
+                        'range',
+                        cast(list[str], convert_to_list(settings[config_id][entry])),
+                        self.__build_from_to_equal(entry, check)
+                    ):
+                        error = True
+        if error is True:
+            self.__print("[!] Missing or incorrect settings data. Cannot proceed", 'CRITICAL', raise_exception=True)
+            sys.exit(1)
+        # Convert input
+        for [entry, convert_type] in self.entry_convert:
+            if convert_type in ["int", "any"] and is_int(settings[config_id][entry]):
+                settings[config_id][entry] = int(settings[config_id][entry])
+            elif convert_type in ["float", "any"] and is_float(settings[config_id][entry]):
+                settings[config_id][entry] = float(settings[config_id][entry])
+            elif convert_type in ["bool", "any"] and (
+                settings[config_id][entry] == "true" or
+                settings[config_id][entry] == "True" or
+                settings[config_id][entry] == "false" or
+                settings[config_id][entry] == "False"
+            ):
+                try:
+                    settings[config_id][entry] = str_to_bool(settings[config_id][entry])
+                except ValueError:
+                    self.__print(
+                        f"[!] Could not convert to boolean for '{entry}': {settings[config_id][entry]}",
+                        'ERROR'
+                    )
+            # string is always string
+
+        return settings[config_id]
+
+    def __build_from_to_equal(
+        self, entry: str, check: str, convert_to_int: bool = False
+    ) -> Tuple[float | None, float | None, float | None]:
+        """
+        split out the "n-m" part to get the to/from/equal
+
+        Arguments:
+            entry {str} -- _description_
+            check {str} -- _description_
+
+        Returns:
+            Tuple[float | None, float | None, float | None] -- _description_
+
+        Throws:
+            ValueError if range/length entries are not float
+        """
+        __from = None
+        __to = None
+        __equal = None
+        try:
+            [__from, __to] = check.split('-')
+            if (__from and not is_float(__from)) or (__to and not is_float(__to)):
+                self.__print(
+                    f"[{entry}] Check value for length is not in: {check}",
+                    'CRITICAL', raise_exception=True
+                )
+                sys.exit(1)
+            if len(__from) == 0:
+                __from = None
+            if len(__to) == 0:
+                __to = None
+        except ValueError:
+            if not is_float(__equal := check):
+                self.__print(
+                    f"[{entry}] Check value for length is not a valid integer: {check}",
+                    'CRITICAL', raise_exception=True
+                )
+                sys.exit(1)
+            if len(__equal) == 0:
+                __equal = None
+        # makre sure this is all int or None
+        if __from is not None:
+            __from = int(__from) if convert_to_int else float(__from)
+        if __to is not None:
+            __to = int(__to) if convert_to_int else float(__to)
+        if __equal is not None:
+            __equal = int(__equal) if convert_to_int else float(__equal)
+        return (
+            __from,
+            __to,
+            __equal
+        )
+
+    def __length_range_validate(
+        self,
+        entry: str,
+        check_type: str,
+        values: Sequence[str | int | float],
+        check: Tuple[float | None, float | None, float | None],
+    ) -> bool:
+        (__from, __to, __equal) = check
+        valid = True
+        for value_raw in convert_to_list(values):
+            value = 0
+            error_mark = ''
+            if check_type == 'length':
+                error_mark = 'length'
+                value = len(str(value_raw))
+            elif check_type == 'range':
+                error_mark = 'range'
+                value = float(str(value_raw))
+            if __equal is not None and value != __equal:
+                self.__print(f"[!] [{entry}] '{value_raw}' {error_mark} does not match {__equal}", 'ERROR')
+                valid = False
+                continue
+            if __from is not None and __to is None and value < __from:
+                self.__print(f"[!] [{entry}] '{value_raw}' {error_mark} smaller than minimum {__from}", 'ERROR')
+                valid = False
+                continue
+            if __from is None and __to is not None and value > __to:
+                self.__print(f"[!] [{entry}] '{value_raw}' {error_mark} larger than maximum {__to}", 'ERROR')
+                valid = False
+                continue
+            if __from is not None and __to is not None and (
+                value < __from or value > __to
+            ):
+                self.__print(
+                    f"[!] [{entry}] '{value_raw}' {error_mark} outside valid range {__from} to {__to}",
+                    'ERROR'
+                )
+                valid = False
+                continue
+        return valid
+
+    def __load_config_file(self) -> configparser.ConfigParser | None:
+        """
+        load and parse the config file
+        if not loadable return None
+        """
+        config = configparser.ConfigParser()
+        if self.config_file.is_file():
+            config.read(self.config_file)
+            return config
+        return None
+
+    def __clean_invalid_setting(
+        self,
+        entry: str,
+        validate: str,
+        value: str,
+        regex: str,
+        regex_clean: str,
+        replace: str = "",
+        print_error: bool = True,
+    ) -> str:
+        """
+        check is a string is invalid, print optional error message and clean up string
+
+        Args:
+            entry (str): what entry key
+            validate (str): validate type
+            value (str): the value to check against
+            regex (str): regex used for checking as r'...'
+            regex_clean (str): regex used for cleaning as r'...'
+            replace (str): replace with character. Defaults to ''
+            print_error (bool): print the error message. Defaults to True
+        """
+        check = re.compile(regex)
+        clean = re.compile(regex_clean)
+        if not check.search(value):
+            self.__print(
+                f"[!] Invalid content for '{entry}' with check '{validate}' and data: {value}",
+                'ERROR', print_error
+            )
+            # clean up
+            return clean.sub(replace, value)
+        # else return as is
+        return value
+
+    def __check_settings(
+        self,
+        check: str, entry: str, setting_value: list[str] | str
+    ) -> list[str] | str:
+        """
+        check each setting valid
+        The settings are defined in the SettingsLoaderCheck class
+
+        Args:
+            check (str): What check to run
+            entry (str): Variable name, just for information message
+            setting_value (list[str | int] | str | int): settings value data
+            entry_split_char (str | None): split char, for list check
+
+        Returns:
+            list[str | int] |111 str | int: cleaned up settings value data
+        """
+        check = check.replace("check:", "")
+        # get the check settings
+        __check_settings = SettingsLoaderCheck.CHECK_SETTINGS.get(check)
+        if __check_settings is None:
+            self.__print(
+                f"[{entry}] Cannot get SettingsLoaderCheck.CHECK_SETTINGS for {check}",
+                'CRITICAL', raise_exception=True
+            )
+            sys.exit(1)
+        # either removes or replaces invalid characters in the list
+        if isinstance(setting_value, list):
+            # clean up invalid characters
+            # loop over result and keep only filled (strip empty)
+            setting_value = [e for e in [
+                self.__clean_invalid_setting(
+                    entry, check, str(__entry),
+                    __check_settings['regex'], __check_settings['regex_clean'], __check_settings['replace']
+                )
+                for __entry in setting_value
+            ] if e]
+        else:
+            setting_value = self.__clean_invalid_setting(
+                entry, check, str(setting_value),
+                __check_settings['regex'], __check_settings['regex_clean'], __check_settings['replace']
+            )
+        # else:
+        #     self.__print(f"[!] Unkown type to check", 'ERROR)
+        # return data
+        return setting_value
+
+    def __check_arguments(self, arguments: dict[str, list[str]], all_set: bool = False) -> bool:
+        """
+        check if ast least one argument is set
+
+        Args:
+            arguments (list[str]): _description_
+
+        Returns:
+            bool: _description_
+        """
+        count_set = 0
+        count_arguments = 0
+        has_argument = False
+        for argument, validate in arguments.items():
+            # if argument is mandatory add to count, if not mandatory set has "has" to skip error
+            mandatory = any(entry == "mandatory:yes" for entry in validate)
+            if not mandatory:
+                has_argument = True
+                continue
+            count_arguments += 1
+            if self.__get_arg(argument):
+                has_argument = True
+                count_set += 1
+        # for all set, True only if all are set
+        if all_set is True:
+            has_argument = count_set == count_arguments
+
+        return has_argument
+
+    def __get_arg(self, entry: str) -> Any:
+        """
+        check if an argument entry xists, if None -> returns None else value of argument
+
+        Arguments:
+            entry {str} -- _description_
+
+        Returns:
+            Any -- _description_
+        """
+        if self.args.get(entry) is None:
+            return None
+        return self.args.get(entry)
+
+    def __print(self, msg: str, level: str, print_error: bool = True, raise_exception: bool = False):
+        """
+        print out error, if Log class is set then print to log instead
+
+        Arguments:
+            msg {str} -- _description_
+            level {str} -- _description_
+
+        Keyword Arguments:
+            print_error {bool} -- _description_ (default: {True})
+        """
+        if self.log is not None:
+            if not Log.validate_log_level(level):
+                level = 'ERROR'
+            self.log.logger.log(Log.get_log_level_int(level), msg)
+        if self.log is None or self.always_print:
+            if print_error:
+                print(msg)
+        if raise_exception:
+            raise ValueError(msg)
+
+
+# __END__

src/corelibs/config_handling/settings_loader_handling/settings_loader_check.py

@@ -0,0 +1,44 @@
+"""
+Class of checks that can be run on value entries
+"""
+
+from typing import TypedDict
+
+
+class SettingsLoaderCheckValue(TypedDict):
+    """Settings check entries"""
+    regex: str
+    regex_clean: str
+    replace: str
+
+
+class SettingsLoaderCheck:
+    """
+    check:<NAME> or check:list+<NAME>
+    """
+    CHECK_SETTINGS: dict[str, SettingsLoaderCheckValue] = {
+        "int": {
+            "regex": r"^[0-9]+$",
+            "regex_clean": r"[^0-9]",
+            "replace": ""
+        },
+        "string.alphanumeric": {
+            "regex": r"^[a-zA-Z0-9]+$",
+            "regex_clean": r"[^a-zA-Z0-9]",
+            "replace": ""
+        },
+        "string.alphanumeric.lower.dash": {
+            "regex": r"^[a-z0-9-]+$",
+            "regex_clean": r"[^a-z0-9-]",
+            "replace": ""
+        },
+        # A-Z a-z 0-9 _ - . ONLY
+        # This one does not remove, but replaces with _
+        "string.alphanumeric.extended.replace": {
+            "regex": r"^[_.a-zA-Z0-9-]+$",
+            "regex_clean": r"[^_.a-zA-Z0-9-]",
+            "replace": "_"
+        },
+    }
+
+# __END__

src/corelibs/iterator_handling/list_helpers.py

@@ -0,0 +1,47 @@
+"""
+List type helpers
+"""
+
+from typing import Any, Sequence
+
+
+def convert_to_list(
+    entry: str | int | float | bool | Sequence[str | int | float | bool | Sequence[Any]]
+) -> Sequence[str | int | float | bool | Sequence[Any]]:
+    """
+    Convert any of the non list values (except dictionary) to a list
+
+    Arguments:
+        entry {str | int | float | bool | list[str  |  int  |  float  |  bool]} -- _description_
+
+    Returns:
+        list[str | int | float | bool] -- _description_
+    """
+    if isinstance(entry, list):
+        return entry
+    return [entry]
+
+
+def is_list_in_list(
+    list_a: Sequence[str | int | float | bool | Sequence[Any]],
+    list_b: Sequence[str | int | float | bool | Sequence[Any]]
+) -> Sequence[str | int | float | bool | Sequence[Any]]:
+    """
+    Return entries from list_a that are not in list_b
+    Type safe compare
+
+    Arguments:
+        list_a {list[Any]} -- _description_
+        list_b {list[Any]} -- _description_
+
+    Returns:
+        list[Any] -- _description_
+    """
+    # Create sets of (value, type) tuples
+    set_a = set((item, type(item)) for item in list_a)
+    set_b = set((item, type(item)) for item in list_b)
+
+    # Get the difference and extract just the values
+    return [item for item, _ in set_a - set_b]
+
+# __END__

src/corelibs/logging_handling/log.py

@@ -0,0 +1,360 @@
+"""
+A log handler wrapper
+if log_settings['log_queue'] is set to multiprocessing.Queue it will launch with listeners
+attach "init_worker_logging" with the set log_queue
+"""
+
+import re
+import logging.handlers
+import logging
+from pathlib import Path
+from typing import Mapping, TextIO, TypedDict, Any, TYPE_CHECKING, cast
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+from corelibs.string_handling.text_colors import Colors
+
+if TYPE_CHECKING:
+    from multiprocessing import Queue
+
+
+class LogSettings(TypedDict):
+    """
+    log settings
+
+    Arguments:
+        TypedDict {_type_} -- _description_
+    """
+    log_level_console: str
+    log_level_file: str
+    console_enabled: bool
+    console_color_output_enabled: bool
+    add_start_info: bool
+    add_end_info: bool
+    log_queue: 'Queue[str] | None'
+
+
+class CustomConsoleFormatter(logging.Formatter):
+    """
+    Custom formatter with colors for console output
+    """
+
+    COLORS = {
+        "DEBUG": Colors.cyan,
+        "INFO": Colors.green,
+        "WARNING": Colors.yellow,
+        "ERROR": Colors.red,
+        "CRITICAL": Colors.red_bold,
+        "EXCEPTION": Colors.magenta_bold,  # will never be written to console
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        set the color highlight
+
+        Arguments:
+            record {logging.LogRecord} -- _description_
+
+        Returns:
+            str -- _description_
+        """
+        # Add color to levelname for console output
+        reset = Colors.reset
+        color = self.COLORS.get(record.levelname, reset)
+        # only highlight level for basic
+        if record.levelname in ['DEBUG', 'INFO']:
+            record.levelname = f"{color}{record.levelname}{reset}"
+            return super().format(record)
+        # highlight whole line
+        message = super().format(record)
+        return f"{color}{message}{reset}"
+
+
+class Log:
+    """
+    logger setup
+    """
+
+    # spacer lenght characters and the character
+    SPACER_CHAR: str = '='
+    SPACER_LENGTH: int = 32
+    # default logging level
+    DEFAULT_LOG_LEVEL: str = 'WARNING'
+    # default settings
+    DEFAULT_LOG_SETTINGS: LogSettings = {
+            "log_level_console": "WARNING",
+            "log_level_file": "DEBUG",
+            "console_enabled": True,
+            "console_color_output_enabled": True,
+            "add_start_info": True,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+
+    def __init__(
+        self,
+        log_path: Path,
+        log_name: str,
+        log_settings: dict[str, 'str | bool | None | Queue[str]'] | LogSettings | None = None,
+    ):
+        # add new level for EXCEPTION
+        logging.addLevelName(LoggingLevel.EXCEPTION.value, 'EXCEPTION')
+        # parse the logging settings
+        self.log_settings = self.__parse_log_settings(log_settings)
+        # if path, set log name with .log
+        # if log name with .log, strip .log for naming
+        if log_path.is_dir():
+            __log_file_name = re.sub(r'[^a-zA-Z0-9]', '', log_name)
+            if not log_name.endswith('.log'):
+                log_path = log_path.joinpath(Path(__log_file_name).with_suffix('.log'))
+            else:
+                log_path = log_path.joinpath(__log_file_name)
+        elif not log_path.suffix == '.log':
+            # add .log if the path is a file but without .log
+            log_path = log_path.with_suffix('.log')
+        # stip .log from the log name if set
+        if not log_name.endswith('.log'):
+            log_name = Path(log_name).stem
+        # general log name
+        self.log_name = log_name
+
+        self.log_queue: 'Queue[str] | None' = None
+        self.listener: logging.handlers.QueueListener | None = None
+
+        # setup handlers
+        # NOTE if console with color is set first, some of the color formatting is set
+        # in the file writer too, for the ones where color is set BEFORE the format
+        self.handlers: list[logging.StreamHandler[TextIO] | logging.handlers.TimedRotatingFileHandler] = [
+            # file handler, always
+            self.__file_handler(self.log_settings['log_level_file'], log_path)
+        ]
+        if self.log_settings['console_enabled']:
+            # console
+            self.handlers.append(self.__console_handler(self.log_settings['log_level_console']))
+        # init listener if we have a log_queue set
+        self.__init_listener(self.log_settings['log_queue'])
+
+        # overall logger start
+        self.__init_log(log_name)
+        # if requests set a start log
+        if self.log_settings['add_start_info'] is True:
+            self.break_line('START')
+
+    def __del__(self):
+        """
+        Call when class is destroyed, make sure the listender is closed or else we throw a thread error
+        """
+        if self.log_settings['add_end_info']:
+            self.break_line('END')
+        self.stop_listener()
+
+    def __parse_log_settings(
+        self,
+        log_settings: dict[str, 'str | bool | None | Queue[str]'] | LogSettings | None
+    ) -> LogSettings:
+        # skip with defaul it not set
+        if log_settings is None:
+            return self.DEFAULT_LOG_SETTINGS
+        # check entries
+        default_log_settings = self.DEFAULT_LOG_SETTINGS
+        # check log levels
+        for __log_entry in ['log_level_console', 'log_level_file']:
+            if log_settings.get(__log_entry) is None:
+                continue
+            # if not valid reset to default, if not in default set to WARNING
+            if not self.validate_log_level(_log_level := log_settings.get(__log_entry, '')):
+                _log_level = self.DEFAULT_LOG_SETTINGS.get(
+                    __log_entry, self.DEFAULT_LOG_LEVEL
+                )
+            default_log_settings[__log_entry] = str(_log_level)
+        # check bool
+        for __log_entry in [
+            "console_enabled",
+            "console_color_output_enabled",
+            "add_start_info",
+            "add_end_info",
+        ]:
+            if log_settings.get(__log_entry) is None:
+                continue
+            if not isinstance(__setting := log_settings.get(__log_entry, ''), bool):
+                __setting = self.DEFAULT_LOG_SETTINGS.get(__log_entry, True)
+            default_log_settings[__log_entry] = __setting
+        # check log queue
+        __setting = log_settings.get('log_queue', self.DEFAULT_LOG_SETTINGS['log_queue'])
+        if __setting is not None:
+            __setting = cast('Queue[str]', __setting)
+        default_log_settings['log_queue'] = __setting
+        return default_log_settings
+
+    def __filter_exceptions(self, record: logging.LogRecord) -> bool:
+        return record.levelname != "EXCEPTION"
+
+    def __console_handler(self, log_level_console: str = 'WARNING') -> logging.StreamHandler[TextIO]:
+        # console logger
+        if not isinstance(getattr(logging, log_level_console.upper(), None), int):
+            log_level_console = 'WARNING'
+        console_handler = logging.StreamHandler()
+        # format layouts
+        format_string = (
+            '[%(asctime)s.%(msecs)03d] '
+            '[%(name)s] '
+            '[%(filename)s:%(funcName)s:%(lineno)d] '
+            '<%(levelname)s> '
+            '%(message)s'
+        )
+        format_date = "%Y-%m-%d %H:%M:%S"
+        # color or not
+        if self.log_settings['console_color_output_enabled']:
+            formatter_console = CustomConsoleFormatter(format_string, datefmt=format_date)
+        else:
+            formatter_console = logging.Formatter(format_string, datefmt=format_date)
+        console_handler.setLevel(log_level_console)
+        # do not show exceptions logs on console
+        console_handler.addFilter(self.__filter_exceptions)
+        console_handler.setFormatter(formatter_console)
+        return console_handler
+
+    def __file_handler(self, log_level_file: str, log_path: Path) -> logging.handlers.TimedRotatingFileHandler:
+        # file logger
+        if not isinstance(getattr(logging, log_level_file.upper(), None), int):
+            log_level_file = 'DEBUG'
+        file_handler = logging.handlers.TimedRotatingFileHandler(
+            filename=log_path,
+            encoding="utf-8",
+            when="D",
+            interval=1
+        )
+        formatter_file_handler = logging.Formatter(
+            (
+                # time stamp
+                '[%(asctime)s.%(msecs)03d] '
+                # log name
+                '[%(name)s] '
+                # filename + pid
+                '[%(filename)s:%(process)d] '
+                # path + func + line number
+                '[%(pathname)s:%(funcName)s:%(lineno)d] '
+                # error level
+                '<%(levelname)s> '
+                # message
+                '%(message)s'
+            ),
+            datefmt="%Y-%m-%dT%H:%M:%S",
+        )
+        file_handler.setLevel(log_level_file)
+        file_handler.setFormatter(formatter_file_handler)
+        return file_handler
+
+    def __init_listener(self, log_queue: 'Queue[str] | None' = None):
+        """
+        If we have a Queue option start the logging queue
+
+        Keyword Arguments:
+            log_queue {Queue[str] | None} -- _description_ (default: {None})
+        """
+        if log_queue is None:
+            return
+        self.log_queue = log_queue
+        self.listener = logging.handlers.QueueListener(
+            self.log_queue,
+            *self.handlers,
+            respect_handler_level=True
+        )
+        self.listener.start()
+
+    def __init_log(self, log_name: str) -> None:
+        """
+        Initialize the main loggger
+        """
+        queue_handler: logging.handlers.QueueHandler | None = None
+        if self.log_queue is not None:
+            queue_handler = logging.handlers.QueueHandler(self.log_queue)
+        # overall logger settings
+        self.logger = logging.getLogger(log_name)
+        # add all the handlers
+        if queue_handler is None:
+            for handler in self.handlers:
+                self.logger.addHandler(handler)
+        else:
+            self.logger.addHandler(queue_handler)
+        # set maximum logging level for all logging output
+        # log level filtering is done per handler
+        self.logger.setLevel(logging.DEBUG)
+
+    @staticmethod
+    def init_worker_logging(log_queue: 'Queue[str]') -> logging.Logger:
+        """
+        This initalizes a logger that can be used in pool/thread queue calls
+        """
+        queue_handler = logging.handlers.QueueHandler(log_queue)
+        # getLogger call MUST be WITHOUT and logger name
+        root_logger = logging.getLogger()
+        root_logger.setLevel(logging.DEBUG)
+        root_logger.handlers.clear()
+        root_logger.addHandler(queue_handler)
+
+        # for debug only
+        root_logger.debug('[LOGGER] Init log: %s - %s', log_queue, root_logger.handlers)
+
+        return root_logger
+
+    def stop_listener(self):
+        """
+        stop the listener
+        """
+        if self.listener is not None:
+            self.listener.stop()
+
+    def break_line(self, info: str = "BREAK"):
+        """
+        add a break line as info level
+
+        Keyword Arguments:
+            info {str} -- _description_ (default: {"BREAK"})
+        """
+        self.logger.info("[%s] %s>", info, self.SPACER_CHAR * self.SPACER_LENGTH)
+
+    def exception(self, msg: object, *args: object, extra: Mapping[str, object] | None = None) -> None:
+        """
+        log on exceotion level
+
+        Args:
+            msg (object): _description_
+            *args (object): arguments for msg
+            extra: Mapping[str, object] | None: extra arguments for the formatting if needed
+        """
+        self.logger.log(LoggingLevel.EXCEPTION.value, msg, *args, exc_info=True, extra=extra)
+
+    @staticmethod
+    def validate_log_level(log_level: Any) -> bool:
+        """
+        if the log level is invalid, will erturn false
+
+        Args:
+            log_level (Any): _description_
+
+        Returns:
+            bool: _description_
+        """
+        try:
+            _ = LoggingLevel.from_any(log_level).value
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def get_log_level_int(log_level: Any) -> int:
+        """
+        Return log level as INT
+        If invalid return set level in default log level
+
+        Arguments:
+            log_level {Any} -- _description_
+
+        Returns:
+            int -- _description_
+        """
+        try:
+            return LoggingLevel.from_any(log_level).value
+        except ValueError:
+            return LoggingLevel.from_string(Log.DEFAULT_LOG_LEVEL).value
+
+# __END__

src/corelibs/logging_handling/logging_level_handling/logging_level.py

@@ -0,0 +1,75 @@
+"""
+All logging levels
+"""
+
+import logging
+from typing import Any
+from enum import Enum
+
+
+class LoggingLevel(Enum):
+    """
+    Log class levels
+    """
+    NOTSET = logging.NOTSET      # 0
+    DEBUG = logging.DEBUG        # 10
+    INFO = logging.INFO          # 20
+    WARNING = logging.WARNING    # 30
+    ERROR = logging.ERROR        # 40
+    CRITICAL = logging.CRITICAL  # 50
+    EXCEPTION = 60               # 60 (manualy set)
+    # Alternative names
+    WARN = logging.WARN          # 30 (alias for WARNING)
+    FATAL = logging.FATAL        # 50 (alias for CRITICAL)
+
+    # Optional: Add string representation for better readability
+    @classmethod
+    def from_string(cls, level_str: str):
+        """Convert string to LogLevel enum"""
+        try:
+            return cls[level_str.upper()]
+        except KeyError as e:
+            raise ValueError(f"Invalid log level: {level_str}") from e
+
+    @classmethod
+    def from_int(cls, level_int: int):
+        """Convert integer to LogLevel enum"""
+        try:
+            return cls(level_int)
+        except ValueError as e:
+            raise ValueError(f"Invalid log level: {level_int}") from e
+
+    @classmethod
+    def from_any(cls, level_any: Any):
+        """Convert either str or int"""
+        if isinstance(level_any, int):
+            return cls.from_int(level_any)
+        return cls.from_string(level_any)
+
+    def to_logging_level(self):
+        """Convert to logging module level"""
+        return self.value
+
+    def to_lower_case(self):
+        """return loser case"""
+        return self.name.lower()
+
+    def __str__(self):
+        return self.name
+
+    def includes(self, level: 'LoggingLevel'):
+        """
+        if given level is included in set level
+        eg: INFO set, ERROR is included in INFO because INFO level would print ERROR
+        """
+        return self.value <= level.value
+
+    def is_higher_than(self, level: 'LoggingLevel'):
+        """if given value is higher than set"""
+        return self.value > level.value
+
+    def is_lower_than(self, level: 'LoggingLevel'):
+        """if given value is lower than set"""
+        return self.value > level.value
+
+# __END__

src/corelibs/string_handling/string_helpers.py

@@ -0,0 +1,163 @@
+"""
+String helpers
+"""
+
+from typing import Any
+from decimal import Decimal, getcontext
+from textwrap import shorten
+
+
+def shorten_string(
+    string: str | int | float, length: int, hard_shorten: bool = False, placeholder: str = " [~]"
+) -> str:
+    """
+    check if entry is too long and cut it, but only for console output
+    Note that if there are no spaces in the string, it will automatically use the hard split mode
+
+    Args:
+        string (str | int | float): _description_
+        length (int): _description_
+        hard_shorten (bool): if shorte should be done on fixed string lenght. Default: False
+        placeholder (str): placeholder string. Default: " [~]"
+
+    Returns:
+        str: _description_
+    """
+    string = str(string)
+    # if placeholder > lenght
+    if len(string) > length:
+        if hard_shorten is True or " " not in string:
+            # hard shorten error
+            if len(placeholder) > length:
+                raise ValueError(f"Cannot shorten string: placeholder {placeholder} is too large for max width")
+            short_string = f"{string[:(length - len(placeholder))]}{placeholder}"
+        else:
+            try:
+                short_string = shorten(string, width=length, placeholder=placeholder)
+            except ValueError as e:
+                raise ValueError(f"Cannot shorten string: {e}") from e
+    else:
+        short_string = string
+
+    return short_string
+
+
+def left_fill(string: str, width: int, char: str = " ") -> str:
+    """
+    left fill for a certain length to fill a max size
+    string is the original string to left padd, width is the maximum width
+    that needs to be filled, char is the filler character
+
+    Arguments:
+        string {str} -- _description_
+        width {int} -- _description_
+
+    Keyword Arguments:
+        char {str} -- _description_ (default: {" "})
+
+    Returns:
+        str -- _description_
+    """
+    # the width needs to be string
+    if width < 0:
+        width = len(string)
+    # char can only be one length long
+    if len(char) != 1:
+        char = " "
+    return (
+        "{:"
+        f"{char}>{width}"
+        "}"
+    ).format(string)
+
+
+def format_number(number: float, precision: int = 0) -> str:
+    """
+    format numbers, current trailing zeros does not work
+    use {:,} or {:,.f} or {:,.<N>f} <N> = number instead of this
+
+    The upper limit of the precision depends on the value of the number itself
+    very large numbers will have no precision at all any more
+
+    Arguments:
+        number {float} -- _description_
+
+    Keyword Arguments:
+        precision {int} -- _description_ (default: {0})
+
+    Returns:
+        str -- _description_
+    """
+    if precision < 0 or precision > 100:
+        precision = 0
+    if precision > 0:
+        getcontext().prec = precision
+        # make it a string to avoid mangling
+        _number = Decimal(str(number))
+    else:
+        _number = number
+    return (
+        "{:,."
+        f"{str(precision)}"
+        "f}"
+    ).format(_number)
+
+
+def is_int(string: Any) -> bool:
+    """
+    check if a value is int
+
+    Arguments:
+        string {Any} -- _description_
+
+    Returns:
+        bool -- _description_
+    """
+    try:
+        int(string)
+        return True
+    except TypeError:
+        return False
+    except ValueError:
+        return False
+
+
+def is_float(string: Any) -> bool:
+    """
+    check if a value is float
+
+    Arguments:
+        string {Any} -- _description_
+
+    Returns:
+        bool -- _description_
+    """
+    try:
+        float(string)
+        return True
+    except TypeError:
+        return False
+    except ValueError:
+        return False
+
+
+def str_to_bool(string: str):
+    """
+    convert string to bool
+
+    Arguments:
+        s {str} -- _description_
+
+    Raises:
+        ValueError: _description_
+
+    Returns:
+        _type_ -- _description_
+    """
+    if string == "True" or string == "true":
+        return True
+    if string == "False" or string == "false":
+        return False
+    raise ValueError(f"Invalid boolean string: {string}")
+
+# __END__

src/corelibs/string_handling/text_colors.py

@@ -0,0 +1,156 @@
+"""
+Basic ANSI colors
+
+Set colors with print(f"something {Colors.yellow}colorful{Colors.end})
+bold + underline + color combinations are possible.
+"""
+
+
+class Colors:
+    """
+    ANSI colors defined
+    """
+    # General sets, these should not be accessd
+    __BOLD = '\033[1m'
+    __UNDERLINE = '\033[4m'
+    __END = '\033[0m'
+    __RESET = '\033[0m'
+    # Define ANSI color codes as class attributes
+    __BLACK = "\033[30m"
+    __RED = "\033[31m"
+    __GREEN = "\033[32m"
+    __YELLOW = "\033[33m"
+    __BLUE = "\033[34m"
+    __MAGENTA = "\033[35m"
+    __CYAN = "\033[36m"
+    __WHITE = "\033[37m"
+
+    # Define bold/bright versions of the colors
+    __BLACK_BOLD = "\033[1;30m"
+    __RED_BOLD = "\033[1;31m"
+    __GREEN_BOLD = "\033[1;32m"
+    __YELLOW_BOLD = "\033[1;33m"
+    __BLUE_BOLD = "\033[1;34m"
+    __MAGENTA_BOLD = "\033[1;35m"
+    __CYAN_BOLD = "\033[1;36m"
+    __WHITE_BOLD = "\033[1;37m"
+
+    # BRIGHT, alternative
+    __BLACK_BRIGHT = '\033[90m'
+    __RED_BRIGHT = '\033[91m'
+    __GREEN_BRIGHT = '\033[92m'
+    __YELLOW_BRIGHT = '\033[93m'
+    __BLUE_BRIGHT = '\033[94m'
+    __MAGENTA_BRIGHT = '\033[95m'
+    __CYAN_BRIGHT = '\033[96m'
+    __WHITE_BRIGHT = '\033[97m'
+
+    # set access vars
+    bold = __BOLD
+    underline = __UNDERLINE
+    end = __END
+    reset = __RESET
+    # normal
+    black = __BLACK
+    red = __RED
+    green = __GREEN
+    yellow = __YELLOW
+    blue = __BLUE
+    magenta = __MAGENTA
+    cyan = __CYAN
+    white = __WHITE
+    # bold
+    black_bold = __BLACK_BOLD
+    red_bold = __RED_BOLD
+    green_bold = __GREEN_BOLD
+    yellow_bold = __YELLOW_BOLD
+    blue_bold = __BLUE_BOLD
+    magenta_bold = __MAGENTA_BOLD
+    cyan_bold = __CYAN_BOLD
+    white_bold = __WHITE_BOLD
+    # bright
+    black_bright = __BLACK_BRIGHT
+    red_bright = __RED_BRIGHT
+    green_bright = __GREEN_BRIGHT
+    yellow_bright = __YELLOW_BRIGHT
+    blue_bright = __BLUE_BRIGHT
+    magenta_bright = __MAGENTA_BRIGHT
+    cyan_bright = __CYAN_BRIGHT
+    white_bright = __WHITE_BRIGHT
+
+    @staticmethod
+    def disable():
+        """
+        No colors
+        """
+        Colors.bold = ''
+        Colors.underline = ''
+        Colors.end = ''
+        Colors.reset = ''
+        # normal
+        Colors.black = ''
+        Colors.red = ''
+        Colors.green = ''
+        Colors.yellow = ''
+        Colors.blue = ''
+        Colors.magenta = ''
+        Colors.cyan = ''
+        Colors.white = ''
+        # bold/bright
+        Colors.black_bold = ''
+        Colors.red_bold = ''
+        Colors.green_bold = ''
+        Colors.yellow_bold = ''
+        Colors.blue_bold = ''
+        Colors.magenta_bold = ''
+        Colors.cyan_bold = ''
+        Colors.white_bold = ''
+        # bold/bright alt
+        Colors.black_bright = ''
+        Colors.red_bright = ''
+        Colors.green_bright = ''
+        Colors.yellow_bright = ''
+        Colors.blue_bright = ''
+        Colors.magenta_bright = ''
+        Colors.cyan_bright = ''
+        Colors.white_bright = ''
+
+    @staticmethod
+    def reset_colors():
+        """
+        reset colors to the original ones
+        """
+        # set access vars
+        Colors.bold = Colors.__BOLD
+        Colors.underline = Colors.__UNDERLINE
+        Colors.end = Colors.__END
+        Colors.reset = Colors.__RESET
+        # normal
+        Colors.black = Colors.__BLACK
+        Colors.red = Colors.__RED
+        Colors.green = Colors.__GREEN
+        Colors.yellow = Colors.__YELLOW
+        Colors.blue = Colors.__BLUE
+        Colors.magenta = Colors.__MAGENTA
+        Colors.cyan = Colors.__CYAN
+        Colors.white = Colors.__WHITE
+        # bold
+        Colors.black_bold = Colors.__BLACK_BOLD
+        Colors.red_bold = Colors.__RED_BOLD
+        Colors.green_bold = Colors.__GREEN_BOLD
+        Colors.yellow_bold = Colors.__YELLOW_BOLD
+        Colors.blue_bold = Colors.__BLUE_BOLD
+        Colors.magenta_bold = Colors.__MAGENTA_BOLD
+        Colors.cyan_bold = Colors.__CYAN_BOLD
+        Colors.white_bold = Colors.__WHITE_BOLD
+        # bright
+        Colors.black_bright = Colors.__BLACK_BRIGHT
+        Colors.red_bright = Colors.__RED_BRIGHT
+        Colors.green_bright = Colors.__GREEN_BRIGHT
+        Colors.yellow_bright = Colors.__YELLOW_BRIGHT
+        Colors.blue_bright = Colors.__BLUE_BRIGHT
+        Colors.magenta_bright = Colors.__MAGENTA_BRIGHT
+        Colors.cyan_bright = Colors.__CYAN_BRIGHT
+        Colors.white_bright = Colors.__WHITE_BRIGHT
+
+# __END__

src/corelibs/string_handling/timestamp_strings.py

@@ -0,0 +1,26 @@
+"""
+Current timestamp strings and time zones
+"""
+
+from datetime import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+
+class TimestampStrings:
+    """
+    set default time stamps
+    """
+
+    TIME_ZONE: str = 'Asia/Tokyo'
+
+    def __init__(self, time_zone: str | None = None):
+        self.timestamp_now = datetime.now()
+        self.time_zone = time_zone if time_zone is not None else self.TIME_ZONE
+        try:
+            self.timestamp_now_tz = datetime.now(ZoneInfo(self.time_zone))
+        except ZoneInfoNotFoundError as e:
+            raise ValueError(f'Zone could not be loaded [{self.time_zone}]: {e}') from e
+        self.today = self.timestamp_now.strftime('%Y-%m-%d')
+        self.timestamp = self.timestamp_now.strftime("%Y-%m-%d %H:%M:%S")
+        self.timestamp_tz = self.timestamp_now_tz.strftime("%Y-%m-%d %H:%M:%S %Z")
+        self.timestamp_file = self.timestamp_now.strftime("%Y-%m-%d_%H%M%S")

test-run/config_handling/config/settings.ini

@@ -0,0 +1,23 @@
+[TestA]
+foo=bar
+foobar=1
+some_match=foo
+some_match_list=foo,bar
+test_list=a,b,c,d f, g h
+other_list=a|b|c|d|
+third_list=xy|ab|df|fg
+str_length=foobar
+int_range=20
+#
+match_target=foo
+match_target_list=foo,bar,baz
+#
+match_source_a=foo
+match_source_b=foo
+; match_source_c=foo
+match_source_list=foo,bar
+
+[TestB]
+element_a=Static energy
+element_b=123.5
+element_c=True

test-run/config_handling/log/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

test-run/config_handling/settings_loader.py

@@ -0,0 +1,77 @@
+"""
+Settings loader test
+"""
+
+from pathlib import Path
+from corelibs.iterator_handling.dump_data import dump_data
+from corelibs.logging_handling.log import Log
+from corelibs.config_handling.settings_loader import SettingsLoader
+
+SCRIPT_PATH: Path = Path(__file__).resolve().parent
+ROOT_PATH: Path = SCRIPT_PATH
+CONFIG_DIR: Path = Path("config")
+CONFIG_FILE: str = "settings.ini"
+
+
+def main():
+    """
+    Main run
+    """
+
+    # for log testing
+    script_path: Path = Path(__file__).resolve().parent
+    log = Log(
+        log_path=script_path.joinpath('log', 'settings_loader.log'),
+        log_name="Settings Loader",
+        log_settings={
+            "log_level_console": 'DEBUG',
+            "log_level_file": 'DEBUG',
+        }
+    )
+    log.logger.info('Settings loader')
+
+    sl = SettingsLoader(
+        {
+            'foo': 'OVERLOAD'
+        },
+        ROOT_PATH.joinpath(CONFIG_DIR, CONFIG_FILE),
+        log=log
+    )
+    try:
+        config_load = 'TestA'
+        config_data = sl.load_settings(
+            config_load,
+            {
+                "foo": ["mandatory:yes"],
+                "foobar": ["check:int"],
+                "some_match": ["matching:foo|bar"],
+                "some_match_list": ["split:,", "matching:foo|bar"],
+                "test_list": [
+                    "check:string.alphanumeric",
+                    "split:,"
+                ],
+                "other_list": ["split:|"],
+                "third_list": [
+                    "split:|",
+                    "check:string.alphanumeric"
+                ],
+                "str_length": [
+                    "length:2-10"
+                ],
+                "int_range": [
+                    "range:2-50"
+                ],
+                "match_target": ["matching:foo"],
+                "match_target_list": ["split:,", "matching:foo|bar|baz",],
+                "match_source_a": ["in:match_target"],
+                "match_source_b": ["in:match_target_list"],
+                "match_source_list": ["split:,", "in:match_target_list"],
+            }
+        )
+        print(f"Load: {config_load} -> {dump_data(config_data)}")
+    except ValueError as e:
+        print(f"Could not load settings: {e}")
+
+
+if __name__ == "__main__":
+    main()

test-run/iterator_handling/list_helpers.py

@@ -0,0 +1,29 @@
+"""
+test list helpers
+"""
+
+from corelibs.iterator_handling.list_helpers import is_list_in_list, convert_to_list
+
+
+def __test_is_list_in_list_a():
+    list_a = [1, "hello", 3.14, True, "world"]
+    list_b = ["hello", True, 42]
+    result = is_list_in_list(list_a, list_b)
+    print(f"RESULT: {result}")
+
+
+def __convert_list():
+    source = "hello"
+    result = convert_to_list(source)
+    print(f"IN: {source} -> {result}")
+
+
+def main():
+    __test_is_list_in_list_a()
+    __convert_list()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/logging_handling/log.py

@@ -0,0 +1,73 @@
+"""
+Log logging_handling.log testing
+"""
+
+# import atexit
+from pathlib import Path
+# this is for testing only
+from corelibs.logging_handling.log import Log
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+def main():
+    """
+    Log testing
+    """
+    script_path: Path = Path(__file__).resolve().parent
+    log = Log(
+        log_path=script_path.joinpath('log', 'test.log'),
+        log_name="Test Log",
+        log_settings={
+            "log_level_console": 'DEBUG',
+            "log_level_file": 'DEBUG',
+            # "console_color_output_enabled": False,
+        }
+    )
+
+    log.logger.debug('[NORMAL] Debug test: %s', log.logger.name)
+    log.logger.info('[NORMAL] Info test: %s', log.logger.name)
+    log.logger.warning('[NORMAL] Warning test: %s', log.logger.name)
+    log.logger.error('[NORMAL] Error test: %s', log.logger.name)
+    log.logger.critical('[NORMAL] Critical test: %s', log.logger.name)
+    log.exception('[NORMAL] Exception test: %s', log.logger.name)
+
+    bad_level = 'WRONG'
+    if not Log.validate_log_level(bad_level):
+        print(f"Invalid level: {bad_level}")
+    good_level = 'WARNING'
+    if Log.validate_log_level(good_level):
+        print(f"Valid level: {good_level}")
+
+    print(f"ERROR is to_logging_level(): {LoggingLevel.ERROR.to_logging_level()}")
+    print(f"ERROR is to_lower_case(): {LoggingLevel.ERROR.to_lower_case()}")
+    print(f"ERROR is: {LoggingLevel.ERROR}")
+    print(f"ERROR is value: {LoggingLevel.ERROR.value}")
+    print(f"ERROR is name: {LoggingLevel.ERROR.name}")
+    print(f"ERROR is from_string(lower): {LoggingLevel.from_string('ERROR')}")
+    print(f"ERROR is from_string(upper): {LoggingLevel.from_string('ERROR')}")
+    print(f"ERROR is from_int: {LoggingLevel.from_int(40)}")
+    print(f"ERROR is from_any(text lower): {LoggingLevel.from_any('ERROR')}")
+    print(f"ERROR is from_any(text upper): {LoggingLevel.from_any('ERROR')}")
+    print(f"ERROR is from_any(int): {LoggingLevel.from_any(40)}")
+    print(f"INFO <= ERROR: {LoggingLevel.INFO.includes(LoggingLevel.ERROR)}")
+    print(f"INFO > ERROR: {LoggingLevel.INFO.is_higher_than(LoggingLevel.ERROR)}")
+    print(f"INFO < ERROR: {LoggingLevel.INFO.is_lower_than(LoggingLevel.ERROR)}")
+    print(f"INFO < ERROR: {LoggingLevel.INFO.is_lower_than(LoggingLevel.ERROR)}")
+
+    try:
+        print(f"INVALID is A: {LoggingLevel.from_string('INVALID')}")
+    except ValueError as e:
+        print(f"* ERROR: {e}")
+
+    try:
+        __test = 5 / 0
+        print(f"Divied: {__test}")
+    except ZeroDivisionError as e:
+        log.logger.critical("Divison through zero: %s", e)
+        log.exception("Divison through zero")
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/logging_handling/log/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

test-run/logging_handling/log_pool.py

@@ -0,0 +1,75 @@
+"""
+Pool Queue log handling
+Thread Queue log handling
+"""
+
+import random
+import time
+from multiprocessing import Queue
+import concurrent.futures
+import logging
+from pathlib import Path
+from corelibs.logging_handling.log import Log
+
+
+def work_function(log_name: str, worker_id: int, data: list[int]) -> int:
+    """
+    simulate worker
+
+    Arguments:
+        worker_id {int} -- _description_
+        data {list[int]} -- _description_
+
+    Returns:
+        int -- _description_
+    """
+    log = logging.getLogger(f'{log_name}-WorkerFn-{worker_id}')
+    log.info('Starting worker: %s', worker_id)
+    time.sleep(random.uniform(1, 3))
+    result = sum(data) * worker_id
+    return result
+
+
+def main():
+    """
+    Queue log tester
+    """
+    print("[START] Queue logger test")
+    log_queue: 'Queue[str]' = Queue()
+    script_path: Path = Path(__file__).resolve().parent
+    log = Log(
+        log_path=script_path.joinpath('log', 'test.log'),
+        log_name="Test Log",
+        log_settings={
+            "log_level_console": 'INFO',
+            "log_level_file": 'INFO',
+            "log_queue": log_queue,
+        }
+    )
+    log.logger.info('Pool Fork logging test')
+    max_forks = 2
+    data_sets = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    with concurrent.futures.ProcessPoolExecutor(
+        max_workers=max_forks,
+        initializer=Log.init_worker_logging,
+        initargs=(log_queue,)
+    ) as executor:
+        log.logger.info('Start workers')
+        futures = [
+            executor.submit(work_function, log.log_name, worker_id, data)
+            for worker_id, data in enumerate(data_sets, 1)
+        ]
+        log.logger.info('Workders started')
+
+        for future in concurrent.futures.as_completed(futures):
+            log.logger.info('Processing result: %s', future.result())
+            print(f"Processing result: {future.result()}")
+
+    log.logger.info('[END] Queue logger test')
+    log.stop_listener()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/logging_handling/log_queue.py

@@ -0,0 +1,42 @@
+"""
+Log logging_handling.log testing
+"""
+
+# import atexit
+from pathlib import Path
+from multiprocessing import Queue
+# this is for testing only
+from corelibs.logging_handling.log import Log
+
+
+def main():
+    """
+    Log testing
+    """
+    script_path: Path = Path(__file__).resolve().parent
+
+    log_queue: 'Queue[str]' = Queue()
+    log_q = Log(
+        log_path=script_path.joinpath('log', 'test_queue.log'),
+        log_name="Test Log",
+        log_settings={
+            "log_level_console": 'WARNING',
+            "log_level_file": 'ERROR',
+            "log_queue": log_queue
+            # "console_color_output_enabled": False,
+        }
+    )
+
+    log_q.logger.debug('[QUEUE] Debug test: %s', log_q.logger.name)
+    log_q.logger.info('[QUEUE] Info test: %s', log_q.logger.name)
+    log_q.logger.warning('[QUEUE] Warning test: %s', log_q.logger.name)
+    log_q.logger.error('[QUEUE] Error test: %s', log_q.logger.name)
+    log_q.logger.critical('[QUEUE] Critical test: %s', log_q.logger.name)
+    log_q.exception('[QUEUE] Exception test: %s', log_q.logger.name)
+    log_q.stop_listener()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/logging_handling/log_queue_legacy.py

@@ -0,0 +1,31 @@
+"""
+Log logging_handling.log testing
+"""
+
+# import atexit
+from pathlib import Path
+from multiprocessing import Queue
+# this is for testing only
+from queue_logger.log_queue import QueueLogger
+
+
+def main():
+    """
+    Log testing
+    """
+    script_path: Path = Path(__file__).resolve().parent
+
+    log_queue: 'Queue[str]' = Queue()
+    log_q_legacy = QueueLogger(
+        log_file=script_path.joinpath('log', 'test_queue_legacy.log'),
+        log_name="Test Log Queue",
+        log_queue=log_queue
+    )
+    log_q_legacy.mlog.info('Log test: %s', 'Queue Legacy')
+    # log_q.stop_listener()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/logging_handling/queue_logger/log_queue.py

@@ -0,0 +1,96 @@
+"""
+test queue logger interface
+NOTE: this has all moved to the default log interface
+"""
+
+import logging
+import logging.handlers
+from pathlib import Path
+from multiprocessing import Queue
+
+
+class QueueLogger:
+    """
+    Queue logger
+    """
+
+    def __init__(self, log_file: Path, log_name: str, log_queue: 'Queue[str] | None' = None):
+        self.log_file = log_file
+        self.log_name = log_name
+        self.handlers = self.setup_logging()
+        self.log_queue: 'Queue[str]' = log_queue if log_queue is not None else Queue()
+        self.listener = logging.handlers.QueueListener(self.log_queue, *self.handlers)
+        self.listener.start()
+
+        self.mlog: logging.Logger = self.main_log(log_name)
+
+    def __del__(self):
+        self.mlog.info("[%s] ================================>", "END")
+        self.listener.stop()
+
+    def setup_logging(self):
+        """
+        setup basic logging
+        """
+
+        # Create formatters
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - [PID:%(process)d] [%(filename)s:%(lineno)d] - %(message)s'
+        )
+
+        console_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+
+        # Create handlers
+        file_handler = logging.FileHandler(self.log_file)
+        file_handler.setFormatter(file_formatter)
+        file_handler.setLevel(logging.DEBUG)
+
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(console_formatter)
+        console_handler.setLevel(logging.DEBUG)
+
+        return [file_handler, console_handler]
+
+    def main_log(self, log_name: str) -> logging.Logger:
+        """
+        main logger
+
+        Arguments:
+            log_name {str} -- _description_
+
+        Returns:
+            logging.Logger -- _description_
+        """
+        mlog_handler = logging.handlers.QueueHandler(self.log_queue)
+        mlog = logging.getLogger(f'{log_name}-MainProcess')
+        mlog.addHandler(mlog_handler)
+        mlog.setLevel(logging.DEBUG)
+        return mlog
+
+    @staticmethod
+    def init_worker_logging(log_queue: 'Queue[str]', log_name: str, ):
+        """
+        Initialize logging for worker processes
+        """
+
+        # Create QueueHandler
+        queue_handler = logging.handlers.QueueHandler(log_queue)
+
+        # Setup root logger for this process
+        # NOTE: This must be EMPTY or new SINGLE NEW logger is created, we need one for EACH fork
+        root_logger = logging.getLogger()
+        root_logger.setLevel(logging.DEBUG)
+        root_logger.handlers.clear()
+        root_logger.addHandler(queue_handler)
+
+        root_logger.info('[LOGGER] Init log: %s - %s', log_queue, log_name)
+
+        return root_logger
+
+    def stop_listener(self):
+        """
+        stop the listener
+        """
+        self.listener.stop()

test-run/string_handling/string_helpers.py

@@ -0,0 +1,88 @@
+"""
+Test string_handling/string_helpers
+"""
+
+import sys
+from decimal import Decimal, getcontext
+from textwrap import shorten
+from corelibs.string_handling.string_helpers import shorten_string, format_number
+from corelibs.string_handling.text_colors import Colors
+
+
+def __sh_shorten_string():
+    string = "hello"
+    length = 3
+    placeholder = " [very long placeholder]"
+    try:
+        result = shorten_string(string, length, placeholder=placeholder)
+        print(f"IN: {string} -> {result}")
+    except ValueError as e:
+        print(f"{Colors.red}Failed: {Colors.bold}{e}{Colors.end}")
+    try:
+        result = shorten(string, width=length, placeholder=placeholder)
+        print(f"IN: {string} -> {result}")
+    except ValueError as e:
+        print(f"Failed: {e}")
+
+
+def __sh_format_number():
+    print(f"Max int: {sys.maxsize}")
+    print(f"Max float: {sys.float_info.max}")
+    number = 1234.56
+    precision = 0
+    result = format_number(number, precision)
+    print(f"Format {number} ({precision}) -> {result}")
+    number = 1234.56
+    precision = 100
+    result = format_number(number, precision)
+    print(f"Format {number} ({precision}) -> {result}")
+    number = 123400000000000001.56
+    if number >= sys.maxsize:
+        print("INT Number too big")
+    if number >= sys.float_info.max:
+        print("FLOAT Number too big")
+    precision = 5
+    result = format_number(number, precision)
+    print(f"Format {number} ({precision}) -> {result}")
+
+    precision = 100
+    getcontext().prec = precision
+    number = Decimal(str(1234.56))
+    result = f"{number:,.100f}"
+    print(f"Format {number} ({precision}) -> {result}")
+
+
+def __sh_colors():
+    for color in [
+        "black",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "white",
+    ]:
+        for change in ['', '_bold', '_bright']:
+            _color = f"{color}{change}"
+            print(f"Color: {getattr(Colors, _color)}{_color}{Colors.end}")
+
+    print(f"Underline: {Colors.underline}UNDERLINE{Colors.reset}")
+    print(f"Bold: {Colors.bold}BOLD{Colors.reset}")
+    print(f"Underline/Yellow: {Colors.underline}{Colors.yellow}UNDERLINE YELLOW{Colors.reset}")
+    print(f"Underline/Yellow/Bold: {Colors.underline}{Colors.bold}{Colors.yellow}UNDERLINE YELLOW BOLD{Colors.reset}")
+
+
+def main():
+    """
+    Test: corelibs.string_handling.string_helpers
+    """
+    __sh_shorten_string()
+    __sh_format_number()
+    __sh_colors()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/timestamp_strings/timestamp_strings.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S uv run --script
+
+"""
+Test for double byte format
+"""
+
+from corelibs.string_handling.timestamp_strings import TimestampStrings
+
+
+def main():
+    ts = TimestampStrings()
+    print(f"TS: {ts.timestamp_now}")
+
+    try:
+        ts = TimestampStrings("invalid")
+    except ValueError as e:
+        print(f"Value error: {e}")
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

tests/unit/iterator_handling/test_list_helpers.py

@@ -0,0 +1,300 @@
+"""
+iterator_handling.list_helepr tests
+"""
+
+from typing import Any
+import pytest
+from corelibs.iterator_handling.list_helpers import convert_to_list, is_list_in_list
+
+
+class TestConvertToList:
+    """Test cases for convert_to_list function"""
+
+    def test_string_input(self):
+        """Test with string inputs"""
+        assert convert_to_list("hello") == ["hello"]
+        assert convert_to_list("") == [""]
+        assert convert_to_list("123") == ["123"]
+        assert convert_to_list("true") == ["true"]
+
+    def test_integer_input(self):
+        """Test with integer inputs"""
+        assert convert_to_list(42) == [42]
+        assert convert_to_list(0) == [0]
+        assert convert_to_list(-10) == [-10]
+        assert convert_to_list(999999) == [999999]
+
+    def test_float_input(self):
+        """Test with float inputs"""
+        assert convert_to_list(3.14) == [3.14]
+        assert convert_to_list(0.0) == [0.0]
+        assert convert_to_list(-2.5) == [-2.5]
+        assert convert_to_list(1.0) == [1.0]
+
+    def test_boolean_input(self):
+        """Test with boolean inputs"""
+        assert convert_to_list(True) == [True]
+        assert convert_to_list(False) == [False]
+
+    def test_list_input_unchanged(self):
+        """Test that list inputs are returned unchanged"""
+        # String lists
+        str_list = ["a", "b", "c"]
+        assert convert_to_list(str_list) == str_list
+        assert convert_to_list(str_list) is str_list  # Same object reference
+
+        # Integer lists
+        int_list = [1, 2, 3]
+        assert convert_to_list(int_list) == int_list
+        assert convert_to_list(int_list) is int_list
+
+        # Float lists
+        float_list = [1.1, 2.2, 3.3]
+        assert convert_to_list(float_list) == float_list
+        assert convert_to_list(float_list) is float_list
+
+        # Boolean lists
+        bool_list = [True, False, True]
+        assert convert_to_list(bool_list) == bool_list
+        assert convert_to_list(bool_list) is bool_list
+
+        # Mixed lists
+        mixed_list = [1, "hello", 3.14, True]
+        assert convert_to_list(mixed_list) == mixed_list
+        assert convert_to_list(mixed_list) is mixed_list
+
+        # Empty list
+        empty_list: list[int] = []
+        assert convert_to_list(empty_list) == empty_list
+        assert convert_to_list(empty_list) is empty_list
+
+    def test_nested_lists(self):
+        """Test with nested lists (should still return the same list)"""
+        nested_list: list[list[int]] = [[1, 2], [3, 4]]
+        assert convert_to_list(nested_list) == nested_list
+        assert convert_to_list(nested_list) is nested_list
+
+    def test_single_element_lists(self):
+        """Test with single element lists"""
+        single_str = ["hello"]
+        assert convert_to_list(single_str) == single_str
+        assert convert_to_list(single_str) is single_str
+
+        single_int = [42]
+        assert convert_to_list(single_int) == single_int
+        assert convert_to_list(single_int) is single_int
+
+
+class TestIsListInList:
+    """Test cases for is_list_in_list function"""
+
+    def test_string_lists(self):
+        """Test with string lists"""
+        list_a = ["a", "b", "c", "d"]
+        list_b = ["b", "d", "e"]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {"a", "c"}
+        assert isinstance(result, list)
+
+    def test_integer_lists(self):
+        """Test with integer lists"""
+        list_a = [1, 2, 3, 4, 5]
+        list_b = [2, 4, 6]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {1, 3, 5}
+        assert isinstance(result, list)
+
+    def test_float_lists(self):
+        """Test with float lists"""
+        list_a = [1.1, 2.2, 3.3, 4.4]
+        list_b = [2.2, 4.4, 5.5]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {1.1, 3.3}
+        assert isinstance(result, list)
+
+    def test_boolean_lists(self):
+        """Test with boolean lists"""
+        list_a = [True, False, True]
+        list_b = [True]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {False}
+        assert isinstance(result, list)
+
+    def test_mixed_type_lists(self):
+        """Test with mixed type lists"""
+        list_a = [1, "hello", 3.14, True, "world"]
+        list_b = ["hello", True, 42]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {1, 3.14, "world"}
+        assert isinstance(result, list)
+
+    def test_empty_lists(self):
+        """Test with empty lists"""
+        # Empty list_a
+        assert is_list_in_list([], [1, 2, 3]) == []
+
+        # Empty list_b
+        list_a = [1, 2, 3]
+        result = is_list_in_list(list_a, [])
+        assert set(result) == {1, 2, 3}
+
+        # Both empty
+        assert is_list_in_list([], []) == []
+
+    def test_no_common_elements(self):
+        """Test when lists have no common elements"""
+        list_a = [1, 2, 3]
+        list_b = [4, 5, 6]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {1, 2, 3}
+
+    def test_all_elements_common(self):
+        """Test when all elements in list_a are in list_b"""
+        list_a = [1, 2, 3]
+        list_b = [1, 2, 3, 4, 5]
+        result = is_list_in_list(list_a, list_b)
+        assert result == []
+
+    def test_identical_lists(self):
+        """Test with identical lists"""
+        list_a = [1, 2, 3]
+        list_b = [1, 2, 3]
+        result = is_list_in_list(list_a, list_b)
+        assert result == []
+
+    def test_duplicate_elements(self):
+        """Test with duplicate elements in lists"""
+        list_a = [1, 2, 2, 3, 3, 3]
+        list_b = [2, 4]
+        result = is_list_in_list(list_a, list_b)
+        # Should return unique elements only (set behavior)
+        assert set(result) == {1, 3}
+        assert isinstance(result, list)
+
+    def test_list_b_larger_than_list_a(self):
+        """Test when list_b is larger than list_a"""
+        list_a = [1, 2]
+        list_b = [2, 3, 4, 5, 6, 7, 8]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {1}
+
+    def test_order_independence(self):
+        """Test that order doesn't matter due to set operations"""
+        list_a = [3, 1, 4, 1, 5]
+        list_b = [1, 2, 6]
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == {3, 4, 5}
+
+
+# Parametrized tests for more comprehensive coverage
+class TestParametrized:
+    """Parametrized tests for better coverage"""
+
+    @pytest.mark.parametrize("input_value,expected", [
+        ("hello", ["hello"]),
+        (42, [42]),
+        (3.14, [3.14]),
+        (True, [True]),
+        (False, [False]),
+        ("", [""]),
+        (0, [0]),
+        (0.0, [0.0]),
+        (-1, [-1]),
+        (-2.5, [-2.5]),
+    ])
+    def test_convert_to_list_parametrized(self, input_value: Any, expected: Any):
+        """Test convert_to_list with various single values"""
+        assert convert_to_list(input_value) == expected
+
+    @pytest.mark.parametrize("input_list", [
+        [1, 2, 3],
+        ["a", "b", "c"],
+        [1.1, 2.2, 3.3],
+        [True, False],
+        [1, "hello", 3.14, True],
+        [],
+        [42],
+        [[1, 2], [3, 4]],
+    ])
+    def test_convert_to_list_with_lists_parametrized(self, input_list: Any):
+        """Test convert_to_list with various list inputs"""
+        result = convert_to_list(input_list)
+        assert result == input_list
+        assert result is input_list  # Same object reference
+
+    @pytest.mark.parametrize("list_a,list_b,expected_set", [
+        ([1, 2, 3], [2], {1, 3}),
+        (["a", "b", "c"], ["b", "d"], {"a", "c"}),
+        ([1, 2, 3], [4, 5, 6], {1, 2, 3}),
+        ([1, 2, 3], [1, 2, 3], set()),
+        ([], [1, 2, 3], set()),
+        ([1, 2, 3], [], {1, 2, 3}),
+        ([True, False], [True], {False}),
+        ([1.1, 2.2, 3.3], [2.2], {1.1, 3.3}),
+    ])
+    def test_is_list_in_list_parametrized(self, list_a: list[Any], list_b: list[Any], expected_set: Any):
+        """Test is_list_in_list with various input combinations"""
+        result = is_list_in_list(list_a, list_b)
+        assert set(result) == expected_set
+        assert isinstance(result, list)
+
+
+# Edge cases and special scenarios
+class TestEdgeCases:
+    """Test edge cases and special scenarios"""
+
+    def test_convert_to_list_with_none_like_values(self):
+        """Test convert_to_list with None-like values (if function supports them)"""
+        # Note: Based on type hints, None is not supported, but testing behavior
+        # This test might need to be adjusted based on actual function behavior
+        pass
+
+    def test_is_list_in_list_preserves_type_distinctions(self):
+        """Test that different types are treated as different"""
+        list_a = [1, "1", 1.0, True]
+        list_b = [1]  # Only integer 1
+        result = is_list_in_list(list_a, list_b)
+
+        # Note: This test depends on how Python's set handles type equality
+        # 1, 1.0, and True are considered equal in sets
+        # "1" is different from 1
+        # expected_items = {"1"}  # String "1" should remain
+        assert "1" in result
+        assert isinstance(result, list)
+
+    def test_large_lists(self):
+        """Test with large lists"""
+        large_list_a = list(range(1000))
+        large_list_b = list(range(500, 1500))
+        result = is_list_in_list(large_list_a, large_list_b)
+        expected = list(range(500))  # 0 to 499
+        assert set(result) == set(expected)
+
+    def test_memory_efficiency(self):
+        """Test that convert_to_list doesn't create unnecessary copies"""
+        original_list = [1, 2, 3, 4, 5]
+        result = convert_to_list(original_list)
+
+        # Should be the same object, not a copy
+        assert result is original_list
+
+        # Modifying the original should affect the result
+        original_list.append(6)
+        assert 6 in result
+
+
+# Performance tests (optional)
+class TestPerformance:
+    """Performance-related tests"""
+
+    def test_is_list_in_list_with_duplicates_performance(self):
+        """Test that function handles duplicates efficiently"""
+        # List with many duplicates
+        list_a = [1, 2, 3] * 100  # 300 elements, many duplicates
+        list_b = [2] * 50  # 50 elements, all the same
+
+        result = is_list_in_list(list_a, list_b)
+
+        # Should still work correctly despite duplicates
+        assert set(result) == {1, 3}
+        assert isinstance(result, list)

tests/unit/string_handling/test_string_helpers.py

@@ -0,0 +1,474 @@
+"""
+PyTest: string_handling/string_helpers
+"""
+
+from textwrap import shorten
+from typing import Any
+import pytest
+from corelibs.string_handling.string_helpers import (
+    shorten_string, left_fill, format_number, is_int, is_float, str_to_bool
+)
+
+
+class TestShortenString:
+    """Tests for shorten_string function"""
+
+    def test_string_shorter_than_length(self):
+        """Test that strings shorter than length are returned unchanged"""
+        result = shorten_string("hello", 10)
+        assert result == "hello"
+
+    def test_string_equal_to_length(self):
+        """Test that strings equal to length are returned unchanged"""
+        result = shorten_string("hello", 5)
+        assert result == "hello"
+
+    def test_hard_shorten_true(self):
+        """Test hard shortening with default placeholder"""
+        result = shorten_string("hello world", 8, hard_shorten=True)
+        assert result == "hell [~]"
+
+    def test_hard_shorten_custom_placeholder(self):
+        """Test hard shortening with custom placeholder"""
+        result = shorten_string("hello world", 8, hard_shorten=True, placeholder="...")
+        assert result == "hello..."
+
+    def test_no_spaces_auto_hard_shorten(self):
+        """Test that strings without spaces automatically use hard shorten"""
+        result = shorten_string("helloworld", 8)
+        assert result == "hell [~]"
+
+    def test_soft_shorten_with_spaces(self):
+        """Test soft shortening using textwrap.shorten"""
+        result = shorten_string("hello world test", 12)
+        # Should use textwrap.shorten behavior
+        expected = shorten("hello world test", width=12, placeholder=" [~]")
+        assert result == expected
+
+    def test_placeholder_too_large_hard_shorten(self):
+        """Test error when placeholder is larger than allowed length"""
+        with pytest.raises(ValueError, match="Cannot shorten string: placeholder .* is too large for max width"):
+            shorten_string("hello", 3, hard_shorten=True, placeholder=" [~]")
+
+    def test_placeholder_too_large_no_spaces(self):
+        """Test error when placeholder is larger than allowed length for string without spaces"""
+        with pytest.raises(ValueError, match="Cannot shorten string: placeholder .* is too large for max width"):
+            shorten_string("hello", 3, placeholder=" [~]")
+
+    def test_textwrap_shorten_error(self):
+        """Test handling of textwrap.shorten ValueError"""
+        # This might be tricky to trigger, but we can mock it
+        with pytest.raises(ValueError, match="Cannot shorten string:"):
+            # Very short length that might cause textwrap.shorten to fail
+            shorten_string("hello world", 1, hard_shorten=False)
+
+    def test_type_conversion(self):
+        """Test that inputs are converted to proper types"""
+        result = shorten_string(12345, 8, hard_shorten=True)
+        assert result == "12345"
+
+    def test_empty_string(self):
+        """Test with empty string"""
+        result = shorten_string("", 5)
+        assert result == ""
+
+    def test_zero_length(self):
+        """Test with zero length"""
+        with pytest.raises(ValueError):
+            shorten_string("hello", 0, hard_shorten=True)
+
+
+class TestLeftFill:
+    """Tests for left_fill function"""
+
+    def test_basic_left_fill(self):
+        """Test basic left filling with spaces"""
+        result = left_fill("hello", 10)
+        assert result == "     hello"
+        assert len(result) == 10
+
+    def test_custom_fill_character(self):
+        """Test left filling with custom character"""
+        result = left_fill("hello", 10, "0")
+        assert result == "00000hello"
+
+    def test_string_longer_than_width(self):
+        """Test when string is longer than width"""
+        result = left_fill("hello world", 5)
+        assert result == "hello world"  # Should return original string
+
+    def test_string_equal_to_width(self):
+        """Test when string equals width"""
+        result = left_fill("hello", 5)
+        assert result == "hello"
+
+    def test_negative_width(self):
+        """Test with negative width"""
+        result = left_fill("hello", -5)
+        assert result == "hello"  # Should use string length
+
+    def test_zero_width(self):
+        """Test with zero width"""
+        result = left_fill("hello", 0)
+        assert result == "hello"  # Should return original string
+
+    def test_invalid_fill_character(self):
+        """Test with invalid fill character (not single char)"""
+        result = left_fill("hello", 10, "abc")
+        assert result == "     hello"  # Should default to space
+
+    def test_empty_fill_character(self):
+        """Test with empty fill character"""
+        result = left_fill("hello", 10, "")
+        assert result == "     hello"  # Should default to space
+
+    def test_empty_string(self):
+        """Test with empty string"""
+        result = left_fill("", 5)
+        assert result == "     "
+
+
+class TestFormatNumber:
+    """Tests for format_number function"""
+
+    def test_integer_default_precision(self):
+        """Test formatting integer with default precision"""
+        result = format_number(1234)
+        assert result == "1,234"
+
+    def test_float_default_precision(self):
+        """Test formatting float with default precision"""
+        result = format_number(1234.56)
+        assert result == "1,235"  # Should round to nearest integer
+
+    def test_with_precision(self):
+        """Test formatting with specified precision"""
+        result = format_number(1234.5678, 2)
+        assert result == "1,234.57"
+
+    def test_large_number(self):
+        """Test formatting large number"""
+        result = format_number(1234567.89, 2)
+        assert result == "1,234,567.89"
+
+    def test_zero(self):
+        """Test formatting zero"""
+        result = format_number(0)
+        assert result == "0"
+
+    def test_negative_number(self):
+        """Test formatting negative number"""
+        result = format_number(-1234.56, 2)
+        assert result == "-1,234.56"
+
+    def test_negative_precision(self):
+        """Test with negative precision (should default to 0)"""
+        result = format_number(1234.56, -1)
+        assert result == "1,235"
+
+    def test_excessive_precision(self):
+        """Test with precision > 100 (should default to 0)"""
+        result = format_number(1234.56, 101)
+        assert result == "1,235"
+
+    def test_precision_boundary_values(self):
+        """Test precision boundary values"""
+        # Test precision = 0 (should work)
+        result = format_number(1234.56, 0)
+        assert result == "1,235"
+
+        # Test precision = 100 (should work)
+        result = format_number(1234.56, 100)
+        assert "1,234.56" in result  # Will have many trailing zeros
+
+    def test_small_decimal(self):
+        """Test formatting small decimal number"""
+        result = format_number(0.123456, 4)
+        assert result == "0.1235"
+
+    def test_very_small_number(self):
+        """Test formatting very small number"""
+        result = format_number(0.001, 3)
+        assert result == "0.001"
+
+
+# Additional integration tests
+class TestIntegration:
+    """Integration tests combining functions"""
+
+    def test_format_and_fill(self):
+        """Test formatting a number then left filling"""
+        formatted = format_number(1234.56, 2)
+        result = left_fill(formatted, 15)
+        assert result.endswith("1,234.56")
+        assert len(result) == 15
+
+    def test_format_and_shorten(self):
+        """Test formatting a large number then shortening"""
+        formatted = format_number(123456789.123, 3)
+        result = shorten_string(formatted, 10)
+        assert len(result) <= 10
+
+
+# Fixtures for parameterized tests
+@pytest.mark.parametrize("input_str,length,expected", [
+    ("hello", 10, "hello"),
+    ("hello world", 5, "h [~]"),
+    ("test", 4, "test"),
+    ("", 5, ""),
+])
+def test_shorten_string_parametrized(input_str: str, length: int, expected: str):
+    """Parametrized test for shorten_string"""
+    result = shorten_string(input_str, length, hard_shorten=True)
+    if expected.endswith(" [~]"):
+        assert result.endswith(" [~]")
+        assert len(result) == length
+    else:
+        assert result == expected
+
+
+@pytest.mark.parametrize("number,precision,expected", [
+    (1000, 0, "1,000"),
+    (1234.56, 2, "1,234.56"),
+    (0, 1, "0.0"),
+    (-500, 0, "-500"),
+])
+def test_format_number_parametrized(number: float | int, precision: int, expected: str):
+    """Parametrized test for format_number"""
+    assert format_number(number, precision) == expected
+
+# ADDED 2025/7/11 Replace 'your_module' with actual module name
+
+
+class TestIsInt:
+    """Test cases for is_int function"""
+
+    def test_valid_integers(self):
+        """Test with valid integer strings"""
+        assert is_int("123") is True
+        assert is_int("0") is True
+        assert is_int("-456") is True
+        assert is_int("+789") is True
+        assert is_int("000") is True
+
+    def test_invalid_integers(self):
+        """Test with invalid integer strings"""
+        assert is_int("12.34") is False
+        assert is_int("abc") is False
+        assert is_int("12a") is False
+        assert is_int("") is False
+        assert is_int(" ") is False
+        assert is_int("12.0") is False
+        assert is_int("1e5") is False
+
+    def test_numeric_types(self):
+        """Test with actual numeric types"""
+        assert is_int(123) is True
+        assert is_int(0) is True
+        assert is_int(-456) is True
+        assert is_int(12.34) is True  # float can be converted to int
+        assert is_int(12.0) is True
+
+    def test_other_types(self):
+        """Test with other data types"""
+        assert is_int(None) is False
+        assert is_int([]) is False
+        assert is_int({}) is False
+        assert is_int(True) is True  # bool is subclass of int
+        assert is_int(False) is True
+
+
+class TestIsFloat:
+    """Test cases for is_float function"""
+
+    def test_valid_floats(self):
+        """Test with valid float strings"""
+        assert is_float("12.34") is True
+        assert is_float("0.0") is True
+        assert is_float("-45.67") is True
+        assert is_float("+78.9") is True
+        assert is_float("123") is True  # integers are valid floats
+        assert is_float("0") is True
+        assert is_float("1e5") is True
+        assert is_float("1.5e-10") is True
+        assert is_float("inf") is True
+        assert is_float("-inf") is True
+        assert is_float("nan") is True
+
+    def test_invalid_floats(self):
+        """Test with invalid float strings"""
+        assert is_float("abc") is False
+        assert is_float("12.34.56") is False
+        assert is_float("12a") is False
+        assert is_float("") is False
+        assert is_float(" ") is False
+        assert is_float("12..34") is False
+
+    def test_numeric_types(self):
+        """Test with actual numeric types"""
+        assert is_float(123) is True
+        assert is_float(12.34) is True
+        assert is_float(0) is True
+        assert is_float(-45.67) is True
+
+    def test_other_types(self):
+        """Test with other data types"""
+        assert is_float(None) is False
+        assert is_float([]) is False
+        assert is_float({}) is False
+        assert is_float(True) is True  # bool can be converted to float
+        assert is_float(False) is True
+
+
+class TestStrToBool:
+    """Test cases for str_to_bool function"""
+
+    def test_valid_true_strings(self):
+        """Test with valid true strings"""
+        assert str_to_bool("True") is True
+        assert str_to_bool("true") is True
+
+    def test_valid_false_strings(self):
+        """Test with valid false strings"""
+        assert str_to_bool("False") is False
+        assert str_to_bool("false") is False
+
+    def test_invalid_strings(self):
+        """Test with invalid boolean strings"""
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("TRUE")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("FALSE")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("yes")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("no")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("1")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("0")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool(" True")
+
+        with pytest.raises(ValueError, match="Invalid boolean string"):
+            str_to_bool("True ")
+
+    def test_error_message_content(self):
+        """Test that error messages contain the invalid input"""
+        with pytest.raises(ValueError) as exc_info:
+            str_to_bool("invalid")
+        assert "Invalid boolean string: invalid" in str(exc_info.value)
+
+    def test_case_sensitivity(self):
+        """Test that function is case sensitive"""
+        with pytest.raises(ValueError):
+            str_to_bool("TRUE")
+
+        with pytest.raises(ValueError):
+            str_to_bool("True ")  # with space
+
+        with pytest.raises(ValueError):
+            str_to_bool(" True")  # with space
+
+
+# Additional edge case tests
+class TestEdgeCases:
+    """Test edge cases and special scenarios"""
+
+    def test_is_int_with_whitespace(self):
+        """Test is_int with whitespace (should work due to int() behavior)"""
+        assert is_int(" 123 ") is True
+        assert is_int("\t456\n") is True
+
+    def test_is_float_with_whitespace(self):
+        """Test is_float with whitespace (should work due to float() behavior)"""
+        assert is_float(" 12.34 ") is True
+        assert is_float("\t45.67\n") is True
+
+    def test_large_numbers(self):
+        """Test with very large numbers"""
+        large_int = "123456789012345678901234567890"
+        assert is_int(large_int) is True
+        assert is_float(large_int) is True
+
+    def test_scientific_notation(self):
+        """Test scientific notation"""
+        assert is_int("1e5") is False  # int() doesn't handle scientific notation
+        assert is_float("1e5") is True
+        assert is_float("1.5e-10") is True
+        assert is_float("2E+3") is True
+
+
+# Parametrized tests for more comprehensive coverage
+class TestParametrized:
+    """Parametrized tests for better coverage"""
+
+    @pytest.mark.parametrize("value,expected", [
+        ("123", True),
+        ("0", True),
+        ("-456", True),
+        ("12.34", False),
+        ("abc", False),
+        ("", False),
+        (123, True),
+        (12.5, True),
+        (None, False),
+    ])
+    def test_is_int_parametrized(self, value: Any, expected: bool):
+        """Test"""
+        assert is_int(value) == expected
+
+    @pytest.mark.parametrize("value,expected", [
+        ("12.34", True),
+        ("123", True),
+        ("0", True),
+        ("-45.67", True),
+        ("inf", True),
+        ("nan", True),
+        ("abc", False),
+        ("", False),
+        (12.34, True),
+        (123, True),
+        (None, False),
+    ])
+    def test_is_float_parametrized(self, value: Any, expected: bool):
+        """test"""
+        assert is_float(value) == expected
+
+    @pytest.mark.parametrize("value,expected", [
+        ("True", True),
+        ("true", True),
+        ("False", False),
+        ("false", False),
+    ])
+    def test_str_to_bool_valid_parametrized(self, value: Any, expected: bool):
+        """test"""
+        assert str_to_bool(value) == expected
+
+    @pytest.mark.parametrize("invalid_value", [
+        "TRUE",
+        "FALSE",
+        "yes",
+        "no",
+        "1",
+        "0",
+        "",
+        " True",
+        "True ",
+        "invalid",
+    ])
+    def test_str_to_bool_invalid_parametrized(self, invalid_value: Any):
+        """test"""
+        with pytest.raises(ValueError):
+            str_to_bool(invalid_value)
+
+# __END__

tests/unit/string_handling/test_timestamp_strings.py

@@ -0,0 +1,157 @@
+"""
+PyTest: string_handling/timestamp_strings
+"""
+
+from datetime import datetime
+from unittest.mock import patch, MagicMock
+from zoneinfo import ZoneInfo
+import pytest
+
+# Assuming the class is in a file called timestamp_strings.py
+from corelibs.string_handling.timestamp_strings import TimestampStrings
+
+
+class TestTimestampStrings:
+    """Test suite for TimestampStrings class"""
+
+    def test_default_initialization(self):
+        """Test initialization with default timezone"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings()
+
+            assert ts.time_zone == 'Asia/Tokyo'
+            assert ts.timestamp_now == mock_now
+            assert ts.today == '2023-12-25'
+            assert ts.timestamp == '2023-12-25 15:30:45'
+            assert ts.timestamp_file == '2023-12-25_153045'
+
+    def test_custom_timezone_initialization(self):
+        """Test initialization with custom timezone"""
+        custom_tz = 'America/New_York'
+
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings(time_zone=custom_tz)
+
+            assert ts.time_zone == custom_tz
+            assert ts.timestamp_now == mock_now
+
+    def test_invalid_timezone_raises_error(self):
+        """Test that invalid timezone raises ValueError"""
+        invalid_tz = 'Invalid/Timezone'
+
+        with pytest.raises(ValueError) as exc_info:
+            TimestampStrings(time_zone=invalid_tz)
+
+        assert 'Zone could not be loaded [Invalid/Timezone]' in str(exc_info.value)
+
+    def test_timestamp_formats(self):
+        """Test various timestamp format outputs"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            # Mock both datetime.now() calls
+            mock_now = datetime(2023, 12, 25, 9, 5, 3)
+            mock_now_tz = datetime(2023, 12, 25, 23, 5, 3, tzinfo=ZoneInfo('Asia/Tokyo'))
+
+            mock_datetime.now.side_effect = [mock_now, mock_now_tz]
+
+            ts = TimestampStrings()
+
+            assert ts.today == '2023-12-25'
+            assert ts.timestamp == '2023-12-25 09:05:03'
+            assert ts.timestamp_file == '2023-12-25_090503'
+            assert 'JST' in ts.timestamp_tz or 'Asia/Tokyo' in ts.timestamp_tz
+
+    def test_different_timezones_produce_different_results(self):
+        """Test that different timezones produce different timestamp_tz values"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 12, 0, 0)
+            mock_datetime.now.return_value = mock_now
+
+            # Create instances with different timezones
+            ts_tokyo = TimestampStrings(time_zone='Asia/Tokyo')
+            ts_ny = TimestampStrings(time_zone='America/New_York')
+
+            # The timezone-aware timestamps should be different
+            assert ts_tokyo.time_zone != ts_ny.time_zone
+            # Note: The actual timestamp_tz values will depend on the mocked datetime
+
+    def test_class_default_timezone(self):
+        """Test that class default timezone is correctly set"""
+        assert TimestampStrings.TIME_ZONE == 'Asia/Tokyo'
+
+    def test_none_timezone_uses_default(self):
+        """Test that passing None for timezone uses class default"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings(time_zone=None)
+
+            assert ts.time_zone == 'Asia/Tokyo'
+
+    def test_timestamp_file_format_no_colons(self):
+        """Test that timestamp_file format doesn't contain colons (safe for filenames)"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings()
+
+            assert ':' not in ts.timestamp_file
+            assert ' ' not in ts.timestamp_file
+            assert ts.timestamp_file == '2023-12-25_153045'
+
+    def test_multiple_instances_independent(self):
+        """Test that multiple instances don't interfere with each other"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            ts1 = TimestampStrings(time_zone='Asia/Tokyo')
+            ts2 = TimestampStrings(time_zone='Europe/London')
+
+            assert ts1.time_zone == 'Asia/Tokyo'
+            assert ts2.time_zone == 'Europe/London'
+            assert ts1.time_zone != ts2.time_zone
+
+    @patch('corelibs.string_handling.timestamp_strings.ZoneInfo')
+    def test_zoneinfo_called_correctly(self, mock_zoneinfo: MagicMock):
+        """Test that ZoneInfo is called with correct timezone"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_datetime.now.return_value = mock_now
+
+            custom_tz = 'Europe/Paris'
+            ts = TimestampStrings(time_zone=custom_tz)
+            assert ts.time_zone == custom_tz
+
+            mock_zoneinfo.assert_called_with(custom_tz)
+
+    def test_edge_case_midnight(self):
+        """Test timestamp formatting at midnight"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 0, 0, 0)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings()
+
+            assert ts.timestamp == '2023-12-25 00:00:00'
+            assert ts.timestamp_file == '2023-12-25_000000'
+
+    def test_edge_case_new_year(self):
+        """Test timestamp formatting at new year"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2024, 1, 1, 0, 0, 0)
+            mock_datetime.now.return_value = mock_now
+
+            ts = TimestampStrings()
+
+            assert ts.today == '2024-01-01'
+            assert ts.timestamp == '2024-01-01 00:00:00'
+
+# __END__

uv.lock

@@ -33,9 +33,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" },
 ]
 
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
 [[package]]
 name = "corelibs"
-version = "0.3.1"
+version = "0.10.1"
 source = { editable = "." }
 dependencies = [
     { name = "jmespath" },
@@ -43,6 +52,12 @@ dependencies = [
     { name = "requests" },
 ]
 
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "pytest-cov" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "jmespath", specifier = ">=1.0.1" },
@@ -50,6 +65,43 @@ requires-dist = [
     { name = "requests", specifier = ">=2.32.4" },
 ]
 
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8.4.1" },
+    { name = "pytest-cov", specifier = ">=6.2.1" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.9.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/b7/c0465ca253df10a9e8dae0692a4ae6e9726d245390aaef92360e1d6d3832/coverage-7.9.2.tar.gz", hash = "sha256:997024fa51e3290264ffd7492ec97d0690293ccd2b45a6cd7d82d945a4a80c8b", size = 813556, upload-time = "2025-07-03T10:54:15.101Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/9d/7a8edf7acbcaa5e5c489a646226bed9591ee1c5e6a84733c0140e9ce1ae1/coverage-7.9.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:985abe7f242e0d7bba228ab01070fde1d6c8fa12f142e43debe9ed1dde686038", size = 212367, upload-time = "2025-07-03T10:53:25.811Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/9e/5cd6f130150712301f7e40fb5865c1bc27b97689ec57297e568d972eec3c/coverage-7.9.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82c3939264a76d44fde7f213924021ed31f55ef28111a19649fec90c0f109e6d", size = 212632, upload-time = "2025-07-03T10:53:27.075Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/de/6287a2c2036f9fd991c61cefa8c64e57390e30c894ad3aa52fac4c1e14a8/coverage-7.9.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae5d563e970dbe04382f736ec214ef48103d1b875967c89d83c6e3f21706d5b3", size = 245793, upload-time = "2025-07-03T10:53:28.408Z" },
+    { url = "https://files.pythonhosted.org/packages/06/cc/9b5a9961d8160e3cb0b558c71f8051fe08aa2dd4b502ee937225da564ed1/coverage-7.9.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bdd612e59baed2a93c8843c9a7cb902260f181370f1d772f4842987535071d14", size = 243006, upload-time = "2025-07-03T10:53:29.754Z" },
+    { url = "https://files.pythonhosted.org/packages/49/d9/4616b787d9f597d6443f5588619c1c9f659e1f5fc9eebf63699eb6d34b78/coverage-7.9.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:256ea87cb2a1ed992bcdfc349d8042dcea1b80436f4ddf6e246d6bee4b5d73b6", size = 244990, upload-time = "2025-07-03T10:53:31.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/83/801cdc10f137b2d02b005a761661649ffa60eb173dcdaeb77f571e4dc192/coverage-7.9.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f44ae036b63c8ea432f610534a2668b0c3aee810e7037ab9d8ff6883de480f5b", size = 245157, upload-time = "2025-07-03T10:53:32.717Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/41911ed7e9d3ceb0ffb019e7635468df7499f5cc3edca5f7dfc078e9c5ec/coverage-7.9.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:82d76ad87c932935417a19b10cfe7abb15fd3f923cfe47dbdaa74ef4e503752d", size = 243128, upload-time = "2025-07-03T10:53:34.009Z" },
+    { url = "https://files.pythonhosted.org/packages/10/41/344543b71d31ac9cb00a664d5d0c9ef134a0fe87cb7d8430003b20fa0b7d/coverage-7.9.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:619317bb86de4193debc712b9e59d5cffd91dc1d178627ab2a77b9870deb2868", size = 244511, upload-time = "2025-07-03T10:53:35.434Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/81/3b68c77e4812105e2a060f6946ba9e6f898ddcdc0d2bfc8b4b152a9ae522/coverage-7.9.2-cp313-cp313-win32.whl", hash = "sha256:0a07757de9feb1dfafd16ab651e0f628fd7ce551604d1bf23e47e1ddca93f08a", size = 214765, upload-time = "2025-07-03T10:53:36.787Z" },
+    { url = "https://files.pythonhosted.org/packages/06/a2/7fac400f6a346bb1a4004eb2a76fbff0e242cd48926a2ce37a22a6a1d917/coverage-7.9.2-cp313-cp313-win_amd64.whl", hash = "sha256:115db3d1f4d3f35f5bb021e270edd85011934ff97c8797216b62f461dd69374b", size = 215536, upload-time = "2025-07-03T10:53:38.188Z" },
+    { url = "https://files.pythonhosted.org/packages/08/47/2c6c215452b4f90d87017e61ea0fd9e0486bb734cb515e3de56e2c32075f/coverage-7.9.2-cp313-cp313-win_arm64.whl", hash = "sha256:48f82f889c80af8b2a7bb6e158d95a3fbec6a3453a1004d04e4f3b5945a02694", size = 213943, upload-time = "2025-07-03T10:53:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/46/e211e942b22d6af5e0f323faa8a9bc7c447a1cf1923b64c47523f36ed488/coverage-7.9.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:55a28954545f9d2f96870b40f6c3386a59ba8ed50caf2d949676dac3ecab99f5", size = 213088, upload-time = "2025-07-03T10:53:40.874Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/2f/762551f97e124442eccd907bf8b0de54348635b8866a73567eb4e6417acf/coverage-7.9.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cdef6504637731a63c133bb2e6f0f0214e2748495ec15fe42d1e219d1b133f0b", size = 213298, upload-time = "2025-07-03T10:53:42.218Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/b7/76d2d132b7baf7360ed69be0bcab968f151fa31abe6d067f0384439d9edb/coverage-7.9.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcd5ebe66c7a97273d5d2ddd4ad0ed2e706b39630ed4b53e713d360626c3dbb3", size = 256541, upload-time = "2025-07-03T10:53:43.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/17/392b219837d7ad47d8e5974ce5f8dc3deb9f99a53b3bd4d123602f960c81/coverage-7.9.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9303aed20872d7a3c9cb39c5d2b9bdbe44e3a9a1aecb52920f7e7495410dfab8", size = 252761, upload-time = "2025-07-03T10:53:45.19Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/77/4256d3577fe1b0daa8d3836a1ebe68eaa07dd2cbaf20cf5ab1115d6949d4/coverage-7.9.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc18ea9e417a04d1920a9a76fe9ebd2f43ca505b81994598482f938d5c315f46", size = 254917, upload-time = "2025-07-03T10:53:46.931Z" },
+    { url = "https://files.pythonhosted.org/packages/53/99/fc1a008eef1805e1ddb123cf17af864743354479ea5129a8f838c433cc2c/coverage-7.9.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6406cff19880aaaadc932152242523e892faff224da29e241ce2fca329866584", size = 256147, upload-time = "2025-07-03T10:53:48.289Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c0/f63bf667e18b7f88c2bdb3160870e277c4874ced87e21426128d70aa741f/coverage-7.9.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d0d4f6ecdf37fcc19c88fec3e2277d5dee740fb51ffdd69b9579b8c31e4232e", size = 254261, upload-time = "2025-07-03T10:53:49.99Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/32/37dd1c42ce3016ff8ec9e4b607650d2e34845c0585d3518b2a93b4830c1a/coverage-7.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c33624f50cf8de418ab2b4d6ca9eda96dc45b2c4231336bac91454520e8d1fac", size = 255099, upload-time = "2025-07-03T10:53:51.354Z" },
+    { url = "https://files.pythonhosted.org/packages/da/2e/af6b86f7c95441ce82f035b3affe1cd147f727bbd92f563be35e2d585683/coverage-7.9.2-cp313-cp313t-win32.whl", hash = "sha256:1df6b76e737c6a92210eebcb2390af59a141f9e9430210595251fbaf02d46926", size = 215440, upload-time = "2025-07-03T10:53:52.808Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/bb/8a785d91b308867f6b2e36e41c569b367c00b70c17f54b13ac29bcd2d8c8/coverage-7.9.2-cp313-cp313t-win_amd64.whl", hash = "sha256:f5fd54310b92741ebe00d9c0d1d7b2b27463952c022da6d47c175d246a98d1bd", size = 216537, upload-time = "2025-07-03T10:53:54.273Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a0/a6bffb5e0f41a47279fd45a8f3155bf193f77990ae1c30f9c224b61cacb0/coverage-7.9.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c48c2375287108c887ee87d13b4070a381c6537d30e8487b24ec721bf2a781cb", size = 214398, upload-time = "2025-07-03T10:53:56.715Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/38/bbe2e63902847cf79036ecc75550d0698af31c91c7575352eb25190d0fb3/coverage-7.9.2-py3-none-any.whl", hash = "sha256:e425cd5b00f6fc0ed7cdbd766c70be8baab4b7839e4d4fe5fac48581dd968ea4", size = 204005, upload-time = "2025-07-03T10:54:13.491Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.10"
@@ -59,6 +111,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
 ]
 
+[[package]]
+name = "iniconfig"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
+]
+
 [[package]]
 name = "jmespath"
 version = "1.0.1"
@@ -68,6 +129,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" },
 ]
 
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
 [[package]]
 name = "psutil"
 version = "7.0.0"
@@ -83,6 +162,45 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" },
 ]
 
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714, upload-time = "2025-06-18T05:48:06.109Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474, upload-time = "2025-06-18T05:48:03.955Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "6.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage" },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/99/668cade231f434aaa59bbfbf49469068d2ddd945000621d3d165d2e7dd7b/pytest_cov-6.2.1.tar.gz", hash = "sha256:25cc6cc0a5358204b8108ecedc51a9b57b34cc6b8c967cc2c01a4e00d8a67da2", size = 69432, upload-time = "2025-06-12T10:47:47.684Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/16/4ea354101abb1287856baa4af2732be351c7bee728065aed451b678153fd/pytest_cov-6.2.1-py3-none-any.whl", hash = "sha256:f5bc4c23f42f1cdd23c70b1dab1bbaef4fc505ba950d53e0081d0730dd7e86d5", size = 24644, upload-time = "2025-06-12T10:47:45.932Z" },
+]
+
 [[package]]
 name = "requests"
 version = "2.32.4"