Move progres and script helpers to corelibs-progress and corelibs-script

Deprecate math helpers in favor of built-in math functions

.gitignore

@@ -4,3 +4,4 @@
 .mypy_cache/
 **/.env
 .coverage
+uv.lock

README.md

@@ -2,12 +2,16 @@
 
 > [!warning]
 > This is pre-production, location of methods and names of paths can change
+>
+> This will be split up into modules per file and this will be just a collection holder
+> See [Deprecated](#deprecated) below
 
 This is a pip package that can be installed into any project and covers the following parts
 
 - logging update with exception logs
 - requests wrapper for easier auth pass on access
 - dict fingerprinting
+- sending email
 - jmespath search
 - json helpers for conten replace and output
 - dump outputs for data for debugging
@@ -20,10 +24,11 @@ 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
+- csv_interface: csv dict writer/reader helper
 - debug_handling: various debug helpers like data dumper, timer, utilization, etc
 - db_handling: SQLite interface class
 - encyption_handling: symmetric encryption
+- email_handling: simple email sending
 - file_handling: crc handling for file content and file names, progress bar
 - json_handling: jmespath support and json date support, replace content in dict with json paths
 - iterator_handling: list and dictionary handling support (search, fingerprinting, etc)
@@ -33,6 +38,51 @@ This is a pip package that can be installed into any project and covers the foll
 - string_handling: byte format, datetime format, datetime compare, hashing, string formats for numbers, double byte string format, etc
 - var_handling: var type checkers, enum base class
 
+## Unfinished
+
+- csv_handling/csv_interface: The CSV DictWriter interface is just in a very basic way implemented
+- script_handling/script_helpers: No idea if there is need for this, tests are written but not finished
+
+## Deprecated
+
+All content in this module will move to stand alone libraries, as of now the following entries have moved and will throw deprecated warnings if used
+
+- check_handling.regex_constants_compiled: corelibs-regex-checks
+- check_handling.regex_constants: corelibs-regex-checks
+- csv_handling.csv_interface: corelibs-csv
+- datetime_handling.datetime_helpers: corelibs-datetime
+- datetime_handling.timestamp_convert: corelibs-datetime
+- datetime_handling.timestamp_strings: corelibs-datetime
+- debug_handling.debug_helpers: corelibs-stack-trace
+- debug_handling.dump_data: corelibs-dump-data
+- debug_handling.profiling: corelibs-debug
+- debug_handling.timer: corelibs-debug
+- debug_handling.writeline: corelibs-debug
+- encryption_handling.symmetrix_encryption: corelibs-encryption
+- exceptions.csv_exceptions: orelibs-csv
+- file_handling.file_bom_encoding: corelibs-file
+- file_handling.file_crc: corelibs-file
+- file_handling.file_handling: corelibs-file
+- iterator_handling.data_search: corelibs-search
+- iterator_handling.dict_helpers: corelibs-iterator
+- iterator_handling.dict_mask: corelibs-dump-data
+- iterator_handling.fingerprint: corelibs-hash
+- iterator_handling.list_helpers: corelibs-iterator
+- json_handling.jmespath_helper: corelibs-search
+- json_handling.json_helper: corelibs-json
+- math_handling.math_helpers: python.math
+- requests_handling.auth_helpers: corelibs-requests
+- requests_handling.caller: corelibs-requests
+- script_handling.progress: corelibs-progress
+- script_handling.script_helpers: corelibs-script
+- string_handling.byte_helpers: corelibs-strings
+- string_handling.double_byte_string_format: corelibs-double-byte-format
+- string_handling.hash_helpers: corelibs-hash
+- string_handling.string_helpers: corelibs-strings
+- string_handling.text_colors: corelibs-text-colors
+- var_handling.enum_base: corelibs-enum-base
+- var_handling.var_helpers: corelibs-var
+
 ## UV setup
 
 uv must be [installed](https://docs.astral.sh/uv/getting-started/installation/)
@@ -43,7 +93,7 @@ Have the following setup in `project.toml`
 
 ```toml
 [[tool.uv.index]]
-name = "egra-gitea"
+name = "opj-pypi"
 url = "https://git.egplusww.jp/api/packages/PyPI/pypi/simple/"
 publish-url = "https://git.egplusww.jp/api/packages/PyPI/pypi"
 explicit = true
@@ -51,15 +101,15 @@ explicit = true
 
 ```sh
 uv build
-uv publish --index egra-gitea --token <gitea token>
+uv publish --index opj-pypi --token <gitea token>
 ```
 
-## Test package
+## Use package
 
 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 -- python -c "import corelibs"
+uv run --with corelibs --index opj-pypi=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/ --no-project -- python -c "import corelibs"
 ```
 
 ### Python tests
@@ -76,38 +126,15 @@ Get a coverate report
 
 ```sh
 uv run pytest --cov=corelibs
+uv run pytest --cov=corelibs --cov-report=term-missing
 ```
 
 ### Other tests
 
-In the test-run folder usage and run tests are located
-
-#### Progress
+In the test-run folder usage and run tests are located, runt them below
 
 ```sh
-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 test-run/string_handling/string_helpers.py
-```
-
-#### Log
-
-```sh
-uv run test-run/logging_handling/log.py
+uv run test-run/<script>
 ```
 
 ## How to install in another project
@@ -115,7 +142,7 @@ uv run test-run/logging_handling/log.py
 This will also add the index entry
 
 ```sh
-uv add corelibs --index egra-gitea=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/
+uv add corelibs --index opj-pypi=https://git.egplusww.jp/api/packages/PyPI/pypi/simple/
 ```
 
 ## Python venv setup

pyproject.toml

@@ -1,37 +1,63 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.30.0"
+version = "0.48.0"
 description = "Collection of utils for Python scripts"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
+    "corelibs-csv>=1.0.0",
+    "corelibs-datetime>=1.0.1",
+    "corelibs-debug>=1.0.0",
+    "corelibs-double-byte-format>=1.0.0",
+    "corelibs-dump-data>=1.0.0",
+    "corelibs-encryption>=1.0.0",
+    "corelibs-enum-base>=1.0.0",
+    "corelibs-file>=1.0.0",
+    "corelibs-hash>=1.0.0",
+    "corelibs-iterator>=1.0.0",
+    "corelibs-json>=1.0.0",
+    "corelibs-progress>=1.0.0",
+    "corelibs-regex-checks>=1.0.0",
+    "corelibs-requests>=1.0.0",
+    "corelibs-script>=1.0.0",
+    "corelibs-search>=1.0.0",
+    "corelibs-stack-trace>=1.0.0",
+    "corelibs-strings>=1.0.0",
+    "corelibs-text-colors>=1.0.0",
+    "corelibs-var>=1.0.0",
     "cryptography>=46.0.3",
     "jmespath>=1.0.1",
     "jsonpath-ng>=1.7.0",
     "psutil>=7.0.0",
-    "requests>=2.32.4",
+    "requests[socks]>=2.32.5",
 ]
-# set this to disable publish to pypi (pip)
-# classifiers = ["Private :: Do Not Upload"]
-
-# MARK: build target
-[[tool.uv.index]]
-name = "egra-gitea"
-url = "https://git.egplusww.jp/api/packages/PyPI/pypi/simple/"
-publish-url = "https://git.egplusww.jp/api/packages/PyPI/pypi"
-explicit = true
 
 # MARK: build system
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+# set this to disable publish to pypi (pip)
+# classifiers = ["Private :: Do Not Upload"]
+
+# MARK: build target
+[[tool.uv.index]]
+name = "opj-pypi"
+url = "https://git.egplusww.jp/api/packages/PyPI/pypi/simple/"
+publish-url = "https://git.egplusww.jp/api/packages/PyPI/pypi"
+
+[tool.uv.sources]
+corelibs-enum-base = { index = "opj-pypi" }
+corelibs-datetime = { index = "opj-pypi" }
+corelibs-var = { index = "opj-pypi" }
+corelibs-text-colors = { index = "opj-pypi" }
 
 [dependency-groups]
 dev = [
     "deepdiff>=8.6.1",
     "pytest>=8.4.1",
     "pytest-cov>=6.2.1",
+    "typing-extensions>=4.15.0",
 ]
 
 # MARK: Python linting
@@ -63,7 +89,31 @@ ignore = [
 [tool.pylint.MASTER]
 # this is for the tests/etc folders
 init-hook='import sys; sys.path.append("src/")'
+
+# MARK: Testing
 [tool.pytest.ini_options]
 testpaths = [
     "tests",
 ]
+
+[tool.coverage.run]
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+    "*/__init__.py"
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "def __str__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:"
+]
+exclude_also = [
+    "def __.*__\\(",
+    "def __.*\\(",
+    "def _.*\\(",
+]

src/corelibs/check_handling/regex_constants.py

@@ -3,8 +3,20 @@ List of regex compiled strings that can be used
 """
 
 import re
+from warnings import warn, deprecated
+from corelibs_regex_checks.regex_constants import (
+    compile_re as compile_re_ng,
+    SUB_EMAIL_BASIC_REGEX as SUB_EMAIL_BASIC_REGEX_NG,
+    EMAIL_BASIC_REGEX as EMAIL_BASIC_REGEX_NG,
+    NAME_EMAIL_SIMPLE_REGEX as NAME_EMAIL_SIMPLE_REGEX_NG,
+    NAME_EMAIL_BASIC_REGEX as NAME_EMAIL_BASIC_REGEX_NG,
+    DOMAIN_WITH_LOCALHOST_REGEX as DOMAIN_WITH_LOCALHOST_REGEX_NG,
+    DOMAIN_WITH_LOCALHOST_PORT_REGEX as DOMAIN_WITH_LOCALHOST_PORT_REGEX_NG,
+    DOMAIN_REGEX as DOMAIN_REGEX_NG
+)
 
 
+@deprecated("Use corelibs_regex_checks.regex_constants.compile_re instead")
 def compile_re(reg: str) -> re.Pattern[str]:
     """
     compile a regex with verbose flag
@@ -15,23 +27,25 @@ def compile_re(reg: str) -> re.Pattern[str]:
     Returns:
         re.Pattern[str] -- _description_
     """
-    return re.compile(reg, re.VERBOSE)
+    return compile_re_ng(reg)
 
 
 # email regex
-EMAIL_BASIC_REGEX: str = r"""
-^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}
-@(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$
-"""
+SUB_EMAIL_BASIC_REGEX = SUB_EMAIL_BASIC_REGEX_NG
+
+EMAIL_BASIC_REGEX = EMAIL_BASIC_REGEX_NG
+# name + email regex for email sending type like "foo bar" <email@mail.com>
+NAME_EMAIL_SIMPLE_REGEX = NAME_EMAIL_SIMPLE_REGEX_NG
+# name + email with the basic regex set
+NAME_EMAIL_BASIC_REGEX = NAME_EMAIL_BASIC_REGEX_NG
 # Domain regex with localhost
-DOMAIN_WITH_LOCALHOST_REGEX: str = r"""
-^(?:localhost|(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[A-Za-z]{2,})$
-"""
+DOMAIN_WITH_LOCALHOST_REGEX = DOMAIN_WITH_LOCALHOST_REGEX_NG
 # domain regex with loclhost and optional port
-DOMAIN_WITH_LOCALHOST_PORT_REGEX: str = r"""
-^(?:localhost|(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[A-Za-z]{2,})(?::\d+)?$
-"""
+DOMAIN_WITH_LOCALHOST_PORT_REGEX = DOMAIN_WITH_LOCALHOST_PORT_REGEX_NG
 # Domain, no localhost
-DOMAIN_REGEX: str = r"^(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[A-Za-z]{2,}$"
+DOMAIN_REGEX = DOMAIN_REGEX_NG
+
+# At the module level, issue a deprecation warning
+warn("Use corelibs_regex_checks.regex_constants instead", DeprecationWarning, stacklevel=2)
 
 # __END__

src/corelibs/check_handling/regex_constants_compiled.py

@@ -0,0 +1,27 @@
+"""
+List of regex compiled strings that can be used
+"""
+
+import warnings
+
+from corelibs_regex_checks.regex_constants_compiled import (
+    COMPILED_EMAIL_BASIC_REGEX as COMPILED_EMAIL_BASIC_REGEX_NG,
+    COMPILED_NAME_EMAIL_SIMPLE_REGEX as COMPILED_NAME_EMAIL_SIMPLE_REGEX_NG,
+    COMPILED_NAME_EMAIL_BASIC_REGEX as COMPILED_NAME_EMAIL_BASIC_REGEX_NG,
+    COMPILED_DOMAIN_WITH_LOCALHOST_REGEX as COMPILED_DOMAIN_WITH_LOCALHOST_REGEX_NG,
+    COMPILED_DOMAIN_WITH_LOCALHOST_PORT_REGEX as COMPILED_DOMAIN_WITH_LOCALHOST_PORT_REGEX_NG,
+    COMPILED_DOMAIN_REGEX as COMPILED_DOMAIN_REGEX_NG
+)
+
+# all above in compiled form
+COMPILED_EMAIL_BASIC_REGEX = COMPILED_EMAIL_BASIC_REGEX_NG
+COMPILED_NAME_EMAIL_SIMPLE_REGEX = COMPILED_NAME_EMAIL_SIMPLE_REGEX_NG
+COMPILED_NAME_EMAIL_BASIC_REGEX = COMPILED_NAME_EMAIL_BASIC_REGEX_NG
+COMPILED_DOMAIN_WITH_LOCALHOST_REGEX = COMPILED_DOMAIN_WITH_LOCALHOST_REGEX_NG
+COMPILED_DOMAIN_WITH_LOCALHOST_PORT_REGEX = COMPILED_DOMAIN_WITH_LOCALHOST_PORT_REGEX_NG
+COMPILED_DOMAIN_REGEX = COMPILED_DOMAIN_REGEX_NG
+
+# At the module level, issue a deprecation warning
+warnings.warn("Use corelibs_regex_checks.regex_constants_compiled instead", DeprecationWarning, stacklevel=2)
+
+# __END__

src/corelibs/config_handling/settings_loader.py

@@ -8,9 +8,9 @@ import re
 import configparser
 from typing import Any, Tuple, Sequence, cast
 from pathlib import Path
+from corelibs_var.var_helpers import is_int, is_float, str_to_bool
 from corelibs.logging_handling.log import Log
 from corelibs.iterator_handling.list_helpers import convert_to_list, is_list_in_list
-from corelibs.var_handling.var_helpers import is_int, is_float, str_to_bool
 from corelibs.config_handling.settings_loader_handling.settings_loader_check import SettingsLoaderCheck
 
 
@@ -53,6 +53,9 @@ class SettingsLoader:
         # for check settings, abort flag
         self.__check_settings_abort: bool = False
 
+        # error messages for raise ValueError
+        self.__error_msg: list[str] = []
+
     # MARK: load settings
     def load_settings(
         self,
@@ -87,12 +90,16 @@ class SettingsLoader:
         Returns:
             dict[str, str]: key = value list
         """
+        # reset error message list before run
+        self.__error_msg = []
         # default set entries
         entry_set_empty: dict[str, str | None] = {}
         # entries that have to be split
         entry_split_char: dict[str, str] = {}
         # entries that should be converted
         entry_convert: dict[str, str] = {}
+        # no args to set
+        args_overrride: list[str] = []
         # all the settings for the config id given
         settings: dict[str, dict[str, Any]] = {
             config_id: {},
@@ -107,7 +114,7 @@ class SettingsLoader:
                 if allow_not_exist is True:
                     return {}
                 raise ValueError(self.__print(
-                    f"[!] Cannot read [{config_id}] block in the {self.config_file}: {e}",
+                    f"[!] Cannot read [{config_id}] block in the file {self.config_file}: {e}",
                     'CRITICAL'
                 )) from e
             try:
@@ -162,12 +169,17 @@ class SettingsLoader:
                                     f"[!] In [{config_id}] the split character setup for entry failed: {check}: {e}",
                                     'CRITICAL'
                                 )) from e
+                        if check == "args_override:yes":
+                            args_overrride.append(key)
                     if skip:
                         continue
-                    settings[config_id][key] = [
-                        __value.replace(" ", "")
-                        for __value in settings[config_id][key].split(split_char)
-                    ]
+                    if settings[config_id][key]:
+                        settings[config_id][key] = [
+                            __value.replace(" ", "")
+                            for __value in settings[config_id][key].split(split_char)
+                        ]
+                    else:
+                        settings[config_id][key] = []
             except KeyError as e:
                 raise ValueError(self.__print(
                     f"[!] Cannot read [{config_id}] block because the entry [{e}] could not be found",
@@ -177,17 +189,23 @@ class SettingsLoader:
             # ignore error if arguments are set
             if not self.__check_arguments(config_validate, True):
                 raise ValueError(self.__print(f"[!] Cannot find file: {self.config_file}", 'CRITICAL'))
-            else:
-                # base set
-                settings[config_id] = {}
+            # 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):
+            if (args_entry := self.__get_arg(entry)) is not None:
                 self.__print(f"[*] Command line option override for: {entry}", 'WARNING')
-                settings[config_id][entry] = self.args.get(entry)
+                if (
+                    # only set if flagged as allowed override from args
+                    entry in args_overrride and
+                    (isinstance(args_entry, list) and entry_split_char.get(entry)) or
+                    (not isinstance(args_entry, list) and not entry_split_char.get(entry))
+                ):
+                    # args is list, but entry has not split, do not set
+                    settings[config_id][entry] = args_entry
             # validate checks
             for check in validate:
                 # CHECKS
@@ -263,7 +281,10 @@ class SettingsLoader:
                     error = True
                     self.__print(f"[!] Missing content entry for: {entry}", 'ERROR')
         if error is True:
-            raise ValueError(self.__print("[!] Missing or incorrect settings data. Cannot proceed", 'CRITICAL'))
+            self.__print("[!] Missing or incorrect settings data. Cannot proceed", 'CRITICAL')
+            raise ValueError(
+                "Missing or incorrect settings data. Cannot proceed: " + "; ".join(self.__error_msg)
+            )
         # set empty
         for [entry, empty_set] in entry_set_empty.items():
             # if set, skip, else set to empty value
@@ -277,10 +298,8 @@ class SettingsLoader:
             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"
+                settings[config_id][entry].lower() == "true" or
+                settings[config_id][entry].lower() == "false"
             ):
                 try:
                     settings[config_id][entry] = str_to_bool(settings[config_id][entry])
@@ -558,7 +577,10 @@ class SettingsLoader:
             self.log.logger.log(Log.get_log_level_int(level), msg, stacklevel=2)
         if self.log is None or self.always_print:
             if print_error:
-                print(msg)
+                print(f"[SettingsLoader] {msg}")
+        if level == 'ERROR':
+            # remove any prefix [!] for error message list
+            self.__error_msg.append(msg.replace('[!] ', '').strip())
         return msg
 
 

src/corelibs/csv_handling/csv_interface.py

@@ -0,0 +1,39 @@
+"""
+Write to CSV file
+- each class set is one file write with one header set
+"""
+
+from warnings import warn
+from corelibs_csv.csv_interface import (
+    CsvReader as CoreLibsCsvReader, CsvWriter as CoreLibsCsvWriter,
+    ENCODING as CoreLibsEncoding,
+    ENCODING_UTF8_SIG as CoreLibsEncodingUtf8Sig,
+    DELIMITER as CoreLibsDelimiter,
+    QUOTECHAR as CoreLibsQuotechar,
+    QUOTING as CoreLibsQuoting
+)
+
+
+ENCODING = CoreLibsEncoding
+ENCODING_UTF8_SIG = CoreLibsEncodingUtf8Sig
+DELIMITER = CoreLibsDelimiter
+QUOTECHAR = CoreLibsQuotechar
+# type: _QuotingType
+QUOTING = CoreLibsQuoting
+
+
+class CsvWriter(CoreLibsCsvWriter):
+    """
+    write to a CSV file
+    """
+
+
+class CsvReader(CoreLibsCsvReader):
+    """
+    read from a CSV file
+    """
+
+
+warn("Use corelibs_csv.csv_interface instead", DeprecationWarning, stacklevel=2)
+
+# __END__

src/corelibs/csv_handling/csv_writer.py

@@ -1,93 +0,0 @@
-"""
-Write to CSV file
-- each class set is one file write with one header set
-"""
-
-from typing import Any
-from pathlib import Path
-from collections import Counter
-import csv
-
-
-class CsvWriter:
-    """
-    write to a CSV file
-    """
-
-    def __init__(
-        self,
-        path: Path,
-        file_name: str,
-        header: dict[str, str],
-        header_order: list[str] | None = None
-    ):
-        self.path = path
-        self.file_name = file_name
-        # Key: index for write for the line dict, Values: header entries
-        self.header = header
-        self.csv_file_writer = self.__open_csv(header_order)
-
-    def __open_csv(self, header_order: list[str] | None) -> 'csv.DictWriter[str] | None':
-        """
-        open csv file for writing, write headers
-
-        Note that if there is no header_order set we use the order in header dictionary
-
-        Arguments:
-            line {list[str] | None} -- optional dedicated header order
-
-        Returns:
-            csv.DictWriter[str] | None: _description_
-        """
-        # if header order is set, make sure all header value fields exist
-        header_values = self.header.values()
-        if header_order is not None:
-            if Counter(header_values) != Counter(header_order):
-                print(
-                    "header order does not match header values: "
-                    f"{', '.join(header_values)} != {', '.join(header_order)}"
-                )
-                return None
-            header_values = header_order
-        # no duplicates
-        if len(header_values) != len(set(header_values)):
-            print(f"Header must have unique values only: {', '.join(header_values)}")
-            return None
-        try:
-            fp = open(
-                self.path.joinpath(self.file_name),
-                "w", encoding="utf-8"
-            )
-            csv_file_writer = csv.DictWriter(
-                fp,
-                fieldnames=header_values,
-                delimiter=",",
-                quotechar='"',
-                quoting=csv.QUOTE_MINIMAL,
-            )
-            csv_file_writer.writeheader()
-            return csv_file_writer
-        except OSError as err:
-            print("OS error:", err)
-            return None
-
-    def write_csv(self, line: dict[str, str]) -> bool:
-        """
-        write member csv line
-
-        Arguments:
-            line {dict[str, str]} -- _description_
-
-        Returns:
-            bool -- _description_
-        """
-        if self.csv_file_writer is None:
-            return False
-        csv_row: dict[str, Any] = {}
-        # only write entries that are in the header list
-        for key, value in self.header.items():
-            csv_row[value] = line[key]
-        self.csv_file_writer.writerow(csv_row)
-        return True
-
-# __END__

src/corelibs/datetime_handling/datetime_helpers.py

@@ -2,26 +2,13 @@
 Various string based date/time helpers
 """
 
-import time as time_t
 from datetime import datetime, time
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
-from typing import Callable
-
-DAYS_OF_WEEK_LONG_TO_SHORT: dict[str, str] = {
-    'Monday': 'Mon',
-    'Tuesday': 'Tue',
-    'Wednesay': 'Wed',
-    'Thursday': 'Thu',
-    'Friday': 'Fri',
-    'Saturday': 'Sat',
-    'Sunday': 'Sun',
-}
-DAYS_OF_WEEK_ISO: dict[int, str] = {
-    1: 'Mon', 2: 'Tue', 3: 'Wed', 4: 'Thu', 5: 'Fri', 6: 'Sat', 7: 'Sun'
-}
-DAYS_OF_WEEK_ISO_REVERSED: dict[str, int] = {value: key for key, value in DAYS_OF_WEEK_ISO.items()}
+from warnings import deprecated
+from zoneinfo import ZoneInfo
+from corelibs_datetime import datetime_helpers
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.create_time instead")
 def create_time(timestamp: float, timestamp_format: str = "%Y-%m-%d %H:%M:%S") -> str:
     """
     just takes a timestamp and prints out humand readable format
@@ -35,21 +22,17 @@ def create_time(timestamp: float, timestamp_format: str = "%Y-%m-%d %H:%M:%S") -
     Returns:
         str -- _description_
     """
-    return time_t.strftime(timestamp_format, time_t.localtime(timestamp))
+    return datetime_helpers.create_time(timestamp, timestamp_format)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.get_system_timezone instead")
 def get_system_timezone():
     """Get system timezone using datetime's automatic detection"""
     # Get current time with system timezone
-    local_time = datetime.now().astimezone()
-
-    # Extract timezone info
-    system_tz = local_time.tzinfo
-    timezone_name = str(system_tz)
-
-    return system_tz, timezone_name
+    return datetime_helpers.get_system_timezone()
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.parse_timezone_data instead")
 def parse_timezone_data(timezone_tz: str = '') -> ZoneInfo:
     """
     parses a string to get the ZoneInfo
@@ -62,40 +45,10 @@ def parse_timezone_data(timezone_tz: str = '') -> ZoneInfo:
     Returns:
         ZoneInfo -- _description_
     """
-    try:
-        return ZoneInfo(timezone_tz)
-    except (ZoneInfoNotFoundError, ValueError, TypeError):
-        # use default
-        time_tz, time_tz_str = get_system_timezone()
-        if time_tz is None:
-            return ZoneInfo('UTC')
-        # TODO build proper TZ lookup
-        tz_mapping = {
-            'JST': 'Asia/Tokyo',
-            'KST': 'Asia/Seoul',
-            'IST': 'Asia/Kolkata',
-            'CST': 'Asia/Shanghai',  # Default to China for CST
-            'AEST': 'Australia/Sydney',
-            'AWST': 'Australia/Perth',
-            'EST': 'America/New_York',
-            'EDT': 'America/New_York',
-            'CDT': 'America/Chicago',
-            'MST': 'America/Denver',
-            'MDT': 'America/Denver',
-            'PST': 'America/Los_Angeles',
-            'PDT': 'America/Los_Angeles',
-            'GMT': 'UTC',
-            'UTC': 'UTC',
-            'CET': 'Europe/Berlin',
-            'CEST': 'Europe/Berlin',
-            'BST': 'Europe/London',
-        }
-        try:
-            return ZoneInfo(tz_mapping[time_tz_str])
-        except (ZoneInfoNotFoundError, IndexError) as e:
-            raise ValueError(f"No mapping for {time_tz_str}: {e}") from e
+    return datetime_helpers.parse_timezone_data(timezone_tz)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.get_datetime_iso8601 instead")
 def get_datetime_iso8601(timezone_tz: str | ZoneInfo = '', sep: str = 'T', timespec: str = 'microseconds') -> str:
     """
     set a datetime in the iso8601 format with microseconds
@@ -103,12 +56,13 @@ def get_datetime_iso8601(timezone_tz: str | ZoneInfo = '', sep: str = 'T', times
     Returns:
         str -- _description_
     """
-    # parse if this is a string
-    if isinstance(timezone_tz, str):
-        timezone_tz = parse_timezone_data(timezone_tz)
-    return datetime.now(timezone_tz).isoformat(sep=sep, timespec=timespec)
+    try:
+        return datetime_helpers.get_datetime_iso8601(timezone_tz, sep, timespec)
+    except KeyError as e:
+        raise ValueError(f"Deprecated ValueError, change to KeyError: {e}") from e
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.validate_date instead")
 def validate_date(date: str, not_before: datetime | None = None, not_after: datetime | None = None) -> bool:
     """
     check if Y-m-d or Y/m/d are parsable and valid
@@ -119,20 +73,10 @@ def validate_date(date: str, not_before: datetime | None = None, not_after: date
     Returns:
         bool -- _description_
     """
-    formats = ['%Y-%m-%d', '%Y/%m/%d']
-    for __format in formats:
-        try:
-            __date = datetime.strptime(date, __format).date()
-            if not_before is not None and __date < not_before.date():
-                return False
-            if not_after is not None and __date > not_after.date():
-                return False
-            return True
-        except ValueError:
-            continue
-    return False
+    return datetime_helpers.validate_date(date, not_before, not_after)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.parse_flexible_date instead")
 def parse_flexible_date(
     date_str: str,
     timezone_tz: str | ZoneInfo | None = None,
@@ -154,45 +98,14 @@ def parse_flexible_date(
     Returns:
         datetime | None -- _description_
     """
-
-    date_str = date_str.strip()
-
-    # Try different parsing methods
-    parsers: list[Callable[[str], datetime]] = [
-        # ISO 8601 format
-        lambda x: datetime.fromisoformat(x),  # pylint: disable=W0108
-        # Simple date format
-        lambda x: datetime.strptime(x, "%Y-%m-%d"),
-        # Alternative ISO formats (fallback)
-        lambda x: datetime.strptime(x, "%Y-%m-%dT%H:%M:%S"),
-        lambda x: datetime.strptime(x, "%Y-%m-%dT%H:%M:%S.%f"),
-    ]
-
-    if timezone_tz is not None:
-        if isinstance(timezone_tz, str):
-            timezone_tz = parse_timezone_data(timezone_tz)
-
-    date_new = None
-    for parser in parsers:
-        try:
-            date_new = parser(date_str)
-            break
-        except ValueError:
-            continue
-
-    if date_new is not None:
-        if timezone_tz is not None:
-            # shift time zone (default), this will change the date
-            # if the date has no +HH:MM it will take the local time zone as base
-            if shift_time_zone:
-                return date_new.astimezone(timezone_tz)
-            # just add the time zone
-            return date_new.replace(tzinfo=timezone_tz)
-        return date_new
-
-    return None
+    return datetime_helpers.parse_flexible_date(
+        date_str,
+        timezone_tz,
+        shift_time_zone
+    )
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.compare_dates instead")
 def compare_dates(date1_str: str, date2_str: str) -> None | bool:
     """
     compare two dates, if the first one is newer than the second one return True
@@ -206,23 +119,10 @@ def compare_dates(date1_str: str, date2_str: str) -> None | bool:
     Returns:
         None | bool -- _description_
     """
-
-    try:
-        # Parse both dates
-        date1 = parse_flexible_date(date1_str)
-        date2 = parse_flexible_date(date2_str)
-
-        # Check if parsing was successful
-        if date1 is None or date2 is None:
-            return None
-
-        # Compare dates
-        return date1.date() > date2.date()
-
-    except ValueError:
-        return None
+    return datetime_helpers.compare_dates(date1_str, date2_str)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.find_newest_datetime_in_list instead")
 def find_newest_datetime_in_list(date_list: list[str]) -> None | str:
     """
     Find the newest date from a list of ISO 8601 formatted date strings.
@@ -234,31 +134,10 @@ def find_newest_datetime_in_list(date_list: list[str]) -> None | str:
     Returns:
         str: The date string with the newest/latest date, or None if list is empty or all dates are invalid
     """
-    if not date_list:
-        return None
-
-    valid_dates: list[tuple[str, datetime]] = []
-
-    for date_str in date_list:
-        try:
-            # Parse the date string and store both original string and parsed datetime
-            parsed_date = parse_flexible_date(date_str)
-            if parsed_date is None:
-                continue
-            valid_dates.append((date_str, parsed_date))
-        except ValueError:
-            # Skip invalid date strings
-            continue
-
-    if not valid_dates:
-        return None
-
-    # Find the date string with the maximum datetime value
-    newest_date_str: str = max(valid_dates, key=lambda x: x[1])[0]
-
-    return newest_date_str
+    return datetime_helpers.find_newest_datetime_in_list(date_list)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.parse_day_of_week_range instead")
 def parse_day_of_week_range(dow_days: str) -> list[tuple[int, str]]:
     """
     Parse a day of week list/range string and return a list of tuples with day index and name.
@@ -275,59 +154,13 @@ def parse_day_of_week_range(dow_days: str) -> list[tuple[int, str]]:
     """
     # we have Sun twice because it can be 0 or 7
     # Mon is 1 and Sun is 7, which is ISO standard
-    dow_day = dow_days.split(",")
-    dow_day = [day.strip() for day in dow_day if day.strip()]
-    __out_dow_days: list[tuple[int, str]] = []
-    for __dow_day in dow_day:
-        # if we have a "-" in there fill
-        if "-" in __dow_day:
-            __dow_range = __dow_day.split("-")
-            __dow_range = [day.strip().capitalize() for day in __dow_range if day.strip()]
-            try:
-                start_day = DAYS_OF_WEEK_ISO_REVERSED[__dow_range[0]]
-                end_day = DAYS_OF_WEEK_ISO_REVERSED[__dow_range[1]]
-            except KeyError:
-                # try long time
-                try:
-                    start_day = DAYS_OF_WEEK_ISO_REVERSED[DAYS_OF_WEEK_LONG_TO_SHORT[__dow_range[0]]]
-                    end_day = DAYS_OF_WEEK_ISO_REVERSED[DAYS_OF_WEEK_LONG_TO_SHORT[__dow_range[1]]]
-                except KeyError as e:
-                    raise ValueError(f"Invalid day of week entry found: {__dow_day}: {e}") from e
-            # Check if this spans across the weekend (e.g., Fri-Mon)
-            if start_day > end_day:
-                # Handle weekend-spanning range: start_day to 7, then 1 to end_day
-                __out_dow_days.extend(
-                    [
-                        (i, DAYS_OF_WEEK_ISO[i])
-                        for i in range(start_day, 8)  # start_day to Sunday (7)
-                    ]
-                )
-                __out_dow_days.extend(
-                    [
-                        (i, DAYS_OF_WEEK_ISO[i])
-                        for i in range(1, end_day + 1)  # Monday (1) to end_day
-                    ]
-                )
-            else:
-                # Normal range: start_day to end_day
-                __out_dow_days.extend(
-                    [
-                        (i, DAYS_OF_WEEK_ISO[i])
-                        for i in range(start_day, end_day + 1)
-                    ]
-                )
-        else:
-            try:
-                __out_dow_days.append((DAYS_OF_WEEK_ISO_REVERSED[__dow_day], __dow_day))
-            except KeyError as e:
-                raise ValueError(f"Invalid day of week entry found: {__dow_day}: {e}") from e
-    # if there are duplicates, alert
-    if len(__out_dow_days) != len(set(__out_dow_days)):
-        raise ValueError(f"Duplicate day of week entries found: {__out_dow_days}")
-
-    return __out_dow_days
+    try:
+        return datetime_helpers.parse_day_of_week_range(dow_days)
+    except KeyError as e:
+        raise ValueError(f"Deprecated ValueError, change to KeyError: {e}") from e
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.parse_time_range instead")
 def parse_time_range(time_str: str, time_format: str = "%H:%M") -> tuple[time, time]:
     """
     Parse a time range string in the format "HH:MM-HH:MM" and return a tuple of two time objects.
@@ -343,22 +176,13 @@ def parse_time_range(time_str: str, time_format: str = "%H:%M") -> tuple[time, t
     Returns:
         tuple[time, time] -- start time, end time: leading zeros formattd
     """
-    __time_str = time_str.strip()
-    # split by "-"
-    __time_split = __time_str.split("-")
-    if len(__time_split) != 2:
-        raise ValueError(f"Invalid time block: {__time_str}")
     try:
-        __time_start = datetime.strptime(__time_split[0], time_format).time()
-        __time_end = datetime.strptime(__time_split[1], time_format).time()
-    except ValueError as e:
-        raise ValueError(f"Invalid time block format [{__time_str}]: {e}") from e
-    if __time_start >= __time_end:
-        raise ValueError(f"Invalid time block set, start time after end time or equal: {__time_str}")
-
-    return __time_start, __time_end
+        return datetime_helpers.parse_time_range(time_str, time_format)
+    except KeyError as e:
+        raise ValueError(f"Deprecated ValueError, change to KeyError: {e}") from e
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.times_overlap_or_connect instead")
 def times_overlap_or_connect(time1: tuple[time, time], time2: tuple[time, time], allow_touching: bool = False) -> bool:
     """
     Check if two time ranges overlap or connect
@@ -371,16 +195,10 @@ def times_overlap_or_connect(time1: tuple[time, time], time2: tuple[time, time],
     Returns:
         bool: True if ranges overlap or connect (based on allow_touching)
     """
-    start1, end1 = time1
-    start2, end2 = time2
-
-    if allow_touching:
-        # Only check for actual overlap (touching is OK)
-        return start1 < end2 and start2 < end1
-    # Check for overlap OR touching
-    return start1 <= end2 and start2 <= end1
+    return datetime_helpers.times_overlap_or_connect(time1, time2, allow_touching)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.is_time_in_range instead")
 def is_time_in_range(current_time: str, start_time: str, end_time: str) -> bool:
     """
     Check if current_time is within start_time and end_time (inclusive)
@@ -395,18 +213,10 @@ def is_time_in_range(current_time: str, start_time: str, end_time: str) -> bool:
         bool -- _description_
     """
     # Convert string times to time objects
-    current = datetime.strptime(current_time, "%H:%M:%S").time()
-    start = datetime.strptime(start_time, "%H:%M:%S").time()
-    end = datetime.strptime(end_time, "%H:%M:%S").time()
-
-    # Handle case where range crosses midnight (e.g., 22:00 to 06:00)
-    if start <= end:
-        # Normal case: start time is before end time
-        return start <= current <= end
-    # Crosses midnight: e.g., 22:00 to 06:00
-    return current >= start or current <= end
+    return datetime_helpers.is_time_in_range(current_time, start_time, end_time)
 
 
+@deprecated("Use corelibs_datetime.datetime_helpers.reorder_weekdays_from_today instead")
 def reorder_weekdays_from_today(base_day: str) -> dict[int, str]:
     """
     Reorder the days of the week starting from the specified base_day.
@@ -418,18 +228,8 @@ def reorder_weekdays_from_today(base_day: str) -> dict[int, str]:
         dict[int, str] -- A dictionary mapping day numbers to day names.
     """
     try:
-        today_num = DAYS_OF_WEEK_ISO_REVERSED[base_day]
-    except KeyError:
-        try:
-            today_num = DAYS_OF_WEEK_ISO_REVERSED[DAYS_OF_WEEK_LONG_TO_SHORT[base_day]]
-        except KeyError as e:
-            raise ValueError(f"Invalid day name provided: {base_day}: {e}") from e
-    # Convert to list of tuples
-    items = list(DAYS_OF_WEEK_ISO.items())
-    # Reorder: from today onwards + from beginning to yesterday
-    reordered_items = items[today_num - 1:] + items[:today_num - 1]
-
-    # Convert back to dictionary
-    return dict(reordered_items)
+        return datetime_helpers.reorder_weekdays_from_today(base_day)
+    except KeyError as e:
+        raise ValueError(f"Deprecated ValueError, change to KeyError: {e}") from e
 
 # __END__

src/corelibs/datetime_handling/timestamp_convert.py

@@ -2,19 +2,22 @@
 Convert timestamp strings with time units into seconds and vice versa.
 """
 
-from math import floor
-import re
-from corelibs.var_handling.var_helpers import is_float
+from warnings import deprecated
+from corelibs_datetime import timestamp_convert
+from corelibs_datetime.timestamp_convert import TimeParseError as NewTimeParseError, TimeUnitError as NewTimeUnitError
 
 
+@deprecated("Use corelibs_datetime.timestamp_convert.TimeParseError instead")
 class TimeParseError(Exception):
     """Custom exception for time parsing errors."""
 
 
+@deprecated("Use corelibs_datetime.timestamp_convert.TimeUnitError instead")
 class TimeUnitError(Exception):
     """Custom exception for time parsing errors."""
 
 
+@deprecated("Use corelibs_datetime.timestamp_convert.convert_to_seconds instead")
 def convert_to_seconds(time_string: str | int | float) -> int:
     """
     Conver a string with time units into a seconds string
@@ -35,67 +38,15 @@ def convert_to_seconds(time_string: str | int | float) -> int:
 
     # skip out if this is a number of any type
     # numbers will br made float, rounded and then converted to int
-    if is_float(time_string):
-        return int(round(float(time_string)))
-    time_string = str(time_string)
-
-    # Check if the time string is negative
-    negative = time_string.startswith('-')
-    if negative:
-        time_string = time_string[1:]  # Remove the negative sign for processing
-
-    # Define time unit conversion factors
-    unit_factors: dict[str, int] = {
-        'Y': 31536000,       # 365 days * 86400 seconds/day
-        'M': 2592000 * 12,   # 1 year in seconds (assuming 365 days per year)
-        'd': 86400,          # 1 day in seconds
-        'h': 3600,           # 1 hour in seconds
-        'm': 60,             # minutes to seconds
-        's': 1               # 1 second in seconds
-    }
-    long_unit_names: dict[str, str] = {
-        'year': 'Y',
-        'years': 'Y',
-        'month': 'M',
-        'months': 'M',
-        'day': 'd',
-        'days': 'd',
-        'hour': 'h',
-        'hours': 'h',
-        'minute': 'm',
-        'minutes': 'm',
-        'min': 'm',
-        'second': 's',
-        'seconds': 's',
-        'sec': 's',
-    }
-
-    total_seconds = 0
-
-    seen_units: list[str] = []  # Track units that have been encountered
-
-    # Use regex to match number and time unit pairs
-    for match in re.finditer(r'(\d+)\s*([a-zA-Z]+)', time_string):
-        value, unit = int(match.group(1)), match.group(2)
-
-        # full name check, fallback to original name
-        unit = long_unit_names.get(unit.lower(), unit)
-
-        # Check for duplicate units
-        if unit in seen_units:
-            raise TimeParseError(f"Unit '{unit}' appears more than once.")
-        # Check invalid unit
-        if unit not in unit_factors:
-            raise TimeUnitError(f"Unit '{unit}' is not a valid unit name.")
-        # Add to total seconds based on the units
-        if unit in unit_factors:
-            total_seconds += value * unit_factors[unit]
-
-        seen_units.append(unit)
-
-    return -total_seconds if negative else total_seconds
+    try:
+        return timestamp_convert.convert_to_seconds(time_string)
+    except NewTimeParseError as e:
+        raise TimeParseError(f"Deprecated, use corelibs_datetime.timestamp_convert.TimeParseError: {e}") from e
+    except NewTimeUnitError as e:
+        raise TimeUnitError(f"Deprecated, use corelibs_datetime.timestamp_convert.TimeUnitError: {e}") from e
 
 
+@deprecated("Use corelibs_datetime.timestamp_convert.seconds_to_string instead")
 def seconds_to_string(seconds: str | int | float, show_microseconds: bool = False) -> str:
     """
     Convert seconds to compact human readable format (e.g., "1d 2h 3m 4.567s")
@@ -111,46 +62,10 @@ def seconds_to_string(seconds: str | int | float, show_microseconds: bool = Fals
     Returns:
         str: Compact human readable time format
     """
-    # if not int or float, return as is
-    if not isinstance(seconds, (int, float)):
-        return seconds
-    # Handle negative values
-    negative = seconds < 0
-    seconds = abs(seconds)
-
-    whole_seconds = int(seconds)
-    fractional = seconds - whole_seconds
-
-    days = whole_seconds // 86400
-    hours = (whole_seconds % 86400) // 3600
-    minutes = (whole_seconds % 3600) // 60
-    secs = whole_seconds % 60
-
-    parts: list[str] = []
-    if days > 0:
-        parts.append(f"{days}d")
-    if hours > 0:
-        parts.append(f"{hours}h")
-    if minutes > 0:
-        parts.append(f"{minutes}m")
-
-    # Handle seconds with fractional part
-    if fractional > 0:
-        if show_microseconds:
-            total_seconds = secs + fractional
-            formatted = f"{total_seconds:.6f}".rstrip('0').rstrip('.')
-            parts.append(f"{formatted}s")
-        else:
-            total_seconds = secs + fractional
-            formatted = f"{total_seconds:.3f}".rstrip('0').rstrip('.')
-            parts.append(f"{formatted}s")
-    elif secs > 0 or not parts:
-        parts.append(f"{secs}s")
-
-    result = " ".join(parts)
-    return f"-{result}" if negative else result
+    return timestamp_convert.seconds_to_string(seconds, show_microseconds)
 
 
+@deprecated("Use corelibs_datetime.timestamp_convert.convert_timestamp instead")
 def convert_timestamp(timestamp: float | int | str, show_microseconds: bool = True) -> str:
     """
     format timestamp into human readable format. This function will add 0 values between set values
@@ -168,33 +83,6 @@ def convert_timestamp(timestamp: float | int | str, show_microseconds: bool = Tr
     Returns:
         str -- _description_
     """
-    if not isinstance(timestamp, (int, float)):
-        return timestamp
-    # cut of the ms, but first round them up to four
-    __timestamp_ms_split = str(round(timestamp, 4)).split(".")
-    timestamp = int(__timestamp_ms_split[0])
-    negative = timestamp < 0
-    timestamp = abs(timestamp)
-    try:
-        ms = int(__timestamp_ms_split[1])
-    except IndexError:
-        ms = 0
-    timegroups = (86400, 3600, 60, 1)
-    output: list[int] = []
-    for i in timegroups:
-        output.append(int(floor(timestamp / i)))
-        timestamp = timestamp % i
-    # output has days|hours|min|sec ms
-    time_string = ""
-    if output[0]:
-        time_string = f"{output[0]}d "
-    if output[0] or output[1]:
-        time_string += f"{output[1]}h "
-    if output[0] or output[1] or output[2]:
-        time_string += f"{output[2]}m "
-    time_string += f"{output[3]}s"
-    if show_microseconds:
-        time_string += f" {ms}ms" if ms else " 0ms"
-    return f"-{time_string}" if negative else time_string
+    return timestamp_convert.convert_timestamp(timestamp, show_microseconds)
 
 # __END__

src/corelibs/datetime_handling/timestamp_strings.py

@@ -2,31 +2,20 @@
 Current timestamp strings and time zones
 """
 
-from datetime import datetime
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+from warnings import deprecated
+from zoneinfo import ZoneInfo
+from corelibs_datetime import timestamp_strings
 
 
-class TimestampStrings:
+class TimestampStrings(timestamp_strings.TimestampStrings):
     """
     set default time stamps
     """
 
     TIME_ZONE: str = 'Asia/Tokyo'
 
+    @deprecated("Use corelibs_datetime.timestamp_strings.TimestampStrings instead")
     def __init__(self, time_zone: str | ZoneInfo | None = None):
-        self.timestamp_now = datetime.now()
-        # set time zone as string
-        time_zone = time_zone if time_zone is not None else self.TIME_ZONE
-        self.time_zone = str(time_zone) if not isinstance(time_zone, str) else time_zone
-        # set ZoneInfo type
-        try:
-            self.time_zone_zi = ZoneInfo(self.time_zone)
-        except ZoneInfoNotFoundError as e:
-            raise ValueError(f'Zone could not be loaded [{self.time_zone}]: {e}') from e
-        self.timestamp_now_tz = datetime.now(self.time_zone_zi)
-        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")
+        super().__init__(time_zone)
 
 # __END__

src/corelibs/db_handling/sql_main.py

@@ -0,0 +1,76 @@
+"""
+Main SQL base for any SQL calls
+This is a wrapper for SQLiteIO or other future DB Interfaces
+[Note: at the moment only SQLiteIO is implemented]
+- on class creation connection with ValueError on fail
+- connect method checks if already connected and warns
+- connection class fails with ValueError if not valid target is selected (SQL wrapper type)
+- connected check class method
+- a process class that returns data as list or False if end or error
+
+TODO: adapt more CoreLibs DB IO class flow here
+"""
+
+from typing import TYPE_CHECKING, Any, Literal
+from corelibs_stack_trace.stack import call_stack
+from corelibs.db_handling.sqlite_io import SQLiteIO
+if TYPE_CHECKING:
+    from corelibs.logging_handling.log import Logger
+
+
+IDENT_SPLIT_CHARACTER: str = ':'
+
+
+class SQLMain:
+    """Main SQL interface class"""
+    def __init__(self, log: 'Logger', db_ident: str):
+        self.log = log
+        self.dbh: SQLiteIO | None = None
+        self.db_target: str | None = None
+        self.connect(db_ident)
+        if not self.connected():
+            raise ValueError(f'Failed to connect to database [{call_stack()}]')
+
+    def connect(self, db_ident: str):
+        """setup basic connection"""
+        if self.dbh is not None and self.dbh.conn is not None:
+            self.log.warning(f"A database connection already exists for: {self.db_target} [{call_stack()}]")
+            return
+        self.db_target, db_dsn = db_ident.split(IDENT_SPLIT_CHARACTER)
+        match self.db_target:
+            case 'sqlite':
+                # this is a Path only at the moment
+                self.dbh = SQLiteIO(self.log, db_dsn, row_factory='Dict')
+            case _:
+                raise ValueError(f'SQL interface for {self.db_target} is not implemented [{call_stack()}]')
+        if not self.dbh.db_connected():
+            raise ValueError(f"DB Connection failed for: {self.db_target} [{call_stack()}]")
+
+    def close(self):
+        """close connection"""
+        if self.dbh is None or not self.connected():
+            return
+        # self.log.info(f"Close DB Connection: {self.db_target} [{call_stack()}]")
+        self.dbh.db_close()
+
+    def connected(self) -> bool:
+        """check connectuon"""
+        if self.dbh is None or not self.dbh.db_connected():
+            self.log.warning(f"No connection [{call_stack()}]")
+            return False
+        return True
+
+    def process_query(
+        self, query: str, params: tuple[Any, ...] | None = None
+    ) -> list[tuple[Any, ...]] | list[dict[str, Any]] | Literal[False]:
+        """mini wrapper for execute query"""
+        if self.dbh is not None:
+            result = self.dbh.execute_query(query, params)
+            if result is False:
+                return False
+        else:
+            self.log.error(f"Problem connecting to db: {self.db_target} [{call_stack()}]")
+            return False
+        return result
+
+# __END__

src/corelibs/db_handling/sqlite_io.py

@@ -8,7 +8,7 @@ also method names are subject to change
 from pathlib import Path
 from typing import Any, Literal, TYPE_CHECKING
 import sqlite3
-from corelibs.debug_handling.debug_helpers import call_stack
+from corelibs_stack_trace.stack import call_stack
 if TYPE_CHECKING:
     from corelibs.logging_handling.log import Logger
 

src/corelibs/debug_handling/debug_helpers.py

@@ -2,16 +2,16 @@
 Various debug helpers
 """
 
-import traceback
-import os
-import sys
+from warnings import deprecated
 from typing import Tuple, Type
 from types import TracebackType
+from corelibs_stack_trace.stack import call_stack as call_stack_ng, exception_stack as exception_stack_ng
 
 # _typeshed.OptExcInfo
 OptExcInfo = Tuple[None, None, None] | Tuple[Type[BaseException], BaseException, TracebackType]
 
 
+@deprecated("Use corelibs_stack_trace.stack.call_stack instead")
 def call_stack(
     start: int = 0,
     skip_last: int = -1,
@@ -31,23 +31,15 @@ def call_stack(
     Returns:
         str -- _description_
     """
-    # stack = traceback.extract_stack()[start:depth]
-    # how many of the last entries we skip (so we do not get self), default is -1
-    # start cannot be negative
-    if skip_last > 0:
-        skip_last = skip_last * -1
-    stack = traceback.extract_stack()
-    __stack = stack[start:skip_last]
-    # start possible to high, reset start to 0
-    if not __stack and reset_start_if_empty:
-        start = 0
-        __stack = stack[start:skip_last]
-    if not separator:
-        separator = ' -> '
-    # print(f"* HERE: {dump_data(stack)}")
-    return f"{separator}".join(f"{os.path.basename(f.filename)}:{f.name}:{f.lineno}" for f in __stack)
+    return call_stack_ng(
+        start=start,
+        skip_last=skip_last,
+        separator=separator,
+        reset_start_if_empty=reset_start_if_empty
+    )
 
 
+@deprecated("Use corelibs_stack_trace.stack.exception_stack instead")
 def exception_stack(
     exc_stack: OptExcInfo | None = None,
     separator: str = ' -> '
@@ -62,15 +54,9 @@ def exception_stack(
     Returns:
         str -- _description_
     """
-    if exc_stack is not None:
-        _, _, exc_traceback = exc_stack
-    else:
-        exc_traceback = None
-    _, _, exc_traceback = sys.exc_info()
-    stack = traceback.extract_tb(exc_traceback)
-    if not separator:
-        separator = ' -> '
-    # print(f"* HERE: {dump_data(stack)}")
-    return f"{separator}".join(f"{os.path.basename(f.filename)}:{f.name}:{f.lineno}" for f in stack)
+    return exception_stack_ng(
+        exc_stack=exc_stack,
+        separator=separator
+    )
 
 # __END__

src/corelibs/debug_handling/dump_data.py

@@ -2,10 +2,12 @@
 dict dump as JSON formatted
 """
 
-import json
+from warnings import deprecated
 from typing import Any
+from corelibs_dump_data.dump_data import dump_data as dump_data_ng
 
 
+@deprecated("Use corelibs_dump_data.dump_data.dump_data instead")
 def dump_data(data: Any, use_indent: bool = True) -> str:
     """
     dump formated output from dict/list
@@ -16,7 +18,6 @@ def dump_data(data: Any, use_indent: bool = True) -> str:
     Returns:
         str: _description_
     """
-    indent = 4 if use_indent else None
-    return json.dumps(data, indent=indent, ensure_ascii=False, default=str)
+    return dump_data_ng(data=data, use_indent=use_indent)
 
 # __END__

src/corelibs/debug_handling/profiling.py

@@ -4,123 +4,40 @@ Profile memory usage in Python
 
 # https://docs.python.org/3/library/tracemalloc.html
 
-import os
-import time
-import tracemalloc
-import linecache
-from typing import Tuple
-from tracemalloc import Snapshot
-import psutil
+from warnings import warn, deprecated
+from typing import TYPE_CHECKING
+from corelibs_debug.profiling import display_top as display_top_ng, display_top_str, Profiling as CoreLibsProfiling
+if TYPE_CHECKING:
+    from tracemalloc import Snapshot
 
 
-def display_top(snapshot: Snapshot, key_type: str = 'lineno', limit: int = 10) -> str:
+@deprecated("Use corelibs_debug.profiling.display_top_str with data from display_top instead")
+def display_top(snapshot: 'Snapshot', key_type: str = 'lineno', limit: int = 10) -> str:
     """
     Print tracmalloc stats
     https://docs.python.org/3/library/tracemalloc.html#pretty-top
 
     Args:
-        snapshot (Snapshot): _description_
+        snapshot ('Snapshot'): _description_
         key_type (str, optional): _description_. Defaults to 'lineno'.
         limit (int, optional): _description_. Defaults to 10.
     """
-    snapshot = snapshot.filter_traces((
-        tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
-        tracemalloc.Filter(False, "<unknown>"),
-    ))
-    top_stats = snapshot.statistics(key_type)
-
-    profiler_msg = f"Top {limit} lines"
-    for index, stat in enumerate(top_stats[:limit], 1):
-        frame = stat.traceback[0]
-        # replace "/path/to/module/file.py" with "module/file.py"
-        filename = os.sep.join(frame.filename.split(os.sep)[-2:])
-        profiler_msg += f"#{index}: {filename}:{frame.lineno}: {(stat.size / 1024):.1f} KiB"
-        line = linecache.getline(frame.filename, frame.lineno).strip()
-        if line:
-            profiler_msg += f"    {line}"
-
-    other = top_stats[limit:]
-    if other:
-        size = sum(stat.size for stat in other)
-        profiler_msg += f"{len(other)} other: {(size / 1024):.1f} KiB"
-    total = sum(stat.size for stat in top_stats)
-    profiler_msg += f"Total allocated size: {(total / 1024):.1f} KiB"
-    return profiler_msg
+    return display_top_str(
+        display_top_ng(
+            snapshot=snapshot,
+            key_type=key_type,
+            limit=limit
+        )
+    )
 
 
-class Profiling:
+class Profiling(CoreLibsProfiling):
     """
     Profile memory usage and elapsed time for some block
     Based on: https://stackoverflow.com/a/53301648
     """
 
-    def __init__(self):
-        # profiling id
-        self.__ident: str = ''
-        # memory
-        self.__rss_before: int = 0
-        self.__vms_before: int = 0
-        # self.shared_before: int = 0
-        self.__rss_used: int = 0
-        self.__vms_used: int = 0
-        # self.shared_used: int = 0
-        # time
-        self.__call_start: float = 0
-        self.__elapsed = 0
 
-    def __get_process_memory(self) -> Tuple[int, int]:
-        process = psutil.Process(os.getpid())
-        mi = process.memory_info()
-        # macos does not have mi.shared
-        return mi.rss, mi.vms
-
-    def __elapsed_since(self) -> str:
-        elapsed = time.time() - self.__call_start
-        if elapsed < 1:
-            return str(round(elapsed * 1000, 2)) + "ms"
-        if elapsed < 60:
-            return str(round(elapsed, 2)) + "s"
-        if elapsed < 3600:
-            return str(round(elapsed / 60, 2)) + "min"
-        return str(round(elapsed / 3600, 2)) + "hrs"
-
-    def __format_bytes(self, bytes_data: int) -> str:
-        if abs(bytes_data) < 1000:
-            return str(bytes_data) + "B"
-        if abs(bytes_data) < 1e6:
-            return str(round(bytes_data / 1e3, 2)) + "kB"
-        if abs(bytes_data) < 1e9:
-            return str(round(bytes_data / 1e6, 2)) + "MB"
-        return str(round(bytes_data / 1e9, 2)) + "GB"
-
-    def start_profiling(self, ident: str) -> None:
-        """
-        start the profiling
-        """
-        self.__ident = ident
-        self.__rss_before, self.__vms_before = self.__get_process_memory()
-        self.__call_start = time.time()
-
-    def end_profiling(self) -> None:
-        """
-        end the profiling
-        """
-        if self.__rss_before == 0 and self.__vms_before == 0:
-            print("start_profile() was not called, output will be negative")
-        self.__elapsed = self.__elapsed_since()
-        __rss_after, __vms_after = self.__get_process_memory()
-        self.__rss_used = __rss_after - self.__rss_before
-        self.__vms_used = __vms_after - self.__vms_before
-
-    def print_profiling(self) -> str:
-        """
-        print the profiling time
-        """
-        return (
-            f"Profiling: {self.__ident:>20}  "
-            f"RSS: {self.__format_bytes(self.__rss_used):>8} | "
-            f"VMS: {self.__format_bytes(self.__vms_used):>8} | "
-            f"time: {self.__elapsed:>8}"
-        )
+warn("Use corelibs_debug.profiling.Profiling instead", DeprecationWarning, stacklevel=2)
 
 # __END__

src/corelibs/debug_handling/timer.py

@@ -5,109 +5,16 @@ Returns:
     Timer: class timer for basic time run calculations
 """
 
-from datetime import datetime, timedelta
+from warnings import warn
+from corelibs_debug.timer import Timer as CorelibsTimer
 
 
-class Timer:
+class Timer(CorelibsTimer):
     """
     get difference between start and end date/time
     """
 
-    def __init__(self):
-        """
-        init new start time and set end time to None
-        """
-        self._overall_start_time = datetime.now()
-        self._overall_end_time = None
-        self._overall_run_time = None
-        self._start_time = datetime.now()
-        self._end_time = None
-        self._run_time = None
 
-    # MARK: overall run time
-    def overall_run_time(self) -> timedelta:
-        """
-        overall run time difference from class launch to call of this function
-
-        Returns:
-            timedelta: _description_
-        """
-        self._overall_end_time = datetime.now()
-        self._overall_run_time = self._overall_end_time - self._overall_start_time
-        return self._overall_run_time
-
-    def get_overall_start_time(self) -> datetime:
-        """
-        get set start time
-
-        Returns:
-            datetime: _description_
-        """
-        return self._overall_start_time
-
-    def get_overall_end_time(self) -> datetime | None:
-        """
-        get set end time or None for not set
-
-        Returns:
-            datetime|None: _description_
-        """
-        return self._overall_end_time
-
-    def get_overall_run_time(self) -> timedelta | None:
-        """
-        get run time or None if run time was not called
-
-        Returns:
-            datetime|None: _description_
-        """
-        return self._overall_run_time
-
-    # MARK: set run time
-    def run_time(self) -> timedelta:
-        """
-        difference between start time and current time
-
-        Returns:
-            datetime: _description_
-        """
-        self._end_time = datetime.now()
-        self._run_time = self._end_time - self._start_time
-        return self._run_time
-
-    def reset_run_time(self):
-        """
-        reset start/end and run tine
-        """
-        self._start_time = datetime.now()
-        self._end_time = None
-        self._run_time = None
-
-    def get_start_time(self) -> datetime:
-        """
-        get set start time
-
-        Returns:
-            datetime: _description_
-        """
-        return self._start_time
-
-    def get_end_time(self) -> datetime | None:
-        """
-        get set end time or None for not set
-
-        Returns:
-            datetime|None: _description_
-        """
-        return self._end_time
-
-    def get_run_time(self) -> timedelta | None:
-        """
-        get run time or None if run time was not called
-
-        Returns:
-            datetime|None: _description_
-        """
-        return self._run_time
+warn("Use corelibs_debug.timer.Timer instead", DeprecationWarning, stacklevel=2)
 
 # __END__

src/corelibs/debug_handling/writeline.py

@@ -2,12 +2,19 @@
 Various small helpers for data writing
 """
 
+from warnings import deprecated
 from typing import TYPE_CHECKING
+from corelibs_debug.writeline import (
+    write_l as write_l_ng, pr_header as pr_header_ng,
+    pr_title as pr_title_ng, pr_open as pr_open_ng,
+    pr_close as pr_close_ng, pr_act as pr_act_ng
+)
 if TYPE_CHECKING:
-    from io import TextIOWrapper
+    from io import TextIOWrapper, StringIO
 
 
-def write_l(line: str, fpl: 'TextIOWrapper | None' = None, print_line: bool = False):
+@deprecated("Use corelibs_debug.writeline.write_l instead")
+def write_l(line: str, fpl: 'TextIOWrapper | StringIO | None' = None, print_line: bool = False):
     """
     Write a line to screen and to output file
 
@@ -15,23 +22,30 @@ def write_l(line: str, fpl: 'TextIOWrapper | None' = None, print_line: bool = Fa
         line (String): Line to write
         fpl (Resource): file handler resource, if none write only to console
     """
-    if print_line is True:
-        print(line)
-    if fpl is not None:
-        fpl.write(line + "\n")
+    return write_l_ng(
+        line=line,
+        fpl=fpl,
+        print_line=print_line
+    )
 
 
 # progress printers
 
+@deprecated("Use corelibs_debug.writeline.pr_header instead")
 def pr_header(tag: str, marker_string: str = '#', width: int = 35):
     """_summary_
 
     Args:
         tag (str): _description_
     """
-    print(f" {marker_string} {tag:^{width}} {marker_string}")
+    return pr_header_ng(
+        tag=tag,
+        marker_string=marker_string,
+        width=width
+    )
 
 
+@deprecated("Use corelibs_debug.writeline.pr_title instead")
 def pr_title(tag: str, prefix_string: str = '|', space_filler: str = '.', width: int = 35):
     """_summary_
 
@@ -39,9 +53,15 @@ def pr_title(tag: str, prefix_string: str = '|', space_filler: str = '.', width:
         tag (str): _description_
         prefix_string (str, optional): _description_. Defaults to '|'.
     """
-    print(f" {prefix_string} {tag:{space_filler}<{width}}:", flush=True)
+    return pr_title_ng(
+        tag=tag,
+        prefix_string=prefix_string,
+        space_filler=space_filler,
+        width=width
+    )
 
 
+@deprecated("Use corelibs_debug.writeline.pr_open instead")
 def pr_open(tag: str, prefix_string: str = '|', space_filler: str = '.', width: int = 35):
     """
     writen progress open line with tag
@@ -50,9 +70,15 @@ def pr_open(tag: str, prefix_string: str = '|', space_filler: str = '.', width:
         tag (str): _description_
         prefix_string (str): prefix string. Default: '|'
     """
-    print(f" {prefix_string} {tag:{space_filler}<{width}} [", end="", flush=True)
+    return pr_open_ng(
+        tag=tag,
+        prefix_string=prefix_string,
+        space_filler=space_filler,
+        width=width
+    )
 
 
+@deprecated("Use corelibs_debug.writeline.pr_close instead")
 def pr_close(tag: str = ''):
     """
     write the close tag with new line
@@ -60,9 +86,10 @@ def pr_close(tag: str = ''):
     Args:
         tag (str, optional): _description_. Defaults to ''.
     """
-    print(f"{tag}]", flush=True)
+    return pr_close_ng(tag=tag)
 
 
+@deprecated("Use corelibs_debug.writeline.pr_act instead")
 def pr_act(act: str = "."):
     """
     write progress character
@@ -70,6 +97,6 @@ def pr_act(act: str = "."):
     Args:
         act (str, optional): _description_. Defaults to ".".
     """
-    print(f"{act}", end="", flush=True)
+    return pr_act_ng(act=act)
 
 # __EMD__

src/corelibs/email_handling/send_email.py

@@ -0,0 +1,219 @@
+"""
+Send email wrapper
+"""
+
+import smtplib
+from email.message import EmailMessage
+from email.header import Header
+from email.utils import formataddr, parseaddr
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from corelibs.logging_handling.log import Logger
+
+
+class SendEmail:
+    """
+    send emails based on a template to a list of receivers
+    """
+
+    def __init__(
+        self,
+        log: "Logger",
+        settings: dict[str, Any],
+        template: dict[str, str],
+        from_email: str,
+        combined_send: bool = True,
+        receivers: list[str] | None = None,
+        data: list[dict[str, str]] | None = None,
+    ):
+        """
+        init send email class
+
+        Args:
+            template (dict): Dictionary with body and subject
+            from_email (str): from email as "Name" <email>
+            combined_send (bool): True for sending as one set for all receivers
+            receivers (list): list of emails to send to
+            data (dict): data to replace in template
+            args (Namespace): _description_
+        """
+        self.log = log
+        self.settings = settings
+        # internal settings
+        self.template = template
+        self.from_email = from_email
+        self.combined_send = combined_send
+        self.receivers = receivers
+        self.data = data
+
+    def send_email(
+        self,
+        data: list[dict[str, str]] | None,
+        receivers: list[str] | None,
+        template: dict[str, str] | None = None,
+        from_email: str | None = None,
+        combined_send: bool | None = None,
+        test_only: bool | None = None
+    ):
+        """
+        build email and send
+
+        Arguments:
+            data {list[dict[str, str]] | None} -- _description_
+            receivers {list[str] | None} -- _description_
+            combined_send {bool | None} -- _description_
+
+        Keyword Arguments:
+            template {dict[str, str] | None} -- _description_ (default: {None})
+            from_email {str | None} -- _description_ (default: {None})
+
+        Raises:
+            ValueError: _description_
+            ValueError: _description_
+        """
+        if data is None and self.data is not None:
+            data = self.data
+        if data is None:
+            raise ValueError("No replace data set, cannot send email")
+        if receivers is None and self.receivers is not None:
+            receivers = self.receivers
+        if receivers is None:
+            raise ValueError("No receivers list set, cannot send email")
+        if combined_send is None:
+            combined_send = self.combined_send
+        if test_only is not None:
+            self.settings['test'] = test_only
+
+        if template is None:
+            template = self.template
+        if from_email is None:
+            from_email = self.from_email
+
+        if not template['subject'] or not template['body']:
+            raise ValueError("Both Subject and Body must be set")
+
+        self.log.debug(
+            "[EMAIL]:\n"
+            f"Subject: {template['subject']}\n"
+            f"Body: {template['body']}\n"
+            f"From: {from_email}\n"
+            f"Combined send: {combined_send}\n"
+            f"Receivers: {receivers}\n"
+            f"Replace data: {data}"
+        )
+
+        # send email
+        self.send_email_list(
+            self.prepare_email_content(
+                from_email, template, data
+            ),
+            receivers,
+            combined_send,
+            test_only
+        )
+
+    def prepare_email_content(
+        self,
+        from_email: str,
+        template: dict[str, str],
+        data: list[dict[str, str]],
+    ) -> list[EmailMessage]:
+        """
+        prepare email for sending
+
+        Args:
+            template (dict): template data for this email
+            data (dict): data to replace in email
+
+        Returns:
+            list: Email Message Objects as list
+        """
+        _subject = ""
+        _body = ""
+        msg: list[EmailMessage] = []
+        for replace in data:
+            _subject = template["subject"]
+            _body = template["body"]
+            for key, value in replace.items():
+                placeholder = f"{{{{{key}}}}}"
+                _subject = _subject.replace(placeholder, value)
+                _body = _body.replace(placeholder, value)
+            name, addr = parseaddr(from_email)
+            if name:
+                # Encode the name part with MIME encoding
+                encoded_name = str(Header(name, 'utf-8'))
+                from_email_encoded = formataddr((encoded_name, addr))
+            else:
+                from_email_encoded = from_email
+            # create a simple email and add subhect, from email
+            msg_email = EmailMessage()
+            # msg.set_content(_body, charset='utf-8', cte='quoted-printable')
+            msg_email.set_content(_body, charset="utf-8")
+            msg_email["Subject"] = _subject
+            msg_email["From"] = from_email_encoded
+            # push to array for sening
+            msg.append(msg_email)
+        return msg
+
+    def send_email_list(
+        self,
+        emails: list[EmailMessage],
+        receivers: list[str],
+        combined_send: bool | None = None,
+        test_only: bool | None = None
+    ):
+        """
+        send email to receivers list
+
+        Args:
+            email (list): Email Message object with set obdy, subject, from as list
+            receivers (array): email receivers list as array
+            combined_send (bool): True for sending as one set for all receivers
+        """
+
+        if test_only is not None:
+            self.settings['test'] = test_only
+
+        # localhost (postfix does the rest)
+        smtp = None
+        smtp_host = self.settings.get('smtp_host', "localhost")
+        try:
+            smtp = smtplib.SMTP(smtp_host)
+        except ConnectionRefusedError as e:
+            self.log.error("Could not open SMTP connection to: %s, %s", smtp_host, e)
+        # prepare receiver list
+        receivers_encoded: list[str] = []
+        for __receiver in receivers:
+            to_name, to_addr = parseaddr(__receiver)
+            if to_name:
+                # Encode the name part with MIME encoding
+                encoded_to_name = str(Header(to_name, 'utf-8'))
+                receivers_encoded.append(formataddr((encoded_to_name, to_addr)))
+            else:
+                receivers_encoded.append(__receiver)
+        # loop over messages and then over recievers
+        for msg in emails:
+            if combined_send is True:
+                msg["To"] = ", ".join(receivers_encoded)
+                if not self.settings.get('test'):
+                    if smtp is not None:
+                        smtp.send_message(msg, msg["From"], receivers_encoded)
+                else:
+                    self.log.info(f"[EMAIL] Test, not sending email\n{msg}")
+            else:
+                for receiver in receivers_encoded:
+                    self.log.debug(f"===> Send to: {receiver}")
+                    if "To" in msg:
+                        msg.replace_header("To", receiver)
+                    else:
+                        msg["To"] = receiver
+                    if not self.settings.get('test'):
+                        if smtp is not None:
+                            smtp.send_message(msg)
+                    else:
+                        self.log.info(f"[EMAIL] Test, not sending email\n{msg}")
+        # close smtp
+        if smtp is not None:
+            smtp.quit()
+
+# __END__

src/corelibs/encryption_handling/symmetric_encryption.py

@@ -4,24 +4,11 @@ Will be moved to CoreLibs
 TODO: set key per encryption run
 """
 
-import os
-import json
-import base64
-import hashlib
-from typing import TypedDict, cast
-from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+import warnings
+from corelibs_encryption.symmetric import SymmetricEncryption as CorelibsSymmetricEncryption
 
 
-class PackageData(TypedDict):
-    """encryption package"""
-    encrypted_data: str
-    salt: str
-    key_hash: str
-
-
-class SymmetricEncryption:
+class SymmetricEncryption(CorelibsSymmetricEncryption):
     """
     simple encryption
 
@@ -29,124 +16,7 @@ class SymmetricEncryption:
     key from the password to decrypt
     """
 
-    def __init__(self, password: str):
-        if not password:
-            raise ValueError("A password must be set")
-        self.password = password
-        self.password_hash = hashlib.sha256(password.encode('utf-8')).hexdigest()
 
-    def __derive_key_from_password(self, password: str, salt: bytes) -> bytes:
-        _password = password.encode('utf-8')
-        kdf = PBKDF2HMAC(
-            algorithm=hashes.SHA256(),
-            length=32,
-            salt=salt,
-            iterations=100000,
-        )
-        key = base64.urlsafe_b64encode(kdf.derive(_password))
-        return key
-
-    def __encrypt_with_metadata(self, data: str | bytes) -> PackageData:
-        """Encrypt data and include salt if password-based"""
-        # convert to bytes (for encoding)
-        if isinstance(data, str):
-            data = data.encode('utf-8')
-
-        # generate salt and key from password
-        salt = os.urandom(16)
-        key = self.__derive_key_from_password(self.password, salt)
-        # init the cypher suit
-        cipher_suite = Fernet(key)
-
-        encrypted_data = cipher_suite.encrypt(data)
-
-        # If using password, include salt in the result
-        return {
-            'encrypted_data': base64.urlsafe_b64encode(encrypted_data).decode('utf-8'),
-            'salt': base64.urlsafe_b64encode(salt).decode('utf-8'),
-            'key_hash': hashlib.sha256(key).hexdigest()
-        }
-
-    def encrypt_with_metadata(self, data: str | bytes, return_as: str = 'str') -> str | bytes | PackageData:
-        """encrypt with metadata, but returns data in string"""
-        match return_as:
-            case 'str':
-                return self.encrypt_with_metadata_return_str(data)
-            case 'json':
-                return self.encrypt_with_metadata_return_str(data)
-            case 'bytes':
-                return self.encrypt_with_metadata_return_bytes(data)
-            case 'dict':
-                return self.encrypt_with_metadata_return_dict(data)
-            case _:
-                # default is string json
-                return self.encrypt_with_metadata_return_str(data)
-
-    def encrypt_with_metadata_return_dict(self, data: str | bytes) -> PackageData:
-        """encrypt with metadata, but returns data as PackageData dict"""
-        return self.__encrypt_with_metadata(data)
-
-    def encrypt_with_metadata_return_str(self, data: str | bytes) -> str:
-        """encrypt with metadata, but returns data in string"""
-        return json.dumps(self.__encrypt_with_metadata(data))
-
-    def encrypt_with_metadata_return_bytes(self, data: str | bytes) -> bytes:
-        """encrypt with metadata, but returns data in bytes"""
-        return json.dumps(self.__encrypt_with_metadata(data)).encode('utf-8')
-
-    def decrypt_with_metadata(self, encrypted_package: str | bytes | PackageData, password: str | None = None) -> str:
-        """Decrypt data that may include metadata"""
-        try:
-            # Try to parse as JSON (password-based encryption)
-            if isinstance(encrypted_package, bytes):
-                package_data = cast(PackageData, json.loads(encrypted_package.decode('utf-8')))
-            elif isinstance(encrypted_package, str):
-                package_data = cast(PackageData, json.loads(str(encrypted_package)))
-            else:
-                package_data = encrypted_package
-
-            encrypted_data = base64.urlsafe_b64decode(package_data['encrypted_data'])
-            salt = base64.urlsafe_b64decode(package_data['salt'])
-            pwd = password or self.password
-            key = self.__derive_key_from_password(pwd, salt)
-            if package_data['key_hash'] != hashlib.sha256(key).hexdigest():
-                raise ValueError("Key hash is not matching, possible invalid password")
-            cipher_suite = Fernet(key)
-            decrypted_data = cipher_suite.decrypt(encrypted_data)
-
-        except (json.JSONDecodeError, KeyError, UnicodeDecodeError) as e:
-            raise ValueError(f"Invalid encrypted package format {e}") from e
-
-        return decrypted_data.decode('utf-8')
-
-    @staticmethod
-    def encrypt_data(data: str | bytes, password: str) -> str:
-        """
-        Static method to encrypt some data
-
-        Arguments:
-            data {str | bytes} -- _description_
-            password {str} -- _description_
-
-        Returns:
-            str -- _description_
-        """
-        encryptor = SymmetricEncryption(password)
-        return encryptor.encrypt_with_metadata_return_str(data)
-
-    @staticmethod
-    def decrypt_data(data: str | bytes | PackageData, password: str) -> str:
-        """
-        Static method to decrypt some data
-
-        Arguments:
-            data {str | bytes | PackageData} -- _description_
-            password {str} -- _description_
-
-        Returns:
-            str -- _description_
-        """
-        decryptor = SymmetricEncryption(password)
-        return decryptor.decrypt_with_metadata(data, password=password)
+warnings.warn("Use corelibs_encryption.symmetric.SymmetricEncryption instead", DeprecationWarning, stacklevel=2)
 
 # __END__

src/corelibs/exceptions/csv_exceptions.py

@@ -2,22 +2,39 @@
 Exceptions for csv file reading and processing
 """
 
+from warnings import warn
+from corelibs_csv.csv_exceptions import (
+    NoCsvReader as CoreLibsNoCsvReader,
+    CompulsoryCsvHeaderCheckFailed as CoreLibsCompulsoryCsvHeaderCheckFailed,
+    CsvHeaderDataMissing as CoreLibsCsvHeaderDataMissing,
+    CsvRowDataKeysNotMatching as CoreLibsCsvRowDataKeysNotMatching
+)
 
-class NoCsvReader(Exception):
+
+class NoCsvReader(CoreLibsNoCsvReader):
     """
     CSV reader is none
     """
 
 
-class CsvHeaderDataMissing(Exception):
+class CsvHeaderDataMissing(CoreLibsCsvHeaderDataMissing):
     """
     The csv reader returned None as headers, the header column in the csv file is missing
     """
 
 
-class CompulsoryCsvHeaderCheckFailed(Exception):
+class CompulsoryCsvHeaderCheckFailed(CoreLibsCompulsoryCsvHeaderCheckFailed):
     """
     raise if the header is not matching to the excpeted values
     """
 
+
+class CsvRowDataKeysNotMatching(CoreLibsCsvRowDataKeysNotMatching):
+    """
+    raise if the row data keys do not match the expected header keys
+    """
+
+
+warn("Use corelibs_csv.csv_exceptions instead", DeprecationWarning, stacklevel=2)
+
 # __END__

src/corelibs/file_handling/file_bom_encoding.py

@@ -0,0 +1,42 @@
+"""
+File check if BOM encoded, needed for CSV load
+"""
+
+from warnings import deprecated
+from pathlib import Path
+from corelibs_file.file_bom_encoding import (
+    is_bom_encoded as is_bom_encoding_ng,
+    get_bom_encoding_info,
+    BomEncodingInfo
+)
+
+
+@deprecated("Use corelibs_file.file_bom_encoding.is_bom_encoded instead")
+def is_bom_encoded(file_path: Path) -> bool:
+    """
+    Detect if a file is BOM encoded
+
+    Args:
+        file_path (str): Path to the file to check
+
+    Returns:
+        bool: True if file has BOM, False otherwise
+    """
+    return is_bom_encoding_ng(file_path)
+
+
+@deprecated("Use corelibs_file.file_bom_encoding.get_bom_encoding_info instead")
+def is_bom_encoded_info(file_path: Path) -> BomEncodingInfo:
+    """
+    Enhanced BOM detection with additional file analysis
+
+    Args:
+        file_path (str): Path to the file to check
+
+    Returns:
+        dict: Comprehensive BOM and encoding information
+    """
+    return get_bom_encoding_info(file_path)
+
+
+# __END__

src/corelibs/file_handling/file_crc.py

@@ -2,10 +2,13 @@
 crc handlers for file CRC
 """
 
-import zlib
+from warnings import deprecated
 from pathlib import Path
+from corelibs_file.file_crc import file_crc as file_crc_ng
+from corelibs_file.file_handling import get_file_name
 
 
+@deprecated("Use corelibs_file.file_crc.file_crc instead")
 def file_crc(file_path: Path) -> str:
     """
     With for loop and buffer, create file crc32
@@ -16,13 +19,10 @@ def file_crc(file_path: Path) -> str:
     Returns:
         str: file crc32
     """
-    crc = 0
-    with open(file_path, 'rb', 65536) as ins:
-        for _ in range(int((file_path.stat().st_size / 65536)) + 1):
-            crc = zlib.crc32(ins.read(65536), crc)
-    return f"{crc & 0xFFFFFFFF:08X}"
+    return file_crc_ng(file_path)
 
 
+@deprecated("Use corelibs_file.file_handling.get_file_name instead")
 def file_name_crc(file_path: Path, add_parent_folder: bool = False) -> str:
     """
     either returns file name only from path
@@ -38,9 +38,6 @@ def file_name_crc(file_path: Path, add_parent_folder: bool = False) -> str:
     Returns:
         str: file name as string
     """
-    if add_parent_folder:
-        return str(Path(file_path.parent.name).joinpath(file_path.name))
-    else:
-        return file_path.name
+    return get_file_name(file_path, add_parent_folder=add_parent_folder)
 
 # __END__

src/corelibs/file_handling/file_handling.py

@@ -2,45 +2,37 @@
 File handling utilities
 """
 
-import os
-import shutil
+from warnings import deprecated
 from pathlib import Path
+from corelibs_file.file_handling import remove_all_in_directory as remove_all_in_directory_ng
 
 
-def remove_all_in_directory(directory: Path, ignore_files: list[str] | None = None, verbose: bool = False) -> bool:
+@deprecated("Use corelibs_file.file_handling.remove_all_in_directory instead")
+def remove_all_in_directory(
+    directory: Path,
+    ignore_files: list[str] | None = None,
+    verbose: bool = False,
+    dry_run: bool = False
+) -> bool:
     """
-    remove all files and folders in a directory
-    can exclude files or folders
+    deprecated
 
-    Args:
-        directory (Path): _description_
-        ignore_files (list[str], optional): _description_. Defaults to None.
+    Arguments:
+        directory {Path} -- _description_
+
+    Keyword Arguments:
+        ignore_files {list[str] | None} -- _description_ (default: {None})
+        verbose {bool} -- _description_ (default: {False})
+        dry_run {bool} -- _description_ (default: {False})
 
     Returns:
-        bool: _description_
+        bool -- _description_
     """
-    if not directory.is_dir():
-        return False
-    if ignore_files is None:
-        ignore_files = []
-    if verbose:
-        print(f"Remove old files in: {directory.name} [", end="", flush=True)
-    # remove all files and folders in given directory by recursive globbing
-    for file in directory.rglob("*"):
-        # skip if in ignore files
-        if file.name in ignore_files:
-            continue
-        # remove one file, or a whole directory
-        if file.is_file():
-            os.remove(file)
-            if verbose:
-                print(".", end="", flush=True)
-        elif file.is_dir():
-            shutil.rmtree(file)
-            if verbose:
-                print("/", end="", flush=True)
-    if verbose:
-        print("]", flush=True)
-    return True
+    return remove_all_in_directory_ng(
+        directory,
+        ignore_files=ignore_files,
+        verbose=verbose,
+        dry_run=dry_run
+    )
 
 # __END__

src/corelibs/file_handling/progress.py

@@ -1,477 +0,0 @@
-"""
-AUTHOR: Clemens Schwaighofer
-DATE CREATED: 2009/7/24 (2025/7/2)
-DESCRIPTION: progress percent class (perl -> python)
-
-HOW TO USE
-* load
-from progress import Progress
-* init
-prg = Progress()
-    allowed parameters to pass are (in order)
-    - verbose (0/1/...)       : show output
-    - precision (-2~10)       : -2 (5%), -1 (10%), 0 (normal 0-100%), 1~10 (100.m~%)
-    - microtime (1/0/-1)      : show microtime in eta/run time
-    - wide time (bool)        : padd time so all time column doesn't change width of line
-    - prefix line break (bool): add line break before string and not only after
-prg = Progress(verbose = 1, precision = 2)
-* settings methods
-set_wide_time(bool)
-set_microtime(int -1/0/1)
-set_prefix_lb(bool)
-set_verbose(0/1 int)
-set_precision(-2~10 int)
-set_linecount(int)
-set_filesize(int)
-set_start_time(time optional)
-set_eta_start_time(time optional)
-set_end_time(time optional)
-show_position(file pos optional)
-"""
-
-import time
-from typing import Literal
-from math import floor
-from corelibs.datetime_handling.datetime_helpers import convert_timestamp
-from corelibs.string_handling.byte_helpers import format_bytes
-
-
-class Progress():
-    """
-    file progress output information
-    """
-    def __init__(
-        self,
-        verbose: int = 0,
-        precision: int = 1,
-        microtime: Literal[-1] | Literal[1] | Literal[0] = 0,
-        wide_time: bool = False,
-        prefix_lb: bool = False
-    ):
-        # set default var stuff
-        # max lines in input
-        self.linecount: int = 0
-        # max file size
-        self.filesize: int = 0
-        # * comma after percent
-        self.precision: int = 0
-        # * if flagged 1, then wthe wide 15 char left bound format is used
-        self.wide_time: bool = False
-        # * verbose status from outside
-        self.verbose: bool = False
-        # * microtime output for last run time (1 for enable 0 for auto -1 for disable)
-        self.microtime: Literal[-1] | Literal[1] | Literal[0] = 0
-        # micro time flag for last group
-        self.lg_microtime: bool = False
-        # = flag if output was given
-        self.change = 0
-        # = global start for the full script running time
-        self.start: float | None = None
-        # = for the eta time, can be set after a query or long read in, to not create a wrong ETA time
-        self.start_run: float | None = None
-        # loop start
-        self.start_time: float | None = None
-        # global end
-        self.end: float | None = None
-        # loop end
-        self.end_time: float | None = None
-        # run time in seconds, set when end time method is called
-        self.run_time: float | None = None
-        # = filesize current
-        self.count_size: int | None = None
-        # position current
-        self.count: int = 0
-        # last count (position)
-        self.current_count: int = 0
-        # the current file post
-        self.file_pos: int | None = None
-        # lines processed in the last run
-        self.lines_processed: int = 0
-        # time in th seconds for the last group run (until percent change)
-        self.last_group: float = 0
-        # float value, lines processed per second to the last group run
-        self.lines_in_last_group: float = 0
-        # float values, lines processed per second to complete run
-        self.lines_in_global: float = 0
-        # flaot value, bytes processes per second in the last group run
-        self.bytes_in_last_group: float = 0
-        # float value, bytes processed per second to complete run
-        self.bytes_in_global: float = 0
-        # bytes processed in last run (in bytes)
-        self.size_in_last_group: int = 0
-        # current file position 8size)
-        self.current_size: int = 0
-        # last percent position
-        self.last_percent: int | float = 0
-        # if we have normal % or in steps of 10
-        self.precision_ten_step: int = 0
-        # the default size this is precision + 4
-        self.percent_print: int = 5
-        # this is 1 if it is 1 or 0 for precision or precision size
-        self.percent_precision: int = 1
-        # prefix line with a line break
-        self.prefix_lb: bool = False
-        # estimated time to finish
-        self.eta: float | None = None
-        # run time since start
-        self.full_time_needed: float | None = None
-        # the actual output
-        self.string: str = ''
-
-        # initialize the class
-        self.set_precision(precision)
-        self.set_verbose(verbose)
-        self.set_micro_time(microtime)
-        self.set_wide_time(wide_time)
-        self.set_prefix_lb(prefix_lb)
-        self.set_start_time()
-
-    def reset(self):
-        """
-        resets the current progress to 0, but keeps the overall start variables set
-        """
-        # reset what always gets reset
-        self.count = 0
-        self.count_size = None
-        self.current_count = 0
-        self.linecount = 0
-        self.lines_processed = 0
-        self.last_group = 0
-        self.lines_in_last_group = 0
-        self.lines_in_global = 0
-        self.bytes_in_last_group = 0
-        self.bytes_in_global = 0
-        self.size_in_last_group = 0
-        self.filesize = 0
-        self.current_size = 0
-        self.last_percent = 0
-        self.eta = 0
-        self.full_time_needed = 0
-        self.start_run = None
-        self.start_time = None
-        self.end_time = None
-
-    def set_wide_time(self, wide_time: bool) -> bool:
-        """
-        sets the show wide time flag
-
-        Arguments:
-            wide_time {bool} -- _description_
-
-        Returns:
-            bool -- _description_
-        """
-        self.wide_time = wide_time
-        return self.wide_time
-
-    def set_micro_time(self, microtime: Literal[-1] | Literal[1] | Literal[0]) -> Literal[-1] | Literal[1] | Literal[0]:
-        """sets the show microtime -1 OFF, 0 AUTO, 1 ON
-
-        Returns:
-            _type_ -- _description_
-        """
-        self.microtime = microtime
-        return self.microtime
-
-    def set_prefix_lb(self, prefix_lb: bool) -> bool:
-        """
-        set prefix line break flag
-
-        Arguments:
-            prefix_lb {bool} -- _description_
-
-        Returns:
-            bool -- _description_
-        """
-        self.prefix_lb = prefix_lb
-        return self.prefix_lb
-
-    def set_verbose(self, verbose: int) -> bool:
-        """
-        set the internal verbose flag to 1 if any value higher than 1 is given, else sets it to 0
-
-        Arguments:
-            verbose {int} -- _description_
-
-        Returns:
-            bool -- _description_
-        """
-        if verbose > 0:
-            self.verbose = True
-        else:
-            self.verbose = False
-        return self.verbose
-
-    def set_precision(self, precision: int) -> int:
-        """
-        sets the output precision size. If -2 for five step, -1 for ten step
-        else sets the precision normally, for 0, no precision is set, maximum precision is 10
-
-        Arguments:
-            precision {int} -- _description_
-
-        Returns:
-            int -- _description_
-        """
-        # if not a valid number, we set it to 0
-        if precision < -2 or precision > 10:
-            precision = 0
-        if precision < 0:
-            if precision < -1:
-                self.precision_ten_step = 5
-            else:
-                self.precision_ten_step = 10
-            self.precision = 0  # no comma
-            self.percent_precision = 0  # no print precision
-            self.percent_print = 3  # max 3 length
-        else:
-            # comma values visible
-            self.precision = 10 if precision < 0 or precision > 10 else precision
-            # for calcualtion of precision
-            self.percent_precision = 10 if precision < 0 or precision > 10 else precision
-            # for the format output base is 4, plsut he percent precision length
-            self.percent_print = (3 if precision == 0 else 4) + self.percent_precision
-        # return the set precision
-        return self.precision
-
-    def set_linecount(self, linecount: int) -> int:
-        """
-        set the maximum lines in this file, if value is smaller than 0 or 0, then it is set to 1
-
-        Arguments:
-            linecount {int} -- _description_
-
-        Returns:
-            int -- _description_
-        """
-        if linecount > 0:
-            self.linecount = linecount
-        else:
-            self.linecount = 1
-        return self.linecount
-
-    def set_filesize(self, filesize: int) -> int:
-        """
-        set the maximum filesize for this file, if value is smaller than 0 or 0, then it is set to 1
-
-        Arguments:
-            filesize {int} -- _description_
-
-        Returns:
-            int -- _description_
-        """
-        if filesize > 0:
-            self.filesize = filesize
-        else:
-            self.filesize = 1
-        return self.filesize
-
-    def set_start_time(self, time_value: float = time.time()) -> None:
-        """
-        initial set of the start times, auto set
-
-        Keyword Arguments:
-            time_value {float} -- _description_ (default: {time.time()})
-        """
-        # avoid possible double set of the original start time
-        if not self.start:
-            self.start = time_value
-        self.start_time = time_value
-        self.start_run = time_value
-
-    def set_eta_start_time(self, time_value: float = time.time()) -> None:
-        """
-        sets the loop % run time, for correct ETA calculation
-        calls set start time, as the main start time is only set once
-
-        Keyword Arguments:
-            time_value {float} -- _description_ (default: {time.time()})
-        """
-        self.set_start_time(time_value)
-
-    def set_end_time(self, time_value: float = time.time()) -> None:
-        """
-        set the end time
-
-        Keyword Arguments:
-            time_value {float} -- _description_ (default: {time.time()})
-        """
-        self.end = time_value
-        self.end_time = time_value
-        if self.start is None:
-            self.start = 0
-        # the overall run time in micro seconds
-        self.run_time = self.end - self.start
-
-    def show_position(self, filepos: int = 0) -> str:
-        """
-        processes the current position. either based on read the file size pos, or the line count
-
-        Keyword Arguments:
-            filepos {int} -- _description_ (default: {0})
-
-        Returns:
-            str -- _description_
-        """
-        show_filesize = True  # if we print from file size or line count
-        # microtime flags
-        eta_microtime = False
-        ftn_microtime = False
-        lg_microtime = False
-        # percent precision calc
-        # _p_spf = "{:." + str(self.precision) + "f}"
-        # output format for percent
-        _pr_p_spf = "{:>" + str(self.percent_print) + "." + str(self.percent_precision) + "f}"
-        # set the linecount precision based on the final linecount, if not, leave it empty
-        _pr_lc = "{}"
-        if self.linecount:
-            _pr_lc = "{:>" + str(len(str(f"{self.linecount:,}"))) + ",}"
-        # time format, if flag is set, the wide format is used
-        _pr_tf = "{}"
-        if self.wide_time:
-            _pr_tf = "{:>15}"
-
-        # count up
-        self.count += 1
-        # if we have file pos from parameter
-        if filepos != 0:
-            self.file_pos = filepos
-        else:
-            # we did not, so we set internal value
-            self.file_pos = self.count
-            # we also check if the filesize was set now
-            if self.filesize == 0:
-                self.filesize = self.linecount
-            # set ignore filesize output (no data)
-            show_filesize = False
-        # set the count size based on the file pos, is only used if we have filesize
-        self.count_size = self.file_pos
-        # do normal or down to 10 (0, 10, ...) %
-        if self.precision_ten_step:
-            _percent = int((self.file_pos / float(self.filesize)) * 100)
-            mod = _percent % self.precision_ten_step
-            percent = _percent if mod == 0 else self.last_percent
-        else:
-            # calc percent
-            percent = round(((self.file_pos / float(self.filesize)) * 100), self.precision)
-
-        # output
-        if percent != self.last_percent:
-            self.end_time = time.time()  # current time (for loop time)
-            if self.start is None:
-                self.start = 0
-            if self.start_time is None:
-                self.start_time = 0
-            # for from the beginning
-            full_time_needed = self.end_time - self.start  # how long from the start
-            self.last_group = self.end_time - self.start_time  # how long for last loop
-            self.lines_processed = self.count - self.current_count  # how many lines processed
-            # lines in last group
-            self.lines_in_last_group = (self.lines_processed / self.last_group) if self.last_group else 0
-            # lines in global
-            self.lines_in_global = (self.count / full_time_needed) if full_time_needed else 0
-            # if we have linecount or not
-            if self.linecount == 0:
-                full_time_per_line = (full_time_needed if full_time_needed else 1) / self.count_size  # how long for all
-                # estimate for the rest
-                eta = full_time_per_line * (self.filesize - self.count_size)
-            else:
-                # how long for all
-                full_time_per_line = (full_time_needed if full_time_needed else 1) / self.count
-                # estimate for the rest
-                eta = full_time_per_line * (self.linecount - self.count)
-            # just in case ...
-            if eta < 0:
-                eta = 0
-            # check if to show microtime
-            # ON
-            if self.microtime == 1:
-                eta_microtime = ftn_microtime = lg_microtime = True
-            # AUTO
-            if self.microtime == 0:
-                if eta > 0 and eta < 1:
-                    eta_microtime = True
-                if full_time_needed > 0 and full_time_needed < 1:
-                    ftn_microtime = True
-                # pre check last group: if pre comma part is same add microtime anyway
-                if self.last_group > 0 and self.last_group < 1:
-                    lg_microtime = True
-                if self.last_group == floor(self.last_group):
-                    lg_microtime = True
-                self.last_group = floor(self.last_group)
-            # if with filesize or without
-            if show_filesize:
-                # last group size
-                self.size_in_last_group = self.count_size - self.current_size
-                # calc kb/s if there is any filesize data
-                # last group
-                self.bytes_in_last_group = (self.size_in_last_group / self.last_group) if self.last_group else 0
-                # global
-                self.bytes_in_global = (self.count_size / full_time_needed) if full_time_needed else 0
-                # only used if we run with file size for the next check
-                self.current_size = self.count_size
-
-                if self.verbose >= 1:
-                    self.string = (
-                        f"Processed {_pr_p_spf}% "
-                        "[{} / {}] | "
-                        f"{_pr_lc} / {_pr_lc} Lines | ETA: {_pr_tf} / TR: {_pr_tf} / "
-                        "LR: {:,} "
-                        "lines ({:,}) in {}, {:,.2f} ({:,.2f}) lines/s, {} ({}) b/s"
-                    ).format(
-                        float(percent),
-                        format_bytes(self.count_size),
-                        format_bytes(self.filesize),
-                        self.count,
-                        self.linecount,
-                        convert_timestamp(eta, eta_microtime),
-                        convert_timestamp(full_time_needed, ftn_microtime),
-                        self.lines_processed,
-                        self.size_in_last_group,
-                        convert_timestamp(self.last_group, lg_microtime),
-                        self.lines_in_global,
-                        self.lines_in_last_group,
-                        format_bytes(self.bytes_in_global),
-                        format_bytes(self.bytes_in_last_group)
-                    )
-            else:
-                if self.verbose >= 1:
-                    self.string = (
-                        f"Processed {_pr_p_spf}% | {_pr_lc} / {_pr_lc} Lines "
-                        f"| ETA: {_pr_tf} / TR: {_pr_tf} / "
-                        "LR: {:,} lines in {}, {:,.2f} ({:,.2f}) lines/s"
-                    ).format(
-                        float(percent),
-                        self.count,
-                        self.linecount,
-                        convert_timestamp(eta, eta_microtime),
-                        convert_timestamp(full_time_needed, ftn_microtime),
-                        self.lines_processed,
-                        convert_timestamp(self.last_group, lg_microtime),
-                        self.lines_in_global,
-                        self.lines_in_last_group
-                    )
-            # prefix return string with line break if flagged
-            self.string = ("\n" if self.prefix_lb else '') + self.string
-            # print the string if verbose is turned on
-            if self.verbose >= 1:
-                print(self.string)
-
-            # write back vars
-            self.last_percent = percent
-            self.eta = eta
-            self.full_time_needed = full_time_needed
-            self.lg_microtime = lg_microtime
-            # for the next run, check data
-            self.start_time = time.time()
-            self.current_count = self.count
-            # trigger if this is a change
-            self.change = 1
-        else:
-            # trigger if this is a change
-            self.change = 0
-        # return string
-        return self.string
-    # } END OF ShowPosition
-
-# __END__

src/corelibs/iterator_handling/data_search.py

@@ -2,27 +2,31 @@
 wrapper around search path
 """
 
-from typing import Any, TypedDict, NotRequired
+from typing import Any
 from warnings import deprecated
+from corelibs_search.data_search import (
+    ArraySearchList as CorelibsArraySearchList,
+    find_in_array_from_list as corelibs_find_in_array_from_list,
+    key_lookup as corelibs_key_lookup,
+    value_lookup as corelibs_value_lookup
+)
 
 
-class ArraySearchList(TypedDict):
+class ArraySearchList(CorelibsArraySearchList):
     """find in array from list search dict"""
-    key: str
-    value: str | bool | int | float | list[str | None]
-    case_sensitive: NotRequired[bool]
 
 
-@deprecated("Use find_in_array_from_list()")
+@deprecated("Use corelibs_search.data_search.find_in_array_from_list instead")
 def array_search(
     search_params: list[ArraySearchList],
     data: list[dict[str, Any]],
     return_index: bool = False
 ) -> list[dict[str, Any]]:
     """depreacted, old call order"""
-    return find_in_array_from_list(data, search_params, return_index)
+    return corelibs_find_in_array_from_list(data, search_params, return_index)
 
 
+@deprecated("Use corelibs_search.data_search.find_in_array_from_list instead")
 def find_in_array_from_list(
     data: list[dict[str, Any]],
     search_params: list[ArraySearchList],
@@ -48,69 +52,14 @@ def find_in_array_from_list(
         list: list of found elements, or if return index
                 list of dics with "index" and "data", where "data" holds the result list
     """
-    if not isinstance(search_params, list):  # type: ignore
-        raise ValueError("search_params must be a list")
-    keys: list[str] = []
-    # check that key and value exist and are set
-    for search in search_params:
-        if not search.get('key') or not search.get('value'):
-            raise KeyError(
-                f"Either Key '{search.get('key', '')}' or "
-                f"Value '{search.get('value', '')}' is missing or empty"
-            )
-        # if double key -> abort
-        if search.get("key") in keys:
-            raise KeyError(
-                f"Key {search.get('key', '')} already exists in search_params"
-            )
-        keys.append(str(search['key']))
-
-    return_items: list[dict[str, Any]] = []
-    for si_idx, search_item in enumerate(data):
-        # for each search entry, all must match
-        matching = 0
-        for search in search_params:
-            # either Value direct or if Value is list then any of those items can match
-            # values are compared in lower case if case senstive is off
-            # lower case left side
-            # TODO: allow nested Keys. eg "Key: ["Key a", "key b"]" to be ["Key a"]["key b"]
-            if search.get("case_sensitive", True) is False:
-                search_value = search_item.get(str(search['key']), "").lower()
-            else:
-                search_value = search_item.get(str(search['key']), "")
-            # lower case right side
-            if isinstance(search['value'], list):
-                search_in = [
-                    str(k).lower()
-                    if search.get("case_sensitive", True) is False else k
-                    for k in search['value']
-                ]
-            elif search.get("case_sensitive", True) is False:
-                search_in = str(search['value']).lower()
-            else:
-                search_in = search['value']
-            # compare check
-            if (
-                (
-                    isinstance(search_in, list) and
-                    search_value in search_in
-                ) or
-                search_value == search_in
-            ):
-                matching += 1
-        if len(search_params) == matching:
-            if return_index is True:
-                # the data is now in "data sub set"
-                return_items.append({
-                    "index": si_idx,
-                    "data": search_item
-                })
-            else:
-                return_items.append(search_item)
-    # return all found or empty list
-    return return_items
+    return corelibs_find_in_array_from_list(
+        data,
+        search_params,
+        return_index
+    )
 
 
+@deprecated("Use corelibs_search.data_search.key_lookup instead")
 def key_lookup(haystack: dict[str, str], key: str) -> str:
     """
     simple key lookup in haystack, erturns empty string if not found
@@ -122,9 +71,10 @@ def key_lookup(haystack: dict[str, str], key: str) -> str:
     Returns:
         str: _description_
     """
-    return haystack.get(key, "")
+    return corelibs_key_lookup(haystack, key)
 
 
+@deprecated("Use corelibs_search.data_search.value_lookup instead")
 def value_lookup(haystack: dict[str, str], value: str, raise_on_many: bool = False) -> str:
     """
     find by value, if not found returns empty, if not raise on many returns the first one
@@ -140,11 +90,6 @@ def value_lookup(haystack: dict[str, str], value: str, raise_on_many: bool = Fal
     Returns:
         str: _description_
     """
-    keys = [__key for __key, __value in haystack.items() if __value == value]
-    if not keys:
-        return ""
-    if raise_on_many is True and len(keys) > 1:
-        raise ValueError("More than one element found with the same name")
-    return keys[0]
+    return corelibs_value_lookup(haystack, value, raise_on_many)
 
 # __END__

src/corelibs/iterator_handling/dict_helpers.py

@@ -1,88 +1,51 @@
 """
-Dict helpers
+Various helper functions for type data clean up
 """
 
-
-from typing import TypeAlias, Union, Dict, List, Any, cast
-
-# definitions for the mask run below
-MaskableValue: TypeAlias = Union[str, int, float, bool, None]
-NestedDict: TypeAlias = Dict[str, Union[MaskableValue, List[Any], 'NestedDict']]
-ProcessableValue: TypeAlias = Union[MaskableValue, List[Any], NestedDict]
+from warnings import deprecated
+from typing import Any
+from corelibs_iterator.dict_support import (
+    delete_keys_from_set as corelibs_delete_keys_from_set,
+    convert_to_dict_type,
+    set_entry as corelibs_set_entry
+)
 
 
-def mask(
-    data_set: dict[str, Any],
-    mask_keys: list[str] | None = None,
-    mask_str: str = "***",
-    mask_str_edges: str = '_',
-    skip: bool = False
-) -> dict[str, Any]:
+@deprecated("Use corelibs_iterator.dict_support.delete_keys_from_set instead")
+def delete_keys_from_set(
+    set_data: dict[str, Any] | list[Any] | str, keys: list[str]
+) -> dict[str, Any] | list[Any] | Any:
     """
-    mask data for output
-    Checks if mask_keys list exist in any key in the data set either from the start or at the end
+    remove all keys from set_data
 
-    Use the mask_str_edges to define how searches inside a string should work. Default it must start
-    and end with '_', remove to search string in string
-
-    Arguments:
-        data_set {dict[str, str]} -- _description_
-
-    Keyword Arguments:
-        mask_keys {list[str] | None} -- _description_ (default: {None})
-        mask_str {str} -- _description_ (default: {"***"})
-        mask_str_edges {str} -- _description_ (default: {"_"})
-        skip {bool} -- if set to true skip (default: {False})
+    Args:
+        set_data (dict[str, Any] | list[Any] | None): _description_
+        keys (list[str]): _description_
 
     Returns:
-        dict[str, str] -- _description_
+        dict[str, Any] | list[Any] | None: _description_
     """
-    if skip is True:
-        return data_set
-    if mask_keys is None:
-        mask_keys = ["encryption", "password", "secret"]
-    else:
-        # make sure it is lower case
-        mask_keys = [mask_key.lower() for mask_key in mask_keys]
-
-    def should_mask_key(key: str) -> bool:
-        """Check if a key should be masked"""
-        __key_lower = key.lower()
-        return any(
-            __key_lower.startswith(mask_key) or
-            __key_lower.endswith(mask_key) or
-            f"{mask_str_edges}{mask_key}{mask_str_edges}" in __key_lower
-            for mask_key in mask_keys
-        )
-
-    def mask_recursive(obj: ProcessableValue) -> ProcessableValue:
-        """Recursively mask values in nested structures"""
-        if isinstance(obj, dict):
-            return {
-                key: mask_value(value) if should_mask_key(key) else mask_recursive(value)
-                for key, value in obj.items()
-            }
-        if isinstance(obj, list):
-            return [mask_recursive(item) for item in obj]
-        return obj
-
-    def mask_value(value: Any) -> Any:
-        """Handle masking based on value type"""
-        if isinstance(value, list):
-            # Mask each individual value in the list
-            return [mask_str for _ in cast('list[Any]', value)]
-        if isinstance(value, dict):
-            # Recursively process the dictionary instead of masking the whole thing
-            return mask_recursive(cast('ProcessableValue', value))
-        # Mask primitive values
-        return mask_str
-
-    return {
-        key: mask_value(value) if should_mask_key(key) else mask_recursive(value)
-        for key, value in data_set.items()
-    }
+    # skip everything if there is no keys list
+    return corelibs_delete_keys_from_set(set_data, keys)
 
 
+@deprecated("Use corelibs_iterator.dict_support.convert_to_dict_type instead")
+def build_dict(
+    any_dict: Any, ignore_entries: list[str] | None = None
+) -> dict[str, Any | list[Any] | dict[Any, Any]]:
+    """
+    rewrite any AWS *TypeDef to new dict so we can add/change entrys
+
+    Args:
+        any_dict (Any): _description_
+
+    Returns:
+        dict[str, Any | list[Any]]: _description_
+    """
+    return convert_to_dict_type(any_dict, ignore_entries)
+
+
+@deprecated("Use corelibs_iterator.dict_support.set_entry instead")
 def set_entry(dict_set: dict[str, Any], key: str, value_set: Any) -> dict[str, Any]:
     """
     set a new entry in the dict set
@@ -95,9 +58,6 @@ def set_entry(dict_set: dict[str, Any], key: str, value_set: Any) -> dict[str, A
     Returns:
         dict[str, Any] -- _description_
     """
-    if not dict_set.get(key):
-        dict_set[key] = {}
-    dict_set[key] = value_set
-    return dict_set
+    return corelibs_set_entry(dict_set, key, value_set)
 
 # __END__

src/corelibs/iterator_handling/dict_mask.py

@@ -0,0 +1,52 @@
+"""
+Dict helpers
+"""
+
+from warnings import deprecated
+from typing import TypeAlias, Union, Dict, List, Any
+from corelibs_dump_data.dict_mask import (
+    mask as corelibs_mask
+)
+
+# definitions for the mask run below
+MaskableValue: TypeAlias = Union[str, int, float, bool, None]
+NestedDict: TypeAlias = Dict[str, Union[MaskableValue, List[Any], 'NestedDict']]
+ProcessableValue: TypeAlias = Union[MaskableValue, List[Any], NestedDict]
+
+
+@deprecated("use corelibs_dump_data.dict_mask.mask instead")
+def mask(
+    data_set: dict[str, Any],
+    mask_keys: list[str] | None = None,
+    mask_str: str = "***",
+    mask_str_edges: str = '_',
+    skip: bool = False
+) -> dict[str, Any] | list[Any]:
+    """
+    mask data for output
+    Checks if mask_keys list exist in any key in the data set either from the start or at the end
+
+    Use the mask_str_edges to define how searches inside a string should work. Default it must start
+    and end with '_', remove to search string in string
+
+    Arguments:
+        data_set {dict[str, Any]} -- _description_
+
+    Keyword Arguments:
+        mask_keys {list[str] | None} -- _description_ (default: {None})
+        mask_str {str} -- _description_ (default: {"***"})
+        mask_str_edges {str} -- _description_ (default: {"_"})
+        skip {bool} -- if set to true skip (default: {False})
+
+    Returns:
+        dict[str, str] -- _description_
+    """
+    return corelibs_mask(
+        data_set,
+        mask_keys,
+        mask_str,
+        mask_str_edges,
+        skip
+    )
+
+# __END__

src/corelibs/iterator_handling/fingerprint.py

@@ -2,13 +2,35 @@
 Various dictionary, object and list hashers
 """
 
-import json
-import hashlib
+from warnings import deprecated
 from typing import Any
+from corelibs_hash.fingerprint import (
+    hash_object as corelibs_hash_object,
+    dict_hash_frozen as corelibs_dict_hash_frozen,
+    dict_hash_crc as corelibs_dict_hash_crc
+)
 
 
+@deprecated("use corelibs_hash.fingerprint.hash_object instead")
+def hash_object(obj: Any) -> str:
+    """
+    RECOMMENDED for new use
+    Create a hash for any dict or list with mixed key types
+
+    Arguments:
+        obj {Any} -- _description_
+
+    Returns:
+        str -- _description_
+    """
+    return corelibs_hash_object(obj)
+
+
+@deprecated("use corelibs_hash.fingerprint.hash_object instead")
 def dict_hash_frozen(data: dict[Any, Any]) -> int:
     """
+    NOT RECOMMENDED, use dict_hash_crc or hash_object instead
+    If used, DO NOT CHANGE
     hash a dict via freeze
 
     Args:
@@ -17,23 +39,23 @@ def dict_hash_frozen(data: dict[Any, Any]) -> int:
     Returns:
         str: _description_
     """
-    return hash(frozenset(data.items()))
+    return corelibs_dict_hash_frozen(data)
 
 
+@deprecated("use corelibs_hash.fingerprint.dict_hash_crc and for new use hash_object instead")
 def dict_hash_crc(data: dict[Any, Any] | list[Any]) -> str:
     """
-    Create a sha256 hash over dict
+    LEGACY METHOD, must be kept for fallback, if used by other code, DO NOT CHANGE
+    Create a sha256 hash over dict or list
     alternative for
     dict_hash_frozen
 
     Args:
-        data (dict | list): _description_
+        data (dict[Any, Any] | list[Any]): _description_
 
     Returns:
-        str: _description_
+        str: sha256 hash, prefiex with HO_ if fallback used
     """
-    return hashlib.sha256(
-        json.dumps(data, sort_keys=True, ensure_ascii=True).encode('utf-8')
-    ).hexdigest()
+    return corelibs_dict_hash_crc(data)
 
 # __END__

src/corelibs/iterator_handling/list_helpers.py

@@ -2,9 +2,16 @@
 List type helpers
 """
 
+from warnings import deprecated
 from typing import Any, Sequence
+from corelibs_iterator.list_support import (
+    convert_to_list as corelibs_convert_to_list,
+    is_list_in_list as corelibs_is_list_in_list,
+    make_unique_list_of_dicts as corelibs_make_unique_list_of_dicts
+)
 
 
+@deprecated("use corelibs_iterator.list_support.convert_to_list instead")
 def convert_to_list(
     entry: str | int | float | bool | Sequence[str | int | float | bool | Sequence[Any]]
 ) -> Sequence[str | int | float | bool | Sequence[Any]]:
@@ -17,11 +24,10 @@ def convert_to_list(
     Returns:
         list[str | int | float | bool] -- _description_
     """
-    if isinstance(entry, list):
-        return entry
-    return [entry]
+    return corelibs_convert_to_list(entry)
 
 
+@deprecated("use corelibs_iterator.list_support.is_list_in_list instead")
 def is_list_in_list(
     list_a: Sequence[str | int | float | bool | Sequence[Any]],
     list_b: Sequence[str | int | float | bool | Sequence[Any]]
@@ -37,11 +43,20 @@ def is_list_in_list(
     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)
+    return corelibs_is_list_in_list(list_a, list_b)
 
-    # Get the difference and extract just the values
-    return [item for item, _ in set_a - set_b]
+
+@deprecated("use corelibs_iterator.list_support.make_unique_list_of_dicts instead")
+def make_unique_list_of_dicts(dict_list: list[Any]) -> list[Any]:
+    """
+    Create a list of unique dictionary entries
+
+    Arguments:
+        dict_list {list[Any]} -- _description_
+
+    Returns:
+        list[Any] -- _description_
+    """
+    return corelibs_make_unique_list_of_dicts(dict_list)
 
 # __END__

src/corelibs/iterator_handling/manage_dict.py

@@ -1,63 +0,0 @@
-"""
-Various helper functions for type data clean up
-"""
-
-from typing import Any, cast
-
-
-def delete_keys_from_set(
-    set_data: dict[str, Any] | list[Any] | str, keys: list[str]
-) -> dict[str, Any] | list[Any] | Any:
-    """
-    remove all keys from set_data
-
-    Args:
-        set_data (dict[str, Any] | list[Any] | None): _description_
-        keys (list[str]): _description_
-
-    Returns:
-        dict[str, Any] | list[Any] | None: _description_
-    """
-    # skip everything if there is no keys list
-    if not keys:
-        return set_data
-    if isinstance(set_data, dict):
-        for key, value in set_data.copy().items():
-            if key in keys:
-                del set_data[key]
-            if isinstance(value, (dict, list)):
-                delete_keys_from_set(value, keys)  # type: ignore Partly unknown
-    elif isinstance(set_data, list):
-        for value in set_data:
-            if isinstance(value, (dict, list)):
-                delete_keys_from_set(value, keys)  # type: ignore Partly unknown
-    else:
-        set_data = [set_data]
-
-    return set_data
-
-
-def build_dict(
-    any_dict: Any, ignore_entries: list[str] | None = None
-) -> dict[str, Any | list[Any] | dict[Any, Any]]:
-    """
-    rewrite any AWS *TypeDef to new dict so we can add/change entrys
-
-    Args:
-        any_dict (Any): _description_
-
-    Returns:
-        dict[str, Any | list[Any]]: _description_
-    """
-    if ignore_entries is None:
-        return cast(dict[str, Any | list[Any] | dict[Any, Any]], any_dict)
-    # ignore entries can be one key or key nested
-    # return {
-    #     key: value for key, value in any_dict.items() if key not in ignore_entries
-    # }
-    return cast(
-        dict[str, Any | list[Any] | dict[Any, Any]],
-        delete_keys_from_set(any_dict, ignore_entries)
-    )
-
-# __END__

src/corelibs/json_handling/jmespath_helper.py

@@ -2,11 +2,12 @@
 helper functions for jmespath interfaces
 """
 
+from warnings import deprecated
 from typing import Any
-import jmespath
-import jmespath.exceptions
+from corelibs_search.jmespath_search import jmespath_search as jmespath_search_ng
 
 
+@deprecated("Use corelibs_search.jmespath_search.jmespath_search instead")
 def jmespath_search(search_data: dict[Any, Any] | list[Any], search_params: str) -> Any:
     """
     jmespath search wrapper
@@ -22,18 +23,6 @@ def jmespath_search(search_data: dict[Any, Any] | list[Any], search_params: str)
     Returns:
         Any: dict/list/etc, None if nothing found
     """
-    try:
-        search_result = jmespath.search(search_params, search_data)
-    except jmespath.exceptions.LexerError as excp:
-        raise ValueError(f"Compile failed: {search_params}: {excp}") from excp
-    except jmespath.exceptions.ParseError as excp:
-        raise ValueError(f"Parse failed: {search_params}: {excp}") from excp
-    except jmespath.exceptions.JMESPathTypeError as excp:
-        raise ValueError(f"Search failed with JMESPathTypeError: {search_params}: {excp}") from excp
-    except TypeError as excp:
-        raise ValueError(f"Type error for search_params: {excp}") from excp
-    return search_result
-
-# TODO: compile jmespath setup
+    return jmespath_search_ng(search_data, search_params)
 
 # __END__

src/corelibs/json_handling/json_helper.py

@@ -2,35 +2,37 @@
 json encoder for datetime
 """
 
+from warnings import warn, deprecated
 from typing import Any
-from json import JSONEncoder, dumps
-from datetime import datetime, date
-import copy
-from jsonpath_ng import parse  # pyright: ignore[reportMissingTypeStubs, reportUnknownVariableType]
+from corelibs_json.json_support import (
+    default_isoformat as default_isoformat_ng,
+    DateTimeEncoder as DateTimeEncoderCoreLibs,
+    json_dumps as json_dumps_ng,
+    modify_with_jsonpath as modify_with_jsonpath_ng,
+)
 
 
 # subclass JSONEncoder
-class DateTimeEncoder(JSONEncoder):
+class DateTimeEncoder(DateTimeEncoderCoreLibs):
     """
     Override the default method
-    cls=DateTimeEncoder
+    dumps(..., cls=DateTimeEncoder, ...)
     """
-    def default(self, o: Any) -> str | None:
-        if isinstance(o, (date, datetime)):
-            return o.isoformat()
-        return None
 
 
-def default(obj: Any) -> str | None:
+warn("Use corelibs_json.json_support.DateTimeEncoder instead", DeprecationWarning, stacklevel=2)
+
+
+@deprecated("Use corelibs_json.json_support.default_isoformat instead")
+def default_isoformat(obj: Any) -> str | None:
     """
     default override
-    default=default
+    dumps(..., default=default, ...)
     """
-    if isinstance(obj, (date, datetime)):
-        return obj.isoformat()
-    return None
+    return default_isoformat_ng(obj)
 
 
+@deprecated("Use corelibs_json.json_support.json_dumps instead")
 def json_dumps(data: Any):
     """
     wrapper for json.dumps with sure dump without throwing Exceptions
@@ -41,22 +43,15 @@ def json_dumps(data: Any):
     Returns:
         _type_ -- _description_
     """
-    return dumps(data, ensure_ascii=False, default=str)
+    return json_dumps_ng(data)
 
 
+@deprecated("Use corelibs_json.json_support.modify_with_jsonpath instead")
 def modify_with_jsonpath(data: dict[Any, Any], path: str, new_value: Any):
     """
     Modify dictionary using JSONPath (more powerful than JMESPath for modifications)
     """
-    result = copy.deepcopy(data)
-    jsonpath_expr = parse(path)  # pyright: ignore[reportUnknownVariableType]
-
-    # Find and update all matches
-    matches = jsonpath_expr.find(result)  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
-    for match in matches:  # pyright: ignore[reportUnknownVariableType]
-        match.full_path.update(result, new_value)  # pyright: ignore[reportUnknownMemberType]
-
-    return result
+    return modify_with_jsonpath_ng(data, path, new_value)
 
 # __END__
 

src/corelibs/logging_handling/log.py

@@ -11,15 +11,68 @@ from datetime import datetime
 import time
 from pathlib import Path
 import atexit
+from enum import Flag, auto
 from typing import MutableMapping, TextIO, TypedDict, Any, TYPE_CHECKING, cast
+from corelibs_stack_trace.stack import call_stack, exception_stack
+from corelibs_text_colors.text_colors import Colors
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
-from corelibs.string_handling.text_colors import Colors
-from corelibs.debug_handling.debug_helpers import call_stack, exception_stack
 
 if TYPE_CHECKING:
     from multiprocessing import Queue
 
 
+class ConsoleFormat(Flag):
+    """console format type bitmap flags"""
+    TIME = auto()
+    TIME_SECONDS = auto()
+    TIME_MILLISECONDS = auto()
+    TIME_MICROSECONDS = auto()
+    TIMEZONE = auto()
+    NAME = auto()
+    FILE = auto()
+    FUNCTION = auto()
+    LINENO = auto()
+    LEVEL = auto()
+
+
+class ConsoleFormatSettings:
+    """Console format quick settings groups"""
+    # shows everything, time with milliseconds, and time zone, log name, file, function, line number
+    ALL = (
+        ConsoleFormat.TIME |
+        ConsoleFormat.TIMEZONE |
+        ConsoleFormat.NAME |
+        ConsoleFormat.FILE |
+        ConsoleFormat.FUNCTION |
+        ConsoleFormat.LINENO |
+        ConsoleFormat.LEVEL
+    )
+    # show time with no time zone, file, line and level
+    CONDENSED = ConsoleFormat.TIME | ConsoleFormat.FILE | ConsoleFormat.LINENO | ConsoleFormat.LEVEL
+    # only time and level
+    MINIMAL = ConsoleFormat.TIME | ConsoleFormat.LEVEL
+    # only level
+    BARE = ConsoleFormat.LEVEL
+    # only message
+    NONE = ConsoleFormat(0)
+
+    @staticmethod
+    def from_string(setting_str: str, default: ConsoleFormat | None = None) -> ConsoleFormat | None:
+        """
+        Get a console format setting, if does not exist set to None
+
+        Arguments:
+            setting_str {str} -- what to search for
+            default {ConsoleFormat | None} -- if not found return this (default: {None})
+
+        Returns:
+            ConsoleFormat | None -- found ConsoleFormat or None
+        """
+        if hasattr(ConsoleFormatSettings, setting_str):
+            return getattr(ConsoleFormatSettings, setting_str)
+        return default
+
+
 # MARK: Log settings TypedDict
 class LogSettings(TypedDict):
     """log settings, for Log setup"""
@@ -28,6 +81,7 @@ class LogSettings(TypedDict):
     per_run_log: bool
     console_enabled: bool
     console_color_output_enabled: bool
+    console_format_type: ConsoleFormat
     add_start_info: bool
     add_end_info: bool
     log_queue: 'Queue[str] | None'
@@ -338,6 +392,24 @@ class LogParent:
         except IndexError:
             return LoggingLevel.NOTSET
 
+    def any_handler_is_minimum_level(self, log_level: LoggingLevel) -> bool:
+        """
+        if any handler is set to minimum level
+
+        Arguments:
+            log_level {LoggingLevel} -- _description_
+
+        Returns:
+            bool -- _description_
+        """
+        for handler in self.handlers.values():
+            try:
+                if LoggingLevel.from_any(handler.level).includes(log_level):
+                    return True
+            except (IndexError, AttributeError):
+                continue
+        return False
+
     @staticmethod
     def validate_log_level(log_level: Any) -> bool:
         """
@@ -395,6 +467,9 @@ class Log(LogParent):
     logger setup
     """
 
+    CONSOLE_HANDLER: str = 'stream_handler'
+    FILE_HANDLER: str = 'file_handler'
+
     # spacer lenght characters and the character
     SPACER_CHAR: str = '='
     SPACER_LENGTH: int = 32
@@ -409,6 +484,8 @@ class Log(LogParent):
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": True,
+        # do not print log title, file, function and line number
+        "console_format_type": ConsoleFormatSettings.ALL,
         "add_start_info": True,
         "add_end_info": False,
         "log_queue": None,
@@ -419,7 +496,10 @@ class Log(LogParent):
         self,
         log_path: Path,
         log_name: str,
-        log_settings: dict[str, 'LoggingLevel | str | bool | None | Queue[str]'] | LogSettings | None = None,
+        log_settings: (
+            dict[str, 'LoggingLevel | str | bool | None | Queue[str] | ConsoleFormat'] |  # noqa: E501 # pylint: disable=line-too-long
+            LogSettings | None
+        ) = None,
         other_handlers: dict[str, Any] | None = None
     ):
         LogParent.__init__(self)
@@ -455,14 +535,16 @@ class Log(LogParent):
         # in the file writer too, for the ones where color is set BEFORE the format
         # Any is logging.StreamHandler, logging.FileHandler and all logging.handlers.*
         self.handlers: dict[str, Any] = {}
-        self.add_handler('file_handler', self.__create_file_handler(
-            'file_handler', self.log_settings['log_level_file'], log_path)
+        self.add_handler(self.FILE_HANDLER, self.__create_file_handler(
+            self.FILE_HANDLER, self.log_settings['log_level_file'], log_path)
         )
         if self.log_settings['console_enabled']:
             # console
-            self.add_handler('stream_handler', self.__create_console_handler(
-                'stream_handler', self.log_settings['log_level_console'])
-            )
+            self.add_handler(self.CONSOLE_HANDLER, self.__create_console_handler(
+                self.CONSOLE_HANDLER,
+                self.log_settings['log_level_console'],
+                console_format_type=self.log_settings['console_format_type'],
+            ))
         # add other handlers,
         if other_handlers is not None:
             for handler_key, handler in other_handlers.items():
@@ -481,14 +563,15 @@ class Log(LogParent):
         """
         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']:
+        if hasattr(self, 'log_settings') and self.log_settings.get('add_end_info'):
             self.break_line('END')
         self.stop_listener()
 
     # MARK: parse log settings
     def __parse_log_settings(
         self,
-        log_settings: dict[str, 'LoggingLevel | str | bool | None | Queue[str]'] | LogSettings | None
+        log_settings: dict[str, 'LoggingLevel | str | bool | None | Queue[str] | ConsoleFormat'] |  # noqa: E501 # pylint: disable=line-too-long
+            LogSettings | None
     ) -> LogSettings:
         # skip with defaul it not set
         if log_settings is None:
@@ -518,6 +601,10 @@ class Log(LogParent):
             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 console log type
+        if (console_format_type := log_settings.get('console_format_type')) is None:
+            console_format_type = self.DEFAULT_LOG_SETTINGS['console_format_type']
+        default_log_settings['console_format_type'] = cast('ConsoleFormat', console_format_type)
         # check log queue
         __setting = log_settings.get('log_queue', self.DEFAULT_LOG_SETTINGS['log_queue'])
         if __setting is not None:
@@ -551,34 +638,182 @@ class Log(LogParent):
         self.handlers[handler_name] = handler
         return True
 
+    # MARK: console logger format
+    def __build_console_format_from_string(self, console_format_type: ConsoleFormat) -> str:
+        """
+        Build console format string from the given console format type
+
+        Arguments:
+            console_format_type {ConsoleFormat} -- _description_
+
+        Returns:
+            str -- _description_
+        """
+        format_string = ''
+        # time part if any of the times are requested
+        if (
+            ConsoleFormat.TIME in console_format_type or
+            ConsoleFormat.TIME_SECONDS in console_format_type or
+            ConsoleFormat.TIME_MILLISECONDS in console_format_type or
+            ConsoleFormat.TIME_MICROSECONDS in console_format_type
+        ):
+            format_string += '[%(asctime)s] '
+        # set log name
+        if ConsoleFormat.NAME in console_format_type:
+            format_string += '[%(name)s] '
+        # for any file/function/line number call
+        if (
+            ConsoleFormat.FILE in console_format_type or
+            ConsoleFormat.FUNCTION in console_format_type or
+            ConsoleFormat.LINENO in console_format_type
+        ):
+            format_string += '['
+            set_group: list[str] = []
+            if ConsoleFormat.FILE in console_format_type:
+                set_group.append('%(filename)s')
+            if ConsoleFormat.FUNCTION in console_format_type:
+                set_group.append('%(funcName)s')
+            if ConsoleFormat.LINENO in console_format_type:
+                set_group.append('%(lineno)d')
+            format_string += ':'.join(set_group)
+            format_string += '] '
+        # level if wanted
+        if ConsoleFormat.LEVEL in console_format_type:
+            format_string += '<%(levelname)s> '
+        # always message
+        format_string += '%(message)s'
+        return format_string
+
+    def __set_time_format_for_console_formatter(
+        self, formatter_console: CustomConsoleFormatter | logging.Formatter, console_format_type: ConsoleFormat
+    ) -> None:
+        """
+        Format time for a given format handler, this is for console format only
+
+        Arguments:
+            formatter_console {CustomConsoleFormatter | logging.Formatter} -- _description_
+            console_format_type {ConsoleFormat} -- _description_
+        """
+        # default for TIME is milliseconds
+        # if we have multiple set, the smallest precision wins
+        if ConsoleFormat.TIME_MICROSECONDS in console_format_type:
+            iso_precision = 'microseconds'
+        elif (
+            ConsoleFormat.TIME_MILLISECONDS in console_format_type or
+            ConsoleFormat.TIME in console_format_type
+        ):
+            iso_precision = 'milliseconds'
+        elif ConsoleFormat.TIME_SECONDS in console_format_type:
+            iso_precision = 'seconds'
+        else:
+            iso_precision = 'milliseconds'
+        # do timestamp modification only if we have time requested
+        if (
+            ConsoleFormat.TIME in console_format_type or
+            ConsoleFormat.TIME_SECONDS in console_format_type or
+            ConsoleFormat.TIME_MILLISECONDS in console_format_type or
+            ConsoleFormat.TIME_MICROSECONDS in console_format_type
+        ):
+            # if we have with TZ we as the asttimezone call
+            if ConsoleFormat.TIMEZONE in console_format_type:
+                formatter_console.formatTime = (
+                    lambda record, datefmt=None:
+                        datetime
+                        .fromtimestamp(record.created)
+                        .astimezone()
+                        .isoformat(sep=" ", timespec=iso_precision)
+                )
+            else:
+                formatter_console.formatTime = (
+                    lambda record, datefmt=None:
+                        datetime
+                        .fromtimestamp(record.created)
+                        .isoformat(sep=" ", timespec=iso_precision)
+                )
+
+    def __set_console_formatter(self, console_format_type: ConsoleFormat) -> CustomConsoleFormatter | logging.Formatter:
+        """
+        Build the full formatter and return it
+
+        Arguments:
+            console_format_type {ConsoleFormat} -- _description_
+
+        Returns:
+            CustomConsoleFormatter | logging.Formatter -- _description_
+        """
+        format_string = self.__build_console_format_from_string(console_format_type)
+        if self.log_settings['console_color_output_enabled']:
+            # formatter_console = CustomConsoleFormatter(format_string, datefmt=format_date)
+            formatter_console = CustomConsoleFormatter(format_string)
+        else:
+            # formatter_console = logging.Formatter(format_string, datefmt=format_date)
+            formatter_console = logging.Formatter(format_string)
+        self.__set_time_format_for_console_formatter(formatter_console, console_format_type)
+        self.log_settings['console_format_type'] = console_format_type
+        return formatter_console
+
+    # MARK: console handler update
+    def update_console_formatter(
+        self,
+        console_format_type: ConsoleFormat,
+    ):
+        """
+        Update the console formatter for format layout and time stamp format
+
+        Arguments:
+            console_format_type {ConsoleFormat} -- _description_
+        """
+        # skip if console not enabled
+        if not self.log_settings['console_enabled']:
+            return
+        # skip if format has not changed
+        if self.log_settings['console_format_type'] == console_format_type:
+            return
+        # update the formatter
+        self.handlers[self.CONSOLE_HANDLER].setFormatter(
+            self.__set_console_formatter(console_format_type)
+        )
+
+    def get_console_formatter(self) -> ConsoleFormat:
+        """
+        Get the current console formatter, this the settings type
+        Note that if eg "ALL" is set it will return the combined information but not the ALL flag name itself
+
+        Returns:
+            ConsoleFormat -- _description_
+        """
+        return self.log_settings['console_format_type']
+
     # MARK: console handler
     def __create_console_handler(
         self, handler_name: str,
-        log_level_console: LoggingLevel = LoggingLevel.WARNING, filter_exceptions: bool = True
+        log_level_console: LoggingLevel = LoggingLevel.WARNING,
+        filter_exceptions: bool = True,
+        console_format_type: ConsoleFormat = ConsoleFormatSettings.ALL,
     ) -> logging.StreamHandler[TextIO]:
         # console logger
         if not self.validate_log_level(log_level_console):
             log_level_console = self.DEFAULT_LOG_LEVEL_CONSOLE
         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)
+        # print(f"Console format type: {console_format_type}")
+        # build the format string based on what flags are set
+        # format_string = self.__build_console_format_from_string(console_format_type)
+        # # basic date, but this will be overridden to ISO in formatTime
+        # # 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)
+        #     formatter_console = CustomConsoleFormatter(format_string)
+        # else:
+        #     # formatter_console = logging.Formatter(format_string, datefmt=format_date)
+        #     formatter_console = logging.Formatter(format_string)
+        # # set the time format
+        # self.__set_time_format_for_console_formatter(formatter_console, console_format_type)
         console_handler.set_name(handler_name)
         console_handler.setLevel(log_level_console.name)
         # do not show exceptions logs on console
         console_handler.addFilter(CustomHandlerFilter('console', filter_exceptions))
-        console_handler.setFormatter(formatter_console)
+        console_handler.setFormatter(self.__set_console_formatter(console_format_type))
         return console_handler
 
     # MARK: file handler
@@ -614,13 +849,14 @@ class Log(LogParent):
         formatter_file_handler = logging.Formatter(
             (
                 # time stamp
-                '[%(asctime)s.%(msecs)03d] '
+                # '[%(asctime)s.%(msecs)03d] '
+                '[%(asctime)s] '
                 # log name
                 '[%(name)s] '
                 # filename + pid
-                '[%(filename)s:%(process)d] '
-                # path + func + line number
-                '[%(pathname)s:%(funcName)s:%(lineno)d] '
+                # '[%(filename)s:%(process)d] '
+                # pid + path/filename + func + line number
+                '[%(process)d:%(pathname)s:%(funcName)s:%(lineno)d] '
                 # error level
                 '<%(levelname)s> '
                 # message
@@ -628,6 +864,13 @@ class Log(LogParent):
             ),
             datefmt="%Y-%m-%dT%H:%M:%S",
         )
+        formatter_file_handler.formatTime = (
+            lambda record, datefmt=None:
+                datetime
+                .fromtimestamp(record.created)
+                .astimezone()
+                .isoformat(sep="T", timespec="microseconds")
+        )
         file_handler.set_name(handler_name)
         file_handler.setLevel(log_level_file.name)
         # do not show errors flagged with console (they are from exceptions)

src/corelibs/math_handling/math_helpers.py

@@ -0,0 +1,38 @@
+"""
+Various math helpers
+"""
+
+from warnings import deprecated
+import math
+
+
+@deprecated("Use math.gcd instead")
+def gcd(a: int, b: int):
+    """
+    Calculate: Greatest Common Divisor
+
+    Arguments:
+        a {int} -- _description_
+        b {int} -- _description_
+
+    Returns:
+        _type_ -- _description_
+    """
+    return math.gcd(a, b)
+
+
+@deprecated("Use math.lcm instead")
+def lcd(a: int, b: int):
+    """
+    Calculate: Least Common Denominator
+
+    Arguments:
+        a {int} -- _description_
+        b {int} -- _description_
+
+    Returns:
+        _type_ -- _description_
+    """
+    return math.lcm(a, b)
+
+# __END__

src/corelibs/requests_handling/auth_helpers.py

@@ -2,9 +2,11 @@
 Various HTTP auth helpers
 """
 
-from base64 import b64encode
+from warnings import deprecated
+from corelibs_requests.auth_helpers import basic_auth as corelibs_basic_auth
 
 
+@deprecated("use corelibs_requests.auth_helpers.basic_auth instead")
 def basic_auth(username: str, password: str) -> str:
     """
     setup basic auth, for debug
@@ -16,5 +18,6 @@ def basic_auth(username: str, password: str) -> str:
     Returns:
         str -- _description_
     """
-    token = b64encode(f"{username}:{password}".encode('utf-8')).decode("ascii")
-    return f'Basic {token}'
+    return corelibs_basic_auth(username, password)
+
+# __END__

src/corelibs/requests_handling/caller.py

@@ -3,188 +3,35 @@ requests lib interface
 V2 call type
 """
 
-from typing import Any
-import warnings
-import requests
-# to hide the verfiy warnings because of the bad SSL settings from Netskope, Akamai, etc
-warnings.filterwarnings('ignore', message='Unverified HTTPS request')
+from warnings import warn
+from corelibs_requests.caller import (
+    Caller as CoreLibsCaller,
+    ProxyConfig as CoreLibsProxyConfig,
+    ErrorResponse as CoreLibsErrorResponse
+)
 
 
-class Caller:
-    """_summary_"""
+class ErrorResponse(CoreLibsErrorResponse):
+    """
+    Error response structure. This is returned if a request could not be completed
+    """
 
-    def __init__(
-        self,
-        header: dict[str, str],
-        verify: bool = True,
-        timeout: int = 20,
-        proxy: dict[str, str] | None = None
-    ):
-        self.headers = header
-        self.timeout: int = timeout
-        self.cafile = "/Library/Application Support/Netskope/STAgent/data/nscacert.pem"
-        self.verify = verify
-        self.proxy = proxy
 
-    def __timeout(self, timeout: int | None) -> int:
-        if timeout is not None:
-            return timeout
-        return self.timeout
+class ProxyConfig(CoreLibsProxyConfig):
+    """
+    Socks proxy settings
+    """
 
-    def __call(
-        self,
-        action: str,
-        url: str,
-        data: dict[str, Any] | None = None,
-        params: dict[str, Any] | None = None,
-        timeout: int | None = None
-    ) -> requests.Response | None:
-        """
-        call wrapper, on error returns None
 
-        Args:
-            action (str): _description_
-            url (str): _description_
-            data (dict | None): _description_. Defaults to None.
-            params (dict | None): _description_. Defaults to None.
+class Caller(CoreLibsCaller):
+    """
+    requests lib interface
+    """
 
-        Returns:
-            requests.Response | None: _description_
-        """
 
-        if data is None:
-            data = {}
-        try:
-            response = None
-            if action == "get":
-                response = requests.get(
-                    url,
-                    params=params,
-                    headers=self.headers,
-                    timeout=self.__timeout(timeout),
-                    verify=self.verify,
-                    proxies=self.proxy
-                )
-            elif action == "post":
-                response = requests.post(
-                    url,
-                    params=params,
-                    json=data,
-                    headers=self.headers,
-                    timeout=self.__timeout(timeout),
-                    verify=self.verify,
-                    proxies=self.proxy
-                )
-            elif action == "put":
-                response = requests.put(
-                    url,
-                    params=params,
-                    json=data,
-                    headers=self.headers,
-                    timeout=self.__timeout(timeout),
-                    verify=self.verify,
-                    proxies=self.proxy
-                )
-            elif action == "patch":
-                response = requests.patch(
-                    url,
-                    params=params,
-                    json=data,
-                    headers=self.headers,
-                    timeout=self.__timeout(timeout),
-                    verify=self.verify,
-                    proxies=self.proxy
-                )
-            elif action == "delete":
-                response = requests.delete(
-                    url,
-                    params=params,
-                    headers=self.headers,
-                    timeout=self.__timeout(timeout),
-                    verify=self.verify,
-                    proxies=self.proxy
-                )
-            return response
-        except requests.exceptions.InvalidSchema as e:
-            print(f"Invalid URL during '{action}' for {url}:\n\t{e}")
-            return None
-        except requests.exceptions.ReadTimeout as e:
-            print(f"Timeout ({self.timeout}s) during '{action}' for {url}:\n\t{e}")
-            return None
-        except requests.exceptions.ConnectionError as e:
-            print(f"Connection error during '{action}' for {url}:\n\t{e}")
-            return None
-
-    def get(self, url: str, params: dict[str, Any] | None = None) -> requests.Response | None:
-        """
-        get data
-
-        Args:
-            url (str): _description_
-            params (dict | None): _description_
-
-        Returns:
-            requests.Response: _description_
-        """
-        return self.__call('get', url, params=params)
-
-    def post(
-        self, url: str, data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
-    ) -> requests.Response | None:
-        """
-        post data
-
-        Args:
-            url (str): _description_
-            data (dict | None): _description_
-            params (dict | None): _description_
-
-        Returns:
-            requests.Response | None: _description_
-        """
-        return self.__call('post', url, data, params)
-
-    def put(
-        self, url: str, data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
-    ) -> requests.Response | None:
-        """_summary_
-
-        Args:
-            url (str): _description_
-            data (dict | None): _description_
-            params (dict | None): _description_
-
-        Returns:
-            requests.Response | None: _description_
-        """
-        return self.__call('put', url, data, params)
-
-    def patch(
-        self, url: str, data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
-    ) -> requests.Response | None:
-        """_summary_
-
-        Args:
-            url (str): _description_
-            data (dict | None): _description_
-            params (dict | None): _description_
-
-        Returns:
-            requests.Response | None: _description_
-        """
-        return self.__call('patch', url, data, params)
-
-    def delete(self, url: str, params: dict[str, Any] | None = None) -> requests.Response | None:
-        """
-        delete
-
-        Args:
-            url (str): _description_
-            params (dict | None): _description_
-
-        Returns:
-            requests.Response | None: _description_
-        """
-        return self.__call('delete', url, params=params)
+warn(
+    "corelibs.requests_handling.caller is deprecated, use corelibs_requests.caller instead",
+    DeprecationWarning, stacklevel=2
+)
 
 # __END__

src/corelibs/script_handling/progress.py

@@ -0,0 +1,44 @@
+"""
+AUTHOR: Clemens Schwaighofer
+DATE CREATED: 2009/7/24 (2025/7/2)
+DESCRIPTION: progress percent class (perl -> python)
+
+HOW TO USE
+* load
+from progress import Progress
+* init
+prg = Progress()
+    allowed parameters to pass are (in order)
+    - verbose (0/1/...)       : show output
+    - precision (-2~10)       : -2 (5%), -1 (10%), 0 (normal 0-100%), 1~10 (100.m~%)
+    - microtime (1/0/-1)      : show microtime in eta/run time
+    - wide time (bool)        : padd time so all time column doesn't change width of line
+    - prefix line break (bool): add line break before string and not only after
+prg = Progress(verbose = 1, precision = 2)
+* settings methods
+set_wide_time(bool)
+set_microtime(int -1/0/1)
+set_prefix_lb(bool)
+set_verbose(0/1 int)
+set_precision(-2~10 int)
+set_linecount(int)
+set_filesize(int)
+set_start_time(time optional)
+set_eta_start_time(time optional)
+set_end_time(time optional)
+show_position(file pos optional)
+"""
+
+from warnings import warn
+from corelibs_progress.progress import Progress as CoreProgress  # for type checking only
+
+
+class Progress(CoreProgress):
+    """
+    file progress output information
+    """
+
+
+warn("Use 'corelibs_progress.progress.Progress'", DeprecationWarning, stacklevel=2)
+
+# __END__

src/corelibs/script_handling/script_helpers.py

@@ -2,13 +2,16 @@
 Helper methods for scripts
 """
 
-import time
-import os
-import sys
+from warnings import deprecated
 from pathlib import Path
-import psutil
+from corelibs_script.script_support import (
+    wait_abort as corelibs_wait_abort,
+    lock_run as corelibs_lock_run,
+    unlock_run as corelibs_unlock_run,
+)
 
 
+@deprecated("use corelibs_script.script_support.wait_abort instead")
 def wait_abort(sleep: int = 5) -> None:
     """
     wait a certain time for an abort command
@@ -16,18 +19,10 @@ def wait_abort(sleep: int = 5) -> None:
     Keyword Arguments:
         sleep {int} -- _description_ (default: {5})
     """
-    try:
-        print(f"Waiting {sleep} seconds (Press CTRL +C to abort) [", end="", flush=True)
-        for _ in range(1, sleep):
-            print(".", end="", flush=True)
-            time.sleep(1)
-        print("]", flush=True)
-    except KeyboardInterrupt:
-        print("\nInterrupted by user")
-        sys.exit(0)
-    print("\n\n")
+    corelibs_wait_abort(sleep)
 
 
+@deprecated("use corelibs_script.script_support.lock_run instead")
 def lock_run(lock_file: Path) -> None:
     """
     lock a script run
@@ -41,44 +36,10 @@ def lock_run(lock_file: Path) -> None:
         Exception: _description_
         IOError: _description_
     """
-    no_file = False
-    run_pid = os.getpid()
-    # or os.path.isfile()
-    try:
-        with open(lock_file, "r", encoding="UTF-8") as fp:
-            exists = False
-            pid = fp.read()
-            fp.close()
-            if pid:
-                # check if this pid exists
-                for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-                    try:
-                        if pid == proc.info['pid']:
-                            exists = True
-                            break
-                    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                        # in case we cannot access
-                        continue
-            if not exists:
-                # no pid but lock file, unlink
-                try:
-                    lock_file.unlink()
-                    no_file = True
-                except IOError as e:
-                    raise IOError(f"Cannot remove lock_file: {lock_file}: {e}") from e
-            else:
-                raise IOError(f"Script is already running with PID {pid}")
-    except IOError:
-        no_file = True
-    if no_file:
-        try:
-            with open(lock_file, "w", encoding="UTF-8") as fp:
-                fp.write(str(run_pid))
-                fp.close()
-        except IOError as e:
-            raise IOError(f"Cannot open run lock file '{lock_file}' for writing: {e}") from e
+    corelibs_lock_run(lock_file)
 
 
+@deprecated("use corelibs_script.script_support.unlock_run instead")
 def unlock_run(lock_file: Path) -> None:
     """
     removes the lock file
@@ -89,9 +50,6 @@ def unlock_run(lock_file: Path) -> None:
     Raises:
         Exception: _description_
     """
-    try:
-        lock_file.unlink()
-    except IOError as e:
-        raise IOError(f"Cannot remove lock_file: {lock_file}: {e}") from e
+    corelibs_unlock_run(lock_file)
 
 # __END__

src/corelibs/string_handling/byte_helpers.py

@@ -2,7 +2,11 @@
 Format bytes
 """
 
+from warnings import deprecated
+from corelibs_strings.string_format import format_bytes as corelibs_format_bytes
 
+
+@deprecated("Use corelibs_strings.string_format.format_bytes instead")
 def format_bytes(byte_value: float | int | str) -> str:
     """
     Format a byte value to a human readable string
@@ -14,24 +18,9 @@ def format_bytes(byte_value: float | int | str) -> str:
         str -- _description_
     """
     # if string exit
-    if isinstance(byte_value, str):
-        return byte_value
-    # empty byte value is set to 0
-    if not byte_value:
-        byte_value = float(0)
-    # if not float, convert to flaot
-    if isinstance(byte_value, int):
-        byte_value = float(byte_value)
-    # loop through valid extensions
-    for unit in ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB"]:
-        # never go into the negativ and check if it is smaller than next set
-        # if it is, print out return string
-        if abs(byte_value) < 1024.0:
-            return f"{byte_value:,.2f} {unit}"
-        # divided for the next loop check
-        byte_value /= 1024.0
-    # if it is too big, return YB
-    return f"{byte_value:,.2f} YB"
+    return corelibs_format_bytes(
+        byte_value=byte_value,
+    )
 
 
 # __NED__

src/corelibs/string_handling/double_byte_string_format.py

@@ -2,225 +2,18 @@
 Format double byte strings to exact length
 """
 
-import unicodedata
+from warnings import warn
+from corelibs_double_byte_format.double_byte_string_format import (
+    DoubleByteFormatString as CorelibsDoubleByteFormatString
+)
 
 
-class DoubleByteFormatString:
+class DoubleByteFormatString(CorelibsDoubleByteFormatString):
     """
     Format a string to exact length
     """
 
-    def __init__(
-        self,
-        string: str,
-        cut_length: int,
-        format_length: int | None = None,
-        placeholder: str = '..',
-        format_string: str = '{{:<{len}}}'
-    ):
-        """
-        shorts a string to exact cut length and sets it to format length
 
-        after "cut_length" cut the "placeholder" will be added, so that the new cut_length is never
-        larget than the cut_length given (".." is counted to cut_length)
-        if format_length if set and outside format_length will be set
-        the cut_length is adjusted to format_length if the format_length is shorter
-
-        Example
-
-        "Foo bar baz" 10 charcters -> 5 cut_length -> 10 format_length
-        "Foo..      "
-
-        use class.get_string_short() for cut length shortend string
-        use class.get_string_short_formated() to get the shorted string to format length padding
-
-        creates a class that shortens and sets the format length
-        to use with a print format run the format needs to be pre set in
-        the style of {{:<{len}}} style
-        self.get_string_short_formated() for the "len" parameter
-
-        Args:
-            string (str): string to work with
-            cut_length (int): width to shorten to
-            format_length (int | None): format length. Defaults to None
-            placeholder (str, optional): placeholder to put after shortened string. Defaults to '..'.
-            format_string (str, optional): format string. Defaults to '{{:<{len}}}'
-        """
-        # output variables
-        self.string_short: str = ''
-        self.string_width_value: int = 0
-        self.string_short_width: int = 0
-        self.format_length_value: int = 0
-        # internal varaibles
-        self.placeholder: str = placeholder
-        # original string
-        self.string: str = ''
-        # width to cut string to
-        self.cut_length: int = 0
-        # format length to set to
-        self.format_length: int = 0
-        # main string
-        self.string = str(string)
-
-        self.format_string: str = format_string
-
-        # if width is > 0 set, else set width of string (fallback)
-        if cut_length > 0:
-            self.cut_length = cut_length
-        elif cut_length <= 0:
-            self.cut_length = self.__string_width_calc(self.string)
-        # format length set, if not set or smaller than 0, set to width of string
-        self.format_length = self.cut_length
-        if format_length is not None and format_length > 0:
-            self.format_length = format_length
-        # check that width is not larger then length if yes, set width to length
-        self.cut_length = min(self.cut_length, self.format_length)
-
-        # process the string shorten and format length calculation
-        self.process()
-
-    def process(self):
-        """
-        runs all the class methods to set string length, the string shortened
-        and the format length
-        """
-        # call the internal ones to set the data
-        if self.string:
-            self.__string_width()
-            self.__shorten_string()
-            if self.format_length:
-                self.__format_length()
-
-    def get_string_short(self) -> str:
-        """
-        get the shortend string
-
-        Returns:
-            str -- _description_
-        """
-        return self.string_short
-
-    def get_string_short_formated(self, format_string: str = '{{:<{len}}}') -> str:
-        """
-        get the formatted string
-
-        Keyword Arguments:
-            format_string {_type_} -- _description_ (default: {'{{:<{len}}}'})
-
-        Returns:
-            str -- _description_
-        """
-        if not format_string:
-            format_string = self.format_string
-        return format_string.format(
-            len=self.get_format_length()
-        ).format(
-            self.get_string_short()
-        )
-
-    def get_format_length(self) -> int:
-        """
-        get the format length for outside length set
-
-        Returns:
-            int -- _description_
-        """
-        return self.format_length_value
-
-    def get_cut_length(self) -> int:
-        """
-        get the actual cut length
-
-        Returns:
-            int -- _description_
-        """
-        return self.cut_length
-
-    def get_requested_cut_length(self) -> int:
-        """
-        get the requested cut length
-
-        Returns:
-            int -- _description_
-        """
-        return self.cut_length
-
-    def get_requested_format_length(self) -> int:
-        """
-        get the requested format length
-
-        Returns:
-            int -- _description_
-        """
-        return self.format_length
-
-    def __string_width_calc(self, string: str) -> int:
-        """
-        does the actual string width calculation
-
-        Args:
-            string (str): string to calculate from
-
-        Returns:
-            int: stringth width
-        """
-        return sum(1 + (unicodedata.east_asian_width(c) in "WF") for c in string)
-
-    def __string_width(self):
-        """
-        calculates the string width based on the characters
-        this is an internal method and should not be called on itself
-        """
-        # only run if string is set and is valid string
-        if self.string:
-            # calculate width. add +1 for each double byte character
-            self.string_width_value = self.__string_width_calc(self.string)
-
-    def __format_length(self):
-        """
-        set the format length based on the length for the format
-        and the shortend string
-        this is an internal method and should not be called on itself
-        """
-        if not self.string_short:
-            self.__shorten_string()
-        # get correct format length based on string
-        if (
-            self.string_short and
-            self.format_length > 0 and
-            self.string_short_width > 0
-        ):
-            # length: format length wanted
-            # substract the width of the shortend string - the length of the shortend string
-            self.format_length_value = self.format_length - (self.string_short_width - len(self.string_short))
-        else:
-            # if we have nothing to shorten the length, keep the old one
-            self.format_length_value = self.format_length
-
-    def __shorten_string(self):
-        """
-        shorten string down to set width
-        this is an internal method and should not be called on itself
-        """
-        # set string width if not set
-        if not self.string_width_value:
-            self.__string_width()
-        # if the double byte string width is larger than the wanted width
-        if self.string_width_value > self.cut_length:
-            cur_len = 0
-            self.string_short = ''
-            for char in str(self.string):
-                # set the current length if we add the character
-                cur_len += 2 if unicodedata.east_asian_width(char) in "WF" else 1
-                # if the new length is smaller than the output length to shorten too add the char
-                if cur_len <= (self.cut_length - len(self.placeholder)):
-                    self.string_short += char
-                    self.string_short_width = cur_len
-            # return string with new width and placeholder
-            self.string_short = f"{self.string_short}{self.placeholder}"
-            self.string_short_width += len(self.placeholder)
-        else:
-            # if string is same saze just copy
-            self.string_short = self.string
+warn("Use 'corelibs_double_byte_format.double_byte_string_format' instead", DeprecationWarning, stacklevel=2)
 
 # __END__

src/corelibs/string_handling/hash_helpers.py

@@ -2,10 +2,11 @@
 Various hash helpers for strings and things
 """
 
-import re
-import hashlib
+from warnings import deprecated
+from corelibs_hash.string_hash import crc32b_fix as corelibs_crc32b_fix, sha1_short as corelibs_sha1_short
 
 
+@deprecated("Use corelibs_hash.string_hash.crc32b_fix instead")
 def crc32b_fix(crc: str) -> str:
     """
     fix a CRC32B with wrong order (from old PHP)
@@ -16,15 +17,10 @@ def crc32b_fix(crc: str) -> str:
     Returns:
         str -- _description_
     """
-    # left pad with 0 to 8 chars
-    crc = ("0" * (8 - len(crc))) + crc
-    # flip two chars (byte hex)
-    crc = re.sub(
-        r"^([a-z0-9]{2})([a-z0-9]{2})([a-z0-9]{2})([a-z0-9]{2})$", r"\4\3\2\1", crc
-    )
-    return crc
+    return corelibs_crc32b_fix(crc)
 
 
+@deprecated("Use corelibs_hash.string_hash.sha1_short instead")
 def sha1_short(string: str) -> str:
     """
     Return a 9 character long SHA1 part
@@ -35,6 +31,6 @@ def sha1_short(string: str) -> str:
     Returns:
         str -- _description_
     """
-    return hashlib.sha1(string.encode('utf-8')).hexdigest()[:9]
+    return corelibs_sha1_short(string)
 
 # __END__

src/corelibs/string_handling/string_helpers.py

@@ -2,11 +2,16 @@
 String helpers
 """
 
-import re
-from decimal import Decimal, getcontext
-from textwrap import shorten
+from warnings import deprecated
+from corelibs_strings.string_support import (
+    shorten_string as corelibs_shorten_string,
+    left_fill as corelibs_left_fill,
+    prepare_url_slash as corelibs_prepare_url_slash,
+)
+from corelibs_strings.string_format import format_number as corelibs_format_number
 
 
+@deprecated("Use corelibs_strings.string_support.shorten_string instead")
 def shorten_string(
     string: str | int | float, length: int, hard_shorten: bool = False, placeholder: str = " [~]"
 ) -> str:
@@ -23,25 +28,15 @@ def shorten_string(
     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
+    return corelibs_shorten_string(
+        string=string,
+        length=length,
+        hard_shorten=hard_shorten,
+        placeholder=placeholder,
+    )
 
 
+@deprecated("Use corelibs_strings.string_support.left_fill instead")
 def left_fill(string: str, width: int, char: str = " ") -> str:
     """
     left fill for a certain length to fill a max size
@@ -58,19 +53,14 @@ def left_fill(string: str, width: int, char: str = " ") -> str:
     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)
+    return corelibs_left_fill(
+        string=string,
+        width=width,
+        char=char,
+    )
 
 
+@deprecated("Use corelibs_strings.string_format.format_number instead")
 def format_number(number: float, precision: int = 0) -> str:
     """
     format numbers, current trailing zeros does not work
@@ -88,21 +78,13 @@ def format_number(number: float, precision: int = 0) -> str:
     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)
+    return corelibs_format_number(
+        number=number,
+        precision=precision,
+    )
 
 
+@deprecated("Use corelibs_strings.string_support.prepare_url_slash instead")
 def prepare_url_slash(url: str) -> str:
     """
     if the URL does not start with /, add slash
@@ -114,9 +96,8 @@ def prepare_url_slash(url: str) -> str:
     Returns:
         str -- _description_
     """
-    url = re.sub(r'\/+', '/', url)
-    if not url.startswith("/"):
-        url = "/" + url
-    return url
+    return corelibs_prepare_url_slash(
+        url=url,
+    )
 
 # __END__

src/corelibs/string_handling/text_colors.py

@@ -5,152 +5,14 @@ Set colors with print(f"something {Colors.yellow}colorful{Colors.end})
 bold + underline + color combinations are possible.
 """
 
+from warnings import deprecated
+from corelibs_text_colors.text_colors import Colors as ColorsNew
 
-class Colors:
+
+@deprecated("Use src.corelibs_text_colors.text_colors instead")
+class Colors(ColorsNew):
     """
     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/var_handling/enum_base.py

@@ -2,74 +2,24 @@
 Enum base classes
 """
 
-from enum import Enum
-from typing import Any
+import warnings
+from corelibs_enum_base.enum_base import EnumBase as CorelibsEnumBase
 
 
-class EnumBase(Enum):
+class EnumBase(CorelibsEnumBase):
     """
     base for enum
+
+    .. deprecated::
+        Use corelibs_enum_base.EnumBase instead
+    DEPRECATED: Use corelibs_enum_base.enum_base.EnumBase instead
+
     lookup_any and from_any will return "EnumBase" and the sub class name
     run the return again to "from_any" to get a clean value, or cast it
     """
 
-    @classmethod
-    def lookup_key(cls, enum_key: str):
-        """Lookup from key side (must be string)"""
-        # if there is a ":", then this is legacy, replace with ___
-        if ":" in enum_key:
-            enum_key = enum_key.replace(':', '___')
-        try:
-            return cls[enum_key.upper()]
-        except KeyError as e:
-            raise ValueError(f"Invalid key: {enum_key}") from e
-        except AttributeError as e:
-            raise ValueError(f"Invalid key: {enum_key}") from e
 
-    @classmethod
-    def lookup_value(cls, enum_value: Any):
-        """Lookup through value side"""
-        try:
-            return cls(enum_value)
-        except ValueError as e:
-            raise ValueError(f"Invalid value: {enum_value}") from e
+# At the module level, issue a deprecation warning
+warnings.warn("Use corelibs_enum_base.enum_base.EnumBase instead", DeprecationWarning, stacklevel=2)
 
-    @classmethod
-    def from_any(cls, enum_any: Any):
-        """
-        This only works in the following order
-        -> class itself, as is
-        -> str, assume key lookup
-        -> if failed try other
-
-        Arguments:
-            enum_any {Any} -- _description_
-
-        Returns:
-            _type_ -- _description_
-        """
-        if isinstance(enum_any, cls):
-            return enum_any
-        # try key first if it is string
-        # if failed try value
-        if isinstance(enum_any, str):
-            try:
-                return cls.lookup_key(enum_any)
-            except (ValueError, AttributeError):
-                try:
-                    return cls.lookup_value(enum_any)
-                except ValueError as e:
-                    raise ValueError(f"Could not find as key or value: {enum_any}") from e
-        return cls.lookup_value(enum_any)
-
-    def to_value(self) -> Any:
-        """Convert to value"""
-        return self.value
-
-    def to_lower_case(self) -> str:
-        """return lower case"""
-        return self.name.lower()
-
-    def __str__(self) -> str:
-        """return [Enum].NAME like it was called with .name"""
-        return self.name
+# __EMD__

src/corelibs/var_handling/enum_base.pyi

@@ -0,0 +1,15 @@
+"""
+Enum base classes [STPUB]
+"""
+
+from typing_extensions import deprecated
+from corelibs_enum_base.enum_base import EnumBase as CorelibsEnumBase
+
+
+@deprecated("Use corelibs_enum_base.enum_base.EnumBase instead")
+class EnumBase(CorelibsEnumBase):
+    """
+    base for enum
+    lookup_any and from_any will return "EnumBase" and the sub class name
+    run the return again to "from_any" to get a clean value, or cast it
+    """

src/corelibs/var_handling/var_helpers.py

@@ -3,8 +3,11 @@ variable convert, check, etc helepr
 """
 
 from typing import Any
+from warnings import deprecated
+import corelibs_var.var_helpers
 
 
+@deprecated("Use corelibs_var.var_helpers.is_int instead")
 def is_int(string: Any) -> bool:
     """
     check if a value is int
@@ -15,15 +18,10 @@ def is_int(string: Any) -> bool:
     Returns:
         bool -- _description_
     """
-    try:
-        int(string)
-        return True
-    except TypeError:
-        return False
-    except ValueError:
-        return False
+    return corelibs_var.var_helpers.is_int(string)
 
 
+@deprecated("Use corelibs_var.var_helpers.is_float instead")
 def is_float(string: Any) -> bool:
     """
     check if a value is float
@@ -34,15 +32,10 @@ def is_float(string: Any) -> bool:
     Returns:
         bool -- _description_
     """
-    try:
-        float(string)
-        return True
-    except TypeError:
-        return False
-    except ValueError:
-        return False
+    return corelibs_var.var_helpers.is_float(string)
 
 
+@deprecated("Use corelibs_var.var_helpers.str_to_bool instead")
 def str_to_bool(string: str):
     """
     convert string to bool
@@ -56,10 +49,6 @@ def str_to_bool(string: str):
     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}")
+    return corelibs_var.var_helpers.str_to_bool(string)
 
 # __END__

test-run/check_handling/regex_checks.py

@@ -0,0 +1,109 @@
+"""
+Test check andling for regex checks
+"""
+
+from corelibs_text_colors.text_colors import Colors
+from corelibs.check_handling.regex_constants import (
+    compile_re, DOMAIN_WITH_LOCALHOST_REGEX, EMAIL_BASIC_REGEX, NAME_EMAIL_BASIC_REGEX, SUB_EMAIL_BASIC_REGEX
+)
+from corelibs.check_handling.regex_constants_compiled import (
+    COMPILED_DOMAIN_WITH_LOCALHOST_REGEX, COMPILED_EMAIL_BASIC_REGEX,
+    COMPILED_NAME_EMAIL_SIMPLE_REGEX, COMPILED_NAME_EMAIL_BASIC_REGEX
+)
+
+NAME_EMAIL_SIMPLE_REGEX = r"""
+^\s*(?:"(?P<name1>[^"]+)"\s*<(?P<email1>[^>]+)>|
+(?P<name2>.+?)\s*<(?P<email2>[^>]+)>|
+<(?P<email3>[^>]+)>|
+(?P<email4>[^\s<>]+))\s*$
+"""
+
+
+def domain_test():
+    """
+    domain regex test
+    """
+    print("=" * 30)
+    test_domains = [
+        "example.com",
+        "localhost",
+        "subdomain.localhost",
+        "test.localhost.com",
+        "some-domain.org"
+    ]
+
+    regex_domain_check = COMPILED_DOMAIN_WITH_LOCALHOST_REGEX
+    print(f"REGEX: {DOMAIN_WITH_LOCALHOST_REGEX}")
+    print(f"Check regex: {regex_domain_check.search('localhost')}")
+
+    for domain in test_domains:
+        if regex_domain_check.search(domain):
+            print(f"Matched: {domain}")
+        else:
+            print(f"Did not match: {domain}")
+
+
+def email_test():
+    """
+    email regex test
+    """
+    print("=" * 30)
+    email_list = """
+    e@bar.com
+    <f@foobar.com>
+    "Master" <foobar@bar.com>
+    "not valid" not@valid.com
+    also not valid not@valid.com
+    some header <something@bar.com>
+    test master <master@master.com>
+    日本語 <japan@jp.net>
+    "ひほん カケ苦" <foo@bar.com>
+    single@entry.com
+    arsch@popsch.com
+    test open <open@open.com>
+    """
+
+    print(f"REGEX: SUB_EMAIL_BASIC_REGEX: {SUB_EMAIL_BASIC_REGEX}")
+    print(f"REGEX: EMAIL_BASIC_REGEX: {EMAIL_BASIC_REGEX}")
+    print(f"REGEX: COMPILED_NAME_EMAIL_SIMPLE_REGEX: {COMPILED_NAME_EMAIL_SIMPLE_REGEX}")
+    print(f"REGEX: NAME_EMAIL_BASIC_REGEX: {NAME_EMAIL_BASIC_REGEX}")
+
+    basic_email = COMPILED_EMAIL_BASIC_REGEX
+    sub_basic_email = compile_re(SUB_EMAIL_BASIC_REGEX)
+    simple_name_email_regex = COMPILED_NAME_EMAIL_SIMPLE_REGEX
+    full_name_email_regex = COMPILED_NAME_EMAIL_BASIC_REGEX
+    for email in email_list.splitlines():
+        email = email.strip()
+        if not email:
+            continue
+        print(f">>> Testing:        {email}")
+        if not basic_email.match(email):
+            print(f"{Colors.red}[EMAIL ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[EMAIL ] Matched : {email}{Colors.reset}")
+        if not sub_basic_email.match(email):
+            print(f"{Colors.red}[SUB   ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[SUB   ] Matched : {email}{Colors.reset}")
+        if not simple_name_email_regex.match(email):
+            print(f"{Colors.red}[SIMPLE] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[SIMPLE] Matched : {email}{Colors.reset}")
+        if not full_name_email_regex.match(email):
+            print(f"{Colors.red}[FULL  ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[FULL  ] Matched : {email}{Colors.reset}")
+
+
+def main():
+    """
+    Test regex checks
+    """
+    domain_test()
+    email_test()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/config_handling/config/settings.ini

@@ -1,16 +1,23 @@
 [TestA]
 foo=bar
+overload_from_args=bar
 foobar=1
 bar=st
+arg_overload=should_not_be_set_because_of_command_line_is_list
+arg_overload_list=too,be,long
+arg_overload_not_set=this should not be set because of override flag
+just_values=too,be,long
 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
+empty_list=
 str_length=foobar
 int_range=20
 int_range_not_set=
 int_range_not_set_empty_set=5
+bool_var=True
 #
 match_target=foo
 match_target_list=foo,bar,baz
@@ -32,3 +39,6 @@ email_bad=gii@bar.com
 [LoadTest]
 a.b.c=foo
 d:e:f=bar
+
+[ErrorTest]
+some_value=42

test-run/config_handling/settings_loader.py

@@ -4,7 +4,7 @@ Settings loader test
 
 import re
 from pathlib import Path
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.logging_handling.log import Log
 from corelibs.config_handling.settings_loader import SettingsLoader
 from corelibs.config_handling.settings_loader_handling.settings_loader_check import SettingsLoaderCheck
@@ -21,11 +21,6 @@ def main():
     Main run
     """
 
-    value = "2025/1/1"
-    regex_c = re.compile(SettingsLoaderCheck.CHECK_SETTINGS['string.date']['regex'], re.VERBOSE)
-    result = regex_c.search(value)
-    print(f"regex {regex_c} check against {value} -> {result}")
-
     # for log testing
     log = Log(
         log_path=ROOT_PATH.joinpath(LOG_DIR, 'settings_loader.log'),
@@ -37,9 +32,17 @@ def main():
     )
     log.logger.info('Settings loader')
 
+    value = "2025/1/1"
+    regex_c = re.compile(SettingsLoaderCheck.CHECK_SETTINGS['string.date']['regex'], re.VERBOSE)
+    result = regex_c.search(value)
+    log.info(f"regex {regex_c} check against {value} -> {result}")
+
     sl = SettingsLoader(
         {
-            'foo': 'OVERLOAD'
+            'overload_from_args': 'OVERLOAD from ARGS',
+            'arg_overload': ['should', 'not', 'be', 'set'],
+            'arg_overload_list': ['overload', 'this', 'list'],
+            'arg_overload_not_set': "DO_NOT_SET",
         },
         ROOT_PATH.joinpath(CONFIG_DIR, CONFIG_FILE),
         log=log
@@ -50,9 +53,11 @@ def main():
             config_load,
             {
                 # "doesnt": ["split:,"],
-                "foo": ["mandatory:yes"],
+                "overload_from_args": ["args_override:yes", "mandatory:yes"],
                 "foobar": ["check:int"],
                 "bar": ["mandatory:yes"],
+                "arg_overload_list": ["args_override:yes", "split:,",],
+                "arg_overload_not_set": [],
                 "some_match": ["matching:foo|bar"],
                 "some_match_list": ["split:,", "matching:foo|bar"],
                 "test_list": [
@@ -64,6 +69,9 @@ def main():
                     "split:|",
                     "check:string.alphanumeric"
                 ],
+                "empty_list": [
+                    "split:,",
+                ],
                 "str_length": [
                     "length:2-10"
                 ],
@@ -76,6 +84,7 @@ def main():
                 "int_range_not_set_empty_set": [
                     "empty:"
                 ],
+                "bool_var": ["convert:bool"],
                 "match_target": ["matching:foo"],
                 "match_target_list": ["split:,", "matching:foo|bar|baz",],
                 "match_source_a": ["in:match_target"],
@@ -120,6 +129,20 @@ def main():
     except ValueError as e:
         print(f"Could not load settings: {e}")
 
+    try:
+        config_load = 'ErrorTest'
+        config_data = sl.load_settings(
+            config_load,
+            {
+                "some_value": [
+                    "check:string.email.basic",
+                ],
+            }
+        )
+        print(f"[{config_load}] Load: {config_load} -> {dump_data(config_data)}")
+    except ValueError as e:
+        print(f"Could not load settings: {e}")
+
 
 if __name__ == "__main__":
     main()

test-run/db_handling/sql_main.py

@@ -0,0 +1,139 @@
+"""
+SQL Main wrapper test
+"""
+
+from pathlib import Path
+from uuid import uuid4
+import json
+from corelibs_dump_data.dump_data import dump_data
+from corelibs.logging_handling.log import Log, Logger
+from corelibs.db_handling.sql_main import SQLMain
+
+SCRIPT_PATH: Path = Path(__file__).resolve().parent
+ROOT_PATH: Path = SCRIPT_PATH
+DATABASE_DIR: Path = Path("database")
+LOG_DIR: Path = Path("log")
+
+
+def main() -> None:
+    """
+    Comment
+    """
+    log = Log(
+        log_path=ROOT_PATH.joinpath(LOG_DIR, 'sqlite_main.log'),
+        log_name="SQLite Main",
+        log_settings={
+            "log_level_console": 'DEBUG',
+            "log_level_file": 'DEBUG',
+        }
+    )
+    sql_main = SQLMain(
+        log=Logger(log.get_logger_settings()),
+        db_ident=f"sqlite:{ROOT_PATH.joinpath(DATABASE_DIR, 'test_sqlite_main.db')}"
+    )
+    if sql_main.connected():
+        log.info("SQL Main connected successfully")
+    else:
+        log.error('SQL Main connection failed')
+    if sql_main.dbh is None:
+        log.error('SQL Main DBH instance is None')
+        return
+
+    if sql_main.dbh.trigger_exists('trg_test_a_set_date_updated_on_update'):
+        log.info("Trigger trg_test_a_set_date_updated_on_update exists")
+    if sql_main.dbh.table_exists('test_a'):
+        log.info("Table test_a exists, dropping for clean test")
+        sql_main.dbh.execute_query("DROP TABLE test_a;")
+    # create a dummy table
+    table_sql = """
+    CREATE TABLE IF NOT EXISTS test_a (
+        test_a_id INTEGER PRIMARY KEY,
+        date_created TEXT DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+        date_updated TEXT,
+        uid TEXT NOT NULL UNIQUE,
+        set_current_timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+        text_a TEXT,
+        content,
+        int_a INTEGER,
+        float_a REAL
+    );
+    """
+
+    result = sql_main.dbh.execute_query(table_sql)
+    log.debug(f"Create table result: {result}")
+    trigger_sql = """
+    CREATE TRIGGER trg_test_a_set_date_updated_on_update
+        AFTER UPDATE ON test_a
+        FOR EACH ROW
+        WHEN OLD.date_updated IS NULL OR NEW.date_updated = OLD.date_updated
+    BEGIN
+        UPDATE test_a
+        SET date_updated = (strftime('%Y-%m-%d %H:%M:%f', 'now'))
+        WHERE test_a_id = NEW.test_a_id;
+    END;
+    """
+    result = sql_main.dbh.execute_query(trigger_sql)
+    log.debug(f"Create trigger result: {result}")
+    result = sql_main.dbh.meta_data_detail('test_a')
+    log.debug(f"Table meta data detail: {dump_data(result)}")
+    # INSERT DATA
+    sql = """
+    INSERT INTO test_a (uid, text_a, content, int_a, float_a)
+    VALUES (?, ?, ?, ?, ?)
+    RETURNING test_a_id, uid;
+    """
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            str(uuid4()),
+            'Some text A',
+            json.dumps({'foo': 'bar', 'number': 42}),
+            123,
+            123.456,
+        )
+    )
+    log.debug(f"[1] Insert data result: {dump_data(result)}")
+    __uid: str = ''
+    if result is not False:
+        # first one only of interest
+        result = dict(result[0])
+        __uid = str(result.get('uid', ''))
+    # second insert
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            str(uuid4()),
+            'Some text A',
+            json.dumps({'foo': 'bar', 'number': 42}),
+            123,
+            123.456,
+        )
+    )
+    log.debug(f"[2] Insert data result: {dump_data(result)}")
+    result = sql_main.dbh.execute_query("SELECT * FROM test_a;")
+    log.debug(f"Select data result: {dump_data(result)}")
+    result = sql_main.dbh.return_one("SELECT * FROM test_a WHERE uid = ?;", (__uid,))
+    log.debug(f"Fetch row result: {dump_data(result)}")
+    sql = """
+    UPDATE test_a
+    SET text_a = ?
+    WHERE uid = ?;
+    """
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            'Some updated text A',
+            __uid,
+        )
+    )
+    log.debug(f"Update data result: {dump_data(result)}")
+    result = sql_main.dbh.return_one("SELECT * FROM test_a WHERE uid = ?;", (__uid,))
+    log.debug(f"Fetch row after update result: {dump_data(result)}")
+
+    sql_main.close()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/db_handling/sqlite_io.py

@@ -1,14 +1,12 @@
-#!/usr/bin/env python3
-
 """
-Main comment
+SQLite IO test
 """
 
 from pathlib import Path
 from uuid import uuid4
 import json
 import sqlite3
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.logging_handling.log import Log, Logger
 from corelibs.db_handling.sqlite_io import SQLiteIO
 

test-run/encryption/symmetric_encryption.py

@@ -5,7 +5,7 @@ Symmetric encryption test
 """
 
 import json
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.encryption_handling.symmetric_encryption import SymmetricEncryption
 
 

test-run/file_handling/file_bom_check.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+"""
+BOM check for files
+"""
+
+from pathlib import Path
+from corelibs_dump_data.dump_data import dump_data
+from corelibs.file_handling.file_bom_encoding import is_bom_encoded, is_bom_encoded_info
+
+
+def main() -> None:
+    """
+    Check files for BOM encoding
+    """
+    base_path = Path(__file__).resolve().parent
+    for file_path in [
+        'test-data/sample_with_bom.csv',
+        'test-data/sample_without_bom.csv',
+    ]:
+        has_bom = is_bom_encoded(base_path.joinpath(file_path))
+        bom_info = is_bom_encoded_info(base_path.joinpath(file_path))
+        print(f'File: {file_path}')
+        print(f'  Has BOM: {has_bom}')
+        print(f'  BOM Info: {dump_data(bom_info)}')
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/file_handling/test-data/sample_with_bom.csv

@@ -0,0 +1,6 @@
+Name,Age,City,Country
+John Doe,25,New York,USA
+Jane Smith,30,London,UK
+山田太郎,28,東京,Japan
+María García,35,Madrid,Spain
+François Dupont,42,Paris,France

test-run/file_handling/test-data/sample_without_bom.csv

@@ -0,0 +1,6 @@
+Name,Age,City,Country
+John Doe,25,New York,USA
+Jane Smith,30,London,UK
+山田太郎,28,東京,Japan
+María García,35,Madrid,Spain
+François Dupont,42,Paris,France

test-run/iterator_handling/data_search.py

@@ -5,7 +5,7 @@ Search data tests
 iterator_handling.data_search
 """
 
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.iterator_handling.data_search import find_in_array_from_list, ArraySearchList
 
 
@@ -24,12 +24,19 @@ def main() -> None:
             "lookup_value_c": "B02",
             "replace_value": "R02",
         },
+        {
+            "lookup_value_p": "A03",
+            "lookup_value_c": "B03",
+            "replace_value": "R03",
+        },
     ]
     test_foo = ArraySearchList(
-        key = "lookup_value_p",
-        value = "A01"
+        key="lookup_value_p",
+        value="A01"
     )
-    print(test_foo)
+    result = find_in_array_from_list(data, [test_foo])
+    print(f"Search A: {dump_data(test_foo)} -> {dump_data(result)}")
+
     search: list[ArraySearchList] = [
         {
             "key": "lookup_value_p",
@@ -38,12 +45,122 @@ def main() -> None:
         {
             "key": "lookup_value_c",
             "value": "B01"
+        },
+    ]
+    result = find_in_array_from_list(data, search)
+    print(f"Search B: {dump_data(search)} -> {dump_data(result)}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "A01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": "B01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": "B02"
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search C: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search C raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "A01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": ["B01", "B02"]
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search D: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search D raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": ["A01", "A03"]
+        },
+        {
+            "key": "lookup_value_c",
+            "value": ["B01", "B02"]
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search E: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search E raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "NOT FOUND"
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search F: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search F raised KeyError: {e}")
+
+    data = [
+        {
+            "sd_user_id": "1593",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1592",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1596",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1594",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1595",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1861",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1862",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1860",
+            "email": "",
+            "employee_id": ""
         }
     ]
-
-    result = find_in_array_from_list(data, search)
-
-    print(f"Search {dump_data(search)} -> {dump_data(result)}")
+    result = find_in_array_from_list(data, [ArraySearchList(
+        key="sd_user_id",
+        value="1593"
+    )])
+    print(f"Search F: -> {dump_data(result)}")
 
 
 if __name__ == "__main__":

test-run/iterator_handling/dict_helpers.py

@@ -3,8 +3,9 @@ Iterator helper testing
 """
 
 from typing import Any
-from corelibs.debug_handling.dump_data import dump_data
-from corelibs.iterator_handling.dict_helpers import mask, set_entry
+from corelibs_dump_data.dump_data import dump_data
+from corelibs.iterator_handling.dict_mask import mask
+from corelibs.iterator_handling.dict_helpers import set_entry
 
 
 def __mask():

test-run/iterator_handling/list_helpers.py

@@ -2,7 +2,10 @@
 test list helpers
 """
 
-from corelibs.iterator_handling.list_helpers import is_list_in_list, convert_to_list
+from typing import Any
+from corelibs_dump_data.dump_data import dump_data
+from corelibs.iterator_handling.list_helpers import is_list_in_list, convert_to_list, make_unique_list_of_dicts
+from corelibs.iterator_handling.fingerprint import dict_hash_crc
 
 
 def __test_is_list_in_list_a():
@@ -18,9 +21,66 @@ def __convert_list():
     print(f"IN: {source} -> {result}")
 
 
+def __make_unique_list_of_dicts():
+    dict_list = [
+        {"a": 1, "b": 2, "nested": {"x": 10, "y": 20}},
+        {"a": 1, "b": 2, "nested": {"x": 10, "y": 20}},
+        {"b": 2, "a": 1, "nested": {"y": 20, "x": 10}},
+        {"b": 2, "a": 1, "nested": {"y": 20, "x": 30}},
+        {"a": 3, "b": 4, "nested": {"x": 30, "y": 40}}
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list = [
+        {"a": 1, 1: "one"},
+        {1: "one", "a": 1},
+        {"a": 2, 1: "one"}
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list = [
+        {"a": 1, "b": [1, 2, 3]},
+        {"b": [1, 2, 3], "a": 1},
+        {"a": 1, "b": [1, 2, 4]},
+        1, 2, "String", 1, "Foobar"
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list: list[Any] = [
+        [],
+        {},
+        [],
+        {},
+        {"a": []},
+        {"a": []},
+        {"a": {}},
+        {"a": {}},
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list: list[Any] = [
+        (1, 2),
+        (1, 2),
+        (2, 3),
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+
 def main():
+    """List helpers test runner"""
     __test_is_list_in_list_a()
     __convert_list()
+    __make_unique_list_of_dicts()
 
 
 if __name__ == "__main__":

test-run/json_handling/jmespath_helper.py

@@ -4,7 +4,7 @@
 jmes path testing
 """
 
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.json_handling.jmespath_helper import jmespath_search
 
 

test-run/json_handling/json_replace.py

@@ -5,7 +5,7 @@ JSON content replace tets
 """
 
 from deepdiff import DeepDiff
-from corelibs.debug_handling.dump_data import dump_data
+from corelibs_dump_data.dump_data import dump_data
 from corelibs.json_handling.json_helper import modify_with_jsonpath
 
 

test-run/logging_handling/log.py

@@ -6,8 +6,8 @@ Log logging_handling.log testing
 import sys
 from pathlib import Path
 # this is for testing only
-from corelibs.logging_handling.log import Log, Logger
-from corelibs.debug_handling.debug_helpers import exception_stack, call_stack
+from corelibs_stack_trace.stack import exception_stack, call_stack
+from corelibs.logging_handling.log import Log, Logger, ConsoleFormat, ConsoleFormatSettings
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
 
@@ -24,11 +24,23 @@ def main():
             # "log_level_console": None,
             "log_level_file": 'DEBUG',
             # "console_color_output_enabled": False,
-            "per_run_log": True
+            "per_run_log": True,
+            # "console_format_type": ConsoleFormatSettings.NONE,
+            # "console_format_type": ConsoleFormatSettings.MINIMAL,
+            # "console_format_type": ConsoleFormat.TIME_MICROSECONDS | ConsoleFormat.NAME | ConsoleFormat.LEVEL,
+            "console_format_type": None,
+            # "console_format_type": ConsoleFormat.NAME,
+            # "console_format_type": (
+            #     ConsoleFormat.TIME | ConsoleFormat.TIMEZONE | ConsoleFormat.LINENO | ConsoleFormat.LEVEL
+            # ),
         }
     )
     logn = Logger(log.get_logger_settings())
 
+    log.info("ConsoleFormatType FILE is: %s", ConsoleFormat.FILE)
+    log.info("ConsoleFormatSettings ALL is: %s", ConsoleFormatSettings.ALL)
+    log.info("ConsoleFormatSettings lookup is: %s", ConsoleFormatSettings.from_string('ALL'))
+
     log.logger.debug('[NORMAL] Debug test: %s', log.logger.name)
     log.lg.debug('[NORMAL] Debug test: %s', log.logger.name)
     log.debug('[NORMAL-] Debug test: %s', log.logger.name)
@@ -94,10 +106,34 @@ def main():
 
     for key, handler in log.handlers.items():
         print(f"Handler (handlers) [{key}] {handler} -> {handler.level} -> {LoggingLevel.from_any(handler.level)}")
-    log.set_log_level('stream_handler', LoggingLevel.ERROR)
+    log.set_log_level(Log.CONSOLE_HANDLER, LoggingLevel.ERROR)
     log.logger.warning('[NORMAL] Invisible Warning test: %s', log.logger.name)
     log.logger.error('[NORMAL] Visible Error test: %s', log.logger.name)
-    # log.handlers['stream_handler'].se
+    log.logger.debug('[NORMAL] Visible Debug test: %s', log.logger.name)
+    print(f"*** Any handler is minimum level ERROR: {log.any_handler_is_minimum_level(LoggingLevel.ERROR)}")
+    print(f"*** Any handler is minimum level DEBUG: {log.any_handler_is_minimum_level(LoggingLevel.DEBUG)}")
+    for handler in log.handlers.values():
+        print(
+            f"*** Setting handler {handler} is level {LoggingLevel.from_any(handler.level).name} -> "
+            f"*** INC {LoggingLevel.from_any(handler.level).includes(LoggingLevel.DEBUG)}")
+
+    print(f"*** WARNING includes ERROR: {LoggingLevel.WARNING.includes(LoggingLevel.ERROR)}")
+    print(f"*** ERROR includes WARNING: {LoggingLevel.ERROR.includes(LoggingLevel.WARNING)}")
+
+    log.set_log_level(Log.CONSOLE_HANDLER, LoggingLevel.DEBUG)
+    log.debug('Current logging format: %s', log.log_settings['console_format_type'])
+    log.debug('Current console formatter: %s', log.get_console_formatter())
+    log.update_console_formatter(ConsoleFormat.TIME | ConsoleFormat.LINENO)
+    log.info('Does hit show less A')
+    log.debug('Current console formatter after A: %s', log.get_console_formatter())
+    log.update_console_formatter(ConsoleFormat.TIME | ConsoleFormat.LINENO)
+    log.info('Does hit show less B')
+    log.debug('Current console formatter after B: %s', log.get_console_formatter())
+    log.update_console_formatter(ConsoleFormatSettings.ALL)
+    log.info('Does hit show less C')
+    log.debug('Current console formatter after C: %s', log.get_console_formatter())
+    print(f"*** Any handler is minimum level ERROR: {log.any_handler_is_minimum_level(LoggingLevel.ERROR)}")
+    print(f"*** Any handler is minimum level DEBUG: {log.any_handler_is_minimum_level(LoggingLevel.DEBUG)}")
 
 
 if __name__ == "__main__":

test-run/progress/progress_test.py

@@ -9,7 +9,7 @@ from random import randint
 import sys
 import io
 from pathlib import Path
-from corelibs.file_handling.progress import Progress
+from corelibs.script_handling.progress import Progress
 from corelibs.datetime_handling.datetime_helpers import create_time
 from corelibs.datetime_handling.timestamp_convert import convert_timestamp
 
@@ -37,8 +37,8 @@ def main():
     # prg.SetStartTime(time.time())
     prg.set_start_time()
     print(
-        f"PRECISION: {prg.precision} | TEN STEP: {prg.precision_ten_step} | "
-        f"WIDE TEME: {prg.wide_time} | MICROTIME: {prg.microtime} | VERBOSE: {prg.verbose}"
+        f"PRECISION: {prg.__precision} | TEN STEP: {prg.precision_ten_step} | "
+        f"WIDE TEME: {prg.__wide_time} | MICROTIME: {prg.microtime} | VERBOSE: {prg.verbose}"
     )
 
     if use_file:
@@ -56,7 +56,7 @@ def main():
             print(
                 f"Buffer size: {io.DEFAULT_BUFFER_SIZE} | "
                 f"Do Buffering: {fh.line_buffering} | "
-                f"File size: {prg.filesize}"
+                f"File size: {prg.__filesize}"
             )
             data = fh.readline()
             while data:
@@ -72,7 +72,7 @@ def main():
         print(f"Starting: {create_time(prg.start if prg.start is not None else 0)}")
         prg.set_linecount(256)
         i = 1
-        while i <= prg.linecount:
+        while i <= prg.__linecount:
             sleep = randint(1, 9)
             sleep /= 7
             time.sleep(sleep)

test-run/requests_handling/caller.py

@@ -0,0 +1,38 @@
+"""
+Caller tests
+"""
+
+from corelibs_dump_data.dump_data import dump_data
+from corelibs.requests_handling.caller import Caller, ErrorResponse
+from corelibs.requests_handling.auth_helpers import basic_auth
+
+
+def test_basic_auth():
+    """basic auth test"""
+    user = "user"
+    password = "pass"
+    auth_header = basic_auth(user, password)
+    print(f"Auth Header for '{user}' & '{password}': {auth_header}")
+
+
+def test_caller():
+    """Caller tests"""
+    caller = Caller()
+    response = caller.get("https://httpbin.org/get")
+    if isinstance(response, ErrorResponse):
+        print(f"Error: {response.message}")
+    else:
+        print(f"Response Status Code: {response.status_code}")
+        print(f"Response Content: {dump_data(response.json())}")
+
+
+def main():
+    """main"""
+    test_caller()
+    test_basic_auth()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

tests/unit/config_handling/test_settings_loader.py

@@ -0,0 +1,881 @@
+"""
+Unit tests for SettingsLoader class
+"""
+
+import configparser
+from pathlib import Path
+from unittest.mock import Mock
+import pytest
+from pytest import CaptureFixture
+from corelibs.config_handling.settings_loader import SettingsLoader
+from corelibs.logging_handling.log import Log
+
+
+class TestSettingsLoaderInit:
+    """Test cases for SettingsLoader initialization"""
+
+    def test_init_with_valid_config_file(self, tmp_path: Path):
+        """Test initialization with a valid config file"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[Section]\nkey=value\n")
+
+        loader = SettingsLoader(
+            args={},
+            config_file=config_file,
+            log=None,
+            always_print=False
+        )
+
+        assert loader.args == {}
+        assert loader.config_file == config_file
+        assert loader.log is None
+        assert loader.always_print is False
+        assert loader.config_parser is not None
+        assert isinstance(loader.config_parser, configparser.ConfigParser)
+
+    def test_init_with_missing_config_file(self, tmp_path: Path):
+        """Test initialization with missing config file"""
+        config_file = tmp_path.joinpath("missing.ini")
+
+        loader = SettingsLoader(
+            args={},
+            config_file=config_file,
+            log=None,
+            always_print=False
+        )
+
+        assert loader.config_parser is None
+
+    def test_init_with_invalid_config_folder(self):
+        """Test initialization with invalid config folder path"""
+        config_file = Path("/nonexistent/path/test.ini")
+
+        with pytest.raises(ValueError, match="Cannot find the config folder"):
+            SettingsLoader(
+                args={},
+                config_file=config_file,
+                log=None,
+                always_print=False
+            )
+
+    def test_init_with_log(self, tmp_path: Path):
+        """Test initialization with Log object"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[Section]\nkey=value\n")
+        mock_log = Mock(spec=Log)
+
+        loader = SettingsLoader(
+            args={"test": "value"},
+            config_file=config_file,
+            log=mock_log,
+            always_print=True
+        )
+
+        assert loader.log == mock_log
+        assert loader.always_print is True
+
+
+class TestLoadSettings:
+    """Test cases for load_settings method"""
+
+    def test_load_settings_basic(self, tmp_path: Path):
+        """Test loading basic settings without validation"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nkey1=value1\nkey2=value2\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings("TestSection")
+
+        assert result == {"key1": "value1", "key2": "value2"}
+
+    def test_load_settings_with_missing_section(self, tmp_path: Path):
+        """Test loading settings with missing section"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[OtherSection]\nkey=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Cannot read \\[MissingSection\\]"):
+            loader.load_settings("MissingSection")
+
+    def test_load_settings_allow_not_exist(self, tmp_path: Path):
+        """Test loading settings with allow_not_exist flag"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[OtherSection]\nkey=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings("MissingSection", allow_not_exist=True)
+
+        assert result == {}
+
+    def test_load_settings_mandatory_field_present(self, tmp_path: Path):
+        """Test mandatory field validation when field is present"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nrequired_field=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"required_field": ["mandatory:yes"]}
+        )
+
+        assert result["required_field"] == "value"
+
+    def test_load_settings_mandatory_field_missing(self, tmp_path: Path):
+        """Test mandatory field validation when field is missing"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nother_field=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"required_field": ["mandatory:yes"]}
+            )
+
+    def test_load_settings_mandatory_field_empty(self, tmp_path: Path):
+        """Test mandatory field validation when field is empty"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nrequired_field=\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"required_field": ["mandatory:yes"]}
+            )
+
+    def test_load_settings_with_split(self, tmp_path: Path):
+        """Test splitting values into lists"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=a,b,c,d\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:,"]}
+        )
+
+        assert result["list_field"] == ["a", "b", "c", "d"]
+
+    def test_load_settings_with_custom_split_char(self, tmp_path: Path):
+        """Test splitting with custom delimiter"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=a|b|c|d\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:|"]}
+        )
+
+        assert result["list_field"] == ["a", "b", "c", "d"]
+
+    def test_load_settings_split_removes_spaces(self, tmp_path: Path):
+        """Test that split removes spaces from values"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=a, b , c , d\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:,"]}
+        )
+
+        assert result["list_field"] == ["a", "b", "c", "d"]
+
+    def test_load_settings_empty_split_char_fallback(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test fallback to default split char when empty"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=a,b,c\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:"]}
+        )
+
+        assert result["list_field"] == ["a", "b", "c"]
+        captured = capsys.readouterr()
+        assert "fallback to:" in captured.out
+
+    def test_load_settings_split_empty_value(self, tmp_path: Path):
+        """Test that split on empty value results in empty list"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:,"]}
+        )
+
+        assert result["list_field"] == []
+
+    def test_load_settings_convert_to_int(self, tmp_path: Path):
+        """Test converting values to int"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=123\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"number": ["convert:int"]}
+        )
+
+        assert result["number"] == 123
+        assert isinstance(result["number"], int)
+
+    def test_load_settings_convert_to_float(self, tmp_path: Path):
+        """Test converting values to float"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=123.45\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"number": ["convert:float"]}
+        )
+
+        assert result["number"] == 123.45
+        assert isinstance(result["number"], float)
+
+    def test_load_settings_convert_to_bool_true(self, tmp_path: Path):
+        """Test converting values to boolean True"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nflag1=true\nflag2=True\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"flag1": ["convert:bool"], "flag2": ["convert:bool"]}
+        )
+
+        assert result["flag1"] is True
+        assert result["flag2"] is True
+
+    def test_load_settings_convert_to_bool_false(self, tmp_path: Path):
+        """Test converting values to boolean False"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nflag1=false\nflag2=False\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"flag1": ["convert:bool"], "flag2": ["convert:bool"]}
+        )
+
+        assert result["flag1"] is False
+        assert result["flag2"] is False
+
+    def test_load_settings_convert_invalid_type(self, tmp_path: Path):
+        """Test converting with invalid type raises error"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=test\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="convert type is invalid"):
+            loader.load_settings(
+                "TestSection",
+                {"value": ["convert:invalid"]}
+            )
+
+    def test_load_settings_empty_set_to_none(self, tmp_path: Path):
+        """Test setting empty values to None"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nother=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"field": ["empty:"]}
+        )
+
+        assert result["field"] is None
+
+    def test_load_settings_empty_set_to_custom_value(self, tmp_path: Path):
+        """Test setting empty values to custom value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nother=value\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"field": ["empty:default"]}
+        )
+
+        assert result["field"] == "default"
+
+    def test_load_settings_matching_valid(self, tmp_path: Path):
+        """Test matching validation with valid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nmode=production\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"mode": ["matching:development|staging|production"]}
+        )
+
+        assert result["mode"] == "production"
+
+    def test_load_settings_matching_invalid(self, tmp_path: Path):
+        """Test matching validation with invalid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nmode=invalid\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"mode": ["matching:development|staging|production"]}
+            )
+
+    def test_load_settings_in_valid(self, tmp_path: Path):
+        """Test 'in' validation with valid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nallowed=a,b,c\nvalue=b\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {
+                "allowed": ["split:,"],
+                "value": ["in:allowed"]
+            }
+        )
+
+        assert result["value"] == "b"
+
+    def test_load_settings_in_invalid(self, tmp_path: Path):
+        """Test 'in' validation with invalid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nallowed=a,b,c\nvalue=d\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {
+                    "allowed": ["split:,"],
+                    "value": ["in:allowed"]
+                }
+            )
+
+    def test_load_settings_in_missing_target(self, tmp_path: Path):
+        """Test 'in' validation with missing target"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=a\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"value": ["in:missing_target"]}
+            )
+
+    def test_load_settings_length_exact(self, tmp_path: Path):
+        """Test length validation with exact match"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=test\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["length:4"]}
+        )
+
+        assert result["value"] == "test"
+
+    def test_load_settings_length_exact_invalid(self, tmp_path: Path):
+        """Test length validation with exact match failure"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=test\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"value": ["length:5"]}
+            )
+
+    def test_load_settings_length_range(self, tmp_path: Path):
+        """Test length validation with range"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=testing\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["length:5-10"]}
+        )
+
+        assert result["value"] == "testing"
+
+    def test_load_settings_length_min_only(self, tmp_path: Path):
+        """Test length validation with minimum only"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=testing\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["length:5-"]}
+        )
+
+        assert result["value"] == "testing"
+
+    def test_load_settings_length_max_only(self, tmp_path: Path):
+        """Test length validation with maximum only"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=test\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["length:-10"]}
+        )
+
+        assert result["value"] == "test"
+
+    def test_load_settings_range_valid(self, tmp_path: Path):
+        """Test range validation with valid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=25\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"number": ["range:10-50"]}
+        )
+
+        assert result["number"] == "25"
+
+    def test_load_settings_range_invalid(self, tmp_path: Path):
+        """Test range validation with invalid value"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=100\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"number": ["range:10-50"]}
+            )
+
+    def test_load_settings_check_int_valid(self, tmp_path: Path):
+        """Test check:int with valid integer"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=12345\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"number": ["check:int"]}
+        )
+
+        assert result["number"] == "12345"
+
+    def test_load_settings_check_int_cleanup(self, tmp_path: Path):
+        """Test check:int with cleanup"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nnumber=12a34b5\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"number": ["check:int"]}
+        )
+
+        assert result["number"] == "12345"
+
+    def test_load_settings_check_email_valid(self, tmp_path: Path):
+        """Test check:string.email.basic with valid email"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nemail=test@example.com\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"email": ["check:string.email.basic"]}
+        )
+
+        assert result["email"] == "test@example.com"
+
+    def test_load_settings_check_email_invalid(self, tmp_path: Path):
+        """Test check:string.email.basic with invalid email"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nemail=not-an-email\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Missing or incorrect settings data"):
+            loader.load_settings(
+                "TestSection",
+                {"email": ["check:string.email.basic"]}
+            )
+
+    def test_load_settings_args_override(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test command line arguments override config values"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=config_value\n")
+
+        loader = SettingsLoader(
+            args={"value": "arg_value"},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": []}
+        )
+
+        assert result["value"] == "arg_value"
+        captured = capsys.readouterr()
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_no_flag(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test default behavior (no args_override:yes) with list argument that has split"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=a,b,c\n")
+
+        loader = SettingsLoader(
+            args={"value": ["x", "y", "z"]},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["split:,"]}
+        )
+
+        # Without args_override:yes flag, should use config value (no override)
+        assert result["value"] == ["a", "b", "c"]
+        captured = capsys.readouterr()
+        # Message is printed but without args_override:yes flag, override doesn't happen
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_list_no_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test that list arguments without split entry are skipped"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=config_value\n")
+
+        loader = SettingsLoader(
+            args={"value": ["arg1", "arg2", "arg3"]},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": []}
+        )
+
+        # Should keep config value since args is list but no split defined
+        assert result["value"] == "config_value"
+        captured = capsys.readouterr()
+        # Message is printed but list without split prevents the override
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_list_with_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test that list arguments with split entry and args_override:yes are applied"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=a,b,c\n")
+
+        loader = SettingsLoader(
+            args={"value": ["arg1", "arg2", "arg3"]},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["split:,", "args_override:yes"]}
+        )
+
+        # Should use args value because split is defined AND args_override:yes is set
+        assert result["value"] == ["arg1", "arg2", "arg3"]
+        captured = capsys.readouterr()
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_no_with_mandatory(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test default behavior (no args_override:yes) with mandatory field and list args with split"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=config1,config2\n")
+
+        loader = SettingsLoader(
+            args={"value": ["arg1", "arg2"]},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["mandatory:yes", "split:,"]}
+        )
+
+        # Should use config value because args_override:yes is not set (default: no override)
+        assert result["value"] == ["config1", "config2"]
+        captured = capsys.readouterr()
+        # Message is printed but without args_override:yes flag, override doesn't happen
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_no_with_mandatory_valid(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test default behavior with string args (always overrides due to current logic)"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=config_value\n")
+
+        loader = SettingsLoader(
+            args={"value": "arg_value"},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["mandatory:yes"]}
+        )
+
+        # Current behavior: string args without split always override (regardless of args_override:yes)
+        assert result["value"] == "arg_value"
+        captured = capsys.readouterr()
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_args_string_no_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test that string arguments with args_override:yes work normally"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=config_value\n")
+
+        loader = SettingsLoader(
+            args={"value": "arg_value"},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"value": ["args_override:yes"]}
+        )
+
+        # Should use args value for non-list args with args_override:yes
+        assert result["value"] == "arg_value"
+        captured = capsys.readouterr()
+        assert "Command line option override" in captured.out
+
+    def test_load_settings_no_config_file_with_args(self, tmp_path: Path):
+        """Test loading settings without config file but with mandatory args"""
+        config_file = tmp_path.joinpath("missing.ini")
+
+        loader = SettingsLoader(
+            args={"required": "value"},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "TestSection",
+            {"required": ["mandatory:yes"]}
+        )
+
+        assert result["required"] == "value"
+
+    def test_load_settings_no_config_file_missing_args(self, tmp_path: Path):
+        """Test loading settings without config file and missing args"""
+        config_file = tmp_path.joinpath("missing.ini")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Cannot find file"):
+            loader.load_settings(
+                "TestSection",
+                {"required": ["mandatory:yes"]}
+            )
+
+    def test_load_settings_check_list_with_split(self, tmp_path: Path):
+        """Test check validation with list values"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist=abc,def,ghi\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list": ["split:,", "check:string.alphanumeric"]}
+        )
+
+        assert result["list"] == ["abc", "def", "ghi"]
+
+    def test_load_settings_check_list_cleanup(self, tmp_path: Path):
+        """Test check validation cleans up list values"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist=ab-c,de_f,gh!i\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list": ["split:,", "check:string.alphanumeric"]}
+        )
+
+        assert result["list"] == ["abc", "def", "ghi"]
+
+    def test_load_settings_invalid_check_type(self, tmp_path: Path):
+        """Test with invalid check type"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nvalue=test\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+
+        with pytest.raises(ValueError, match="Cannot get SettingsLoaderCheck.CHECK_SETTINGS"):
+            loader.load_settings(
+                "TestSection",
+                {"value": ["check:invalid.check.type"]}
+            )
+
+
+class TestComplexScenarios:
+    """Test cases for complex real-world scenarios"""
+
+    def test_complex_validation_scenario(self, tmp_path: Path):
+        """Test complex scenario with multiple validations"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text(
+            "[Production]\n"
+            "environment=production\n"
+            "allowed_envs=development,staging,production\n"
+            "port=8080\n"
+            "host=example.com\n"
+            "timeout=30\n"
+            "debug=false\n"
+            "features=auth,logging,monitoring\n"
+        )
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "Production",
+            {
+                "environment": [
+                    "mandatory:yes",
+                    "matching:development|staging|production",
+                    "in:allowed_envs"
+                ],
+                "allowed_envs": ["split:,"],
+                "port": ["mandatory:yes", "convert:int", "range:1-65535"],
+                "host": ["mandatory:yes"],
+                "timeout": ["convert:int", "range:1-"],
+                "debug": ["convert:bool"],
+                "features": ["split:,", "check:string.alphanumeric"],
+            }
+        )
+
+        assert result["environment"] == "production"
+        assert result["allowed_envs"] == ["development", "staging", "production"]
+        assert result["port"] == 8080
+        assert isinstance(result["port"], int)
+        assert result["host"] == "example.com"
+        assert result["timeout"] == 30
+        assert result["debug"] is False
+        assert result["features"] == ["auth", "logging", "monitoring"]
+
+    def test_email_list_validation(self, tmp_path: Path):
+        """Test email list with validation"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text(
+            "[EmailConfig]\n"
+            "emails=test@example.com,admin@domain.org,user+tag@site.co.uk\n"
+        )
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "EmailConfig",
+            {"emails": ["split:,", "mandatory:yes", "check:string.email.basic"]}
+        )
+
+        assert len(result["emails"]) == 3
+        assert "test@example.com" in result["emails"]
+
+    def test_mixed_args_and_config(self, tmp_path: Path):
+        """Test mixing command line args and config file"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text(
+            "[Settings]\n"
+            "value1=config_value1\n"
+            "value2=config_value2\n"
+        )
+
+        loader = SettingsLoader(
+            args={"value1": "arg_value1"},
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "Settings",
+            {"value1": [], "value2": []}
+        )
+
+        assert result["value1"] == "arg_value1"  # Overridden by arg
+        assert result["value2"] == "config_value2"  # From config
+
+    def test_multiple_check_types(self, tmp_path: Path):
+        """Test multiple different check types"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text(
+            "[Checks]\n"
+            "numbers=123,456,789\n"
+            "alphas=abc,def,ghi\n"
+            "emails=test@example.com\n"
+            "date=2025-01-15\n"
+        )
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "Checks",
+            {
+                "numbers": ["split:,", "check:int"],
+                "alphas": ["split:,", "check:string.alphanumeric"],
+                "emails": ["check:string.email.basic"],
+                "date": ["check:string.date"],
+            }
+        )
+
+        assert result["numbers"] == ["123", "456", "789"]
+        assert result["alphas"] == ["abc", "def", "ghi"]
+        assert result["emails"] == "test@example.com"
+        assert result["date"] == "2025-01-15"
+
+    def test_args_no_and_list_skip_combination(self, tmp_path: Path, capsys: CaptureFixture[str]):
+        """Test combination of args_override:yes flag and list argument skip behavior"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text(
+            "[Settings]\n"
+            "no_override=a,b,c\n"
+            "list_no_split=config_list\n"
+            "list_with_split=x,y,z\n"
+            "normal=config_normal\n"
+        )
+
+        loader = SettingsLoader(
+            args={
+                "no_override": ["arg1", "arg2"],
+                "list_no_split": ["arg1", "arg2"],
+                "list_with_split": ["p", "q", "r"],
+                "normal": "arg_normal"
+            },
+            config_file=config_file
+        )
+        result = loader.load_settings(
+            "Settings",
+            {
+                "no_override": ["split:,"],
+                "list_no_split": [],
+                "list_with_split": ["split:,", "args_override:yes"],
+                "normal": ["args_override:yes"]
+            }
+        )
+
+        # Should use config value (no args_override:yes flag for list with split)
+        assert result["no_override"] == ["a", "b", "c"]
+        # Should use config value because args is list without split
+        assert result["list_no_split"] == "config_list"
+        # Should use args value because split is defined AND args_override:yes is set
+        assert result["list_with_split"] == ["p", "q", "r"]
+        # Should use args value (args_override:yes set for string arg)
+        assert result["normal"] == "arg_normal"
+
+        captured = capsys.readouterr()
+        # Should see override messages (even though list_no_split prints, it doesn't apply)
+        assert "Command line option override" in captured.out
+
+
+# __END__

tests/unit/datetime_handling/__init__.py

@@ -1,3 +0,0 @@
-"""
-Unit tests for encryption_handling module
-"""

tests/unit/datetime_handling/test_convert_to_seconds.py

@@ -1,205 +0,0 @@
-"""
-Unit tests for convert_to_seconds function from timestamp_strings module.
-"""
-
-import pytest
-from corelibs.datetime_handling.timestamp_convert import convert_to_seconds, TimeParseError, TimeUnitError
-
-
-class TestConvertToSeconds:
-    """Test class for convert_to_seconds function."""
-
-    def test_numeric_input_int(self):
-        """Test with integer input."""
-        assert convert_to_seconds(42) == 42
-        assert convert_to_seconds(0) == 0
-        assert convert_to_seconds(-5) == -5
-
-    def test_numeric_input_float(self):
-        """Test with float input."""
-        assert convert_to_seconds(42.7) == 43  # rounds to 43
-        assert convert_to_seconds(42.3) == 42  # rounds to 42
-        assert convert_to_seconds(42.5) == 42  # rounds to 42 (banker's rounding)
-        assert convert_to_seconds(0.0) == 0
-        assert convert_to_seconds(-5.7) == -6
-
-    def test_numeric_string_input(self):
-        """Test with numeric string input."""
-        assert convert_to_seconds("42") == 42
-        assert convert_to_seconds("42.7") == 43
-        assert convert_to_seconds("42.3") == 42
-        assert convert_to_seconds("0") == 0
-        assert convert_to_seconds("-5.7") == -6
-
-    def test_single_unit_seconds(self):
-        """Test with seconds unit."""
-        assert convert_to_seconds("30s") == 30
-        assert convert_to_seconds("1s") == 1
-        assert convert_to_seconds("0s") == 0
-
-    def test_single_unit_minutes(self):
-        """Test with minutes unit."""
-        assert convert_to_seconds("5m") == 300  # 5 * 60
-        assert convert_to_seconds("1m") == 60
-        assert convert_to_seconds("0m") == 0
-
-    def test_single_unit_hours(self):
-        """Test with hours unit."""
-        assert convert_to_seconds("2h") == 7200  # 2 * 3600
-        assert convert_to_seconds("1h") == 3600
-        assert convert_to_seconds("0h") == 0
-
-    def test_single_unit_days(self):
-        """Test with days unit."""
-        assert convert_to_seconds("1d") == 86400  # 1 * 86400
-        assert convert_to_seconds("2d") == 172800  # 2 * 86400
-        assert convert_to_seconds("0d") == 0
-
-    def test_single_unit_months(self):
-        """Test with months unit (30 days * 12 = 1 year)."""
-        # Note: The code has M: 2592000 * 12 which is 1 year, not 1 month
-        # This seems like a bug in the original code, but testing what it actually does
-        assert convert_to_seconds("1M") == 31104000  # 2592000 * 12
-        assert convert_to_seconds("2M") == 62208000  # 2 * 2592000 * 12
-
-    def test_single_unit_years(self):
-        """Test with years unit."""
-        assert convert_to_seconds("1Y") == 31536000  # 365 * 86400
-        assert convert_to_seconds("2Y") == 63072000  # 2 * 365 * 86400
-
-    def test_long_unit_names(self):
-        """Test with long unit names."""
-        assert convert_to_seconds("1year") == 31536000
-        assert convert_to_seconds("2years") == 63072000
-        assert convert_to_seconds("1month") == 31104000
-        assert convert_to_seconds("2months") == 62208000
-        assert convert_to_seconds("1day") == 86400
-        assert convert_to_seconds("2days") == 172800
-        assert convert_to_seconds("1hour") == 3600
-        assert convert_to_seconds("2hours") == 7200
-        assert convert_to_seconds("1minute") == 60
-        assert convert_to_seconds("2minutes") == 120
-        assert convert_to_seconds("30min") == 1800
-        assert convert_to_seconds("1second") == 1
-        assert convert_to_seconds("2seconds") == 2
-        assert convert_to_seconds("30sec") == 30
-
-    def test_multiple_units(self):
-        """Test with multiple units combined."""
-        assert convert_to_seconds("1h30m") == 5400  # 3600 + 1800
-        assert convert_to_seconds("1d2h") == 93600  # 86400 + 7200
-        assert convert_to_seconds("1h30m45s") == 5445  # 3600 + 1800 + 45
-        assert convert_to_seconds("2d3h4m5s") == 183845  # 172800 + 10800 + 240 + 5
-
-    def test_multiple_units_with_spaces(self):
-        """Test with multiple units and spaces."""
-        assert convert_to_seconds("1h 30m") == 5400
-        assert convert_to_seconds("1d 2h") == 93600
-        assert convert_to_seconds("1h 30m 45s") == 5445
-        assert convert_to_seconds("2d 3h 4m 5s") == 183845
-
-    def test_mixed_unit_formats(self):
-        """Test with mixed short and long unit names."""
-        assert convert_to_seconds("1hour 30min") == 5400
-        assert convert_to_seconds("1day 2hours") == 93600
-        assert convert_to_seconds("1h 30minutes 45sec") == 5445
-
-    def test_negative_values(self):
-        """Test with negative time strings."""
-        assert convert_to_seconds("-30s") == -30
-        assert convert_to_seconds("-1h") == -3600
-        assert convert_to_seconds("-1h30m") == -5400
-        assert convert_to_seconds("-2d3h4m5s") == -183845
-
-    def test_case_insensitive_long_names(self):
-        """Test that long unit names are case insensitive."""
-        assert convert_to_seconds("1Hour") == 3600
-        assert convert_to_seconds("1MINUTE") == 60
-        assert convert_to_seconds("1Day") == 86400
-        assert convert_to_seconds("2YEARS") == 63072000
-
-    def test_duplicate_units_error(self):
-        """Test that duplicate units raise TimeParseError."""
-        with pytest.raises(TimeParseError, match="Unit 'h' appears more than once"):
-            convert_to_seconds("1h2h")
-
-        with pytest.raises(TimeParseError, match="Unit 's' appears more than once"):
-            convert_to_seconds("30s45s")
-
-        with pytest.raises(TimeParseError, match="Unit 'm' appears more than once"):
-            convert_to_seconds("1m30m")
-
-    def test_invalid_units_error(self):
-        """Test that invalid units raise TimeUnitError."""
-        with pytest.raises(TimeUnitError, match="Unit 'x' is not a valid unit name"):
-            convert_to_seconds("30x")
-
-        with pytest.raises(TimeUnitError, match="Unit 'invalid' is not a valid unit name"):
-            convert_to_seconds("1invalid")
-
-        with pytest.raises(TimeUnitError, match="Unit 'z' is not a valid unit name"):
-            convert_to_seconds("1h30z")
-
-    def test_empty_string(self):
-        """Test with empty string."""
-        assert convert_to_seconds("") == 0
-
-    def test_no_matches(self):
-        """Test with string that has no time units."""
-        assert convert_to_seconds("hello") == 0
-        assert convert_to_seconds("no time here") == 0
-
-    def test_zero_values(self):
-        """Test with zero values for different units."""
-        assert convert_to_seconds("0s") == 0
-        assert convert_to_seconds("0m") == 0
-        assert convert_to_seconds("0h") == 0
-        assert convert_to_seconds("0d") == 0
-        assert convert_to_seconds("0h0m0s") == 0
-
-    def test_large_values(self):
-        """Test with large time values."""
-        assert convert_to_seconds("999d") == 86313600  # 999 * 86400
-        assert convert_to_seconds("100Y") == 3153600000  # 100 * 31536000
-
-    def test_order_independence(self):
-        """Test that order of units doesn't matter."""
-        assert convert_to_seconds("30m1h") == 5400  # same as 1h30m
-        assert convert_to_seconds("45s30m1h") == 5445  # same as 1h30m45s
-        assert convert_to_seconds("5s4m3h2d") == 183845  # same as 2d3h4m5s
-
-    def test_whitespace_handling(self):
-        """Test various whitespace scenarios."""
-        assert convert_to_seconds("1 h") == 3600
-        assert convert_to_seconds("1h  30m") == 5400
-        assert convert_to_seconds("  1h30m  ") == 5400
-        assert convert_to_seconds("1h\t30m") == 5400
-
-    def test_mixed_case_short_units(self):
-        """Test that short units work with different cases."""
-        # Note: The regex only matches [a-zA-Z]+ so case matters for the lookup
-        with pytest.raises(TimeUnitError, match="Unit 'H' is not a valid unit name"):
-            convert_to_seconds("1H")  # 'H' is not in unit_factors, raises error
-        assert convert_to_seconds("1h") == 3600  # lowercase works
-
-    def test_boundary_conditions(self):
-        """Test boundary conditions and edge cases."""
-        # Test with leading zeros
-        assert convert_to_seconds("01h") == 3600
-        assert convert_to_seconds("001m") == 60
-
-        # Test very small values
-        assert convert_to_seconds("1s") == 1
-
-    def test_negative_with_multiple_units(self):
-        """Test negative values with multiple units."""
-        assert convert_to_seconds("-1h30m45s") == -5445
-        assert convert_to_seconds("-2d3h") == -183600
-
-    def test_duplicate_with_long_names(self):
-        """Test duplicate detection with long unit names."""
-        with pytest.raises(TimeParseError, match="Unit 'h' appears more than once"):
-            convert_to_seconds("1hour2h")  # both resolve to 'h'
-
-        with pytest.raises(TimeParseError, match="Unit 's' appears more than once"):
-            convert_to_seconds("1second30sec")  # both resolve to 's'

tests/unit/datetime_handling/test_datetime_helpers.py

@@ -1,690 +0,0 @@
-"""
-PyTest: datetime_handling/datetime_helpers
-"""
-
-from datetime import datetime, time
-from zoneinfo import ZoneInfo
-import pytest
-
-from corelibs.datetime_handling.datetime_helpers import (
-    create_time,
-    get_system_timezone,
-    parse_timezone_data,
-    get_datetime_iso8601,
-    validate_date,
-    parse_flexible_date,
-    compare_dates,
-    find_newest_datetime_in_list,
-    parse_day_of_week_range,
-    parse_time_range,
-    times_overlap_or_connect,
-    is_time_in_range,
-    reorder_weekdays_from_today,
-    DAYS_OF_WEEK_LONG_TO_SHORT,
-    DAYS_OF_WEEK_ISO,
-    DAYS_OF_WEEK_ISO_REVERSED,
-)
-
-
-class TestConstants:
-    """Test suite for module constants"""
-
-    def test_days_of_week_long_to_short(self):
-        """Test DAYS_OF_WEEK_LONG_TO_SHORT dictionary"""
-        assert DAYS_OF_WEEK_LONG_TO_SHORT['Monday'] == 'Mon'
-        assert DAYS_OF_WEEK_LONG_TO_SHORT['Tuesday'] == 'Tue'
-        assert DAYS_OF_WEEK_LONG_TO_SHORT['Friday'] == 'Fri'
-        assert DAYS_OF_WEEK_LONG_TO_SHORT['Sunday'] == 'Sun'
-        assert len(DAYS_OF_WEEK_LONG_TO_SHORT) == 7
-
-    def test_days_of_week_iso(self):
-        """Test DAYS_OF_WEEK_ISO dictionary"""
-        assert DAYS_OF_WEEK_ISO[1] == 'Mon'
-        assert DAYS_OF_WEEK_ISO[5] == 'Fri'
-        assert DAYS_OF_WEEK_ISO[7] == 'Sun'
-        assert len(DAYS_OF_WEEK_ISO) == 7
-
-    def test_days_of_week_iso_reversed(self):
-        """Test DAYS_OF_WEEK_ISO_REVERSED dictionary"""
-        assert DAYS_OF_WEEK_ISO_REVERSED['Mon'] == 1
-        assert DAYS_OF_WEEK_ISO_REVERSED['Fri'] == 5
-        assert DAYS_OF_WEEK_ISO_REVERSED['Sun'] == 7
-        assert len(DAYS_OF_WEEK_ISO_REVERSED) == 7
-
-
-class TestCreateTime:
-    """Test suite for create_time function"""
-
-    def test_create_time_default_format(self):
-        """Test create_time with default format"""
-        timestamp = 1609459200.0  # 2021-01-01 00:00:00 UTC
-        result = create_time(timestamp)
-        # Result depends on system timezone, so just check format
-        assert len(result) == 19
-        assert '-' in result
-        assert ':' in result
-
-    def test_create_time_custom_format(self):
-        """Test create_time with custom format"""
-        timestamp = 1609459200.0
-        result = create_time(timestamp, "%Y/%m/%d")
-        # Check basic format structure
-        assert '/' in result
-        assert len(result) == 10
-
-    def test_create_time_with_microseconds(self):
-        """Test create_time with microseconds in format"""
-        timestamp = 1609459200.123456
-        result = create_time(timestamp, "%Y-%m-%d %H:%M:%S")
-        assert len(result) == 19
-
-
-class TestGetSystemTimezone:
-    """Test suite for get_system_timezone function"""
-
-    def test_get_system_timezone_returns_tuple(self):
-        """Test that get_system_timezone returns a tuple"""
-        result = get_system_timezone()
-        assert isinstance(result, tuple)
-        assert len(result) == 2
-
-    def test_get_system_timezone_returns_valid_data(self):
-        """Test that get_system_timezone returns valid timezone info"""
-        system_tz, timezone_name = get_system_timezone()
-        assert system_tz is not None
-        assert isinstance(timezone_name, str)
-        assert len(timezone_name) > 0
-
-
-class TestParseTimezoneData:
-    """Test suite for parse_timezone_data function"""
-
-    def test_parse_timezone_data_valid_timezone(self):
-        """Test parse_timezone_data with valid timezone string"""
-        result = parse_timezone_data('Asia/Tokyo')
-        assert isinstance(result, ZoneInfo)
-        assert str(result) == 'Asia/Tokyo'
-
-    def test_parse_timezone_data_utc(self):
-        """Test parse_timezone_data with UTC"""
-        result = parse_timezone_data('UTC')
-        assert isinstance(result, ZoneInfo)
-        assert str(result) == 'UTC'
-
-    def test_parse_timezone_data_empty_string(self):
-        """Test parse_timezone_data with empty string falls back to system timezone"""
-        result = parse_timezone_data('')
-        assert isinstance(result, ZoneInfo)
-
-    def test_parse_timezone_data_invalid_timezone(self):
-        """Test parse_timezone_data with invalid timezone falls back to system timezone"""
-        # Invalid timezones fall back to system timezone or UTC
-        result = parse_timezone_data('Invalid/Timezone')
-        assert isinstance(result, ZoneInfo)
-        # Should be either system timezone or UTC
-
-    def test_parse_timezone_data_none(self):
-        """Test parse_timezone_data with None falls back to system timezone"""
-        result = parse_timezone_data()
-        assert isinstance(result, ZoneInfo)
-
-    def test_parse_timezone_data_various_timezones(self):
-        """Test parse_timezone_data with various timezone strings"""
-        timezones = ['America/New_York', 'Europe/London', 'Asia/Seoul']
-        for tz in timezones:
-            result = parse_timezone_data(tz)
-            assert isinstance(result, ZoneInfo)
-            assert str(result) == tz
-
-
-class TestGetDatetimeIso8601:
-    """Test suite for get_datetime_iso8601 function"""
-
-    def test_get_datetime_iso8601_default_params(self):
-        """Test get_datetime_iso8601 with default parameters"""
-        result = get_datetime_iso8601()
-        # Should be in ISO 8601 format with T separator and microseconds
-        assert 'T' in result
-        assert '.' in result  # microseconds
-        # Check basic ISO 8601 format
-        datetime.fromisoformat(result)  # Should not raise
-
-    def test_get_datetime_iso8601_custom_timezone_string(self):
-        """Test get_datetime_iso8601 with custom timezone string"""
-        result = get_datetime_iso8601('UTC')
-        assert '+00:00' in result or 'Z' in result or result.endswith('+00:00')
-
-    def test_get_datetime_iso8601_custom_timezone_zoneinfo(self):
-        """Test get_datetime_iso8601 with ZoneInfo object"""
-        tz = ZoneInfo('Asia/Tokyo')
-        result = get_datetime_iso8601(tz)
-        assert 'T' in result
-        datetime.fromisoformat(result)  # Should not raise
-
-    def test_get_datetime_iso8601_custom_separator(self):
-        """Test get_datetime_iso8601 with custom separator"""
-        result = get_datetime_iso8601(sep=' ')
-        assert ' ' in result
-        assert 'T' not in result
-
-    def test_get_datetime_iso8601_different_timespec(self):
-        """Test get_datetime_iso8601 with different timespec values"""
-        result_seconds = get_datetime_iso8601(timespec='seconds')
-        assert '.' not in result_seconds  # No microseconds
-
-        result_milliseconds = get_datetime_iso8601(timespec='milliseconds')
-        # Should have milliseconds (3 digits after decimal)
-        assert '.' in result_milliseconds
-
-
-class TestValidateDate:
-    """Test suite for validate_date function"""
-
-    def test_validate_date_valid_hyphen_format(self):
-        """Test validate_date with valid Y-m-d format"""
-        assert validate_date('2023-12-25') is True
-        assert validate_date('2024-01-01') is True
-
-    def test_validate_date_valid_slash_format(self):
-        """Test validate_date with valid Y/m/d format"""
-        assert validate_date('2023/12/25') is True
-        assert validate_date('2024/01/01') is True
-
-    def test_validate_date_invalid_format(self):
-        """Test validate_date with invalid format"""
-        assert validate_date('25-12-2023') is False
-        assert validate_date('2023.12.25') is False
-        assert validate_date('invalid') is False
-
-    def test_validate_date_invalid_date(self):
-        """Test validate_date with invalid date values"""
-        assert validate_date('2023-13-01') is False  # Invalid month
-        assert validate_date('2023-02-30') is False  # Invalid day
-
-    def test_validate_date_with_not_before(self):
-        """Test validate_date with not_before constraint"""
-        not_before = datetime(2023, 12, 1)
-        assert validate_date('2023-12-25', not_before=not_before) is True
-        assert validate_date('2023-11-25', not_before=not_before) is False
-
-    def test_validate_date_with_not_after(self):
-        """Test validate_date with not_after constraint"""
-        not_after = datetime(2023, 12, 31)
-        assert validate_date('2023-12-25', not_after=not_after) is True
-        assert validate_date('2024-01-01', not_after=not_after) is False
-
-    def test_validate_date_with_both_constraints(self):
-        """Test validate_date with both not_before and not_after constraints"""
-        not_before = datetime(2023, 12, 1)
-        not_after = datetime(2023, 12, 31)
-        assert validate_date('2023-12-15', not_before=not_before, not_after=not_after) is True
-        assert validate_date('2023-11-30', not_before=not_before, not_after=not_after) is False
-        assert validate_date('2024-01-01', not_before=not_before, not_after=not_after) is False
-
-
-class TestParseFlexibleDate:
-    """Test suite for parse_flexible_date function"""
-
-    def test_parse_flexible_date_iso8601_full(self):
-        """Test parse_flexible_date with full ISO 8601 format"""
-        result = parse_flexible_date('2023-12-25T15:30:45')
-        assert isinstance(result, datetime)
-        assert result.year == 2023
-        assert result.month == 12
-        assert result.day == 25
-        assert result.hour == 15
-        assert result.minute == 30
-        assert result.second == 45
-
-    def test_parse_flexible_date_iso8601_with_microseconds(self):
-        """Test parse_flexible_date with microseconds"""
-        result = parse_flexible_date('2023-12-25T15:30:45.123456')
-        assert isinstance(result, datetime)
-        assert result.microsecond == 123456
-
-    def test_parse_flexible_date_simple_date(self):
-        """Test parse_flexible_date with simple date format"""
-        result = parse_flexible_date('2023-12-25')
-        assert isinstance(result, datetime)
-        assert result.year == 2023
-        assert result.month == 12
-        assert result.day == 25
-
-    def test_parse_flexible_date_with_timezone_string(self):
-        """Test parse_flexible_date with timezone string"""
-        result = parse_flexible_date('2023-12-25T15:30:45', timezone_tz='Asia/Tokyo')
-        assert isinstance(result, datetime)
-        assert result.tzinfo is not None
-
-    def test_parse_flexible_date_with_timezone_zoneinfo(self):
-        """Test parse_flexible_date with ZoneInfo object"""
-        tz = ZoneInfo('UTC')
-        result = parse_flexible_date('2023-12-25T15:30:45', timezone_tz=tz)
-        assert isinstance(result, datetime)
-        assert result.tzinfo is not None
-
-    def test_parse_flexible_date_with_timezone_no_shift(self):
-        """Test parse_flexible_date with timezone but no shift"""
-        result = parse_flexible_date('2023-12-25T15:30:45', timezone_tz='UTC', shift_time_zone=False)
-        assert isinstance(result, datetime)
-        assert result.hour == 15  # Should not shift
-
-    def test_parse_flexible_date_with_timezone_shift(self):
-        """Test parse_flexible_date with timezone shift"""
-        result = parse_flexible_date('2023-12-25T15:30:45+00:00', timezone_tz='Asia/Tokyo', shift_time_zone=True)
-        assert isinstance(result, datetime)
-        assert result.tzinfo is not None
-
-    def test_parse_flexible_date_invalid_format(self):
-        """Test parse_flexible_date with invalid format returns None"""
-        result = parse_flexible_date('invalid-date')
-        assert result is None
-
-    def test_parse_flexible_date_whitespace(self):
-        """Test parse_flexible_date with whitespace"""
-        result = parse_flexible_date('  2023-12-25  ')
-        assert isinstance(result, datetime)
-        assert result.year == 2023
-
-
-class TestCompareDates:
-    """Test suite for compare_dates function"""
-
-    def test_compare_dates_first_newer(self):
-        """Test compare_dates when first date is newer"""
-        result = compare_dates('2024-01-02', '2024-01-01')
-        assert result is True
-
-    def test_compare_dates_first_older(self):
-        """Test compare_dates when first date is older"""
-        result = compare_dates('2024-01-01', '2024-01-02')
-        assert result is False
-
-    def test_compare_dates_equal(self):
-        """Test compare_dates when dates are equal"""
-        result = compare_dates('2024-01-01', '2024-01-01')
-        assert result is False
-
-    def test_compare_dates_with_time(self):
-        """Test compare_dates with time components (should only compare dates)"""
-        result = compare_dates('2024-01-02T10:00:00', '2024-01-01T23:59:59')
-        assert result is True
-
-    def test_compare_dates_invalid_first_date(self):
-        """Test compare_dates with invalid first date"""
-        result = compare_dates('invalid', '2024-01-01')
-        assert result is None
-
-    def test_compare_dates_invalid_second_date(self):
-        """Test compare_dates with invalid second date"""
-        result = compare_dates('2024-01-01', 'invalid')
-        assert result is None
-
-    def test_compare_dates_both_invalid(self):
-        """Test compare_dates with both dates invalid"""
-        result = compare_dates('invalid1', 'invalid2')
-        assert result is None
-
-
-class TestFindNewestDatetimeInList:
-    """Test suite for find_newest_datetime_in_list function"""
-
-    def test_find_newest_datetime_in_list_basic(self):
-        """Test find_newest_datetime_in_list with basic list"""
-        dates = [
-            '2023-12-25T10:00:00',
-            '2024-01-01T12:00:00',
-            '2023-11-15T08:00:00'
-        ]
-        result = find_newest_datetime_in_list(dates)
-        assert result == '2024-01-01T12:00:00'
-
-    def test_find_newest_datetime_in_list_with_timezone(self):
-        """Test find_newest_datetime_in_list with timezone-aware dates"""
-        dates = [
-            '2025-08-06T16:17:39.747+09:00',
-            '2025-08-05T16:17:39.747+09:00',
-            '2025-08-07T16:17:39.747+09:00'
-        ]
-        result = find_newest_datetime_in_list(dates)
-        assert result == '2025-08-07T16:17:39.747+09:00'
-
-    def test_find_newest_datetime_in_list_empty_list(self):
-        """Test find_newest_datetime_in_list with empty list"""
-        result = find_newest_datetime_in_list([])
-        assert result is None
-
-    def test_find_newest_datetime_in_list_single_date(self):
-        """Test find_newest_datetime_in_list with single date"""
-        dates = ['2024-01-01T12:00:00']
-        result = find_newest_datetime_in_list(dates)
-        assert result == '2024-01-01T12:00:00'
-
-    def test_find_newest_datetime_in_list_with_invalid_dates(self):
-        """Test find_newest_datetime_in_list with some invalid dates"""
-        dates = [
-            '2023-12-25T10:00:00',
-            'invalid-date',
-            '2024-01-01T12:00:00'
-        ]
-        result = find_newest_datetime_in_list(dates)
-        assert result == '2024-01-01T12:00:00'
-
-    def test_find_newest_datetime_in_list_all_invalid(self):
-        """Test find_newest_datetime_in_list with all invalid dates"""
-        dates = ['invalid1', 'invalid2', 'invalid3']
-        result = find_newest_datetime_in_list(dates)
-        assert result is None
-
-    def test_find_newest_datetime_in_list_mixed_formats(self):
-        """Test find_newest_datetime_in_list with mixed date formats"""
-        dates = [
-            '2023-12-25',
-            '2024-01-01T12:00:00',
-            '2023-11-15T08:00:00.123456'
-        ]
-        result = find_newest_datetime_in_list(dates)
-        assert result == '2024-01-01T12:00:00'
-
-
-class TestParseDayOfWeekRange:
-    """Test suite for parse_day_of_week_range function"""
-
-    def test_parse_day_of_week_range_single_day(self):
-        """Test parse_day_of_week_range with single day"""
-        result = parse_day_of_week_range('Mon')
-        assert result == [(1, 'Mon')]
-
-    def test_parse_day_of_week_range_multiple_days(self):
-        """Test parse_day_of_week_range with multiple days"""
-        result = parse_day_of_week_range('Mon,Wed,Fri')
-        assert len(result) == 3
-        assert (1, 'Mon') in result
-        assert (3, 'Wed') in result
-        assert (5, 'Fri') in result
-
-    def test_parse_day_of_week_range_simple_range(self):
-        """Test parse_day_of_week_range with simple range"""
-        result = parse_day_of_week_range('Mon-Fri')
-        assert len(result) == 5
-        assert result[0] == (1, 'Mon')
-        assert result[-1] == (5, 'Fri')
-
-    def test_parse_day_of_week_range_weekend_spanning(self):
-        """Test parse_day_of_week_range with weekend-spanning range"""
-        result = parse_day_of_week_range('Fri-Mon')
-        assert len(result) == 4
-        assert (5, 'Fri') in result
-        assert (6, 'Sat') in result
-        assert (7, 'Sun') in result
-        assert (1, 'Mon') in result
-
-    def test_parse_day_of_week_range_long_names(self):
-        """Test parse_day_of_week_range with long day names - only works in ranges"""
-        # Long names only work in ranges, not as standalone days
-        # This is a limitation of the current implementation
-        with pytest.raises(ValueError) as exc_info:
-            parse_day_of_week_range('Monday,Wednesday')
-        assert 'Invalid day of week entry found' in str(exc_info.value)
-
-    def test_parse_day_of_week_range_mixed_format(self):
-        """Test parse_day_of_week_range with short names and ranges"""
-        result = parse_day_of_week_range('Mon,Wed-Fri')
-        assert len(result) == 4
-        assert (1, 'Mon') in result
-        assert (3, 'Wed') in result
-        assert (4, 'Thu') in result
-        assert (5, 'Fri') in result
-
-    def test_parse_day_of_week_range_invalid_day(self):
-        """Test parse_day_of_week_range with invalid day"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_day_of_week_range('InvalidDay')
-        assert 'Invalid day of week entry found' in str(exc_info.value)
-
-    def test_parse_day_of_week_range_duplicate_days(self):
-        """Test parse_day_of_week_range with duplicate days"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_day_of_week_range('Mon,Mon')
-        assert 'Duplicate day of week entries found' in str(exc_info.value)
-
-    def test_parse_day_of_week_range_whitespace_handling(self):
-        """Test parse_day_of_week_range with extra whitespace"""
-        result = parse_day_of_week_range(' Mon , Wed , Fri ')
-        assert len(result) == 3
-        assert (1, 'Mon') in result
-
-
-class TestParseTimeRange:
-    """Test suite for parse_time_range function"""
-
-    def test_parse_time_range_valid(self):
-        """Test parse_time_range with valid time range"""
-        start, end = parse_time_range('09:00-17:00')
-        assert start == time(9, 0)
-        assert end == time(17, 0)
-
-    def test_parse_time_range_different_times(self):
-        """Test parse_time_range with different time values"""
-        start, end = parse_time_range('08:30-12:45')
-        assert start == time(8, 30)
-        assert end == time(12, 45)
-
-    def test_parse_time_range_invalid_block(self):
-        """Test parse_time_range with invalid block format"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_time_range('09:00')
-        assert 'Invalid time block' in str(exc_info.value)
-
-    def test_parse_time_range_invalid_format(self):
-        """Test parse_time_range with invalid time format"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_time_range('25:00-26:00')
-        assert 'Invalid time block format' in str(exc_info.value)
-
-    def test_parse_time_range_start_after_end(self):
-        """Test parse_time_range with start time after end time"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_time_range('17:00-09:00')
-        assert 'start time after end time' in str(exc_info.value)
-
-    def test_parse_time_range_equal_times(self):
-        """Test parse_time_range with equal start and end times"""
-        with pytest.raises(ValueError) as exc_info:
-            parse_time_range('09:00-09:00')
-        assert 'start time after end time or equal' in str(exc_info.value)
-
-    def test_parse_time_range_custom_format(self):
-        """Test parse_time_range with custom time format"""
-        start, end = parse_time_range('09:00:00-17:00:00', time_format='%H:%M:%S')
-        assert start == time(9, 0, 0)
-        assert end == time(17, 0, 0)
-
-    def test_parse_time_range_whitespace(self):
-        """Test parse_time_range with whitespace"""
-        start, end = parse_time_range('  09:00-17:00  ')
-        assert start == time(9, 0)
-        assert end == time(17, 0)
-
-
-class TestTimesOverlapOrConnect:
-    """Test suite for times_overlap_or_connect function"""
-
-    def test_times_overlap_or_connect_clear_overlap(self):
-        """Test times_overlap_or_connect with clear overlap"""
-        time1 = (time(9, 0), time(12, 0))
-        time2 = (time(10, 0), time(14, 0))
-        assert times_overlap_or_connect(time1, time2) is True
-
-    def test_times_overlap_or_connect_no_overlap(self):
-        """Test times_overlap_or_connect with no overlap"""
-        time1 = (time(9, 0), time(12, 0))
-        time2 = (time(13, 0), time(17, 0))
-        assert times_overlap_or_connect(time1, time2) is False
-
-    def test_times_overlap_or_connect_touching_not_allowed(self):
-        """Test times_overlap_or_connect with touching ranges (not allowed)"""
-        time1 = (time(8, 0), time(10, 0))
-        time2 = (time(10, 0), time(12, 0))
-        assert times_overlap_or_connect(time1, time2, allow_touching=False) is True
-
-    def test_times_overlap_or_connect_touching_allowed(self):
-        """Test times_overlap_or_connect with touching ranges (allowed)"""
-        time1 = (time(8, 0), time(10, 0))
-        time2 = (time(10, 0), time(12, 0))
-        assert times_overlap_or_connect(time1, time2, allow_touching=True) is False
-
-    def test_times_overlap_or_connect_one_contains_other(self):
-        """Test times_overlap_or_connect when one range contains the other"""
-        time1 = (time(9, 0), time(17, 0))
-        time2 = (time(10, 0), time(12, 0))
-        assert times_overlap_or_connect(time1, time2) is True
-
-    def test_times_overlap_or_connect_same_start(self):
-        """Test times_overlap_or_connect with same start time"""
-        time1 = (time(9, 0), time(12, 0))
-        time2 = (time(9, 0), time(14, 0))
-        assert times_overlap_or_connect(time1, time2) is True
-
-    def test_times_overlap_or_connect_same_end(self):
-        """Test times_overlap_or_connect with same end time"""
-        time1 = (time(9, 0), time(12, 0))
-        time2 = (time(10, 0), time(12, 0))
-        assert times_overlap_or_connect(time1, time2) is True
-
-
-class TestIsTimeInRange:
-    """Test suite for is_time_in_range function"""
-
-    def test_is_time_in_range_within_range(self):
-        """Test is_time_in_range with time within range"""
-        assert is_time_in_range('10:00:00', '09:00:00', '17:00:00') is True
-
-    def test_is_time_in_range_at_start(self):
-        """Test is_time_in_range with time at start of range"""
-        assert is_time_in_range('09:00:00', '09:00:00', '17:00:00') is True
-
-    def test_is_time_in_range_at_end(self):
-        """Test is_time_in_range with time at end of range"""
-        assert is_time_in_range('17:00:00', '09:00:00', '17:00:00') is True
-
-    def test_is_time_in_range_before_range(self):
-        """Test is_time_in_range with time before range"""
-        assert is_time_in_range('08:00:00', '09:00:00', '17:00:00') is False
-
-    def test_is_time_in_range_after_range(self):
-        """Test is_time_in_range with time after range"""
-        assert is_time_in_range('18:00:00', '09:00:00', '17:00:00') is False
-
-    def test_is_time_in_range_crosses_midnight(self):
-        """Test is_time_in_range with range crossing midnight"""
-        # Range from 22:00 to 06:00
-        assert is_time_in_range('23:00:00', '22:00:00', '06:00:00') is True
-        assert is_time_in_range('03:00:00', '22:00:00', '06:00:00') is True
-        assert is_time_in_range('12:00:00', '22:00:00', '06:00:00') is False
-
-    def test_is_time_in_range_midnight_boundary(self):
-        """Test is_time_in_range at midnight"""
-        assert is_time_in_range('00:00:00', '22:00:00', '06:00:00') is True
-
-
-class TestReorderWeekdaysFromToday:
-    """Test suite for reorder_weekdays_from_today function"""
-
-    def test_reorder_weekdays_from_monday(self):
-        """Test reorder_weekdays_from_today starting from Monday"""
-        result = reorder_weekdays_from_today('Mon')
-        values = list(result.values())
-        assert values[0] == 'Mon'
-        assert values[-1] == 'Sun'
-        assert len(result) == 7
-
-    def test_reorder_weekdays_from_wednesday(self):
-        """Test reorder_weekdays_from_today starting from Wednesday"""
-        result = reorder_weekdays_from_today('Wed')
-        values = list(result.values())
-        assert values[0] == 'Wed'
-        assert values[1] == 'Thu'
-        assert values[-1] == 'Tue'
-
-    def test_reorder_weekdays_from_sunday(self):
-        """Test reorder_weekdays_from_today starting from Sunday"""
-        result = reorder_weekdays_from_today('Sun')
-        values = list(result.values())
-        assert values[0] == 'Sun'
-        assert values[-1] == 'Sat'
-
-    def test_reorder_weekdays_from_long_name(self):
-        """Test reorder_weekdays_from_today with long day name"""
-        result = reorder_weekdays_from_today('Friday')
-        values = list(result.values())
-        assert values[0] == 'Fri'
-        assert values[-1] == 'Thu'
-
-    def test_reorder_weekdays_invalid_day(self):
-        """Test reorder_weekdays_from_today with invalid day name"""
-        with pytest.raises(ValueError) as exc_info:
-            reorder_weekdays_from_today('InvalidDay')
-        assert 'Invalid day name provided' in str(exc_info.value)
-
-    def test_reorder_weekdays_preserves_all_days(self):
-        """Test that reorder_weekdays_from_today preserves all 7 days"""
-        for day in ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']:
-            result = reorder_weekdays_from_today(day)
-            assert len(result) == 7
-            assert set(result.values()) == {'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'}
-
-
-class TestEdgeCases:
-    """Test suite for edge cases and integration scenarios"""
-
-    def test_parse_flexible_date_with_various_iso_formats(self):
-        """Test parse_flexible_date handles various ISO format variations"""
-        formats = [
-            '2023-12-25',
-            '2023-12-25T15:30:45',
-            '2023-12-25T15:30:45.123456',
-        ]
-        for date_str in formats:
-            result = parse_flexible_date(date_str)
-            assert result is not None
-            assert isinstance(result, datetime)
-
-    def test_timezone_consistency_across_functions(self):
-        """Test timezone handling consistency across functions"""
-        tz_str = 'Asia/Tokyo'
-        tz_obj = parse_timezone_data(tz_str)
-        
-        # Both should work with get_datetime_iso8601
-        result1 = get_datetime_iso8601(tz_str)
-        result2 = get_datetime_iso8601(tz_obj)
-        
-        assert result1 is not None
-        assert result2 is not None
-
-    def test_date_validation_and_parsing_consistency(self):
-        """Test that validate_date and parse_flexible_date agree"""
-        valid_dates = ['2023-12-25', '2024/01/01']
-        for date_str in valid_dates:
-            # normalize format for parse_flexible_date
-            normalized = date_str.replace('/', '-')
-            assert validate_date(date_str) is True
-            assert parse_flexible_date(normalized) is not None
-
-    def test_day_of_week_range_complex_scenario(self):
-        """Test parse_day_of_week_range with complex mixed input"""
-        result = parse_day_of_week_range('Mon,Wed-Fri,Sun')
-        assert len(result) == 5
-        assert (1, 'Mon') in result
-        assert (3, 'Wed') in result
-        assert (4, 'Thu') in result
-        assert (5, 'Fri') in result
-        assert (7, 'Sun') in result
-
-    def test_time_range_boundary_conditions(self):
-        """Test parse_time_range with boundary times"""
-        start, end = parse_time_range('00:00-23:59')
-        assert start == time(0, 0)
-        assert end == time(23, 59)
-
-# __END__

tests/unit/datetime_handling/test_seconds_to_string.py

@@ -1,462 +0,0 @@
-"""
-PyTest: datetime_handling/timestamp_convert - seconds_to_string and convert_timestamp functions
-"""
-
-from corelibs.datetime_handling.timestamp_convert import seconds_to_string, convert_timestamp
-
-
-class TestSecondsToString:
-    """Test suite for seconds_to_string function"""
-
-    def test_basic_integer_seconds(self):
-        """Test conversion of basic integer seconds"""
-        assert seconds_to_string(0) == "0s"
-        assert seconds_to_string(1) == "1s"
-        assert seconds_to_string(30) == "30s"
-        assert seconds_to_string(59) == "59s"
-
-    def test_minutes_conversion(self):
-        """Test conversion involving minutes"""
-        assert seconds_to_string(60) == "1m"
-        assert seconds_to_string(90) == "1m 30s"
-        assert seconds_to_string(120) == "2m"
-        assert seconds_to_string(3599) == "59m 59s"
-
-    def test_hours_conversion(self):
-        """Test conversion involving hours"""
-        assert seconds_to_string(3600) == "1h"
-        assert seconds_to_string(3660) == "1h 1m"
-        assert seconds_to_string(3661) == "1h 1m 1s"
-        assert seconds_to_string(7200) == "2h"
-        assert seconds_to_string(7260) == "2h 1m"
-
-    def test_days_conversion(self):
-        """Test conversion involving days"""
-        assert seconds_to_string(86400) == "1d"
-        assert seconds_to_string(86401) == "1d 1s"
-        assert seconds_to_string(90000) == "1d 1h"
-        assert seconds_to_string(90061) == "1d 1h 1m 1s"
-        assert seconds_to_string(172800) == "2d"
-
-    def test_complex_combinations(self):
-        """Test complex time combinations"""
-        # 1 day, 2 hours, 3 minutes, 4 seconds
-        total = 86400 + 7200 + 180 + 4
-        assert seconds_to_string(total) == "1d 2h 3m 4s"
-
-        # 5 days, 23 hours, 59 minutes, 59 seconds
-        total = 5 * 86400 + 23 * 3600 + 59 * 60 + 59
-        assert seconds_to_string(total) == "5d 23h 59m 59s"
-
-    def test_fractional_seconds_default_precision(self):
-        """Test fractional seconds with default precision (3 decimal places)"""
-        assert seconds_to_string(0.1) == "0.1s"
-        assert seconds_to_string(0.123) == "0.123s"
-        assert seconds_to_string(0.1234) == "0.123s"
-        assert seconds_to_string(1.5) == "1.5s"
-        assert seconds_to_string(1.567) == "1.567s"
-        assert seconds_to_string(1.5678) == "1.568s"
-
-    def test_fractional_seconds_microsecond_precision(self):
-        """Test fractional seconds with microsecond precision"""
-        assert seconds_to_string(0.1, show_microseconds=True) == "0.1s"
-        assert seconds_to_string(0.123456, show_microseconds=True) == "0.123456s"
-        assert seconds_to_string(0.1234567, show_microseconds=True) == "0.123457s"
-        assert seconds_to_string(1.5, show_microseconds=True) == "1.5s"
-        assert seconds_to_string(1.567890, show_microseconds=True) == "1.56789s"
-
-    def test_fractional_seconds_with_larger_units(self):
-        """Test fractional seconds combined with larger time units"""
-        # 1 minute and 30.5 seconds
-        assert seconds_to_string(90.5) == "1m 30.5s"
-        assert seconds_to_string(90.5, show_microseconds=True) == "1m 30.5s"
-
-        # 1 hour, 1 minute, and 1.123 seconds
-        total = 3600 + 60 + 1.123
-        assert seconds_to_string(total) == "1h 1m 1.123s"
-        assert seconds_to_string(total, show_microseconds=True) == "1h 1m 1.123s"
-
-    def test_negative_values(self):
-        """Test negative time values"""
-        assert seconds_to_string(-1) == "-1s"
-        assert seconds_to_string(-60) == "-1m"
-        assert seconds_to_string(-90) == "-1m 30s"
-        assert seconds_to_string(-3661) == "-1h 1m 1s"
-        assert seconds_to_string(-86401) == "-1d 1s"
-        assert seconds_to_string(-1.5) == "-1.5s"
-        assert seconds_to_string(-90.123) == "-1m 30.123s"
-
-    def test_zero_handling(self):
-        """Test various zero values"""
-        assert seconds_to_string(0) == "0s"
-        assert seconds_to_string(0.0) == "0s"
-        assert seconds_to_string(-0) == "0s"
-        assert seconds_to_string(-0.0) == "0s"
-
-    def test_float_input_types(self):
-        """Test various float input types"""
-        assert seconds_to_string(1.0) == "1s"
-        assert seconds_to_string(60.0) == "1m"
-        assert seconds_to_string(3600.0) == "1h"
-        assert seconds_to_string(86400.0) == "1d"
-
-    def test_large_values(self):
-        """Test handling of large time values"""
-        # 365 days (1 year)
-        year_seconds = 365 * 86400
-        assert seconds_to_string(year_seconds) == "365d"
-
-        # 1000 days
-        assert seconds_to_string(1000 * 86400) == "1000d"
-
-        # Large number with all units
-        large_time = 999 * 86400 + 23 * 3600 + 59 * 60 + 59.999
-        result = seconds_to_string(large_time)
-        assert result.startswith("999d")
-        assert "23h" in result
-        assert "59m" in result
-        assert "59.999s" in result
-
-    def test_rounding_behavior(self):
-        """Test rounding behavior for fractional seconds"""
-        # Default precision (3 decimal places) - values are truncated via rstrip
-        assert seconds_to_string(1.0004) == "1s"  # Truncates trailing zeros after rstrip
-        assert seconds_to_string(1.0005) == "1s"  # Truncates trailing zeros after rstrip
-        assert seconds_to_string(1.9999) == "2s"  # Rounds up and strips .000
-
-        # Microsecond precision (6 decimal places)
-        assert seconds_to_string(1.0000004, show_microseconds=True) == "1s"
-        assert seconds_to_string(1.0000005, show_microseconds=True) == "1.000001s"
-
-    def test_trailing_zero_removal(self):
-        """Test that trailing zeros are properly removed"""
-        assert seconds_to_string(1.100) == "1.1s"
-        assert seconds_to_string(1.120) == "1.12s"
-        assert seconds_to_string(1.123) == "1.123s"
-        assert seconds_to_string(1.100000, show_microseconds=True) == "1.1s"
-        assert seconds_to_string(1.123000, show_microseconds=True) == "1.123s"
-
-    def test_invalid_input_types(self):
-        """Test handling of invalid input types"""
-        # String inputs should be returned as-is
-        assert seconds_to_string("invalid") == "invalid"
-        assert seconds_to_string("not a number") == "not a number"
-        assert seconds_to_string("") == ""
-
-    def test_edge_cases_boundary_values(self):
-        """Test edge cases at unit boundaries"""
-        # Exactly 1 minute - 1 second
-        assert seconds_to_string(59) == "59s"
-        assert seconds_to_string(59.999) == "59.999s"
-
-        # Exactly 1 hour - 1 second
-        assert seconds_to_string(3599) == "59m 59s"
-        assert seconds_to_string(3599.999) == "59m 59.999s"
-
-        # Exactly 1 day - 1 second
-        assert seconds_to_string(86399) == "23h 59m 59s"
-        assert seconds_to_string(86399.999) == "23h 59m 59.999s"
-
-    def test_very_small_fractional_seconds(self):
-        """Test very small fractional values"""
-        assert seconds_to_string(0.001) == "0.001s"
-        assert seconds_to_string(0.0001) == "0s"  # Below default precision
-        assert seconds_to_string(0.000001, show_microseconds=True) == "0.000001s"
-        assert seconds_to_string(0.0000001, show_microseconds=True) == "0s"  # Below microsecond precision
-
-    def test_precision_consistency(self):
-        """Test that precision is consistent across different scenarios"""
-        # With other units present
-        assert seconds_to_string(61.123456) == "1m 1.123s"
-        assert seconds_to_string(61.123456, show_microseconds=True) == "1m 1.123456s"
-
-        # Large values with fractional seconds
-        large_val = 90061.123456  # 1d 1h 1m 1.123456s
-        assert seconds_to_string(large_val) == "1d 1h 1m 1.123s"
-        assert seconds_to_string(large_val, show_microseconds=True) == "1d 1h 1m 1.123456s"
-
-    def test_string_numeric_inputs(self):
-        """Test string inputs that represent numbers"""
-        # String inputs should be returned as-is, even if they look like numbers
-        assert seconds_to_string("60") == "60"
-        assert seconds_to_string("1.5") == "1.5"
-        assert seconds_to_string("0") == "0"
-        assert seconds_to_string("-60") == "-60"
-
-
-class TestConvertTimestamp:
-    """Test suite for convert_timestamp function"""
-
-    def test_basic_integer_seconds(self):
-        """Test conversion of basic integer seconds"""
-        assert convert_timestamp(0) == "0s 0ms"
-        assert convert_timestamp(1) == "1s 0ms"
-        assert convert_timestamp(30) == "30s 0ms"
-        assert convert_timestamp(59) == "59s 0ms"
-
-    def test_basic_without_microseconds(self):
-        """Test conversion without showing microseconds"""
-        assert convert_timestamp(0, show_microseconds=False) == "0s"
-        assert convert_timestamp(1, show_microseconds=False) == "1s"
-        assert convert_timestamp(30, show_microseconds=False) == "30s"
-        assert convert_timestamp(59, show_microseconds=False) == "59s"
-
-    def test_minutes_conversion(self):
-        """Test conversion involving minutes"""
-        assert convert_timestamp(60) == "1m 0s 0ms"
-        assert convert_timestamp(90) == "1m 30s 0ms"
-        assert convert_timestamp(120) == "2m 0s 0ms"
-        assert convert_timestamp(3599) == "59m 59s 0ms"
-
-    def test_minutes_conversion_without_microseconds(self):
-        """Test conversion involving minutes without microseconds"""
-        assert convert_timestamp(60, show_microseconds=False) == "1m 0s"
-        assert convert_timestamp(90, show_microseconds=False) == "1m 30s"
-        assert convert_timestamp(120, show_microseconds=False) == "2m 0s"
-
-    def test_hours_conversion(self):
-        """Test conversion involving hours"""
-        assert convert_timestamp(3600) == "1h 0m 0s 0ms"
-        assert convert_timestamp(3660) == "1h 1m 0s 0ms"
-        assert convert_timestamp(3661) == "1h 1m 1s 0ms"
-        assert convert_timestamp(7200) == "2h 0m 0s 0ms"
-        assert convert_timestamp(7260) == "2h 1m 0s 0ms"
-
-    def test_hours_conversion_without_microseconds(self):
-        """Test conversion involving hours without microseconds"""
-        assert convert_timestamp(3600, show_microseconds=False) == "1h 0m 0s"
-        assert convert_timestamp(3660, show_microseconds=False) == "1h 1m 0s"
-        assert convert_timestamp(3661, show_microseconds=False) == "1h 1m 1s"
-
-    def test_days_conversion(self):
-        """Test conversion involving days"""
-        assert convert_timestamp(86400) == "1d 0h 0m 0s 0ms"
-        assert convert_timestamp(86401) == "1d 0h 0m 1s 0ms"
-        assert convert_timestamp(90000) == "1d 1h 0m 0s 0ms"
-        assert convert_timestamp(90061) == "1d 1h 1m 1s 0ms"
-        assert convert_timestamp(172800) == "2d 0h 0m 0s 0ms"
-
-    def test_days_conversion_without_microseconds(self):
-        """Test conversion involving days without microseconds"""
-        assert convert_timestamp(86400, show_microseconds=False) == "1d 0h 0m 0s"
-        assert convert_timestamp(86401, show_microseconds=False) == "1d 0h 0m 1s"
-        assert convert_timestamp(90000, show_microseconds=False) == "1d 1h 0m 0s"
-
-    def test_complex_combinations(self):
-        """Test complex time combinations"""
-        # 1 day, 2 hours, 3 minutes, 4 seconds
-        total = 86400 + 7200 + 180 + 4
-        assert convert_timestamp(total) == "1d 2h 3m 4s 0ms"
-
-        # 5 days, 23 hours, 59 minutes, 59 seconds
-        total = 5 * 86400 + 23 * 3600 + 59 * 60 + 59
-        assert convert_timestamp(total) == "5d 23h 59m 59s 0ms"
-
-    def test_fractional_seconds_with_microseconds(self):
-        """Test fractional seconds showing microseconds"""
-        # Note: ms value is the integer of the decimal part string after rounding to 4 places
-        assert convert_timestamp(0.1) == "0s 1ms"  # 0.1 → "0.1" → ms=1
-        assert convert_timestamp(0.123) == "0s 123ms"  # 0.123 → "0.123" → ms=123
-        assert convert_timestamp(0.1234) == "0s 1234ms"  # 0.1234 → "0.1234" → ms=1234
-        assert convert_timestamp(1.5) == "1s 5ms"  # 1.5 → "1.5" → ms=5
-        assert convert_timestamp(1.567) == "1s 567ms"  # 1.567 → "1.567" → ms=567
-        assert convert_timestamp(1.5678) == "1s 5678ms"  # 1.5678 rounds to 1.5678 → ms=5678
-
-    def test_fractional_seconds_rounding(self):
-        """Test rounding of fractional seconds to 4 decimal places"""
-        # The function rounds to 4 decimal places before splitting
-        assert convert_timestamp(0.12345) == "0s 1235ms"  # Rounds to 0.1235
-        assert convert_timestamp(0.123456) == "0s 1235ms"  # Rounds to 0.1235
-        assert convert_timestamp(1.99999) == "2s 0ms"  # Rounds to 2.0
-
-    def test_fractional_seconds_with_larger_units(self):
-        """Test fractional seconds combined with larger time units"""
-        # 1 minute and 30.5 seconds
-        assert convert_timestamp(90.5) == "1m 30s 5ms"
-
-        # 1 hour, 1 minute, and 1.123 seconds
-        total = 3600 + 60 + 1.123
-        assert convert_timestamp(total) == "1h 1m 1s 123ms"
-
-    def test_negative_values(self):
-        """Test negative time values"""
-        assert convert_timestamp(-1) == "-1s 0ms"
-        assert convert_timestamp(-60) == "-1m 0s 0ms"
-        assert convert_timestamp(-90) == "-1m 30s 0ms"
-        assert convert_timestamp(-3661) == "-1h 1m 1s 0ms"
-        assert convert_timestamp(-86401) == "-1d 0h 0m 1s 0ms"
-        assert convert_timestamp(-1.5) == "-1s 5ms"
-        assert convert_timestamp(-90.123) == "-1m 30s 123ms"
-
-    def test_negative_without_microseconds(self):
-        """Test negative values without microseconds"""
-        assert convert_timestamp(-1, show_microseconds=False) == "-1s"
-        assert convert_timestamp(-60, show_microseconds=False) == "-1m 0s"
-        assert convert_timestamp(-90.123, show_microseconds=False) == "-1m 30s"
-
-    def test_zero_handling(self):
-        """Test various zero values"""
-        assert convert_timestamp(0) == "0s 0ms"
-        assert convert_timestamp(0.0) == "0s 0ms"
-        assert convert_timestamp(-0) == "0s 0ms"
-        assert convert_timestamp(-0.0) == "0s 0ms"
-
-    def test_zero_filling_behavior(self):
-        """Test that zeros are filled between set values"""
-        # If we have days and seconds, hours and minutes should be 0
-        assert convert_timestamp(86401) == "1d 0h 0m 1s 0ms"
-
-        # If we have hours and seconds, minutes should be 0
-        assert convert_timestamp(3601) == "1h 0m 1s 0ms"
-
-        # If we have days and hours, minutes and seconds should be 0
-        assert convert_timestamp(90000) == "1d 1h 0m 0s 0ms"
-
-    def test_milliseconds_display(self):
-        """Test milliseconds are always shown when show_microseconds=True"""
-        # Even with no fractional part, 0ms should be shown
-        assert convert_timestamp(1) == "1s 0ms"
-        assert convert_timestamp(60) == "1m 0s 0ms"
-        assert convert_timestamp(3600) == "1h 0m 0s 0ms"
-
-        # With fractional part, ms should be shown
-        assert convert_timestamp(1.001) == "1s 1ms"  # "1.001" → ms=1
-        assert convert_timestamp(1.0001) == "1s 1ms"  # "1.0001" → ms=1
-
-    def test_float_input_types(self):
-        """Test various float input types"""
-        assert convert_timestamp(1.0) == "1s 0ms"
-        assert convert_timestamp(60.0) == "1m 0s 0ms"
-        assert convert_timestamp(3600.0) == "1h 0m 0s 0ms"
-        assert convert_timestamp(86400.0) == "1d 0h 0m 0s 0ms"
-
-    def test_large_values(self):
-        """Test handling of large time values"""
-        # 365 days (1 year)
-        year_seconds = 365 * 86400
-        assert convert_timestamp(year_seconds) == "365d 0h 0m 0s 0ms"
-
-        # 1000 days
-        assert convert_timestamp(1000 * 86400) == "1000d 0h 0m 0s 0ms"
-
-        # Large number with all units
-        large_time = 999 * 86400 + 23 * 3600 + 59 * 60 + 59.999
-        result = convert_timestamp(large_time)
-        assert result.startswith("999d")
-        assert "23h" in result
-        assert "59m" in result
-        assert "59s" in result
-        assert "999ms" in result  # 59.999 rounds to 59.999, ms=999
-
-    def test_invalid_input_types(self):
-        """Test handling of invalid input types"""
-        # String inputs should be returned as-is
-        assert convert_timestamp("invalid") == "invalid"
-        assert convert_timestamp("not a number") == "not a number"
-        assert convert_timestamp("") == ""
-
-    def test_string_numeric_inputs(self):
-        """Test string inputs that represent numbers"""
-        # String inputs should be returned as-is, even if they look like numbers
-        assert convert_timestamp("60") == "60"
-        assert convert_timestamp("1.5") == "1.5"
-        assert convert_timestamp("0") == "0"
-        assert convert_timestamp("-60") == "-60"
-
-    def test_edge_cases_boundary_values(self):
-        """Test edge cases at unit boundaries"""
-        # Exactly 1 minute - 1 second
-        assert convert_timestamp(59) == "59s 0ms"
-        assert convert_timestamp(59.999) == "59s 999ms"
-
-        # Exactly 1 hour - 1 second
-        assert convert_timestamp(3599) == "59m 59s 0ms"
-        assert convert_timestamp(3599.999) == "59m 59s 999ms"
-
-        # Exactly 1 day - 1 second
-        assert convert_timestamp(86399) == "23h 59m 59s 0ms"
-        assert convert_timestamp(86399.999) == "23h 59m 59s 999ms"
-
-    def test_very_small_fractional_seconds(self):
-        """Test very small fractional values"""
-        assert convert_timestamp(0.001) == "0s 1ms"  # 0.001 → "0.001" → ms=1
-        assert convert_timestamp(0.0001) == "0s 1ms"  # 0.0001 → "0.0001" → ms=1
-        assert convert_timestamp(0.00005) == "0s 1ms"  # 0.00005 rounds to 0.0001 → ms=1
-        assert convert_timestamp(0.00004) == "0s 0ms"  # 0.00004 rounds to 0.0 → ms=0
-
-    def test_milliseconds_extraction(self):
-        """Test that milliseconds are correctly extracted from fractional part"""
-        # The ms value is the integer of the decimal part string, not a conversion
-        # So 0.1 → "0.1" → ms=1, NOT 100ms as you might expect
-        assert convert_timestamp(0.1) == "0s 1ms"
-        # 0.01 seconds → "0.01" → ms=1 (int("01") = 1)
-        assert convert_timestamp(0.01) == "0s 1ms"
-        # 0.001 seconds → "0.001" → ms=1
-        assert convert_timestamp(0.001) == "0s 1ms"
-        # 0.0001 seconds → "0.0001" → ms=1
-        assert convert_timestamp(0.0001) == "0s 1ms"
-        # 0.00004 seconds rounds to "0.0" → ms=0
-        assert convert_timestamp(0.00004) == "0s 0ms"
-
-    def test_comparison_with_seconds_to_string(self):
-        """Test differences between convert_timestamp and seconds_to_string"""
-        # convert_timestamp fills zeros and adds ms
-        # seconds_to_string omits zeros and no ms
-        assert convert_timestamp(86401) == "1d 0h 0m 1s 0ms"
-        assert seconds_to_string(86401) == "1d 1s"
-
-        assert convert_timestamp(3661) == "1h 1m 1s 0ms"
-        assert seconds_to_string(3661) == "1h 1m 1s"
-
-        # With microseconds disabled, still different due to zero-filling
-        assert convert_timestamp(86401, show_microseconds=False) == "1d 0h 0m 1s"
-        assert seconds_to_string(86401) == "1d 1s"
-
-    def test_precision_consistency(self):
-        """Test that precision is consistent across different scenarios"""
-        # With other units present
-        assert convert_timestamp(61.123456) == "1m 1s 1235ms"  # Rounds to 61.1235
-
-        # Large values with fractional seconds
-        large_val = 90061.123456  # 1d 1h 1m 1.123456s
-        assert convert_timestamp(large_val) == "1d 1h 1m 1s 1235ms"  # Rounds to .1235
-
-    def test_microseconds_flag_consistency(self):
-        """Test that show_microseconds flag works consistently"""
-        test_values = [0, 1, 60, 3600, 86400, 1.5, 90.123, -60]
-
-        for val in test_values:
-            with_ms = convert_timestamp(val, show_microseconds=True)
-            without_ms = convert_timestamp(val, show_microseconds=False)
-
-            # With microseconds should contain 'ms', without should not
-            assert "ms" in with_ms
-            assert "ms" not in without_ms
-
-            # Both should start with same sign if negative
-            if val < 0:
-                assert with_ms.startswith("-")
-                assert without_ms.startswith("-")
-
-    def test_format_consistency(self):
-        """Test that output format is consistent"""
-        # All outputs should have consistent spacing and unit ordering
-        # Format should be: [d ]h m s[ ms]
-        result = convert_timestamp(93784.5678)  # 1d 2h 3m 4.5678s
-        # 93784.5678 rounds to 93784.5678, splits to ["93784", "5678"]
-        assert result == "1d 2h 3m 4s 5678ms"
-
-        # Verify parts are in correct order
-        parts = result.split()
-        # Extract units properly: last 1-2 chars that are letters
-        units = []
-        for p in parts:
-            if p.endswith('ms'):
-                units.append('ms')
-            elif p[-1].isalpha():
-                units.append(p[-1])
-        # Should be in order: d, h, m, s, ms
-        expected_order = ['d', 'h', 'm', 's', 'ms']
-        assert units == expected_order
-
-# __END__

tests/unit/datetime_handling/test_timestamp_strings.py

@@ -1,194 +0,0 @@
-"""
-PyTest: datetime_handling/timestamp_strings
-"""
-
-from datetime import datetime
-from unittest.mock import patch
-from zoneinfo import ZoneInfo
-import pytest
-
-# Assuming the class is in a file called timestamp_strings.py
-from corelibs.datetime_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.datetime_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.datetime_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.datetime_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.datetime_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.datetime_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.datetime_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.datetime_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
-
-    def test_zoneinfo_called_correctly_with_string(self):
-        """Test that ZoneInfo is called with correct timezone when passing string"""
-        with patch('corelibs.datetime_handling.timestamp_strings.ZoneInfo') as mock_zoneinfo:
-            with patch('corelibs.datetime_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_zoneinfo_object_parameter(self):
-        """Test that ZoneInfo objects can be passed directly as timezone parameter"""
-        with patch('corelibs.datetime_handling.timestamp_strings.datetime') as mock_datetime:
-            mock_now = datetime(2023, 12, 25, 15, 30, 45)
-            mock_now_tz = datetime(2023, 12, 25, 15, 30, 45, tzinfo=ZoneInfo('Europe/Paris'))
-            mock_datetime.now.side_effect = [mock_now, mock_now_tz]
-
-            # Create a ZoneInfo object
-            custom_tz_obj = ZoneInfo('Europe/Paris')
-            ts = TimestampStrings(time_zone=custom_tz_obj)
-
-            # The time_zone should be the ZoneInfo object itself
-            assert ts.time_zone_zi is custom_tz_obj
-            assert isinstance(ts.time_zone_zi, ZoneInfo)
-
-    def test_zoneinfo_object_vs_string_equivalence(self):
-        """Test that ZoneInfo object and string produce equivalent results"""
-        with patch('corelibs.datetime_handling.timestamp_strings.datetime') as mock_datetime:
-            mock_now = datetime(2023, 12, 25, 15, 30, 45)
-            mock_now_tz = datetime(2023, 12, 25, 15, 30, 45, tzinfo=ZoneInfo('Europe/Paris'))
-            mock_datetime.now.side_effect = [mock_now, mock_now_tz, mock_now, mock_now_tz]
-
-            # Test with string
-            ts_string = TimestampStrings(time_zone='Europe/Paris')
-
-            # Test with ZoneInfo object
-            ts_zoneinfo = TimestampStrings(time_zone=ZoneInfo('Europe/Paris'))
-
-            # Both should produce the same timestamp formats (though time_zone attributes will differ)
-            assert ts_string.today == ts_zoneinfo.today
-            assert ts_string.timestamp == ts_zoneinfo.timestamp
-            assert ts_string.timestamp_file == ts_zoneinfo.timestamp_file
-
-            # The time_zone attributes will be different types but represent the same timezone
-            assert str(ts_string.time_zone) == 'Europe/Paris'
-            assert isinstance(ts_zoneinfo.time_zone_zi, ZoneInfo)
-
-    def test_edge_case_midnight(self):
-        """Test timestamp formatting at midnight"""
-        with patch('corelibs.datetime_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.datetime_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__

tests/unit/db_handling/test_sql_main.py

@@ -0,0 +1,461 @@
+"""
+PyTest: db_handling/sql_main
+Tests for SQLMain class - Main SQL interface wrapper
+
+Note: Pylance warnings about "Redefining name from outer scope" in fixtures are expected.
+This is standard pytest fixture behavior where fixture parameters shadow fixture definitions.
+"""
+# pylint: disable=redefined-outer-name,too-many-public-methods,protected-access
+# pyright: reportUnknownParameterType=false, reportUnknownArgumentType=false
+# pyright: reportMissingParameterType=false, reportUnknownVariableType=false
+# pyright: reportArgumentType=false, reportGeneralTypeIssues=false
+
+from pathlib import Path
+from typing import Generator
+from unittest.mock import MagicMock, patch
+import pytest
+from corelibs.db_handling.sql_main import SQLMain, IDENT_SPLIT_CHARACTER
+from corelibs.db_handling.sqlite_io import SQLiteIO
+
+
+# Test fixtures
+@pytest.fixture
+def mock_logger() -> MagicMock:
+    """Create a mock logger for testing"""
+    logger = MagicMock()
+    logger.debug = MagicMock()
+    logger.info = MagicMock()
+    logger.warning = MagicMock()
+    logger.error = MagicMock()
+    return logger
+
+
+@pytest.fixture
+def temp_db_path(tmp_path: Path) -> Path:
+    """Create a temporary database file path"""
+    return tmp_path / "test_database.db"
+
+
+@pytest.fixture
+def mock_sqlite_io() -> Generator[MagicMock, None, None]:
+    """Create a mock SQLiteIO instance"""
+    mock_io = MagicMock(spec=SQLiteIO)
+    mock_io.conn = MagicMock()
+    mock_io.db_connected = MagicMock(return_value=True)
+    mock_io.db_close = MagicMock()
+    mock_io.execute_query = MagicMock(return_value=[])
+    yield mock_io
+
+
+# Test constant
+class TestConstants:
+    """Tests for module-level constants"""
+
+    def test_ident_split_character(self):
+        """Test that IDENT_SPLIT_CHARACTER is defined correctly"""
+        assert IDENT_SPLIT_CHARACTER == ':'
+
+
+# Test SQLMain class initialization
+class TestSQLMainInit:
+    """Tests for SQLMain.__init__"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_successful_initialization_sqlite(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful initialization with SQLite"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        assert sql_main.log == mock_logger
+        assert sql_main.dbh == mock_sqlite_instance
+        assert sql_main.db_target == 'sqlite'
+        mock_sqlite_class.assert_called_once_with(mock_logger, str(temp_db_path), row_factory='Dict')
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_initialization_connection_failure(self, mock_sqlite_class: MagicMock, mock_logger: MagicMock):
+        """Test initialization fails when connection cannot be established"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = None
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = 'sqlite:/path/to/db.db'
+        with pytest.raises(ValueError, match='DB Connection failed for: sqlite'):
+            SQLMain(mock_logger, db_ident)
+
+    def test_initialization_invalid_db_target(self, mock_logger: MagicMock):
+        """Test initialization with unsupported database target"""
+        db_ident = 'postgresql:/path/to/db'
+        with pytest.raises(ValueError, match='SQL interface for postgresql is not implemented'):
+            SQLMain(mock_logger, db_ident)
+
+    def test_initialization_malformed_db_ident(self, mock_logger: MagicMock):
+        """Test initialization with malformed db_ident string"""
+        db_ident = 'sqlite_no_colon'
+        with pytest.raises(ValueError):
+            SQLMain(mock_logger, db_ident)
+
+
+# Test SQLMain.connect method
+class TestSQLMainConnect:
+    """Tests for SQLMain.connect"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_when_already_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connect warns when already connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Reset mock to check second call
+        mock_logger.warning.reset_mock()
+
+        # Try to connect again
+        sql_main.connect(f'sqlite:{temp_db_path}')
+
+        # Should have warned about existing connection
+        mock_logger.warning.assert_called_once()
+        assert 'already exists' in str(mock_logger.warning.call_args)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_sqlite_success(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful SQLite connection"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main.connect(db_ident)
+
+        assert sql_main.db_target == 'sqlite'
+        assert sql_main.dbh == mock_sqlite_instance
+        mock_sqlite_class.assert_called_once_with(mock_logger, str(temp_db_path), row_factory='Dict')
+
+    def test_connect_unsupported_database(self, mock_logger: MagicMock):
+        """Test connect with unsupported database type"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = 'mysql:/path/to/db'
+        with pytest.raises(ValueError, match='SQL interface for mysql is not implemented'):
+            sql_main.connect(db_ident)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_db_connection_failed(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connect raises error when DB connection fails"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = f'sqlite:{temp_db_path}'
+        with pytest.raises(ValueError, match='DB Connection failed for: sqlite'):
+            sql_main.connect(db_ident)
+
+
+# Test SQLMain.close method
+class TestSQLMainClose:
+    """Tests for SQLMain.close"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_close_successful(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful database close"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        sql_main.close()
+
+        mock_sqlite_instance.db_close.assert_called_once()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_close_when_not_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test close when not connected does nothing"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Change db_connected to return False to simulate disconnection
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+
+        sql_main.close()
+
+        # Should not raise error and should exit early
+        assert mock_sqlite_instance.db_close.call_count == 0
+
+    def test_close_when_dbh_is_none(self, mock_logger: MagicMock):
+        """Test close when dbh is None"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = 'sqlite'
+
+        # Should not raise error
+        sql_main.close()
+
+
+# Test SQLMain.connected method
+class TestSQLMainConnected:
+    """Tests for SQLMain.connected"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connected_returns_true(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connected returns True when connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        assert sql_main.connected() is True
+        mock_logger.warning.assert_not_called()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connected_returns_false_when_not_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connected returns False and warns when not connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Reset warning calls from init
+        mock_logger.warning.reset_mock()
+
+        # Change db_connected to return False to simulate disconnection
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+
+        assert sql_main.connected() is False
+        mock_logger.warning.assert_called_once()
+        assert 'No connection' in str(mock_logger.warning.call_args)
+
+    def test_connected_returns_false_when_dbh_is_none(self, mock_logger: MagicMock):
+        """Test connected returns False when dbh is None"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = 'sqlite'
+
+        assert sql_main.connected() is False
+        mock_logger.warning.assert_called_once()
+
+
+# Test SQLMain.process_query method
+class TestSQLMainProcessQuery:
+    """Tests for SQLMain.process_query"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_success_no_params(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful query execution without parameters"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        expected_result = [{'id': 1, 'name': 'test'}]
+        mock_sqlite_instance.execute_query = MagicMock(return_value=expected_result)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test"
+        result = sql_main.process_query(query)
+
+        assert result == expected_result
+        mock_sqlite_instance.execute_query.assert_called_once_with(query, None)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_success_with_params(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful query execution with parameters"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        expected_result = [{'id': 1, 'name': 'test'}]
+        mock_sqlite_instance.execute_query = MagicMock(return_value=expected_result)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test WHERE id = ?"
+        params = (1,)
+        result = sql_main.process_query(query, params)
+
+        assert result == expected_result
+        mock_sqlite_instance.execute_query.assert_called_once_with(query, params)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_returns_false_on_error(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns False when execute_query fails"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM nonexistent"
+        result = sql_main.process_query(query)
+
+        assert result is False
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_dbh_is_none(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns False when dbh is None"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Manually set dbh to None
+        sql_main.dbh = None
+
+        query = "SELECT * FROM test"
+        result = sql_main.process_query(query)
+
+        assert result is False
+        mock_logger.error.assert_called_once()
+        assert 'Problem connecting to db' in str(mock_logger.error.call_args)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_returns_empty_list(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns empty list when no results"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=[])
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test WHERE 1=0"
+        result = sql_main.process_query(query)
+
+        assert result == []
+
+
+# Integration-like tests
+class TestSQLMainIntegration:
+    """Integration-like tests for complete workflows"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_full_workflow_connect_query_close(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test complete workflow: connect, query, close"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=[{'count': 5}])
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Execute query
+        result = sql_main.process_query("SELECT COUNT(*) as count FROM test")
+        assert result == [{'count': 5}]
+
+        # Check connected
+        assert sql_main.connected() is True
+
+        # Close connection
+        sql_main.close()
+        mock_sqlite_instance.db_close.assert_called_once()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_multiple_queries_same_connection(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test multiple queries on the same connection"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(side_effect=[
+            [{'id': 1}],
+            [{'id': 2}],
+            [{'id': 3}]
+        ])
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        result1 = sql_main.process_query("SELECT * FROM test WHERE id = 1")
+        result2 = sql_main.process_query("SELECT * FROM test WHERE id = 2")
+        result3 = sql_main.process_query("SELECT * FROM test WHERE id = 3")
+
+        assert result1 == [{'id': 1}]
+        assert result2 == [{'id': 2}]
+        assert result3 == [{'id': 3}]
+        assert mock_sqlite_instance.execute_query.call_count == 3
+
+
+# __END__

tests/unit/encryption_handling/__init__.py

@@ -1,3 +0,0 @@
-"""
-Unit tests for encryption_handling module
-"""

tests/unit/encryption_handling/test_symmetric_encryption.py

@@ -1,665 +0,0 @@
-"""
-PyTest: encryption_handling/symmetric_encryption
-"""
-# pylint: disable=redefined-outer-name
-# ^ Disabled because pytest fixtures intentionally redefine names
-
-import os
-import json
-import base64
-import hashlib
-import pytest
-from corelibs.encryption_handling.symmetric_encryption import (
-    SymmetricEncryption
-)
-
-
-class TestSymmetricEncryptionInitialization:
-    """Tests for SymmetricEncryption initialization"""
-
-    def test_valid_password_initialization(self):
-        """Test initialization with a valid password"""
-        encryptor = SymmetricEncryption("test_password")
-        assert encryptor.password == "test_password"
-        assert encryptor.password_hash == hashlib.sha256("test_password".encode('utf-8')).hexdigest()
-
-    def test_empty_password_raises_error(self):
-        """Test that empty password raises ValueError"""
-        with pytest.raises(ValueError, match="A password must be set"):
-            SymmetricEncryption("")
-
-    def test_password_hash_is_consistent(self):
-        """Test that password hash is consistently generated"""
-        encryptor1 = SymmetricEncryption("test_password")
-        encryptor2 = SymmetricEncryption("test_password")
-        assert encryptor1.password_hash == encryptor2.password_hash
-
-    def test_different_passwords_different_hashes(self):
-        """Test that different passwords produce different hashes"""
-        encryptor1 = SymmetricEncryption("password1")
-        encryptor2 = SymmetricEncryption("password2")
-        assert encryptor1.password_hash != encryptor2.password_hash
-
-
-class TestEncryptWithMetadataReturnDict:
-    """Tests for encrypt_with_metadata_return_dict method"""
-
-    def test_encrypt_string_returns_package_data(self):
-        """Test encrypting a string returns PackageData dict"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_dict("test data")
-
-        assert isinstance(result, dict)
-        assert 'encrypted_data' in result
-        assert 'salt' in result
-        assert 'key_hash' in result
-
-    def test_encrypt_bytes_returns_package_data(self):
-        """Test encrypting bytes returns PackageData dict"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_dict(b"test data")
-
-        assert isinstance(result, dict)
-        assert 'encrypted_data' in result
-        assert 'salt' in result
-        assert 'key_hash' in result
-
-    def test_encrypted_data_is_base64_encoded(self):
-        """Test that encrypted_data is base64 encoded"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_dict("test data")
-
-        # Should not raise exception when decoding
-        base64.urlsafe_b64decode(result['encrypted_data'])
-
-    def test_salt_is_base64_encoded(self):
-        """Test that salt is base64 encoded"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_dict("test data")
-
-        # Should not raise exception when decoding
-        salt = base64.urlsafe_b64decode(result['salt'])
-        # Salt should be 16 bytes
-        assert len(salt) == 16
-
-    def test_key_hash_is_valid_hex(self):
-        """Test that key_hash is a valid hex string"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_dict("test data")
-
-        # Should be 64 characters (SHA256 hex)
-        assert len(result['key_hash']) == 64
-        # Should only contain hex characters
-        int(result['key_hash'], 16)
-
-    def test_different_salts_for_each_encryption(self):
-        """Test that each encryption uses a different salt"""
-        encryptor = SymmetricEncryption("test_password")
-        result1 = encryptor.encrypt_with_metadata_return_dict("test data")
-        result2 = encryptor.encrypt_with_metadata_return_dict("test data")
-
-        assert result1['salt'] != result2['salt']
-        assert result1['encrypted_data'] != result2['encrypted_data']
-
-
-class TestEncryptWithMetadataReturnStr:
-    """Tests for encrypt_with_metadata_return_str method"""
-
-    def test_returns_json_string(self):
-        """Test that method returns a valid JSON string"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_str("test data")
-
-        assert isinstance(result, str)
-        # Should be valid JSON
-        parsed = json.loads(result)
-        assert 'encrypted_data' in parsed
-        assert 'salt' in parsed
-        assert 'key_hash' in parsed
-
-    def test_json_string_parseable(self):
-        """Test that returned JSON string can be parsed back"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_str("test data")
-
-        parsed = json.loads(result)
-        assert isinstance(parsed, dict)
-
-
-class TestEncryptWithMetadataReturnBytes:
-    """Tests for encrypt_with_metadata_return_bytes method"""
-
-    def test_returns_bytes(self):
-        """Test that method returns bytes"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_bytes("test data")
-
-        assert isinstance(result, bytes)
-
-    def test_bytes_contains_valid_json(self):
-        """Test that returned bytes contain valid JSON"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata_return_bytes("test data")
-
-        # Should be valid JSON when decoded
-        parsed = json.loads(result.decode('utf-8'))
-        assert 'encrypted_data' in parsed
-        assert 'salt' in parsed
-        assert 'key_hash' in parsed
-
-
-class TestEncryptWithMetadata:
-    """Tests for encrypt_with_metadata method with different return types"""
-
-    def test_return_as_str(self):
-        """Test encrypt_with_metadata with return_as='str'"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data", return_as='str')
-
-        assert isinstance(result, str)
-        json.loads(result)  # Should be valid JSON
-
-    def test_return_as_json(self):
-        """Test encrypt_with_metadata with return_as='json'"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data", return_as='json')
-
-        assert isinstance(result, str)
-        json.loads(result)  # Should be valid JSON
-
-    def test_return_as_bytes(self):
-        """Test encrypt_with_metadata with return_as='bytes'"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data", return_as='bytes')
-
-        assert isinstance(result, bytes)
-
-    def test_return_as_dict(self):
-        """Test encrypt_with_metadata with return_as='dict'"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data", return_as='dict')
-
-        assert isinstance(result, dict)
-        assert 'encrypted_data' in result
-
-    def test_default_return_type(self):
-        """Test encrypt_with_metadata default return type"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data")
-
-        # Default should be 'str'
-        assert isinstance(result, str)
-
-    def test_invalid_return_type_defaults_to_str(self):
-        """Test that invalid return_as defaults to str"""
-        encryptor = SymmetricEncryption("test_password")
-        result = encryptor.encrypt_with_metadata("test data", return_as='invalid')
-
-        assert isinstance(result, str)
-
-
-class TestDecryptWithMetadata:
-    """Tests for decrypt_with_metadata method"""
-
-    def test_decrypt_string_package(self):
-        """Test decrypting a string JSON package"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_decrypt_bytes_package(self):
-        """Test decrypting a bytes JSON package"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_bytes("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_decrypt_dict_package(self):
-        """Test decrypting a dict PackageData"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_dict("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_decrypt_with_different_password_fails(self):
-        """Test that decrypting with wrong password fails"""
-        encryptor = SymmetricEncryption("password1")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-
-        decryptor = SymmetricEncryption("password2")
-        with pytest.raises(ValueError, match="Key hash is not matching"):
-            decryptor.decrypt_with_metadata(encrypted)
-
-    def test_decrypt_with_explicit_password(self):
-        """Test decrypting with explicitly provided password"""
-        encryptor = SymmetricEncryption("password1")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-
-        # Decrypt with different password parameter
-        decryptor = SymmetricEncryption("password1")
-        decrypted = decryptor.decrypt_with_metadata(encrypted, password="password1")
-
-        assert decrypted == "test data"
-
-    def test_decrypt_invalid_json_raises_error(self):
-        """Test that invalid JSON raises ValueError"""
-        encryptor = SymmetricEncryption("test_password")
-
-        with pytest.raises(ValueError, match="Invalid encrypted package format"):
-            encryptor.decrypt_with_metadata("not valid json")
-
-    def test_decrypt_missing_fields_raises_error(self):
-        """Test that missing required fields raises ValueError"""
-        encryptor = SymmetricEncryption("test_password")
-        invalid_package = json.dumps({"encrypted_data": "test"})
-
-        with pytest.raises(ValueError, match="Invalid encrypted package format"):
-            encryptor.decrypt_with_metadata(invalid_package)
-
-    def test_decrypt_unicode_data(self):
-        """Test encrypting and decrypting unicode data"""
-        encryptor = SymmetricEncryption("test_password")
-        unicode_data = "Hello 世界 🌍"
-        encrypted = encryptor.encrypt_with_metadata_return_str(unicode_data)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == unicode_data
-
-    def test_decrypt_empty_string(self):
-        """Test encrypting and decrypting empty string"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str("")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == ""
-
-    def test_decrypt_long_data(self):
-        """Test encrypting and decrypting long data"""
-        encryptor = SymmetricEncryption("test_password")
-        long_data = "A" * 10000
-        encrypted = encryptor.encrypt_with_metadata_return_str(long_data)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == long_data
-
-
-class TestStaticMethods:
-    """Tests for static methods encrypt_data and decrypt_data"""
-
-    def test_encrypt_data_static_method(self):
-        """Test static encrypt_data method"""
-        encrypted = SymmetricEncryption.encrypt_data("test data", "test_password")
-
-        assert isinstance(encrypted, str)
-        # Should be valid JSON
-        parsed = json.loads(encrypted)
-        assert 'encrypted_data' in parsed
-        assert 'salt' in parsed
-        assert 'key_hash' in parsed
-
-    def test_decrypt_data_static_method(self):
-        """Test static decrypt_data method"""
-        encrypted = SymmetricEncryption.encrypt_data("test data", "test_password")
-        decrypted = SymmetricEncryption.decrypt_data(encrypted, "test_password")
-
-        assert decrypted == "test data"
-
-    def test_static_methods_roundtrip(self):
-        """Test complete roundtrip using static methods"""
-        original = "test data with special chars: !@#$%^&*()"
-        encrypted = SymmetricEncryption.encrypt_data(original, "test_password")
-        decrypted = SymmetricEncryption.decrypt_data(encrypted, "test_password")
-
-        assert decrypted == original
-
-    def test_static_decrypt_with_bytes(self):
-        """Test static decrypt_data with bytes input"""
-        encrypted = SymmetricEncryption.encrypt_data("test data", "test_password")
-        encrypted_bytes = encrypted.encode('utf-8')
-        decrypted = SymmetricEncryption.decrypt_data(encrypted_bytes, "test_password")
-
-        assert decrypted == "test data"
-
-    def test_static_decrypt_with_dict(self):
-        """Test static decrypt_data with PackageData dict"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted_dict = encryptor.encrypt_with_metadata_return_dict("test data")
-        decrypted = SymmetricEncryption.decrypt_data(encrypted_dict, "test_password")
-
-        assert decrypted == "test data"
-
-    def test_static_encrypt_bytes_data(self):
-        """Test static encrypt_data with bytes input"""
-        encrypted = SymmetricEncryption.encrypt_data(b"test data", "test_password")
-        decrypted = SymmetricEncryption.decrypt_data(encrypted, "test_password")
-
-        assert decrypted == "test data"
-
-
-class TestEncryptionSecurity:
-    """Security-related tests for encryption"""
-
-    def test_same_data_different_encryption(self):
-        """Test that same data produces different encrypted outputs due to salt"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted1 = encryptor.encrypt_with_metadata_return_str("test data")
-        encrypted2 = encryptor.encrypt_with_metadata_return_str("test data")
-
-        assert encrypted1 != encrypted2
-
-    def test_password_not_recoverable_from_hash(self):
-        """Test that password hash is one-way"""
-        encryptor = SymmetricEncryption("secret_password")
-        # The password_hash should be SHA256 hex (64 chars)
-        assert len(encryptor.password_hash) == 64
-        # Password should not be easily derivable from hash
-        assert "secret_password" not in encryptor.password_hash
-
-    def test_encrypted_data_not_plaintext(self):
-        """Test that encrypted data doesn't contain plaintext"""
-        encryptor = SymmetricEncryption("test_password")
-        plaintext = "very_secret_data_12345"
-        encrypted = encryptor.encrypt_with_metadata_return_str(plaintext)
-
-        # Plaintext should not appear in encrypted output
-        assert plaintext not in encrypted
-
-    def test_modified_encrypted_data_fails_decryption(self):
-        """Test that modified encrypted data fails to decrypt"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-
-        # Modify the encrypted data
-        encrypted_dict = json.loads(encrypted)
-        encrypted_dict['encrypted_data'] = encrypted_dict['encrypted_data'][:-5] + "AAAAA"
-        modified_encrypted = json.dumps(encrypted_dict)
-
-        # Should fail to decrypt
-        with pytest.raises(Exception):  # Fernet will raise an exception
-            encryptor.decrypt_with_metadata(modified_encrypted)
-
-    def test_modified_salt_fails_decryption(self):
-        """Test that modified salt fails to decrypt"""
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-
-        # Modify the salt
-        encrypted_dict = json.loads(encrypted)
-        original_salt = base64.urlsafe_b64decode(encrypted_dict['salt'])
-        modified_salt = bytes([b ^ 1 for b in original_salt])
-        encrypted_dict['salt'] = base64.urlsafe_b64encode(modified_salt).decode('utf-8')
-        modified_encrypted = json.dumps(encrypted_dict)
-
-        # Should fail to decrypt due to key hash mismatch
-        with pytest.raises(ValueError, match="Key hash is not matching"):
-            encryptor.decrypt_with_metadata(modified_encrypted)
-
-
-class TestEdgeCases:
-    """Edge case tests"""
-
-    def test_very_long_password(self):
-        """Test with very long password"""
-        long_password = "a" * 1000
-        encryptor = SymmetricEncryption(long_password)
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_special_characters_in_data(self):
-        """Test encryption of data with special characters"""
-        special_data = "!@#$%^&*()_+-=[]{}|;':\",./<>?\n\t\r"
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(special_data)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == special_data
-
-    def test_binary_data_utf8_bytes(self):
-        """Test encryption of UTF-8 encoded bytes"""
-        # Test with UTF-8 encoded bytes
-        utf8_bytes = "Hello 世界 🌍".encode('utf-8')
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(utf8_bytes)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "Hello 世界 🌍"
-
-    def test_binary_data_with_base64_encoding(self):
-        """Test encryption of arbitrary binary data using base64 encoding"""
-        # For arbitrary binary data, encode to base64 first
-        binary_data = bytes(range(256))
-        base64_encoded = base64.b64encode(binary_data).decode('utf-8')
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(base64_encoded)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        # Decode back to binary
-        decoded_binary = base64.b64decode(decrypted)
-        assert decoded_binary == binary_data
-
-    def test_binary_data_image_simulation(self):
-        """Test encryption of simulated binary image data"""
-        # Simulate image binary data (random bytes)
-        image_data = os.urandom(1024)  # 1KB of random binary data
-        base64_encoded = base64.b64encode(image_data).decode('utf-8')
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(base64_encoded)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        # Verify round-trip
-        decoded_data = base64.b64decode(decrypted)
-        assert decoded_data == image_data
-
-    def test_binary_data_with_null_bytes(self):
-        """Test encryption of data containing null bytes"""
-        # Create data with null bytes
-        data_with_nulls = "text\x00with\x00nulls\x00bytes"
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(data_with_nulls)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == data_with_nulls
-
-    def test_binary_data_bytes_input(self):
-        """Test encryption with bytes input directly"""
-        # UTF-8 compatible bytes
-        byte_data = b"Binary data test"
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(byte_data)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "Binary data test"
-
-    def test_binary_data_large_file_simulation(self):
-        """Test encryption of large binary data (simulated file)"""
-        # Simulate a larger binary file (10KB)
-        large_data = os.urandom(10240)
-        base64_encoded = base64.b64encode(large_data).decode('utf-8')
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(base64_encoded)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        # Verify integrity
-        decoded_data = base64.b64decode(decrypted)
-        assert len(decoded_data) == 10240
-        assert decoded_data == large_data
-
-    def test_binary_data_json_with_base64(self):
-        """Test encryption of JSON containing base64 encoded binary data"""
-        binary_data = os.urandom(256)
-        json_data = json.dumps({
-            "filename": "test.bin",
-            "data": base64.b64encode(binary_data).decode('utf-8'),
-            "size": len(binary_data)
-        })
-
-        encryptor = SymmetricEncryption("test_password")
-        encrypted = encryptor.encrypt_with_metadata_return_str(json_data)
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        # Parse and verify
-        parsed = json.loads(decrypted)
-        assert parsed["filename"] == "test.bin"
-        assert parsed["size"] == 256
-        decoded_binary = base64.b64decode(parsed["data"])
-        assert decoded_binary == binary_data
-
-    def test_numeric_password(self):
-        """Test with numeric string password"""
-        encryptor = SymmetricEncryption("12345")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_unicode_password(self):
-        """Test with unicode password"""
-        encryptor = SymmetricEncryption("パスワード123")
-        encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-        decrypted = encryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-
-class TestIntegration:
-    """Integration tests"""
-
-    def test_multiple_encrypt_decrypt_cycles(self):
-        """Test multiple encryption/decryption cycles"""
-        encryptor = SymmetricEncryption("test_password")
-        original = "test data"
-
-        # Encrypt and decrypt multiple times
-        for _ in range(5):
-            encrypted = encryptor.encrypt_with_metadata_return_str(original)
-            decrypted = encryptor.decrypt_with_metadata(encrypted)
-            assert decrypted == original
-
-    def test_different_return_types_interoperability(self):
-        """Test that different return types can be decrypted"""
-        encryptor = SymmetricEncryption("test_password")
-        original = "test data"
-
-        # Encrypt with different return types
-        encrypted_str = encryptor.encrypt_with_metadata_return_str(original)
-        encrypted_bytes = encryptor.encrypt_with_metadata_return_bytes(original)
-        encrypted_dict = encryptor.encrypt_with_metadata_return_dict(original)
-
-        # All should decrypt to the same value
-        assert encryptor.decrypt_with_metadata(encrypted_str) == original
-        assert encryptor.decrypt_with_metadata(encrypted_bytes) == original
-        assert encryptor.decrypt_with_metadata(encrypted_dict) == original
-
-    def test_cross_instance_encryption_decryption(self):
-        """Test that different instances with same password can decrypt"""
-        encryptor1 = SymmetricEncryption("test_password")
-        encryptor2 = SymmetricEncryption("test_password")
-
-        encrypted = encryptor1.encrypt_with_metadata_return_str("test data")
-        decrypted = encryptor2.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-    def test_static_and_instance_methods_compatible(self):
-        """Test that static and instance methods are compatible"""
-        # Encrypt with static method
-        encrypted = SymmetricEncryption.encrypt_data("test data", "test_password")
-
-        # Decrypt with instance method
-        decryptor = SymmetricEncryption("test_password")
-        decrypted = decryptor.decrypt_with_metadata(encrypted)
-
-        assert decrypted == "test data"
-
-        # And vice versa
-        encryptor = SymmetricEncryption("test_password")
-        encrypted2 = encryptor.encrypt_with_metadata_return_str("test data 2")
-        decrypted2 = SymmetricEncryption.decrypt_data(encrypted2, "test_password")
-
-        assert decrypted2 == "test data 2"
-
-
-# Parametrized tests
-@pytest.mark.parametrize("data", [
-    "simple text",
-    "text with spaces and punctuation!",
-    "123456789",
-    "unicode: こんにちは",
-    "emoji: 🔐🔑",
-    "",
-    "a" * 1000,  # Long string
-])
-def test_encrypt_decrypt_various_data(data: str):
-    """Parametrized test for various data types"""
-    encryptor = SymmetricEncryption("test_password")
-    encrypted = encryptor.encrypt_with_metadata_return_str(data)
-    decrypted = encryptor.decrypt_with_metadata(encrypted)
-    assert decrypted == data
-
-
-@pytest.mark.parametrize("password", [
-    "simple",
-    "with spaces",
-    "special!@#$%",
-    "unicode世界",
-    "123456",
-    "a" * 100,  # Long password
-])
-def test_various_passwords(password: str):
-    """Parametrized test for various passwords"""
-    encryptor = SymmetricEncryption(password)
-    encrypted = encryptor.encrypt_with_metadata_return_str("test data")
-    decrypted = encryptor.decrypt_with_metadata(encrypted)
-    assert decrypted == "test data"
-
-
-@pytest.mark.parametrize("return_type,expected_type", [
-    ("str", str),
-    ("json", str),
-    ("bytes", bytes),
-    ("dict", dict),
-])
-def test_return_types_parametrized(return_type: str, expected_type: type):
-    """Parametrized test for different return types"""
-    encryptor = SymmetricEncryption("test_password")
-    result = encryptor.encrypt_with_metadata("test data", return_as=return_type)
-    assert isinstance(result, expected_type)
-
-
-# Fixtures
-@pytest.fixture
-def encryptor() -> SymmetricEncryption:
-    """Fixture providing a basic encryptor instance"""
-    return SymmetricEncryption("test_password")
-
-
-@pytest.fixture
-def sample_encrypted_data(encryptor: SymmetricEncryption) -> str:
-    """Fixture providing sample encrypted data"""
-    return encryptor.encrypt_with_metadata_return_str("sample data")
-
-
-def test_with_encryptor_fixture(encryptor: SymmetricEncryption) -> None:
-    """Test using encryptor fixture"""
-    encrypted: str = encryptor.encrypt_with_metadata_return_str("test")
-    decrypted: str = encryptor.decrypt_with_metadata(encrypted)
-    assert decrypted == "test"
-
-
-def test_with_encrypted_data_fixture(encryptor: SymmetricEncryption, sample_encrypted_data: str) -> None:
-    """Test using encrypted data fixture"""
-    decrypted: str = encryptor.decrypt_with_metadata(sample_encrypted_data)
-    assert decrypted == "sample data"
-
-# __END__

tests/unit/iterator_handling/test_dict_helpers.py

@@ -1,291 +0,0 @@
-"""
-tests for corelibs.iterator_handling.dict_helpers
-"""
-
-import pytest
-from typing import Any
-from corelibs.iterator_handling.dict_helpers import mask
-
-
-def test_mask_default_behavior():
-    """Test masking with default mask_keys"""
-    data = {
-        "username": "john_doe",
-        "password": "secret123",
-        "email": "john@example.com",
-        "api_secret": "abc123",
-        "encryption_key": "xyz789"
-    }
-
-    result = mask(data)
-
-    assert result["username"] == "john_doe"
-    assert result["password"] == "***"
-    assert result["email"] == "john@example.com"
-    assert result["api_secret"] == "***"
-    assert result["encryption_key"] == "***"
-
-
-def test_mask_custom_keys():
-    """Test masking with custom mask_keys"""
-    data = {
-        "username": "john_doe",
-        "token": "abc123",
-        "api_key": "xyz789",
-        "password": "secret123"
-    }
-
-    result = mask(data, mask_keys=["token", "api"])
-
-    assert result["username"] == "john_doe"
-    assert result["token"] == "***"
-    assert result["api_key"] == "***"
-    assert result["password"] == "secret123"  # Not masked with custom keys
-
-
-def test_mask_custom_mask_string():
-    """Test masking with custom mask string"""
-    data = {"password": "secret123"}
-
-    result = mask(data, mask_str="[HIDDEN]")
-
-    assert result["password"] == "[HIDDEN]"
-
-
-def test_mask_case_insensitive():
-    """Test that masking is case insensitive"""
-    data = {
-        "PASSWORD": "secret123",
-        "Secret_Key": "abc123",
-        "ENCRYPTION_data": "xyz789"
-    }
-
-    result = mask(data)
-
-    assert result["PASSWORD"] == "***"
-    assert result["Secret_Key"] == "***"
-    assert result["ENCRYPTION_data"] == "***"
-
-
-def test_mask_key_patterns():
-    """Test different key matching patterns (start, end, contains)"""
-    data = {
-        "password_hash": "hash123",  # starts with
-        "user_password": "secret123",  # ends with
-        "my_secret_key": "abc123",  # contains with edges
-        "secretvalue": "xyz789",  # contains without edges
-        "startsecretvalue": "xyz123",  # contains without edges
-        "normal_key": "normal_value"
-    }
-
-    result = mask(data)
-
-    assert result["password_hash"] == "***"
-    assert result["user_password"] == "***"
-    assert result["my_secret_key"] == "***"
-    assert result["secretvalue"] == "***"  # will mask beacuse starts with
-    assert result["startsecretvalue"] == "xyz123"  # will not mask
-    assert result["normal_key"] == "normal_value"
-
-
-def test_mask_custom_edges():
-    """Test masking with custom edge characters"""
-    data = {
-        "my-secret-key": "abc123",
-        "my_secret_key": "xyz789"
-    }
-
-    result = mask(data, mask_str_edges="-")
-
-    assert result["my-secret-key"] == "***"
-    assert result["my_secret_key"] == "xyz789"  # Underscore edges don't match
-
-
-def test_mask_empty_edges():
-    """Test masking with empty edge characters (substring matching)"""
-    data = {
-        "secretvalue": "abc123",
-        "mysecretkey": "xyz789",
-        "normal_key": "normal_value"
-    }
-
-    result = mask(data, mask_str_edges="")
-
-    assert result["secretvalue"] == "***"
-    assert result["mysecretkey"] == "***"
-    assert result["normal_key"] == "normal_value"
-
-
-def test_mask_nested_dict():
-    """Test masking nested dictionaries"""
-    data = {
-        "user": {
-            "name": "john",
-            "password": "secret123",
-            "profile": {
-                "email": "john@example.com",
-                "encryption_key": "abc123"
-            }
-        },
-        "api_secret": "xyz789"
-    }
-
-    result = mask(data)
-
-    assert result["user"]["name"] == "john"
-    assert result["user"]["password"] == "***"
-    assert result["user"]["profile"]["email"] == "john@example.com"
-    assert result["user"]["profile"]["encryption_key"] == "***"
-    assert result["api_secret"] == "***"
-
-
-def test_mask_lists():
-    """Test masking lists and nested structures with lists"""
-    data = {
-        "users": [
-            {"name": "john", "password": "secret1"},
-            {"name": "jane", "password": "secret2"}
-        ],
-        "secrets": ["secret1", "secret2", "secret3"]
-    }
-
-    result = mask(data)
-    print(f"R {result['secrets']}")
-
-    assert result["users"][0]["name"] == "john"
-    assert result["users"][0]["password"] == "***"
-    assert result["users"][1]["name"] == "jane"
-    assert result["users"][1]["password"] == "***"
-    assert result["secrets"] == ["***", "***", "***"]
-
-
-def test_mask_mixed_types():
-    """Test masking with different value types"""
-    data = {
-        "password": "string_value",
-        "secret_number": 12345,
-        "encryption_flag": True,
-        "secret_float": 3.14,
-        "password_none": None,
-        "normal_key": "normal_value"
-    }
-
-    result = mask(data)
-
-    assert result["password"] == "***"
-    assert result["secret_number"] == "***"
-    assert result["encryption_flag"] == "***"
-    assert result["secret_float"] == "***"
-    assert result["password_none"] == "***"
-    assert result["normal_key"] == "normal_value"
-
-
-def test_mask_skip_true():
-    """Test that skip=True returns original data unchanged"""
-    data = {
-        "password": "secret123",
-        "encryption_key": "abc123",
-        "normal_key": "normal_value"
-    }
-
-    result = mask(data, skip=True)
-
-    assert result == data
-    assert result is data  # Should return the same object
-
-
-def test_mask_empty_dict():
-    """Test masking empty dictionary"""
-    data: dict[str, Any] = {}
-
-    result = mask(data)
-
-    assert result == {}
-
-
-def test_mask_none_mask_keys():
-    """Test explicit None mask_keys uses defaults"""
-    data = {"password": "secret123", "token": "abc123"}
-
-    result = mask(data, mask_keys=None)
-
-    assert result["password"] == "***"
-    assert result["token"] == "abc123"  # Not in default keys
-
-
-def test_mask_empty_mask_keys():
-    """Test empty mask_keys list"""
-    data = {"password": "secret123", "secret": "abc123"}
-
-    result = mask(data, mask_keys=[])
-
-    assert result["password"] == "secret123"
-    assert result["secret"] == "abc123"
-
-
-def test_mask_complex_nested_structure():
-    """Test masking complex nested structure"""
-    data = {
-        "config": {
-            "database": {
-                "host": "localhost",
-                "password": "db_secret",
-                "users": [
-                    {"name": "admin", "password": "admin123"},
-                    {"name": "user", "secret_key": "user456"}
-                ]
-            },
-            "api": {
-                "endpoints": ["api1", "api2"],
-                "encryption_settings": {
-                    "enabled": True,
-                    "secret": "api_secret"
-                }
-            }
-        }
-    }
-
-    result = mask(data)
-
-    assert result["config"]["database"]["host"] == "localhost"
-    assert result["config"]["database"]["password"] == "***"
-    assert result["config"]["database"]["users"][0]["name"] == "admin"
-    assert result["config"]["database"]["users"][0]["password"] == "***"
-    assert result["config"]["database"]["users"][1]["name"] == "user"
-    assert result["config"]["database"]["users"][1]["secret_key"] == "***"
-    assert result["config"]["api"]["endpoints"] == ["api1", "api2"]
-    assert result["config"]["api"]["encryption_settings"]["enabled"] is True
-    assert result["config"]["api"]["encryption_settings"]["secret"] == "***"
-
-
-def test_mask_preserves_original_data():
-    """Test that original data is not modified"""
-    original_data = {
-        "password": "secret123",
-        "username": "john_doe"
-    }
-    data_copy = original_data.copy()
-
-    result = mask(original_data)
-
-    assert original_data == data_copy  # Original unchanged
-    assert result != original_data  # Result is different
-    assert result["password"] == "***"
-    assert original_data["password"] == "secret123"
-
-
-@pytest.mark.parametrize("mask_key,expected_keys", [
-    (["pass"], ["password", "user_pass", "my_pass_key"]),
-    (["key"], ["api_key", "secret_key", "my_key_value"]),
-    (["token"], ["token", "auth_token", "my_token_here"]),
-])
-def test_mask_parametrized_keys(mask_key: list[str], expected_keys: list[str]):
-    """Parametrized test for different mask key patterns"""
-    data = {key: "value" for key in expected_keys}
-    data["normal_entry"] = "normal_value"
-
-    result = mask(data, mask_keys=mask_key)
-
-    for key in expected_keys:
-        assert result[key] == "***"
-    assert result["normal_entry"] == "normal_value"

tests/unit/iterator_handling/test_list_helpers.py

@@ -1,300 +0,0 @@
-"""
-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/json_handling/__init__.py

@@ -1,3 +0,0 @@
-"""
-tests for json_handling module
-"""

tests/unit/json_handling/test_json_helper.py

@@ -1,698 +0,0 @@
-"""
-tests for corelibs.json_handling.json_helper
-"""
-
-import json
-from datetime import datetime, date
-from typing import Any
-from corelibs.json_handling.json_helper import (
-    DateTimeEncoder,
-    default,
-    json_dumps,
-    modify_with_jsonpath
-)
-
-
-# MARK: DateTimeEncoder tests
-class TestDateTimeEncoder:
-    """Test cases for DateTimeEncoder class"""
-
-    def test_datetime_encoding(self):
-        """Test encoding datetime objects"""
-        dt = datetime(2025, 10, 23, 15, 30, 45, 123456)
-        data = {"timestamp": dt}
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["timestamp"] == "2025-10-23T15:30:45.123456"
-
-    def test_date_encoding(self):
-        """Test encoding date objects"""
-        d = date(2025, 10, 23)
-        data = {"date": d}
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["date"] == "2025-10-23"
-
-    def test_mixed_datetime_date_encoding(self):
-        """Test encoding mixed datetime and date objects"""
-        dt = datetime(2025, 10, 23, 15, 30, 45)
-        d = date(2025, 10, 23)
-        data = {
-            "timestamp": dt,
-            "date": d,
-            "name": "test"
-        }
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["timestamp"] == "2025-10-23T15:30:45"
-        assert decoded["date"] == "2025-10-23"
-        assert decoded["name"] == "test"
-
-    def test_nested_datetime_encoding(self):
-        """Test encoding nested structures with datetime objects"""
-        data = {
-            "event": {
-                "name": "Meeting",
-                "start": datetime(2025, 10, 23, 10, 0, 0),
-                "end": datetime(2025, 10, 23, 11, 0, 0),
-                "participants": [
-                    {"name": "Alice", "joined": datetime(2025, 10, 23, 10, 5, 0)},
-                    {"name": "Bob", "joined": datetime(2025, 10, 23, 10, 10, 0)}
-                ]
-            }
-        }
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["event"]["start"] == "2025-10-23T10:00:00"
-        assert decoded["event"]["end"] == "2025-10-23T11:00:00"
-        assert decoded["event"]["participants"][0]["joined"] == "2025-10-23T10:05:00"
-        assert decoded["event"]["participants"][1]["joined"] == "2025-10-23T10:10:00"
-
-    def test_list_of_datetimes(self):
-        """Test encoding list of datetime objects"""
-        data = {
-            "timestamps": [
-                datetime(2025, 10, 23, 10, 0, 0),
-                datetime(2025, 10, 23, 11, 0, 0),
-                datetime(2025, 10, 23, 12, 0, 0)
-            ]
-        }
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["timestamps"][0] == "2025-10-23T10:00:00"
-        assert decoded["timestamps"][1] == "2025-10-23T11:00:00"
-        assert decoded["timestamps"][2] == "2025-10-23T12:00:00"
-
-    def test_encoder_with_normal_types(self):
-        """Test that encoder works with standard JSON types"""
-        data = {
-            "string": "test",
-            "number": 42,
-            "float": 3.14,
-            "boolean": True,
-            "null": None,
-            "list": [1, 2, 3],
-            "dict": {"key": "value"}
-        }
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded == data
-
-    def test_encoder_returns_none_for_unsupported_types(self):
-        """Test that encoder default method returns None for unsupported types"""
-        encoder = DateTimeEncoder()
-
-        # The default method should return None for non-date/datetime objects
-        result = encoder.default("string")
-        assert result is None
-
-        result = encoder.default(42)
-        assert result is None
-
-        result = encoder.default([1, 2, 3])
-        assert result is None
-
-
-# MARK: default function tests
-class TestDefaultFunction:
-    """Test cases for the default function"""
-
-    def test_default_datetime(self):
-        """Test default function with datetime"""
-        dt = datetime(2025, 10, 23, 15, 30, 45)
-        result = default(dt)
-        assert result == "2025-10-23T15:30:45"
-
-    def test_default_date(self):
-        """Test default function with date"""
-        d = date(2025, 10, 23)
-        result = default(d)
-        assert result == "2025-10-23"
-
-    def test_default_with_microseconds(self):
-        """Test default function with datetime including microseconds"""
-        dt = datetime(2025, 10, 23, 15, 30, 45, 123456)
-        result = default(dt)
-        assert result == "2025-10-23T15:30:45.123456"
-
-    def test_default_returns_none_for_other_types(self):
-        """Test that default returns None for non-date/datetime objects"""
-        assert default("string") is None
-        assert default(42) is None
-        assert default(3.14) is None
-        assert default(True) is None
-        assert default(None) is None
-        assert default([1, 2, 3]) is None
-        assert default({"key": "value"}) is None
-
-    def test_default_as_json_default_parameter(self):
-        """Test using default function as default parameter in json.dumps"""
-        data = {
-            "timestamp": datetime(2025, 10, 23, 15, 30, 45),
-            "date": date(2025, 10, 23),
-            "name": "test"
-        }
-
-        result = json.dumps(data, default=default)
-        decoded = json.loads(result)
-
-        assert decoded["timestamp"] == "2025-10-23T15:30:45"
-        assert decoded["date"] == "2025-10-23"
-        assert decoded["name"] == "test"
-
-
-# MARK: json_dumps tests
-class TestJsonDumps:
-    """Test cases for json_dumps function"""
-
-    def test_basic_dict(self):
-        """Test json_dumps with basic dictionary"""
-        data = {"name": "test", "value": 42}
-        result = json_dumps(data)
-        decoded = json.loads(result)
-        assert decoded == data
-
-    def test_unicode_characters(self):
-        """Test json_dumps preserves unicode characters (ensure_ascii=False)"""
-        data = {"name": "テスト", "emoji": "🎉", "chinese": "测试"}
-        result = json_dumps(data)
-
-        # ensure_ascii=False means unicode characters should be preserved
-        assert "テスト" in result
-        assert "🎉" in result
-        assert "测试" in result
-
-        decoded = json.loads(result)
-        assert decoded == data
-
-    def test_datetime_objects_as_string(self):
-        """Test json_dumps converts datetime to string (default=str)"""
-        dt = datetime(2025, 10, 23, 15, 30, 45)
-        data = {"timestamp": dt}
-
-        result = json_dumps(data)
-        decoded = json.loads(result)
-
-        # default=str will convert datetime to its string representation
-        assert isinstance(decoded["timestamp"], str)
-        assert "2025-10-23" in decoded["timestamp"]
-
-    def test_date_objects_as_string(self):
-        """Test json_dumps converts date to string"""
-        d = date(2025, 10, 23)
-        data = {"date": d}
-
-        result = json_dumps(data)
-        decoded = json.loads(result)
-
-        assert isinstance(decoded["date"], str)
-        assert "2025-10-23" in decoded["date"]
-
-    def test_complex_nested_structure(self):
-        """Test json_dumps with complex nested structures"""
-        data = {
-            "user": {
-                "name": "John",
-                "age": 30,
-                "active": True,
-                "balance": 100.50,
-                "tags": ["admin", "user"],
-                "metadata": {
-                    "created": datetime(2025, 1, 1, 0, 0, 0),
-                    "updated": date(2025, 10, 23)
-                }
-            },
-            "items": [
-                {"id": 1, "name": "Item 1"},
-                {"id": 2, "name": "Item 2"}
-            ]
-        }
-
-        result = json_dumps(data)
-        decoded = json.loads(result)
-
-        assert decoded["user"]["name"] == "John"
-        assert decoded["user"]["age"] == 30
-        assert decoded["user"]["active"] is True
-        assert decoded["user"]["balance"] == 100.50
-        assert decoded["user"]["tags"] == ["admin", "user"]
-        assert decoded["items"][0]["id"] == 1
-
-    def test_empty_dict(self):
-        """Test json_dumps with empty dictionary"""
-        data: dict[str, Any] = {}
-        result = json_dumps(data)
-        assert result == "{}"
-
-    def test_empty_list(self):
-        """Test json_dumps with empty list"""
-        data: list[Any] = []
-        result = json_dumps(data)
-        assert result == "[]"
-
-    def test_list_data(self):
-        """Test json_dumps with list as root element"""
-        data = [1, 2, 3, "test", True, None]
-        result = json_dumps(data)
-        decoded = json.loads(result)
-        assert decoded == data
-
-    def test_none_value(self):
-        """Test json_dumps with None"""
-        data = None
-        result = json_dumps(data)
-        assert result == "null"
-
-    def test_boolean_values(self):
-        """Test json_dumps with boolean values"""
-        data = {"true_val": True, "false_val": False}
-        result = json_dumps(data)
-        decoded = json.loads(result)
-        assert decoded["true_val"] is True
-        assert decoded["false_val"] is False
-
-    def test_numeric_values(self):
-        """Test json_dumps with various numeric values"""
-        data = {
-            "int": 42,
-            "float": 3.14,
-            "negative": -10,
-            "zero": 0,
-            "scientific": 1e10
-        }
-        result = json_dumps(data)
-        decoded = json.loads(result)
-        assert decoded == data
-
-    def test_custom_object_conversion(self):
-        """Test json_dumps with custom objects (converted via str)"""
-        class CustomObject:
-            """test class"""
-            def __str__(self):
-                return "custom_value"
-
-        data = {"custom": CustomObject()}
-        result = json_dumps(data)
-        decoded = json.loads(result)
-        assert decoded["custom"] == "custom_value"
-
-    def test_special_float_values(self):
-        """Test json_dumps handles special float values"""
-        data = {
-            "infinity": float('inf'),
-            "neg_infinity": float('-inf'),
-            "nan": float('nan')
-        }
-        result = json_dumps(data)
-        # These should be converted to strings via default=str
-        assert "Infinity" in result or "inf" in result.lower()
-
-
-# MARK: modify_with_jsonpath tests
-class TestModifyWithJsonpath:
-    """Test cases for modify_with_jsonpath function"""
-
-    def test_simple_path_modification(self):
-        """Test modifying a simple path"""
-        data = {"name": "old_name", "age": 30}
-        result = modify_with_jsonpath(data, "$.name", "new_name")
-
-        assert result["name"] == "new_name"
-        assert result["age"] == 30
-        # Original data should not be modified
-        assert data["name"] == "old_name"
-
-    def test_nested_path_modification(self):
-        """Test modifying nested path"""
-        data = {
-            "user": {
-                "profile": {
-                    "name": "John",
-                    "age": 30
-                }
-            }
-        }
-
-        result = modify_with_jsonpath(data, "$.user.profile.name", "Jane")
-
-        assert result["user"]["profile"]["name"] == "Jane"
-        assert result["user"]["profile"]["age"] == 30
-        # Original should be unchanged
-        assert data["user"]["profile"]["name"] == "John"
-
-    def test_array_index_modification(self):
-        """Test modifying array element by index"""
-        data = {
-            "items": [
-                {"id": 1, "name": "Item 1"},
-                {"id": 2, "name": "Item 2"},
-                {"id": 3, "name": "Item 3"}
-            ]
-        }
-
-        result = modify_with_jsonpath(data, "$.items[1].name", "Updated Item 2")
-
-        assert result["items"][1]["name"] == "Updated Item 2"
-        assert result["items"][0]["name"] == "Item 1"
-        assert result["items"][2]["name"] == "Item 3"
-        # Original unchanged
-        assert data["items"][1]["name"] == "Item 2"
-
-    def test_wildcard_modification(self):
-        """Test modifying multiple elements with wildcard"""
-        data = {
-            "users": [
-                {"name": "Alice", "active": True},
-                {"name": "Bob", "active": True},
-                {"name": "Charlie", "active": True}
-            ]
-        }
-
-        result = modify_with_jsonpath(data, "$.users[*].active", False)
-
-        # All active fields should be updated
-        for user in result["users"]:
-            assert user["active"] is False
-        # Original unchanged
-        for user in data["users"]:
-            assert user["active"] is True
-
-    def test_deep_copy_behavior(self):
-        """Test that modifications don't affect the original data"""
-        original = {
-            "level1": {
-                "level2": {
-                    "level3": {
-                        "value": "original"
-                    }
-                }
-            }
-        }
-
-        result = modify_with_jsonpath(original, "$.level1.level2.level3.value", "modified")
-
-        assert result["level1"]["level2"]["level3"]["value"] == "modified"
-        assert original["level1"]["level2"]["level3"]["value"] == "original"
-
-        # Verify deep copy by modifying nested dict in result
-        result["level1"]["level2"]["new_key"] = "new_value"
-        assert "new_key" not in original["level1"]["level2"]
-
-    def test_modify_to_different_type(self):
-        """Test changing value to different type"""
-        data = {"count": "10"}
-        result = modify_with_jsonpath(data, "$.count", 10)
-
-        assert result["count"] == 10
-        assert isinstance(result["count"], int)
-        assert data["count"] == "10"
-
-    def test_modify_to_complex_object(self):
-        """Test replacing value with complex object"""
-        data = {"simple": "value"}
-        new_value = {"complex": {"nested": "structure"}}
-
-        result = modify_with_jsonpath(data, "$.simple", new_value)
-
-        assert result["simple"] == new_value
-        assert result["simple"]["complex"]["nested"] == "structure"
-
-    def test_modify_to_list(self):
-        """Test replacing value with list"""
-        data = {"items": None}
-        result = modify_with_jsonpath(data, "$.items", [1, 2, 3])
-
-        assert result["items"] == [1, 2, 3]
-        assert data["items"] is None
-
-    def test_modify_to_none(self):
-        """Test setting value to None"""
-        data = {"value": "something"}
-        result = modify_with_jsonpath(data, "$.value", None)
-
-        assert result["value"] is None
-        assert data["value"] == "something"
-
-    def test_recursive_descent(self):
-        """Test using recursive descent operator"""
-        data: dict[str, Any] = {
-            "store": {
-                "book": [
-                    {"title": "Book 1", "price": 10},
-                    {"title": "Book 2", "price": 20}
-                ],
-                "bicycle": {
-                    "price": 100
-                }
-            }
-        }
-
-        # Update all prices
-        result = modify_with_jsonpath(data, "$..price", 0)
-
-        assert result["store"]["book"][0]["price"] == 0
-        assert result["store"]["book"][1]["price"] == 0
-        assert result["store"]["bicycle"]["price"] == 0
-        # Original unchanged
-        assert data["store"]["book"][0]["price"] == 10
-
-    def test_specific_array_elements(self):
-        """Test updating specific array elements by index"""
-        data = {
-            "products": [
-                {"name": "Product 1", "price": 100, "stock": 5},
-                {"name": "Product 2", "price": 200, "stock": 0},
-                {"name": "Product 3", "price": 150, "stock": 10}
-            ]
-        }
-
-        # Update first product's price
-        result = modify_with_jsonpath(data, "$.products[0].price", 0)
-
-        assert result["products"][0]["price"] == 0
-        assert result["products"][1]["price"] == 200  # not modified
-        assert result["products"][2]["price"] == 150  # not modified
-
-    def test_empty_dict(self):
-        """Test modifying empty dictionary"""
-        data: dict[str, Any] = {}
-        result = modify_with_jsonpath(data, "$.nonexistent", "value")
-
-        # Should return the original empty dict since path doesn't exist
-        assert result == {}
-
-    def test_complex_real_world_scenario(self):
-        """Test complex real-world modification scenario"""
-        data: dict[str, Any] = {
-            "api_version": "1.0",
-            "config": {
-                "database": {
-                    "host": "localhost",
-                    "port": 5432,
-                    "credentials": {
-                        "username": "admin",
-                        "password": "secret"
-                    }
-                },
-                "services": [
-                    {"name": "auth", "enabled": True, "port": 8001},
-                    {"name": "api", "enabled": True, "port": 8002},
-                    {"name": "cache", "enabled": False, "port": 8003}
-                ]
-            }
-        }
-
-        # Update database port
-        result = modify_with_jsonpath(data, "$.config.database.port", 5433)
-        assert result["config"]["database"]["port"] == 5433
-
-        # Update all service ports
-        result2 = modify_with_jsonpath(result, "$.config.services[*].enabled", True)
-        assert all(service["enabled"] for service in result2["config"]["services"])
-
-        # Original unchanged
-        assert data["config"]["database"]["port"] == 5432
-        assert data["config"]["services"][2]["enabled"] is False
-
-    def test_list_slice_modification(self):
-        """Test modifying list slice"""
-        data = {"numbers": [1, 2, 3, 4, 5]}
-
-        # Modify first three elements
-        result = modify_with_jsonpath(data, "$.numbers[0:3]", 0)
-
-        assert result["numbers"][0] == 0
-        assert result["numbers"][1] == 0
-        assert result["numbers"][2] == 0
-        assert result["numbers"][3] == 4
-        assert result["numbers"][4] == 5
-
-    def test_modify_with_datetime_value(self):
-        """Test modifying with datetime value"""
-        data = {"timestamp": "2025-01-01T00:00:00"}
-        new_datetime = datetime(2025, 10, 23, 15, 30, 45)
-
-        result = modify_with_jsonpath(data, "$.timestamp", new_datetime)
-
-        assert result["timestamp"] == new_datetime
-        assert isinstance(result["timestamp"], datetime)
-
-
-# MARK: Integration tests
-class TestIntegration:
-    """Integration tests combining multiple functions"""
-
-    def test_encoder_and_json_dumps_comparison(self):
-        """Test that DateTimeEncoder and json_dumps handle datetimes differently"""
-        dt = datetime(2025, 10, 23, 15, 30, 45)
-        data = {"timestamp": dt}
-
-        # Using DateTimeEncoder produces ISO format
-        with_encoder = json.dumps(data, cls=DateTimeEncoder)
-        decoded_encoder = json.loads(with_encoder)
-        assert decoded_encoder["timestamp"] == "2025-10-23T15:30:45"
-
-        # Using json_dumps (default=str) produces string representation
-        with_dumps = json_dumps(data)
-        decoded_dumps = json.loads(with_dumps)
-        assert isinstance(decoded_dumps["timestamp"], str)
-        assert "2025-10-23" in decoded_dumps["timestamp"]
-
-    def test_modify_and_serialize(self):
-        """Test modifying data and then serializing it"""
-        data = {
-            "event": {
-                "name": "Meeting",
-                "date": date(2025, 10, 23),
-                "attendees": [
-                    {"name": "Alice", "confirmed": False},
-                    {"name": "Bob", "confirmed": False}
-                ]
-            }
-        }
-
-        # Modify confirmation status
-        modified = modify_with_jsonpath(data, "$.event.attendees[*].confirmed", True)
-
-        # Serialize with datetime handling
-        serialized = json.dumps(modified, cls=DateTimeEncoder)
-        decoded = json.loads(serialized)
-
-        assert decoded["event"]["date"] == "2025-10-23"
-        assert decoded["event"]["attendees"][0]["confirmed"] is True
-        assert decoded["event"]["attendees"][1]["confirmed"] is True
-
-    def test_round_trip_with_modification(self):
-        """Test full round trip: serialize -> modify -> serialize"""
-        original = {
-            "config": {
-                "updated": datetime(2025, 10, 23, 15, 30, 45),
-                "version": "1.0"
-            }
-        }
-
-        # Serialize
-        json_str = json.dumps(original, cls=DateTimeEncoder)
-
-        # Deserialize
-        deserialized = json.loads(json_str)
-
-        # Modify
-        modified = modify_with_jsonpath(deserialized, "$.config.version", "2.0")
-
-        # Serialize again
-        final_json = json_dumps(modified)
-        final_data = json.loads(final_json)
-
-        assert final_data["config"]["version"] == "2.0"
-        assert final_data["config"]["updated"] == "2025-10-23T15:30:45"
-
-
-# MARK: Edge cases
-class TestEdgeCases:
-    """Test edge cases and error scenarios"""
-
-    def test_circular_reference_in_modify(self):
-        """Test that modify_with_jsonpath handles data without circular references"""
-        # Note: JSON doesn't support circular references, so we test normal nested data
-        data = {
-            "a": {
-                "b": {
-                    "c": "value"
-                }
-            }
-        }
-
-        result = modify_with_jsonpath(data, "$.a.b.c", "new_value")
-        assert result["a"]["b"]["c"] == "new_value"
-
-    def test_unicode_in_keys_and_values(self):
-        """Test handling unicode in both keys and values"""
-        data = {
-            "日本語": "テスト",
-            "emoji_🎉": "🚀",
-            "normal": "value"
-        }
-
-        result = json_dumps(data)
-        decoded = json.loads(result)
-
-        assert decoded["日本語"] == "テスト"
-        assert decoded["emoji_🎉"] == "🚀"
-        assert decoded["normal"] == "value"
-
-    def test_very_nested_structure(self):
-        """Test deeply nested structure"""
-        # Create a 10-level deep nested structure
-        data: dict[str, Any] = {"level0": {}}
-        current = data["level0"]
-        for i in range(1, 10):
-            current[f"level{i}"] = {}
-            current = current[f"level{i}"]
-        current["value"] = "deep_value"
-
-        result = modify_with_jsonpath(data, "$..value", "modified_deep_value")
-
-        # Navigate to the deep value
-        current = result["level0"]
-        for i in range(1, 10):
-            current = current[f"level{i}"]
-        assert current["value"] == "modified_deep_value"
-
-    def test_large_list_modification(self):
-        """Test modifying large list"""
-        data = {"items": [{"id": i, "value": i * 10} for i in range(100)]}
-
-        result = modify_with_jsonpath(data, "$.items[*].value", 0)
-
-        assert all(item["value"] == 0 for item in result["items"])
-        assert len(result["items"]) == 100
-
-    def test_mixed_date_types_encoding(self):
-        """Test encoding with both date and datetime in same structure"""
-        data = {
-            "created_date": date(2025, 10, 23),
-            "created_datetime": datetime(2025, 10, 23, 15, 30, 45),
-            "updated_date": date(2025, 10, 24),
-            "updated_datetime": datetime(2025, 10, 24, 16, 45, 30)
-        }
-
-        result = json.dumps(data, cls=DateTimeEncoder)
-        decoded = json.loads(result)
-
-        assert decoded["created_date"] == "2025-10-23"
-        assert decoded["created_datetime"] == "2025-10-23T15:30:45"
-        assert decoded["updated_date"] == "2025-10-24"
-        assert decoded["updated_datetime"] == "2025-10-24T16:45:30"

tests/unit/logging_handling/log_testing/test_log_1_settings_parsing_spacers_parameters.py

@@ -0,0 +1,332 @@
+"""
+Unit tests for log settings parsing and spacer constants in Log class.
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+from pathlib import Path
+from typing import Any
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogParent,
+    LogSettings,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test Log Settings Parsing
+class TestLogSettingsParsing:
+    """Test cases for log settings parsing"""
+
+    def test_parse_with_string_log_levels(self, tmp_log_path: Path):
+        """Test parsing with string log levels"""
+        settings: dict[str, Any] = {
+            "log_level_console": "ERROR",
+            "log_level_file": "INFO",
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["log_level_console"] == LoggingLevel.ERROR
+        assert log.log_settings["log_level_file"] == LoggingLevel.INFO
+
+    def test_parse_with_int_log_levels(self, tmp_log_path: Path):
+        """Test parsing with integer log levels"""
+        settings: dict[str, Any] = {
+            "log_level_console": 40,  # ERROR
+            "log_level_file": 20,     # INFO
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["log_level_console"] == LoggingLevel.ERROR
+        assert log.log_settings["log_level_file"] == LoggingLevel.INFO
+
+    def test_parse_with_invalid_bool_settings(self, tmp_log_path: Path):
+        """Test parsing with invalid bool settings"""
+        settings: dict[str, Any] = {
+            "console_enabled": "not_a_bool",
+            "per_run_log": 123,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        # Should fall back to defaults
+        assert log.log_settings["console_enabled"] == Log.DEFAULT_LOG_SETTINGS["console_enabled"]
+        assert log.log_settings["per_run_log"] == Log.DEFAULT_LOG_SETTINGS["per_run_log"]
+
+    def test_parse_console_format_type_all(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to ALL"""
+        settings: dict[str, Any] = {
+            "console_format_type": ConsoleFormatSettings.ALL,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == ConsoleFormatSettings.ALL
+
+    def test_parse_console_format_type_condensed(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to CONDENSED"""
+        settings: dict[str, Any] = {
+            "console_format_type": ConsoleFormatSettings.CONDENSED,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == ConsoleFormatSettings.CONDENSED
+
+    def test_parse_console_format_type_minimal(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to MINIMAL"""
+        settings: dict[str, Any] = {
+            "console_format_type": ConsoleFormatSettings.MINIMAL,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == ConsoleFormatSettings.MINIMAL
+
+    def test_parse_console_format_type_bare(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to BARE"""
+        settings: dict[str, Any] = {
+            "console_format_type": ConsoleFormatSettings.BARE,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == ConsoleFormatSettings.BARE
+
+    def test_parse_console_format_type_none(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to NONE"""
+        settings: dict[str, Any] = {
+            "console_format_type": ConsoleFormatSettings.NONE,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == ConsoleFormatSettings.NONE
+
+    def test_parse_console_format_type_invalid(self, tmp_log_path: Path):
+        """Test parsing with invalid console_format_type raises TypeError"""
+        settings: dict[str, Any] = {
+            "console_format_type": "invalid_format",
+        }
+        # Invalid console_format_type causes TypeError during handler creation
+        # because the code doesn't validate the type before using it
+        with pytest.raises(TypeError, match="'in <string>' requires string as left operand"):
+            Log(
+                log_path=tmp_log_path,
+                log_name="test",
+                log_settings=settings  # type: ignore
+            )
+
+
+# MARK: Test Spacer Constants
+class TestSpacerConstants:
+    """Test cases for spacer constants"""
+
+    def test_spacer_char_constant(self):
+        """Test SPACER_CHAR constant"""
+        assert Log.SPACER_CHAR == '='
+        assert LogParent.SPACER_CHAR == '='
+
+    def test_spacer_length_constant(self):
+        """Test SPACER_LENGTH constant"""
+        assert Log.SPACER_LENGTH == 32
+        assert LogParent.SPACER_LENGTH == 32
+
+
+# MARK: Test ConsoleFormatSettings.from_string
+class TestConsoleFormatSettingsFromString:
+    """Test cases for ConsoleFormatSettings.from_string method"""
+
+    def test_from_string_all(self):
+        """Test from_string with 'ALL' returns correct format"""
+        result = ConsoleFormatSettings.from_string('ALL')
+        assert result == ConsoleFormatSettings.ALL
+
+    def test_from_string_condensed(self):
+        """Test from_string with 'CONDENSED' returns correct format"""
+        result = ConsoleFormatSettings.from_string('CONDENSED')
+        assert result == ConsoleFormatSettings.CONDENSED
+
+    def test_from_string_minimal(self):
+        """Test from_string with 'MINIMAL' returns correct format"""
+        result = ConsoleFormatSettings.from_string('MINIMAL')
+        assert result == ConsoleFormatSettings.MINIMAL
+
+    def test_from_string_bare(self):
+        """Test from_string with 'BARE' returns correct format"""
+        result = ConsoleFormatSettings.from_string('BARE')
+        assert result == ConsoleFormatSettings.BARE
+
+    def test_from_string_none(self):
+        """Test from_string with 'NONE' returns correct format"""
+        result = ConsoleFormatSettings.from_string('NONE')
+        assert result == ConsoleFormatSettings.NONE
+
+    def test_from_string_invalid_returns_none(self):
+        """Test from_string with invalid string returns None"""
+        result = ConsoleFormatSettings.from_string('INVALID')
+        assert result is None
+
+    def test_from_string_invalid_with_default(self):
+        """Test from_string with invalid string returns provided default"""
+        default = ConsoleFormatSettings.ALL
+        result = ConsoleFormatSettings.from_string('INVALID', default=default)
+        assert result == default
+
+    def test_from_string_case_sensitive(self):
+        """Test from_string is case sensitive"""
+        # Lowercase should not match
+        result = ConsoleFormatSettings.from_string('all')
+        assert result is None
+
+    def test_from_string_with_none_default(self):
+        """Test from_string with explicit None default"""
+        result = ConsoleFormatSettings.from_string('NONEXISTENT', default=None)
+        assert result is None
+
+    @pytest.mark.parametrize("setting_name,expected", [
+        ("ALL", ConsoleFormatSettings.ALL),
+        ("CONDENSED", ConsoleFormatSettings.CONDENSED),
+        ("MINIMAL", ConsoleFormatSettings.MINIMAL),
+        ("BARE", ConsoleFormatSettings.BARE),
+        ("NONE", ConsoleFormatSettings.NONE),
+    ])
+    def test_from_string_all_valid_settings(self, setting_name: str, expected: Any):
+        """Test from_string with all valid setting names"""
+        result = ConsoleFormatSettings.from_string(setting_name)
+        assert result == expected
+
+
+# MARK: Parametrized Tests
+class TestParametrized:
+    """Parametrized tests for comprehensive coverage"""
+
+    @pytest.mark.parametrize("log_level,expected", [
+        (LoggingLevel.DEBUG, 10),
+        (LoggingLevel.INFO, 20),
+        (LoggingLevel.WARNING, 30),
+        (LoggingLevel.ERROR, 40),
+        (LoggingLevel.CRITICAL, 50),
+        (LoggingLevel.ALERT, 55),
+        (LoggingLevel.EMERGENCY, 60),
+        (LoggingLevel.EXCEPTION, 70),
+    ])
+    def test_log_level_values(self, log_level: LoggingLevel, expected: int):
+        """Test log level values"""
+        assert log_level.value == expected
+
+    @pytest.mark.parametrize("method_name,level_name", [
+        ("debug", "DEBUG"),
+        ("info", "INFO"),
+        ("warning", "WARNING"),
+        ("error", "ERROR"),
+        ("critical", "CRITICAL"),
+    ])
+    def test_logging_methods_write_correct_level(
+        self,
+        log_instance: Log,
+        tmp_log_path: Path,
+        method_name: str,
+        level_name: str
+    ):
+        """Test each logging method writes correct level"""
+        method = getattr(log_instance, method_name)
+        method(f"Test {level_name} message")
+
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert level_name in content
+        assert f"Test {level_name} message" in content
+
+    @pytest.mark.parametrize("setting_key,valid_value,invalid_value", [
+        ("per_run_log", True, "not_bool"),
+        ("console_enabled", False, 123),
+        ("console_color_output_enabled", True, None),
+        ("console_format_type", ConsoleFormatSettings.ALL, "invalid_format"),
+        ("add_start_info", False, []),
+        ("add_end_info", True, {}),
+    ])
+    def test_bool_setting_validation(
+        self,
+        tmp_log_path: Path,
+        setting_key: str,
+        valid_value: bool,
+        invalid_value: Any
+    ):
+        """Test bool setting validation and fallback"""
+        # Test with valid value
+        settings_valid: dict[str, Any] = {setting_key: valid_value}
+        log_valid = Log(tmp_log_path, "test_valid", settings_valid)  # type: ignore
+        assert log_valid.log_settings[setting_key] == valid_value
+
+        # Test with invalid value (should fall back to default)
+        settings_invalid: dict[str, Any] = {setting_key: invalid_value}
+        log_invalid = Log(tmp_log_path, "test_invalid", settings_invalid)  # type: ignore
+        assert log_invalid.log_settings[setting_key] == Log.DEFAULT_LOG_SETTINGS.get(
+            setting_key, True
+        )
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_2_basic_handling.py

@@ -0,0 +1,518 @@
+"""
+Unit tests for basic Log handling functionality.
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+import logging
+from pathlib import Path
+from typing import Any
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogParent,
+    LogSettings,
+    CustomConsoleFormatter,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test LogParent
+class TestLogParent:
+    """Test cases for LogParent class"""
+
+    def test_validate_log_level_valid(self):
+        """Test validate_log_level with valid levels"""
+        assert LogParent.validate_log_level(LoggingLevel.DEBUG) is True
+        assert LogParent.validate_log_level(10) is True
+        assert LogParent.validate_log_level("INFO") is True
+        assert LogParent.validate_log_level("warning") is True
+
+    def test_validate_log_level_invalid(self):
+        """Test validate_log_level with invalid levels"""
+        assert LogParent.validate_log_level("INVALID") is False
+        assert LogParent.validate_log_level(999) is False
+
+    def test_get_log_level_int_valid(self):
+        """Test get_log_level_int with valid levels"""
+        assert LogParent.get_log_level_int(LoggingLevel.DEBUG) == 10
+        assert LogParent.get_log_level_int(20) == 20
+        assert LogParent.get_log_level_int("ERROR") == 40
+
+    def test_get_log_level_int_invalid(self):
+        """Test get_log_level_int with invalid level returns default"""
+        result = LogParent.get_log_level_int("INVALID")
+        assert result == LoggingLevel.WARNING.value
+
+    def test_debug_without_logger_raises(self):
+        """Test debug method raises when logger not initialized"""
+        parent = LogParent()
+        with pytest.raises(ValueError, match="Logger is not yet initialized"):
+            parent.debug("Test message")
+
+    def test_info_without_logger_raises(self):
+        """Test info method raises when logger not initialized"""
+        parent = LogParent()
+        with pytest.raises(ValueError, match="Logger is not yet initialized"):
+            parent.info("Test message")
+
+    def test_warning_without_logger_raises(self):
+        """Test warning method raises when logger not initialized"""
+        parent = LogParent()
+        with pytest.raises(ValueError, match="Logger is not yet initialized"):
+            parent.warning("Test message")
+
+    def test_error_without_logger_raises(self):
+        """Test error method raises when logger not initialized"""
+        parent = LogParent()
+        with pytest.raises(ValueError, match="Logger is not yet initialized"):
+            parent.error("Test message")
+
+    def test_critical_without_logger_raises(self):
+        """Test critical method raises when logger not initialized"""
+        parent = LogParent()
+        with pytest.raises(ValueError, match="Logger is not yet initialized"):
+            parent.critical("Test message")
+
+    def test_flush_without_queue_returns_false(self, log_instance: Log):
+        """Test flush returns False when no queue"""
+        result = log_instance.flush()
+        assert result is False
+
+    def test_cleanup_without_queue(self, log_instance: Log):
+        """Test cleanup does nothing when no queue"""
+        log_instance.cleanup()  # Should not raise
+
+
+# MARK: Test Log Initialization
+class TestLogInitialization:
+    """Test cases for Log class initialization"""
+
+    def test_init_basic(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test basic Log initialization"""
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=basic_log_settings
+        )
+
+        assert log.log_name == "test_log"
+        assert log.logger is not None
+        assert isinstance(log.logger, logging.Logger)
+        assert "file_handler" in log.handlers
+        assert "stream_handler" in log.handlers
+
+    def test_init_with_log_extension(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test initialization with .log extension in name"""
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log.log",
+            log_settings=basic_log_settings
+        )
+
+        # When log_name ends with .log, the code strips it but the logic keeps it
+        # Based on code: if not log_name.endswith('.log'): log_name = Path(log_name).stem
+        # So if it DOES end with .log, it keeps the original name
+        assert log.log_name == "test_log.log"
+
+    def test_init_with_file_path(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test initialization with file path instead of directory"""
+        log_file = tmp_log_path / "custom.log"
+        log = Log(
+            log_path=log_file,
+            log_name="test",
+            log_settings=basic_log_settings
+        )
+
+        assert log.logger is not None
+        assert log.log_name == "test"
+
+    def test_init_console_disabled(self, tmp_log_path: Path):
+        """Test initialization with console disabled"""
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=settings
+        )
+
+        assert "stream_handler" not in log.handlers
+        assert "file_handler" in log.handlers
+
+    def test_init_per_run_log(self, tmp_log_path: Path):
+        """Test initialization with per_run_log enabled"""
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": True,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=settings
+        )
+
+        assert log.logger is not None
+        # Check that a timestamped log file was created
+        # Files are created in parent directory with sanitized name
+        log_files = list(tmp_log_path.glob("testlog.*.log"))
+        assert len(log_files) > 0
+
+    def test_init_with_none_settings(self, tmp_log_path: Path):
+        """Test initialization with None settings uses defaults"""
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=None
+        )
+
+        assert log.log_settings == Log.DEFAULT_LOG_SETTINGS
+        assert log.logger is not None
+
+    def test_init_with_partial_settings(self, tmp_log_path: Path):
+        """Test initialization with partial settings"""
+        settings: dict[str, Any] = {
+            "log_level_console": LoggingLevel.ERROR,
+            "console_enabled": True,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["log_level_console"] == LoggingLevel.ERROR
+        # Other settings should use defaults
+        assert log.log_settings["log_level_file"] == Log.DEFAULT_LOG_LEVEL_FILE
+
+    def test_init_with_invalid_log_level(self, tmp_log_path: Path):
+        """Test initialization with invalid log level falls back to default"""
+        settings: dict[str, Any] = {
+            "log_level_console": "INVALID_LEVEL",
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=settings  # type: ignore
+        )
+
+        # Invalid log levels are reset to the default for that specific entry
+        # Since INVALID_LEVEL fails validation, it uses DEFAULT_LOG_SETTINGS value
+        assert log.log_settings["log_level_console"] == Log.DEFAULT_LOG_SETTINGS["log_level_console"]
+
+    def test_init_with_color_output(self, tmp_log_path: Path):
+        """Test initialization with color output enabled"""
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": True,
+            "console_color_output_enabled": True,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=settings
+        )
+
+        console_handler = log.handlers["stream_handler"]
+        assert isinstance(console_handler.formatter, CustomConsoleFormatter)
+
+    def test_init_with_other_handlers(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test initialization with additional custom handlers"""
+        custom_handler = logging.StreamHandler()
+        custom_handler.set_name("custom_handler")
+
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=basic_log_settings,
+            other_handlers={"custom": custom_handler}
+        )
+
+        assert "custom" in log.handlers
+        assert log.handlers["custom"] == custom_handler
+
+
+# MARK: Test Log Methods
+class TestLogMethods:
+    """Test cases for Log logging methods"""
+
+    def test_debug_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test debug level logging"""
+        log_instance.debug("Debug message")
+        # Verify log file contains the message
+        # Log file is created with sanitized name (testlog.log)
+        log_file = tmp_log_path / "testlog.log"
+        assert log_file.exists()
+        content = log_file.read_text()
+        assert "Debug message" in content
+        assert "DEBUG" in content
+
+    def test_info_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test info level logging"""
+        log_instance.info("Info message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Info message" in content
+        assert "INFO" in content
+
+    def test_warning_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test warning level logging"""
+        log_instance.warning("Warning message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Warning message" in content
+        assert "WARNING" in content
+
+    def test_error_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test error level logging"""
+        log_instance.error("Error message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Error message" in content
+        assert "ERROR" in content
+
+    def test_critical_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test critical level logging"""
+        log_instance.critical("Critical message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Critical message" in content
+        assert "CRITICAL" in content
+
+    def test_alert_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test alert level logging"""
+        log_instance.alert("Alert message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Alert message" in content
+        assert "ALERT" in content
+
+    def test_emergency_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test emergency level logging"""
+        log_instance.emergency("Emergency message")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Emergency message" in content
+        assert "EMERGENCY" in content
+
+    def test_exception_logging(self, log_instance: Log, tmp_log_path: Path):
+        """Test exception level logging"""
+        try:
+            raise ValueError("Test exception")
+        except ValueError:
+            log_instance.exception("Exception occurred")
+
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Exception occurred" in content
+        assert "EXCEPTION" in content
+        assert "ValueError" in content
+
+    def test_exception_logging_without_error(self, log_instance: Log, tmp_log_path: Path):
+        """Test exception logging with log_error=False"""
+        try:
+            raise ValueError("Test exception")
+        except ValueError:
+            log_instance.exception("Exception occurred", log_error=False)
+
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Exception occurred" in content
+        # Should not have the ERROR level entry
+        assert "<=EXCEPTION=" not in content
+
+    def test_log_with_extra(self, log_instance: Log, tmp_log_path: Path):
+        """Test logging with extra parameters"""
+        extra: dict[str, object] = {"custom_field": "custom_value"}
+        log_instance.info("Info with extra", extra=extra)
+
+        log_file = tmp_log_path / "testlog.log"
+        assert log_file.exists()
+        content = log_file.read_text()
+        assert "Info with extra" in content
+
+    def test_break_line(self, log_instance: Log, tmp_log_path: Path):
+        """Test break_line method"""
+        log_instance.break_line("TEST")
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "[TEST]" in content
+        assert "=" in content
+
+    def test_break_line_default(self, log_instance: Log, tmp_log_path: Path):
+        """Test break_line with default parameter"""
+        log_instance.break_line()
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "[BREAK]" in content
+
+
+# MARK: Test Log Level Handling
+class TestLogLevelHandling:
+    """Test cases for log level handling"""
+
+    def test_set_log_level_file_handler(self, log_instance: Log):
+        """Test setting log level for file handler"""
+        result = log_instance.set_log_level("file_handler", LoggingLevel.ERROR)
+        assert result is True
+        assert log_instance.get_log_level("file_handler") == LoggingLevel.ERROR
+
+    def test_set_log_level_console_handler(self, log_instance: Log):
+        """Test setting log level for console handler"""
+        result = log_instance.set_log_level("stream_handler", LoggingLevel.CRITICAL)
+        assert result is True
+        assert log_instance.get_log_level("stream_handler") == LoggingLevel.CRITICAL
+
+    def test_set_log_level_invalid_handler(self, log_instance: Log):
+        """Test setting log level for non-existent handler raises KeyError"""
+        # The actual implementation uses dict access which raises KeyError, not IndexError
+        with pytest.raises(KeyError):
+            log_instance.set_log_level("nonexistent", LoggingLevel.DEBUG)
+
+    def test_get_log_level_invalid_handler(self, log_instance: Log):
+        """Test getting log level for non-existent handler raises KeyError"""
+        # The actual implementation uses dict access which raises KeyError, not IndexError
+        with pytest.raises(KeyError):
+            log_instance.get_log_level("nonexistent")
+
+    def test_get_log_level(self, log_instance: Log):
+        """Test getting current log level"""
+        level = log_instance.get_log_level("file_handler")
+        assert level == LoggingLevel.DEBUG
+
+
+class DummyHandler:
+    """Dummy log level handler"""
+    def __init__(self, level: LoggingLevel):
+        self.level = level
+
+
+@pytest.fixture
+def log_instance_level() -> Log:
+    """
+    Minimal log instance with dummy handlers
+
+    Returns:
+        Log -- _description_
+    """
+    log = Log(
+        log_path=Path("/tmp/test.log"),
+        log_name="test",
+        log_settings={
+            "log_level_console": LoggingLevel.DEBUG,
+            "log_level_file": LoggingLevel.DEBUG,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": None,
+            "per_run_log": False,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+    )
+    return log
+
+
+def test_any_handler_is_minimum_level_true(log_instance_level: Log):
+    """Test any_handler_is_minimum_level returns True when a handler meets the level"""
+    # Handler with DEBUG level, should include INFO
+    log_instance_level.handlers = {
+        "h1": DummyHandler(LoggingLevel.DEBUG)
+    }
+    assert log_instance_level.any_handler_is_minimum_level(LoggingLevel.INFO) is True
+
+
+def test_any_handler_is_minimum_level_false(log_instance_level: Log):
+    """Test any_handler_is_minimum_level returns False when no handler meets the level"""
+    # Handler with WARNING level, should include ERROR
+    log_instance_level.handlers = {
+        "h1": DummyHandler(LoggingLevel.WARNING)
+    }
+    assert log_instance_level.any_handler_is_minimum_level(LoggingLevel.ERROR) is True
+
+
+def test_any_handler_is_minimum_level_multiple(log_instance_level: Log):
+    """Test any_handler_is_minimum_level with multiple handlers"""
+    # Multiple handlers, one matches
+    log_instance_level.handlers = {
+        "h1": DummyHandler(LoggingLevel.ERROR),
+        "h2": DummyHandler(LoggingLevel.DEBUG)
+    }
+    assert log_instance_level.any_handler_is_minimum_level(LoggingLevel.INFO) is True
+    # None matches
+    log_instance_level.handlers = {
+        "h1": DummyHandler(LoggingLevel.ERROR),
+        "h2": DummyHandler(LoggingLevel.CRITICAL)
+    }
+    assert log_instance_level.any_handler_is_minimum_level(LoggingLevel.DEBUG) is False
+
+
+def test_any_handler_is_minimum_level_handles_exceptions(log_instance_level: Log):
+    """Test any_handler_is_minimum_level handles exceptions gracefully"""
+    # Handler with missing level attribute
+    class BadHandler:
+        pass
+    log_instance_level.handlers = {
+        "h1": BadHandler()
+    }
+    # Should not raise, just return False
+    assert log_instance_level.any_handler_is_minimum_level(LoggingLevel.DEBUG) is False
+# __END__

tests/unit/logging_handling/log_testing/test_log_3_custom_console_formatter.py

@@ -0,0 +1,362 @@
+"""
+Unit tests for CustomConsoleFormatter in logging handling
+"""
+
+# pylint: disable=protected-access,redefined-outer-name
+
+import logging
+from pathlib import Path
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogSettings,
+    CustomConsoleFormatter,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    # Return a new dict each time to avoid state pollution
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test CustomConsoleFormatter
+class TestCustomConsoleFormatter:
+    """Test cases for CustomConsoleFormatter"""
+
+    def test_format_debug_level(self):
+        """Test formatting DEBUG level message"""
+        formatter = CustomConsoleFormatter('[%(levelname)s] %(message)s')
+        record = logging.LogRecord(
+            name="test",
+            level=logging.DEBUG,
+            pathname="test.py",
+            lineno=1,
+            msg="Debug message",
+            args=(),
+            exc_info=None
+        )
+
+        result = formatter.format(record)
+        assert "Debug message" in result
+        assert "DEBUG" in result
+
+    def test_format_info_level(self):
+        """Test formatting INFO level message"""
+        formatter = CustomConsoleFormatter('[%(levelname)s] %(message)s')
+        record = logging.LogRecord(
+            name="test",
+            level=logging.INFO,
+            pathname="test.py",
+            lineno=1,
+            msg="Info message",
+            args=(),
+            exc_info=None
+        )
+
+        result = formatter.format(record)
+        assert "Info message" in result
+        assert "INFO" in result
+
+    def test_format_warning_level(self):
+        """Test formatting WARNING level message"""
+        formatter = CustomConsoleFormatter('[%(levelname)s] %(message)s')
+        record = logging.LogRecord(
+            name="test",
+            level=logging.WARNING,
+            pathname="test.py",
+            lineno=1,
+            msg="Warning message",
+            args=(),
+            exc_info=None
+        )
+
+        result = formatter.format(record)
+        assert "Warning message" in result
+        assert "WARNING" in result
+
+    def test_format_error_level(self):
+        """Test formatting ERROR level message"""
+        formatter = CustomConsoleFormatter('[%(levelname)s] %(message)s')
+        record = logging.LogRecord(
+            name="test",
+            level=logging.ERROR,
+            pathname="test.py",
+            lineno=1,
+            msg="Error message",
+            args=(),
+            exc_info=None
+        )
+
+        result = formatter.format(record)
+        assert "Error message" in result
+        assert "ERROR" in result
+
+    def test_format_critical_level(self):
+        """Test formatting CRITICAL level message"""
+        formatter = CustomConsoleFormatter('[%(levelname)s] %(message)s')
+        record = logging.LogRecord(
+            name="test",
+            level=logging.CRITICAL,
+            pathname="test.py",
+            lineno=1,
+            msg="Critical message",
+            args=(),
+            exc_info=None
+        )
+
+        result = formatter.format(record)
+        assert "Critical message" in result
+        assert "CRITICAL" in result
+
+
+# MARK: Test update_console_formatter
+class TestUpdateConsoleFormatter:
+    """Test cases for update_console_formatter method"""
+
+    def test_update_console_formatter_to_minimal(self, log_instance: Log):
+        """Test updating console formatter to MINIMAL format"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter was updated
+        assert formatter is not None
+
+    def test_update_console_formatter_to_condensed(self, log_instance: Log):
+        """Test updating console formatter to CONDENSED format"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.CONDENSED)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter was updated
+        assert formatter is not None
+
+    def test_update_console_formatter_to_bare(self, log_instance: Log):
+        """Test updating console formatter to BARE format"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.BARE)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter was updated
+        assert formatter is not None
+
+    def test_update_console_formatter_to_none(self, log_instance: Log):
+        """Test updating console formatter to NONE format"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.NONE)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter was updated
+        assert formatter is not None
+
+    def test_update_console_formatter_to_all(self, log_instance: Log):
+        """Test updating console formatter to ALL format"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.ALL)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter was updated
+        assert formatter is not None
+
+    def test_update_console_formatter_when_disabled(
+        self, tmp_log_path: Path, basic_log_settings: LogSettings
+    ):
+        """Test that update_console_formatter does nothing when console is disabled"""
+        # Disable console
+        basic_log_settings['console_enabled'] = False
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=basic_log_settings
+        )
+
+        # This should not raise an error and should return early
+        log.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        # Verify console handler doesn't exist
+        assert log.CONSOLE_HANDLER not in log.handlers
+
+    def test_update_console_formatter_with_color_enabled(
+        self, tmp_log_path: Path, basic_log_settings: LogSettings
+    ):
+        """Test updating console formatter with color output enabled"""
+        basic_log_settings['console_color_output_enabled'] = True
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=basic_log_settings
+        )
+
+        log.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        # Get the console handler's formatter
+        console_handler = log.handlers[log.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter is CustomConsoleFormatter when colors enabled
+        assert isinstance(formatter, CustomConsoleFormatter)
+
+    def test_update_console_formatter_without_color(self, log_instance: Log):
+        """Test updating console formatter without color output"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        # Get the console handler's formatter
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter = console_handler.formatter
+
+        # Verify formatter is standard Formatter when colors disabled
+        assert isinstance(formatter, logging.Formatter)
+        # But not the colored version
+        assert not isinstance(formatter, CustomConsoleFormatter)
+
+    def test_update_console_formatter_multiple_times(self, log_instance: Log):
+        """Test updating console formatter multiple times"""
+        # Update to MINIMAL
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+        console_handler = log_instance.handlers[log_instance.CONSOLE_HANDLER]
+        formatter1 = console_handler.formatter
+
+        # Update to CONDENSED
+        log_instance.update_console_formatter(ConsoleFormatSettings.CONDENSED)
+        formatter2 = console_handler.formatter
+
+        # Update to ALL
+        log_instance.update_console_formatter(ConsoleFormatSettings.ALL)
+        formatter3 = console_handler.formatter
+
+        # Verify each update created a new formatter
+        assert formatter1 is not formatter2
+        assert formatter2 is not formatter3
+        assert formatter1 is not formatter3
+
+    def test_update_console_formatter_preserves_handler_level(self, log_instance: Log):
+        """Test that updating formatter preserves the handler's log level"""
+        original_level = log_instance.handlers[log_instance.CONSOLE_HANDLER].level
+
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        new_level = log_instance.handlers[log_instance.CONSOLE_HANDLER].level
+        assert original_level == new_level
+
+    def test_update_console_formatter_format_output(
+        self, log_instance: Log, caplog: pytest.LogCaptureFixture
+    ):
+        """Test that updated formatter actually affects log output"""
+        # Set to BARE format (message only)
+        log_instance.update_console_formatter(ConsoleFormatSettings.BARE)
+
+        # Configure caplog to capture at the appropriate level
+        with caplog.at_level(logging.WARNING):
+            log_instance.warning("Test warning message")
+
+        # Verify message was logged
+        assert "Test warning message" in caplog.text
+
+    def test_update_console_formatter_none_format_output(
+        self, log_instance: Log, caplog: pytest.LogCaptureFixture
+    ):
+        """Test that NONE formatter outputs only the message without any formatting"""
+        # Set to NONE format (message only, no level indicator)
+        log_instance.update_console_formatter(ConsoleFormatSettings.NONE)
+
+        # Configure caplog to capture at the appropriate level
+        with caplog.at_level(logging.WARNING):
+            log_instance.warning("Test warning message")
+
+        # Verify message was logged
+        assert "Test warning message" in caplog.text
+
+    def test_log_console_format_option_set_to_none(
+        self, tmp_log_path: Path
+    ):
+        """Test that when log_console_format option is set to None, it uses ConsoleFormatSettings.ALL"""
+        # Save the original DEFAULT_LOG_SETTINGS to restore it after test
+        original_default = Log.DEFAULT_LOG_SETTINGS.copy()
+
+        try:
+            # Reset DEFAULT_LOG_SETTINGS to ensure clean state
+            Log.DEFAULT_LOG_SETTINGS = {
+                "log_level_console": Log.DEFAULT_LOG_LEVEL_CONSOLE,
+                "log_level_file": Log.DEFAULT_LOG_LEVEL_FILE,
+                "per_run_log": False,
+                "console_enabled": True,
+                "console_color_output_enabled": True,
+                "console_format_type": ConsoleFormatSettings.ALL,
+                "add_start_info": True,
+                "add_end_info": False,
+                "log_queue": None,
+            }
+
+            # Create a fresh settings dict with console_format_type explicitly set to None
+            settings: LogSettings = {
+                "log_level_console": LoggingLevel.WARNING,
+                "log_level_file": LoggingLevel.DEBUG,
+                "per_run_log": False,
+                "console_enabled": True,
+                "console_color_output_enabled": False,
+                "console_format_type": None,  # type: ignore
+                "add_start_info": False,
+                "add_end_info": False,
+                "log_queue": None,
+            }
+
+            # Verify that None is explicitly set in the input
+            assert settings['console_format_type'] is None
+
+            log = Log(
+                log_path=tmp_log_path,
+                log_name="test_log",
+                log_settings=settings
+            )
+
+            # Verify that None was replaced with ConsoleFormatSettings.ALL
+            # The Log class should replace None with the default value (ALL)
+            assert log.log_settings['console_format_type'] == ConsoleFormatSettings.ALL
+        finally:
+            # Restore original DEFAULT_LOG_SETTINGS
+            Log.DEFAULT_LOG_SETTINGS = original_default
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_4_custom_handler_filter.py

@@ -0,0 +1,124 @@
+"""
+Unit tests for CustomHandlerFilter in logging handling
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+import logging
+from pathlib import Path
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogSettings,
+    CustomHandlerFilter,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test CustomHandlerFilter
+class TestCustomHandlerFilter:
+    """Test cases for CustomHandlerFilter"""
+
+    def test_filter_exceptions_for_console(self):
+        """Test filtering exception records for console handler"""
+        handler_filter = CustomHandlerFilter('console', filter_exceptions=True)
+        record = logging.LogRecord(
+            name="test",
+            level=70,  # EXCEPTION level
+            pathname="test.py",
+            lineno=1,
+            msg="Exception message",
+            args=(),
+            exc_info=None
+        )
+        record.levelname = "EXCEPTION"
+
+        result = handler_filter.filter(record)
+        assert result is False
+
+    def test_filter_non_exceptions_for_console(self):
+        """Test non-exception records pass through console filter"""
+        handler_filter = CustomHandlerFilter('console', filter_exceptions=True)
+        record = logging.LogRecord(
+            name="test",
+            level=logging.ERROR,
+            pathname="test.py",
+            lineno=1,
+            msg="Error message",
+            args=(),
+            exc_info=None
+        )
+
+        result = handler_filter.filter(record)
+        assert result is True
+
+    def test_filter_console_flag_for_file(self):
+        """Test filtering console-flagged records for file handler"""
+        handler_filter = CustomHandlerFilter('file', filter_exceptions=False)
+        record = logging.LogRecord(
+            name="test",
+            level=logging.ERROR,
+            pathname="test.py",
+            lineno=1,
+            msg="Error message",
+            args=(),
+            exc_info=None
+        )
+        record.console = True
+
+        result = handler_filter.filter(record)
+        assert result is False
+
+    def test_filter_normal_record_for_file(self):
+        """Test normal records pass through file filter"""
+        handler_filter = CustomHandlerFilter('file', filter_exceptions=False)
+        record = logging.LogRecord(
+            name="test",
+            level=logging.INFO,
+            pathname="test.py",
+            lineno=1,
+            msg="Info message",
+            args=(),
+            exc_info=None
+        )
+
+        result = handler_filter.filter(record)
+        assert result is True
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_5_handler_management.py

@@ -0,0 +1,209 @@
+"""
+Unit tests for Log handler management
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+import logging
+from pathlib import Path
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogParent,
+    LogSettings,
+    ConsoleFormatSettings,
+    ConsoleFormat,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test Handler Management
+class TestHandlerManagement:
+    """Test cases for handler management"""
+
+    def test_add_handler_before_init(self, tmp_log_path: Path):
+        """Test adding handler before logger initialization"""
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": None,
+        }
+
+        custom_handler = logging.StreamHandler()
+        custom_handler.set_name("custom")
+
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings,
+            other_handlers={"custom": custom_handler}
+        )
+
+        assert "custom" in log.handlers
+
+    def test_add_handler_after_init_raises(self, log_instance: Log):
+        """Test adding handler after initialization raises error"""
+        custom_handler = logging.StreamHandler()
+        custom_handler.set_name("custom2")
+
+        with pytest.raises(ValueError, match="Cannot add handler"):
+            log_instance.add_handler("custom2", custom_handler)
+
+    def test_add_duplicate_handler_returns_false(self):
+        """Test adding duplicate handler returns False"""
+        # Create a Log instance in a way we can test before initialization
+        log = object.__new__(Log)
+        LogParent.__init__(log)
+        log.handlers = {}
+        log.listener = None
+
+        handler1 = logging.StreamHandler()
+        handler1.set_name("test")
+        handler2 = logging.StreamHandler()
+        handler2.set_name("test")
+
+        result1 = log.add_handler("test", handler1)
+        assert result1 is True
+
+        result2 = log.add_handler("test", handler2)
+        assert result2 is False
+
+    def test_change_console_format_to_minimal(self, log_instance: Log):
+        """Test changing console handler format to MINIMAL"""
+        original_formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        new_formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert new_formatter is not original_formatter
+        assert new_formatter is not None
+
+    def test_change_console_format_to_condensed(self, log_instance: Log):
+        """Test changing console handler format to CONDENSED"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.CONDENSED)
+
+        formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert formatter is not None
+
+    def test_change_console_format_to_bare(self, log_instance: Log):
+        """Test changing console handler format to BARE"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.BARE)
+
+        formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert formatter is not None
+
+    def test_change_console_format_to_none(self, log_instance: Log):
+        """Test changing console handler format to NONE"""
+        log_instance.update_console_formatter(ConsoleFormatSettings.NONE)
+
+        formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert formatter is not None
+
+    def test_change_console_format_to_all(self, log_instance: Log):
+        """Test changing console handler format to ALL"""
+        # Start with a different format
+        log_instance.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        log_instance.update_console_formatter(ConsoleFormatSettings.ALL)
+
+        formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert formatter is not None
+
+    def test_change_console_format_multiple_times(self, log_instance: Log):
+        """Test changing console handler format multiple times"""
+        formatters: list[logging.Formatter | None] = []
+
+        for format_type in [
+            ConsoleFormatSettings.MINIMAL,
+            ConsoleFormatSettings.CONDENSED,
+            ConsoleFormatSettings.BARE,
+            ConsoleFormatSettings.NONE,
+            ConsoleFormatSettings.ALL,
+        ]:
+            log_instance.update_console_formatter(format_type)
+            formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+            formatters.append(formatter)
+            assert formatter is not None
+
+        # Verify each formatter is unique (new instance each time)
+        for i, formatter in enumerate(formatters):
+            for j, other_formatter in enumerate(formatters):
+                if i != j:
+                    assert formatter is not other_formatter
+
+    def test_change_console_format_with_disabled_console(
+        self, tmp_log_path: Path, basic_log_settings: LogSettings
+    ):
+        """Test changing console format when console is disabled does nothing"""
+        basic_log_settings['console_enabled'] = False
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test_log",
+            log_settings=basic_log_settings
+        )
+
+        # Should not raise error, just return early
+        log.update_console_formatter(ConsoleFormatSettings.MINIMAL)
+
+        # Console handler should not exist
+        assert log.CONSOLE_HANDLER not in log.handlers
+
+    @pytest.mark.parametrize("format_type", [
+        ConsoleFormatSettings.ALL,
+        ConsoleFormatSettings.CONDENSED,
+        ConsoleFormatSettings.MINIMAL,
+        ConsoleFormatSettings.BARE,
+        ConsoleFormatSettings.NONE,
+    ])
+    def test_change_console_format_parametrized(
+        self, log_instance: Log, format_type: ConsoleFormat  # type: ignore
+    ):
+        """Test changing console format with all format types"""
+        log_instance.update_console_formatter(format_type)
+
+        formatter = log_instance.handlers[log_instance.CONSOLE_HANDLER].formatter
+        assert formatter is not None
+        assert isinstance(formatter, logging.Formatter)
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_6_logger.py

@@ -0,0 +1,94 @@
+"""
+Unit tests for Log, Logger, and LogParent classes
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+from pathlib import Path
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    Logger,
+    LogSettings,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test Logger Class
+class TestLogger:
+    """Test cases for Logger class"""
+
+    def test_logger_init(self, log_instance: Log):
+        """Test Logger initialization"""
+        logger_settings = log_instance.get_logger_settings()
+        logger = Logger(logger_settings)
+
+        assert logger.logger is not None
+        assert logger.lg == logger.logger
+        assert logger.l == logger.logger
+        assert isinstance(logger.handlers, dict)
+        assert len(logger.handlers) > 0
+
+    def test_logger_logging_methods(self, log_instance: Log, tmp_log_path: Path):
+        """Test Logger logging methods"""
+        logger_settings = log_instance.get_logger_settings()
+        logger = Logger(logger_settings)
+
+        logger.debug("Debug from Logger")
+        logger.info("Info from Logger")
+        logger.warning("Warning from Logger")
+        logger.error("Error from Logger")
+        logger.critical("Critical from Logger")
+
+        log_file = tmp_log_path / "testlog.log"
+        content = log_file.read_text()
+        assert "Debug from Logger" in content
+        assert "Info from Logger" in content
+        assert "Warning from Logger" in content
+        assert "Error from Logger" in content
+        assert "Critical from Logger" in content
+
+    def test_logger_shared_queue(self, log_instance: Log):
+        """Test Logger shares the same log queue"""
+        logger_settings = log_instance.get_logger_settings()
+        logger = Logger(logger_settings)
+
+        assert logger.log_queue == log_instance.log_queue
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_7_edge_cases.py

@@ -0,0 +1,116 @@
+"""
+Unit tests for Log, Logger, and LogParent classes
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+import logging
+from pathlib import Path
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogSettings,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test Edge Cases
+class TestEdgeCases:
+    """Test edge cases and special scenarios"""
+
+    def test_log_name_sanitization(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test log name with special characters gets sanitized"""
+        _ = Log(
+            log_path=tmp_log_path,
+            log_name="test@#$%log",
+            log_settings=basic_log_settings
+        )
+
+        # Special characters should be removed from filename
+        log_file = tmp_log_path / "testlog.log"
+        assert log_file.exists() or any(tmp_log_path.glob("test*.log"))
+
+    def test_multiple_log_instances(self, tmp_log_path: Path, basic_log_settings: LogSettings):
+        """Test creating multiple Log instances"""
+        log1 = Log(tmp_log_path, "log1", basic_log_settings)
+        log2 = Log(tmp_log_path, "log2", basic_log_settings)
+
+        log1.info("From log1")
+        log2.info("From log2")
+
+        log_file1 = tmp_log_path / "log1.log"
+        log_file2 = tmp_log_path / "log2.log"
+
+        assert log_file1.exists()
+        assert log_file2.exists()
+        assert "From log1" in log_file1.read_text()
+        assert "From log2" in log_file2.read_text()
+
+    def test_destructor_calls_stop_listener(self, tmp_log_path: Path):
+        """Test destructor calls stop_listener"""
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": True,  # Enable end info
+            "log_queue": None,
+        }
+
+        log = Log(tmp_log_path, "test", settings)
+        del log
+
+        # Check that the log file was finalized
+        log_file = tmp_log_path / "test.log"
+        if log_file.exists():
+            content = log_file.read_text()
+            assert "[END]" in content
+
+    def test_get_logger_settings(self, log_instance: Log):
+        """Test get_logger_settings returns correct structure"""
+        settings = log_instance.get_logger_settings()
+
+        assert "logger" in settings
+        assert "log_queue" in settings
+        assert isinstance(settings["logger"], logging.Logger)
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_99_queue_listener.py

@@ -0,0 +1,144 @@
+"""
+Unit tests for Log, Logger, and LogParent classes
+"""
+
+# pylint: disable=protected-access,redefined-outer-name,use-implicit-booleaness-not-comparison
+
+import logging
+from pathlib import Path
+from unittest.mock import Mock, MagicMock, patch
+from multiprocessing import Queue
+import pytest
+from corelibs.logging_handling.log import (
+    Log,
+    LogSettings,
+    ConsoleFormatSettings,
+)
+from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
+
+
+# MARK: Fixtures
+@pytest.fixture
+def tmp_log_path(tmp_path: Path) -> Path:
+    """Create a temporary directory for log files"""
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    return log_dir
+
+
+@pytest.fixture
+def basic_log_settings() -> LogSettings:
+    """Basic log settings for testing"""
+    return {
+        "log_level_console": LoggingLevel.WARNING,
+        "log_level_file": LoggingLevel.DEBUG,
+        "per_run_log": False,
+        "console_enabled": True,
+        "console_color_output_enabled": False,
+        "console_format_type": ConsoleFormatSettings.ALL,
+        "add_start_info": False,
+        "add_end_info": False,
+        "log_queue": None,
+    }
+
+
+@pytest.fixture
+def log_instance(tmp_log_path: Path, basic_log_settings: LogSettings) -> Log:
+    """Create a basic Log instance"""
+    return Log(
+        log_path=tmp_log_path,
+        log_name="test_log",
+        log_settings=basic_log_settings
+    )
+
+
+# MARK: Test Queue Listener
+class TestQueueListener:
+    """Test cases for queue listener functionality"""
+
+    @patch('logging.handlers.QueueListener')
+    def test_init_listener(self, mock_listener_class: MagicMock, tmp_log_path: Path):
+        """Test listener initialization with queue"""
+        # Create a mock queue without spec to allow attribute setting
+        mock_queue = MagicMock()
+        mock_queue.empty.return_value = True
+        # Configure queue attributes to prevent TypeError in comparisons
+        mock_queue._maxsize = -1  # Standard Queue default
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": mock_queue,  # type: ignore
+        }
+
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings
+        )
+
+        assert log.log_queue == mock_queue
+        mock_listener_class.assert_called_once()
+
+    def test_stop_listener_no_listener(self, log_instance: Log):
+        """Test stop_listener when no listener exists"""
+        log_instance.stop_listener()  # Should not raise
+
+    @patch('logging.handlers.QueueListener')
+    def test_stop_listener_with_listener(self, mock_listener_class: MagicMock, tmp_log_path: Path):
+        """Test stop_listener with active listener"""
+        # Create a mock queue without spec to allow attribute setting
+        mock_queue = MagicMock()
+        mock_queue.empty.return_value = True
+        # Configure queue attributes to prevent TypeError in comparisons
+        mock_queue._maxsize = -1  # Standard Queue default
+        mock_listener = MagicMock()
+        mock_listener_class.return_value = mock_listener
+
+        settings: LogSettings = {
+            "log_level_console": LoggingLevel.WARNING,
+            "log_level_file": LoggingLevel.DEBUG,
+            "per_run_log": False,
+            "console_enabled": False,
+            "console_color_output_enabled": False,
+            "console_format_type": ConsoleFormatSettings.ALL,
+            "add_start_info": False,
+            "add_end_info": False,
+            "log_queue": mock_queue,  # type: ignore
+        }
+
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings
+        )
+
+        log.stop_listener()
+        mock_listener.stop.assert_called_once()
+
+
+# MARK: Test Static Methods
+class TestStaticMethods:
+    """Test cases for static methods"""
+
+    @patch('logging.getLogger')
+    def test_init_worker_logging(self, mock_get_logger: MagicMock):
+        """Test init_worker_logging static method"""
+        mock_queue = Mock(spec=Queue)
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        result = Log.init_worker_logging(mock_queue)
+
+        assert result == mock_logger
+        mock_get_logger.assert_called_once_with()
+        mock_logger.setLevel.assert_called_once_with(logging.DEBUG)
+        mock_logger.handlers.clear.assert_called_once()
+        assert mock_logger.addHandler.called
+
+# __END__

tests/unit/logging_handling/test_error_handling.py

@@ -0,0 +1,503 @@
+"""
+Test cases for ErrorMessage class
+"""
+
+# pylint: disable=use-implicit-booleaness-not-comparison
+
+from typing import Any
+import pytest
+from corelibs.logging_handling.error_handling import ErrorMessage
+
+
+class TestErrorMessageWarnings:
+    """Test cases for warning-related methods"""
+
+    def test_add_warning_basic(self):
+        """Test adding a basic warning message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        message = {"code": "W001", "description": "Test warning"}
+        error_msg.add_warning(message)
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == 1
+        assert warnings[0]["code"] == "W001"
+        assert warnings[0]["description"] == "Test warning"
+        assert warnings[0]["level"] == "Warning"
+
+    def test_add_warning_with_base_message(self):
+        """Test adding a warning with base message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        base_message = {"timestamp": "2025-10-24", "module": "test"}
+        message = {"code": "W002", "description": "Another warning"}
+        error_msg.add_warning(message, base_message)
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == 1
+        assert warnings[0]["timestamp"] == "2025-10-24"
+        assert warnings[0]["module"] == "test"
+        assert warnings[0]["code"] == "W002"
+        assert warnings[0]["description"] == "Another warning"
+        assert warnings[0]["level"] == "Warning"
+
+    def test_add_warning_with_none_base_message(self):
+        """Test adding a warning with None as base message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        message = {"code": "W003", "description": "Warning with None base"}
+        error_msg.add_warning(message, None)
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == 1
+        assert warnings[0]["code"] == "W003"
+        assert warnings[0]["level"] == "Warning"
+
+    def test_add_warning_with_invalid_base_message(self):
+        """Test adding a warning with invalid base message (not a dict)"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        message = {"code": "W004", "description": "Warning with invalid base"}
+        error_msg.add_warning(message, "invalid_base")  # type: ignore
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == 1
+        assert warnings[0]["code"] == "W004"
+        assert warnings[0]["level"] == "Warning"
+
+    def test_add_multiple_warnings(self):
+        """Test adding multiple warnings"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        error_msg.add_warning({"code": "W001", "description": "First warning"})
+        error_msg.add_warning({"code": "W002", "description": "Second warning"})
+        error_msg.add_warning({"code": "W003", "description": "Third warning"})
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == 3
+        assert warnings[0]["code"] == "W001"
+        assert warnings[1]["code"] == "W002"
+        assert warnings[2]["code"] == "W003"
+
+    def test_get_warnings_empty(self):
+        """Test getting warnings when list is empty"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        warnings = error_msg.get_warnings()
+        assert warnings == []
+        assert len(warnings) == 0
+
+    def test_has_warnings_true(self):
+        """Test has_warnings returns True when warnings exist"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        error_msg.add_warning({"code": "W001", "description": "Test warning"})
+        assert error_msg.has_warnings() is True
+
+    def test_has_warnings_false(self):
+        """Test has_warnings returns False when no warnings exist"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        assert error_msg.has_warnings() is False
+
+    def test_reset_warnings(self):
+        """Test resetting warnings list"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        error_msg.add_warning({"code": "W001", "description": "Test warning"})
+        assert error_msg.has_warnings() is True
+
+        error_msg.reset_warnings()
+        assert error_msg.has_warnings() is False
+        assert len(error_msg.get_warnings()) == 0
+
+    def test_warning_level_override(self):
+        """Test that level is always set to Warning even if base contains different level"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        base_message = {"level": "Error"}  # Should be overridden
+        message = {"code": "W001", "description": "Test warning"}
+        error_msg.add_warning(message, base_message)
+
+        warnings = error_msg.get_warnings()
+        assert warnings[0]["level"] == "Warning"
+
+
+class TestErrorMessageErrors:
+    """Test cases for error-related methods"""
+
+    def test_add_error_basic(self):
+        """Test adding a basic error message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        message = {"code": "E001", "description": "Test error"}
+        error_msg.add_error(message)
+
+        errors = error_msg.get_errors()
+        assert len(errors) == 1
+        assert errors[0]["code"] == "E001"
+        assert errors[0]["description"] == "Test error"
+        assert errors[0]["level"] == "Error"
+
+    def test_add_error_with_base_message(self):
+        """Test adding an error with base message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        base_message = {"timestamp": "2025-10-24", "module": "test"}
+        message = {"code": "E002", "description": "Another error"}
+        error_msg.add_error(message, base_message)
+
+        errors = error_msg.get_errors()
+        assert len(errors) == 1
+        assert errors[0]["timestamp"] == "2025-10-24"
+        assert errors[0]["module"] == "test"
+        assert errors[0]["code"] == "E002"
+        assert errors[0]["description"] == "Another error"
+        assert errors[0]["level"] == "Error"
+
+    def test_add_error_with_none_base_message(self):
+        """Test adding an error with None as base message"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        message = {"code": "E003", "description": "Error with None base"}
+        error_msg.add_error(message, None)
+
+        errors = error_msg.get_errors()
+        assert len(errors) == 1
+        assert errors[0]["code"] == "E003"
+        assert errors[0]["level"] == "Error"
+
+    def test_add_error_with_invalid_base_message(self):
+        """Test adding an error with invalid base message (not a dict)"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        message = {"code": "E004", "description": "Error with invalid base"}
+        error_msg.add_error(message, "invalid_base")  # type: ignore
+
+        errors = error_msg.get_errors()
+        assert len(errors) == 1
+        assert errors[0]["code"] == "E004"
+        assert errors[0]["level"] == "Error"
+
+    def test_add_multiple_errors(self):
+        """Test adding multiple errors"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        error_msg.add_error({"code": "E001", "description": "First error"})
+        error_msg.add_error({"code": "E002", "description": "Second error"})
+        error_msg.add_error({"code": "E003", "description": "Third error"})
+
+        errors = error_msg.get_errors()
+        assert len(errors) == 3
+        assert errors[0]["code"] == "E001"
+        assert errors[1]["code"] == "E002"
+        assert errors[2]["code"] == "E003"
+
+    def test_get_errors_empty(self):
+        """Test getting errors when list is empty"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        errors = error_msg.get_errors()
+        assert errors == []
+        assert len(errors) == 0
+
+    def test_has_errors_true(self):
+        """Test has_errors returns True when errors exist"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        error_msg.add_error({"code": "E001", "description": "Test error"})
+        assert error_msg.has_errors() is True
+
+    def test_has_errors_false(self):
+        """Test has_errors returns False when no errors exist"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        assert error_msg.has_errors() is False
+
+    def test_reset_errors(self):
+        """Test resetting errors list"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        error_msg.add_error({"code": "E001", "description": "Test error"})
+        assert error_msg.has_errors() is True
+
+        error_msg.reset_errors()
+        assert error_msg.has_errors() is False
+        assert len(error_msg.get_errors()) == 0
+
+    def test_error_level_override(self):
+        """Test that level is always set to Error even if base contains different level"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        base_message = {"level": "Warning"}  # Should be overridden
+        message = {"code": "E001", "description": "Test error"}
+        error_msg.add_error(message, base_message)
+
+        errors = error_msg.get_errors()
+        assert errors[0]["level"] == "Error"
+
+
+class TestErrorMessageMixed:
+    """Test cases for mixed warning and error operations"""
+
+    def test_errors_and_warnings_independent(self):
+        """Test that errors and warnings are stored independently"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+        error_msg.reset_warnings()
+
+        error_msg.add_error({"code": "E001", "description": "Test error"})
+        error_msg.add_warning({"code": "W001", "description": "Test warning"})
+
+        assert len(error_msg.get_errors()) == 1
+        assert len(error_msg.get_warnings()) == 1
+        assert error_msg.has_errors() is True
+        assert error_msg.has_warnings() is True
+
+    def test_reset_errors_does_not_affect_warnings(self):
+        """Test that resetting errors does not affect warnings"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+        error_msg.reset_warnings()
+
+        error_msg.add_error({"code": "E001", "description": "Test error"})
+        error_msg.add_warning({"code": "W001", "description": "Test warning"})
+
+        error_msg.reset_errors()
+
+        assert error_msg.has_errors() is False
+        assert error_msg.has_warnings() is True
+        assert len(error_msg.get_warnings()) == 1
+
+    def test_reset_warnings_does_not_affect_errors(self):
+        """Test that resetting warnings does not affect errors"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+        error_msg.reset_warnings()
+
+        error_msg.add_error({"code": "E001", "description": "Test error"})
+        error_msg.add_warning({"code": "W001", "description": "Test warning"})
+
+        error_msg.reset_warnings()
+
+        assert error_msg.has_errors() is True
+        assert error_msg.has_warnings() is False
+        assert len(error_msg.get_errors()) == 1
+
+
+class TestErrorMessageClassVariables:
+    """Test cases to verify class-level variable behavior"""
+
+    def test_class_variable_shared_across_instances(self):
+        """Test that error and warning lists are shared across instances"""
+        error_msg1 = ErrorMessage()
+        error_msg2 = ErrorMessage()
+
+        error_msg1.reset_errors()
+        error_msg1.reset_warnings()
+
+        error_msg1.add_error({"code": "E001", "description": "Error from instance 1"})
+        error_msg1.add_warning({"code": "W001", "description": "Warning from instance 1"})
+
+        # Both instances should see the same data
+        assert len(error_msg2.get_errors()) == 1
+        assert len(error_msg2.get_warnings()) == 1
+        assert error_msg2.has_errors() is True
+        assert error_msg2.has_warnings() is True
+
+    def test_reset_affects_all_instances(self):
+        """Test that reset operations affect all instances"""
+        error_msg1 = ErrorMessage()
+        error_msg2 = ErrorMessage()
+
+        error_msg1.reset_errors()
+        error_msg1.reset_warnings()
+
+        error_msg1.add_error({"code": "E001", "description": "Test error"})
+        error_msg1.add_warning({"code": "W001", "description": "Test warning"})
+
+        error_msg2.reset_errors()
+
+        # Both instances should reflect the reset
+        assert error_msg1.has_errors() is False
+        assert error_msg2.has_errors() is False
+
+        error_msg2.reset_warnings()
+
+        assert error_msg1.has_warnings() is False
+        assert error_msg2.has_warnings() is False
+
+
+class TestErrorMessageEdgeCases:
+    """Test edge cases and special scenarios"""
+
+    def test_empty_message_dict(self):
+        """Test adding empty message dictionaries"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+        error_msg.reset_warnings()
+
+        error_msg.add_error({})
+        error_msg.add_warning({})
+
+        errors = error_msg.get_errors()
+        warnings = error_msg.get_warnings()
+
+        assert len(errors) == 1
+        assert len(warnings) == 1
+        assert errors[0] == {"level": "Error"}
+        assert warnings[0] == {"level": "Warning"}
+
+    def test_message_with_complex_data(self):
+        """Test adding messages with complex data structures"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        complex_message = {
+            "code": "E001",
+            "description": "Complex error",
+            "details": {
+                "nested": "data",
+                "list": [1, 2, 3],
+            },
+            "count": 42,
+        }
+        error_msg.add_error(complex_message)
+
+        errors = error_msg.get_errors()
+        assert errors[0]["code"] == "E001"
+        assert errors[0]["details"]["nested"] == "data"
+        assert errors[0]["details"]["list"] == [1, 2, 3]
+        assert errors[0]["count"] == 42
+        assert errors[0]["level"] == "Error"
+
+    def test_base_message_merge_override(self):
+        """Test that message values override base_message values"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        base_message = {"code": "BASE", "description": "Base description", "timestamp": "2025-10-24"}
+        message = {"code": "E001", "description": "Override description"}
+        error_msg.add_error(message, base_message)
+
+        errors = error_msg.get_errors()
+        assert errors[0]["code"] == "E001"  # Overridden
+        assert errors[0]["description"] == "Override description"  # Overridden
+        assert errors[0]["timestamp"] == "2025-10-24"  # From base
+        assert errors[0]["level"] == "Error"  # Set by add_error
+
+    def test_sequential_operations(self):
+        """Test sequential add and reset operations"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        error_msg.add_error({"code": "E001"})
+        assert len(error_msg.get_errors()) == 1
+
+        error_msg.add_error({"code": "E002"})
+        assert len(error_msg.get_errors()) == 2
+
+        error_msg.reset_errors()
+        assert len(error_msg.get_errors()) == 0
+
+        error_msg.add_error({"code": "E003"})
+        assert len(error_msg.get_errors()) == 1
+        assert error_msg.get_errors()[0]["code"] == "E003"
+
+
+class TestParametrized:
+    """Parametrized tests for comprehensive coverage"""
+
+    @pytest.mark.parametrize("base_message,message,expected_keys", [
+        (None, {"code": "E001"}, {"code", "level"}),
+        ({}, {"code": "E001"}, {"code", "level"}),
+        ({"timestamp": "2025-10-24"}, {"code": "E001"}, {"code", "level", "timestamp"}),
+        ({"a": 1, "b": 2}, {"c": 3}, {"a", "b", "c", "level"}),
+    ])
+    def test_error_message_merge_parametrized(
+        self,
+        base_message: dict[str, Any] | None,
+        message: dict[str, Any],
+        expected_keys: set[str]
+    ):
+        """Test error message merging with various combinations"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        error_msg.add_error(message, base_message)
+        errors = error_msg.get_errors()
+
+        assert len(errors) == 1
+        assert set(errors[0].keys()) == expected_keys
+        assert errors[0]["level"] == "Error"
+
+    @pytest.mark.parametrize("base_message,message,expected_keys", [
+        (None, {"code": "W001"}, {"code", "level"}),
+        ({}, {"code": "W001"}, {"code", "level"}),
+        ({"timestamp": "2025-10-24"}, {"code": "W001"}, {"code", "level", "timestamp"}),
+        ({"a": 1, "b": 2}, {"c": 3}, {"a", "b", "c", "level"}),
+    ])
+    def test_warning_message_merge_parametrized(
+        self,
+        base_message: dict[str, Any] | None,
+        message: dict[str, Any],
+        expected_keys: set[str]
+    ):
+        """Test warning message merging with various combinations"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        error_msg.add_warning(message, base_message)
+        warnings = error_msg.get_warnings()
+
+        assert len(warnings) == 1
+        assert set(warnings[0].keys()) == expected_keys
+        assert warnings[0]["level"] == "Warning"
+
+    @pytest.mark.parametrize("count", [0, 1, 5, 10, 100])
+    def test_multiple_errors_parametrized(self, count: int):
+        """Test adding multiple errors"""
+        error_msg = ErrorMessage()
+        error_msg.reset_errors()
+
+        for i in range(count):
+            error_msg.add_error({"code": f"E{i:03d}"})
+
+        errors = error_msg.get_errors()
+        assert len(errors) == count
+        assert error_msg.has_errors() == (count > 0)
+
+    @pytest.mark.parametrize("count", [0, 1, 5, 10, 100])
+    def test_multiple_warnings_parametrized(self, count: int):
+        """Test adding multiple warnings"""
+        error_msg = ErrorMessage()
+        error_msg.reset_warnings()
+
+        for i in range(count):
+            error_msg.add_warning({"code": f"W{i:03d}"})
+
+        warnings = error_msg.get_warnings()
+        assert len(warnings) == count
+        assert error_msg.has_warnings() == (count > 0)
+
+# __END__

tests/unit/string_handling/test_string_helpers.py

@@ -1,327 +0,0 @@
-"""
-PyTest: string_handling/string_helpers
-"""
-
-from textwrap import shorten
-import pytest
-from corelibs.string_handling.string_helpers import (
-    shorten_string, left_fill, format_number, prepare_url_slash
-)
-
-
-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"
-
-
-class TestPrepareUrlSlash:
-    """Tests for prepare_url_slash function"""
-
-    def test_url_without_leading_slash(self):
-        """Test that URL without leading slash gets one added"""
-        result = prepare_url_slash("api/users")
-        assert result == "/api/users"
-
-    def test_url_with_leading_slash(self):
-        """Test that URL with leading slash remains unchanged"""
-        result = prepare_url_slash("/api/users")
-        assert result == "/api/users"
-
-    def test_url_with_double_slashes(self):
-        """Test that double slashes are reduced to single slash"""
-        result = prepare_url_slash("/api//users")
-        assert result == "/api/users"
-
-    def test_url_with_multiple_slashes(self):
-        """Test that multiple consecutive slashes are reduced to single slash"""
-        result = prepare_url_slash("api///users////data")
-        assert result == "/api/users/data"
-
-    def test_url_with_leading_double_slash(self):
-        """Test URL starting with double slash"""
-        result = prepare_url_slash("//api/users")
-        assert result == "/api/users"
-
-    def test_url_without_slash_and_double_slashes(self):
-        """Test URL without leading slash and containing double slashes"""
-        result = prepare_url_slash("api//users//data")
-        assert result == "/api/users/data"
-
-    def test_single_slash(self):
-        """Test single slash URL"""
-        result = prepare_url_slash("/")
-        assert result == "/"
-
-    def test_multiple_slashes_only(self):
-        """Test URL with only multiple slashes"""
-        result = prepare_url_slash("///")
-        assert result == "/"
-
-    def test_empty_string(self):
-        """Test empty string"""
-        result = prepare_url_slash("")
-        assert result == "/"
-
-    def test_url_with_query_params(self):
-        """Test URL with query parameters"""
-        result = prepare_url_slash("/api/users?id=1")
-        assert result == "/api/users?id=1"
-
-    def test_url_with_double_slashes_and_query(self):
-        """Test URL with double slashes and query parameters"""
-        result = prepare_url_slash("api//users?id=1")
-        assert result == "/api/users?id=1"
-
-    def test_complex_url_path(self):
-        """Test complex URL path with multiple segments"""
-        result = prepare_url_slash("api/v1/users/123/profile")
-        assert result == "/api/v1/users/123/profile"
-
-    def test_complex_url_with_multiple_issues(self):
-        """Test URL with both missing leading slash and multiple double slashes"""
-        result = prepare_url_slash("api//v1///users//123////profile")
-        assert result == "/api/v1/users/123/profile"
-
-
-# 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
-
-
-@pytest.mark.parametrize("input_url,expected", [
-    ("api/users", "/api/users"),
-    ("/api/users", "/api/users"),
-    ("api//users", "/api/users"),
-    ("/api//users", "/api/users"),
-    ("//api/users", "/api/users"),
-    ("api///users////data", "/api/users/data"),
-    ("/", "/"),
-    ("///", "/"),
-    ("", "/"),
-    ("api/v1/users/123", "/api/v1/users/123"),
-    ("/api/users?id=1&name=test", "/api/users?id=1&name=test"),
-    ("api//users//123//profile", "/api/users/123/profile"),
-])
-def test_prepare_url_slash_parametrized(input_url: str, expected: str):
-    """Parametrized test for prepare_url_slash"""
-    assert prepare_url_slash(input_url) == expected
-
-# __END__

tests/unit/var_handling/__init__.py

@@ -1,3 +0,0 @@
-"""
-var_handling tests
-"""

tests/unit/var_handling/test_enum_base.py

@@ -1,546 +0,0 @@
-"""
-var_handling.enum_base tests
-"""
-
-from typing import Any
-import pytest
-from corelibs.var_handling.enum_base import EnumBase
-
-
-class SampleBlock(EnumBase):
-    """Sample block enum for testing purposes"""
-    BLOCK_A = "block_a"
-    BLOCK_B = "block_b"
-    HAS_NUM = 5
-    HAS_FLOAT = 3.14
-    LEGACY_KEY = "legacy_value"
-
-
-class SimpleEnum(EnumBase):
-    """Simple enum with string values"""
-    OPTION_ONE = "one"
-    OPTION_TWO = "two"
-    OPTION_THREE = "three"
-
-
-class NumericEnum(EnumBase):
-    """Enum with only numeric values"""
-    FIRST = 1
-    SECOND = 2
-    THIRD = 3
-
-
-class TestEnumBaseLookupKey:
-    """Test cases for lookup_key class method"""
-
-    def test_lookup_key_valid_uppercase(self):
-        """Test lookup_key with valid uppercase key"""
-        result = SampleBlock.lookup_key("BLOCK_A")
-        assert result == SampleBlock.BLOCK_A
-        assert result.name == "BLOCK_A"
-        assert result.value == "block_a"
-
-    def test_lookup_key_valid_lowercase(self):
-        """Test lookup_key with valid lowercase key (should convert to uppercase)"""
-        result = SampleBlock.lookup_key("block_a")
-        assert result == SampleBlock.BLOCK_A
-        assert result.name == "BLOCK_A"
-
-    def test_lookup_key_valid_mixed_case(self):
-        """Test lookup_key with mixed case key"""
-        result = SampleBlock.lookup_key("BlOcK_a")
-        assert result == SampleBlock.BLOCK_A
-        assert result.name == "BLOCK_A"
-
-    def test_lookup_key_with_numeric_enum(self):
-        """Test lookup_key with numeric enum member"""
-        result = SampleBlock.lookup_key("HAS_NUM")
-        assert result == SampleBlock.HAS_NUM
-        assert result.value == 5
-
-    def test_lookup_key_legacy_colon_replacement(self):
-        """Test lookup_key with legacy colon format (converts : to ___)"""
-        # This assumes the enum has a key that might be accessed with legacy format
-        # Should convert : to ___ and look up LEGACY___KEY
-        # Since we don't have this key, we test the behavior with a valid conversion
-        # Let's test with a known key that would work
-        with pytest.raises(ValueError, match="Invalid key"):
-            SampleBlock.lookup_key("BLOCK:A")  # Should fail as BLOCK___A doesn't exist
-
-    def test_lookup_key_invalid_key(self):
-        """Test lookup_key with invalid key"""
-        with pytest.raises(ValueError, match="Invalid key: NONEXISTENT"):
-            SampleBlock.lookup_key("NONEXISTENT")
-
-    def test_lookup_key_empty_string(self):
-        """Test lookup_key with empty string"""
-        with pytest.raises(ValueError, match="Invalid key"):
-            SampleBlock.lookup_key("")
-
-    def test_lookup_key_with_special_characters(self):
-        """Test lookup_key with special characters that might cause AttributeError"""
-        with pytest.raises(ValueError, match="Invalid key"):
-            SampleBlock.lookup_key("@#$%")
-
-    def test_lookup_key_numeric_string(self):
-        """Test lookup_key with numeric string that isn't a key"""
-        with pytest.raises(ValueError, match="Invalid key"):
-            SampleBlock.lookup_key("123")
-
-
-class TestEnumBaseLookupValue:
-    """Test cases for lookup_value class method"""
-
-    def test_lookup_value_valid_string(self):
-        """Test lookup_value with valid string value"""
-        result = SampleBlock.lookup_value("block_a")
-        assert result == SampleBlock.BLOCK_A
-        assert result.name == "BLOCK_A"
-        assert result.value == "block_a"
-
-    def test_lookup_value_valid_integer(self):
-        """Test lookup_value with valid integer value"""
-        result = SampleBlock.lookup_value(5)
-        assert result == SampleBlock.HAS_NUM
-        assert result.name == "HAS_NUM"
-        assert result.value == 5
-
-    def test_lookup_value_valid_float(self):
-        """Test lookup_value with valid float value"""
-        result = SampleBlock.lookup_value(3.14)
-        assert result == SampleBlock.HAS_FLOAT
-        assert result.name == "HAS_FLOAT"
-        assert result.value == 3.14
-
-    def test_lookup_value_invalid_string(self):
-        """Test lookup_value with invalid string value"""
-        with pytest.raises(ValueError, match="Invalid value: nonexistent"):
-            SampleBlock.lookup_value("nonexistent")
-
-    def test_lookup_value_invalid_integer(self):
-        """Test lookup_value with invalid integer value"""
-        with pytest.raises(ValueError, match="Invalid value: 999"):
-            SampleBlock.lookup_value(999)
-
-    def test_lookup_value_case_sensitive(self):
-        """Test that lookup_value is case-sensitive for string values"""
-        with pytest.raises(ValueError, match="Invalid value"):
-            SampleBlock.lookup_value("BLOCK_A")  # Value is "block_a", not "BLOCK_A"
-
-
-class TestEnumBaseFromAny:
-    """Test cases for from_any class method"""
-
-    def test_from_any_with_enum_instance(self):
-        """Test from_any with an enum instance (should return as-is)"""
-        enum_instance = SampleBlock.BLOCK_A
-        result = SampleBlock.from_any(enum_instance)
-        assert result is enum_instance
-        assert result == SampleBlock.BLOCK_A
-
-    def test_from_any_with_string_as_key(self):
-        """Test from_any with string that matches a key"""
-        result = SampleBlock.from_any("BLOCK_A")
-        assert result == SampleBlock.BLOCK_A
-        assert result.name == "BLOCK_A"
-        assert result.value == "block_a"
-
-    def test_from_any_with_string_as_key_lowercase(self):
-        """Test from_any with lowercase string key"""
-        result = SampleBlock.from_any("block_a")
-        # Should first try as key (convert to uppercase and find BLOCK_A)
-        assert result == SampleBlock.BLOCK_A
-
-    def test_from_any_with_string_as_value(self):
-        """Test from_any with string that only matches a value"""
-        # Use a value that isn't also a valid key
-        result = SampleBlock.from_any("block_b")
-        # Should try key first (fail), then value (succeed)
-        assert result == SampleBlock.BLOCK_B
-        assert result.value == "block_b"
-
-    def test_from_any_with_integer(self):
-        """Test from_any with integer value"""
-        result = SampleBlock.from_any(5)
-        assert result == SampleBlock.HAS_NUM
-        assert result.value == 5
-
-    def test_from_any_with_float(self):
-        """Test from_any with float value"""
-        result = SampleBlock.from_any(3.14)
-        assert result == SampleBlock.HAS_FLOAT
-        assert result.value == 3.14
-
-    def test_from_any_with_invalid_string(self):
-        """Test from_any with string that doesn't match key or value"""
-        with pytest.raises(ValueError, match="Could not find as key or value: invalid_string"):
-            SampleBlock.from_any("invalid_string")
-
-    def test_from_any_with_invalid_integer(self):
-        """Test from_any with integer that doesn't match any value"""
-        with pytest.raises(ValueError, match="Invalid value: 999"):
-            SampleBlock.from_any(999)
-
-    def test_from_any_string_key_priority(self):
-        """Test that from_any tries key lookup before value for strings"""
-        # Create an enum where a value matches another key
-        class AmbiguousEnum(EnumBase):
-            KEY_A = "key_b"  # Value is the name of another key
-            KEY_B = "value_b"
-
-        # When we look up "KEY_B", it should find it as a key, not as value "key_b"
-        result = AmbiguousEnum.from_any("KEY_B")
-        assert result == AmbiguousEnum.KEY_B
-        assert result.value == "value_b"
-
-
-class TestEnumBaseToValue:
-    """Test cases for to_value instance method"""
-
-    def test_to_value_string_value(self):
-        """Test to_value with string enum value"""
-        result = SampleBlock.BLOCK_A.to_value()
-        assert result == "block_a"
-        assert isinstance(result, str)
-
-    def test_to_value_integer_value(self):
-        """Test to_value with integer enum value"""
-        result = SampleBlock.HAS_NUM.to_value()
-        assert result == 5
-        assert isinstance(result, int)
-
-    def test_to_value_float_value(self):
-        """Test to_value with float enum value"""
-        result = SampleBlock.HAS_FLOAT.to_value()
-        assert result == 3.14
-        assert isinstance(result, float)
-
-    def test_to_value_equals_value_attribute(self):
-        """Test that to_value returns the same as .value"""
-        enum_instance = SampleBlock.BLOCK_A
-        assert enum_instance.to_value() == enum_instance.value
-
-
-class TestEnumBaseToLowerCase:
-    """Test cases for to_lower_case instance method"""
-
-    def test_to_lower_case_uppercase_name(self):
-        """Test to_lower_case with uppercase enum name"""
-        result = SampleBlock.BLOCK_A.to_lower_case()
-        assert result == "block_a"
-        assert isinstance(result, str)
-
-    def test_to_lower_case_mixed_name(self):
-        """Test to_lower_case with name containing underscores"""
-        result = SampleBlock.HAS_NUM.to_lower_case()
-        assert result == "has_num"
-
-    def test_to_lower_case_consistency(self):
-        """Test that to_lower_case always returns lowercase"""
-        for member in SampleBlock:
-            result = member.to_lower_case()
-            assert result == result.lower()
-            assert result == member.name.lower()
-
-
-class TestEnumBaseStrMethod:
-    """Test cases for __str__ magic method"""
-
-    def test_str_returns_name(self):
-        """Test that str() returns the enum name"""
-        result = str(SampleBlock.BLOCK_A)
-        assert result == "BLOCK_A"
-        assert result == SampleBlock.BLOCK_A.name
-
-    def test_str_all_members(self):
-        """Test str() for all enum members"""
-        for member in SampleBlock:
-            result = str(member)
-            assert result == member.name
-            assert isinstance(result, str)
-
-    def test_str_in_formatting(self):
-        """Test that str works in string formatting"""
-        formatted = f"Enum: {SampleBlock.BLOCK_A}"
-        assert formatted == "Enum: BLOCK_A"
-
-    def test_str_vs_repr(self):
-        """Test difference between str and repr"""
-        enum_instance = SampleBlock.BLOCK_A
-        str_result = str(enum_instance)
-        repr_result = repr(enum_instance)
-
-        assert str_result == "BLOCK_A"
-        # repr should include class name
-        assert "SampleBlock" in repr_result
-
-
-# Parametrized tests for comprehensive coverage
-class TestParametrized:
-    """Parametrized tests for better coverage"""
-
-    @pytest.mark.parametrize("key,expected_member", [
-        ("BLOCK_A", SampleBlock.BLOCK_A),
-        ("block_a", SampleBlock.BLOCK_A),
-        ("BLOCK_B", SampleBlock.BLOCK_B),
-        ("HAS_NUM", SampleBlock.HAS_NUM),
-        ("has_num", SampleBlock.HAS_NUM),
-        ("HAS_FLOAT", SampleBlock.HAS_FLOAT),
-    ])
-    def test_lookup_key_parametrized(self, key: str, expected_member: EnumBase):
-        """Test lookup_key with various valid keys"""
-        result = SampleBlock.lookup_key(key)
-        assert result == expected_member
-
-    @pytest.mark.parametrize("value,expected_member", [
-        ("block_a", SampleBlock.BLOCK_A),
-        ("block_b", SampleBlock.BLOCK_B),
-        (5, SampleBlock.HAS_NUM),
-        (3.14, SampleBlock.HAS_FLOAT),
-        ("legacy_value", SampleBlock.LEGACY_KEY),
-    ])
-    def test_lookup_value_parametrized(self, value: Any, expected_member: EnumBase):
-        """Test lookup_value with various valid values"""
-        result = SampleBlock.lookup_value(value)
-        assert result == expected_member
-
-    @pytest.mark.parametrize("input_any,expected_member", [
-        ("BLOCK_A", SampleBlock.BLOCK_A),
-        ("block_a", SampleBlock.BLOCK_A),
-        ("block_b", SampleBlock.BLOCK_B),
-        (5, SampleBlock.HAS_NUM),
-        (3.14, SampleBlock.HAS_FLOAT),
-        (SampleBlock.BLOCK_A, SampleBlock.BLOCK_A),  # Pass enum instance
-    ])
-    def test_from_any_parametrized(self, input_any: Any, expected_member: EnumBase):
-        """Test from_any with various valid inputs"""
-        result = SampleBlock.from_any(input_any)
-        assert result == expected_member
-
-    @pytest.mark.parametrize("invalid_key", [
-        "NONEXISTENT",
-        "invalid",
-        "123",
-        "",
-        "BLOCK_C",
-    ])
-    def test_lookup_key_invalid_parametrized(self, invalid_key: str):
-        """Test lookup_key with various invalid keys"""
-        with pytest.raises(ValueError, match="Invalid key"):
-            SampleBlock.lookup_key(invalid_key)
-
-    @pytest.mark.parametrize("invalid_value", [
-        "nonexistent",
-        999,
-        -1,
-        0.0,
-        "BLOCK_A",  # This is a key name, not a value
-    ])
-    def test_lookup_value_invalid_parametrized(self, invalid_value: Any):
-        """Test lookup_value with various invalid values"""
-        with pytest.raises(ValueError, match="Invalid value"):
-            SampleBlock.lookup_value(invalid_value)
-
-
-# Edge cases and special scenarios
-class TestEdgeCases:
-    """Test edge cases and special scenarios"""
-
-    def test_enum_with_single_member(self):
-        """Test EnumBase with only one member"""
-        class SingleEnum(EnumBase):
-            ONLY_ONE = "single"
-
-        result = SingleEnum.from_any("ONLY_ONE")
-        assert result == SingleEnum.ONLY_ONE
-        assert result.to_value() == "single"
-
-    def test_enum_iteration(self):
-        """Test iterating over enum members"""
-        members = list(SampleBlock)
-        assert len(members) == 5
-        assert SampleBlock.BLOCK_A in members
-        assert SampleBlock.BLOCK_B in members
-        assert SampleBlock.HAS_NUM in members
-
-    def test_enum_membership(self):
-        """Test checking membership in enum"""
-        assert SampleBlock.BLOCK_A in SampleBlock
-        assert SampleBlock.HAS_NUM in SampleBlock
-
-    def test_enum_comparison(self):
-        """Test comparing enum members"""
-        assert SampleBlock.BLOCK_A == SampleBlock.BLOCK_A
-        assert SampleBlock.BLOCK_A != SampleBlock.BLOCK_B
-        assert SampleBlock.from_any("BLOCK_A") == SampleBlock.BLOCK_A
-
-    def test_enum_identity(self):
-        """Test enum member identity"""
-        member1 = SampleBlock.BLOCK_A
-        member2 = SampleBlock.lookup_key("BLOCK_A")
-        member3 = SampleBlock.from_any("BLOCK_A")
-
-        assert member1 is member2
-        assert member1 is member3
-        assert member2 is member3
-
-    def test_different_enum_classes(self):
-        """Test that different enum classes are distinct"""
-        # Even if they have same keys/values, they're different
-        class OtherEnum(EnumBase):
-            BLOCK_A = "block_a"
-
-        result1 = SampleBlock.from_any("BLOCK_A")
-        result2 = OtherEnum.from_any("BLOCK_A")
-
-        assert result1 != result2
-        assert not isinstance(result1, type(result2))
-
-    def test_numeric_enum_operations(self):
-        """Test operations specific to numeric enums"""
-        assert NumericEnum.FIRST.to_value() == 1
-        assert NumericEnum.SECOND.to_value() == 2
-        assert NumericEnum.THIRD.to_value() == 3
-
-        # Test from_any with integers
-        assert NumericEnum.from_any(1) == NumericEnum.FIRST
-        assert NumericEnum.from_any(2) == NumericEnum.SECOND
-
-    def test_mixed_value_types_in_same_enum(self):
-        """Test enum with mixed value types"""
-        # SampleBlock already has mixed types (strings, int, float)
-        assert isinstance(SampleBlock.BLOCK_A.to_value(), str)
-        assert isinstance(SampleBlock.HAS_NUM.to_value(), int)
-        assert isinstance(SampleBlock.HAS_FLOAT.to_value(), float)
-
-    def test_from_any_chained_calls(self):
-        """Test that from_any can be chained (idempotent)"""
-        result1 = SampleBlock.from_any("BLOCK_A")
-        result2 = SampleBlock.from_any(result1)
-        result3 = SampleBlock.from_any(result2)
-
-        assert result1 == result2 == result3
-        assert result1 is result2 is result3
-
-
-# Integration tests
-class TestIntegration:
-    """Integration tests combining multiple methods"""
-
-    def test_round_trip_key_lookup(self):
-        """Test round-trip from key to enum and back"""
-        original_key = "BLOCK_A"
-        enum_member = SampleBlock.lookup_key(original_key)
-        result_name = str(enum_member)
-
-        assert result_name == original_key
-
-    def test_round_trip_value_lookup(self):
-        """Test round-trip from value to enum and back"""
-        original_value = "block_a"
-        enum_member = SampleBlock.lookup_value(original_value)
-        result_value = enum_member.to_value()
-
-        assert result_value == original_value
-
-    def test_from_any_workflow(self):
-        """Test realistic workflow using from_any"""
-        # Simulate receiving various types of input
-        inputs = [
-            "BLOCK_A",  # Key as string
-            "block_b",  # Value as string
-            5,          # Numeric value
-            SampleBlock.HAS_FLOAT,  # Already an enum
-        ]
-
-        expected = [
-            SampleBlock.BLOCK_A,
-            SampleBlock.BLOCK_B,
-            SampleBlock.HAS_NUM,
-            SampleBlock.HAS_FLOAT,
-        ]
-
-        for input_val, expected_val in zip(inputs, expected):
-            result = SampleBlock.from_any(input_val)
-            assert result == expected_val
-
-    def test_enum_in_dictionary(self):
-        """Test using enum as dictionary key"""
-        enum_dict = {
-            SampleBlock.BLOCK_A: "Value A",
-            SampleBlock.BLOCK_B: "Value B",
-            SampleBlock.HAS_NUM: "Value Num",
-        }
-
-        assert enum_dict[SampleBlock.BLOCK_A] == "Value A"
-        block_b = SampleBlock.from_any("BLOCK_B")
-        assert isinstance(block_b, SampleBlock)
-        assert enum_dict[block_b] == "Value B"
-
-    def test_enum_in_set(self):
-        """Test using enum in a set"""
-        enum_set = {SampleBlock.BLOCK_A, SampleBlock.BLOCK_B, SampleBlock.BLOCK_A}
-
-        assert len(enum_set) == 2  # BLOCK_A should be deduplicated
-        assert SampleBlock.BLOCK_A in enum_set
-        assert SampleBlock.from_any("BLOCK_B") in enum_set
-
-
-# Real-world usage scenarios
-class TestRealWorldScenarios:
-    """Test real-world usage scenarios from enum_test.py"""
-
-    def test_original_enum_test_scenario(self):
-        """Test the scenario from the original enum_test.py"""
-        # BLOCK A: {SampleBlock.from_any('BLOCK_A')}
-        result_a = SampleBlock.from_any('BLOCK_A')
-        assert result_a == SampleBlock.BLOCK_A
-        assert str(result_a) == "BLOCK_A"
-
-        # HAS NUM: {SampleBlock.from_any(5)}
-        result_num = SampleBlock.from_any(5)
-        assert result_num == SampleBlock.HAS_NUM
-        assert result_num.to_value() == 5
-
-        # DIRECT BLOCK: {SampleBlock.BLOCK_A.name} -> {SampleBlock.BLOCK_A.value}
-        assert SampleBlock.BLOCK_A.name == "BLOCK_A"
-        assert SampleBlock.BLOCK_A.value == "block_a"
-
-    def test_config_value_parsing(self):
-        """Test parsing values from configuration (common use case)"""
-        # Simulate config values that might come as strings
-        config_values = ["OPTION_ONE", "option_two", "OPTION_THREE"]
-
-        results = [SimpleEnum.from_any(val) for val in config_values]
-
-        assert results[0] == SimpleEnum.OPTION_ONE
-        assert results[1] == SimpleEnum.OPTION_TWO
-        assert results[2] == SimpleEnum.OPTION_THREE
-
-    def test_api_response_mapping(self):
-        """Test mapping API response values to enum"""
-        # Simulate API returning numeric codes
-        api_codes = [1, 2, 3]
-
-        results = [NumericEnum.from_any(code) for code in api_codes]
-
-        assert results[0] == NumericEnum.FIRST
-        assert results[1] == NumericEnum.SECOND
-        assert results[2] == NumericEnum.THIRD
-
-    def test_validation_with_error_handling(self):
-        """Test validation with proper error handling"""
-        valid_input = "BLOCK_A"
-        invalid_input = "INVALID"
-
-        # Valid input should work
-        result = SampleBlock.from_any(valid_input)
-        assert result == SampleBlock.BLOCK_A
-
-        # Invalid input should raise ValueError
-        try:
-            SampleBlock.from_any(invalid_input)
-            assert False, "Should have raised ValueError"
-        except ValueError as e:
-            assert "Could not find as key or value" in str(e)
-            assert "INVALID" in str(e)

tests/unit/var_handling/test_var_helpers.py

@@ -1,241 +0,0 @@
-"""
-var helpers
-"""
-
-# ADDED 2025/7/11 Replace 'your_module' with actual module name
-
-from typing import Any
-import pytest
-from corelibs.var_handling.var_helpers import is_int, is_float, str_to_bool
-
-
-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)

uv.lock

@@ -1,434 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.13"
-
-[[package]]
-name = "certifi"
-version = "2025.10.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
-]
-
-[[package]]
-name = "cffi"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
-    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
-    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
-    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
-    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
-    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
-    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
-    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
-    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
-    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
-    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
-    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
-    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
-    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
-    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
-    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
-    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
-    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
-    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
-    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
-    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
-    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
-    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
-]
-
-[[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.30.0"
-source = { editable = "." }
-dependencies = [
-    { name = "cryptography" },
-    { name = "jmespath" },
-    { name = "jsonpath-ng" },
-    { name = "psutil" },
-    { name = "requests" },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "deepdiff" },
-    { name = "pytest" },
-    { name = "pytest-cov" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "cryptography", specifier = ">=46.0.3" },
-    { name = "jmespath", specifier = ">=1.0.1" },
-    { name = "jsonpath-ng", specifier = ">=1.7.0" },
-    { name = "psutil", specifier = ">=7.0.0" },
-    { name = "requests", specifier = ">=2.32.4" },
-]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "deepdiff", specifier = ">=8.6.1" },
-    { name = "pytest", specifier = ">=8.4.1" },
-    { name = "pytest-cov", specifier = ">=6.2.1" },
-]
-
-[[package]]
-name = "coverage"
-version = "7.11.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1c/38/ee22495420457259d2f3390309505ea98f98a5eed40901cf62196abad006/coverage-7.11.0.tar.gz", hash = "sha256:167bd504ac1ca2af7ff3b81d245dfea0292c5032ebef9d66cc08a7d28c1b8050", size = 811905, upload-time = "2025-10-15T15:15:08.542Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/7f/85e4dfe65e400645464b25c036a26ac226cf3a69d4a50c3934c532491cdd/coverage-7.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cc3f49e65ea6e0d5d9bd60368684fe52a704d46f9e7fc413918f18d046ec40e1", size = 216129, upload-time = "2025-10-15T15:13:25.371Z" },
-    { url = "https://files.pythonhosted.org/packages/96/5d/dc5fa98fea3c175caf9d360649cb1aa3715e391ab00dc78c4c66fabd7356/coverage-7.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f39ae2f63f37472c17b4990f794035c9890418b1b8cca75c01193f3c8d3e01be", size = 216380, upload-time = "2025-10-15T15:13:26.976Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/f5/3da9cc9596708273385189289c0e4d8197d37a386bdf17619013554b3447/coverage-7.11.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7db53b5cdd2917b6eaadd0b1251cf4e7d96f4a8d24e174bdbdf2f65b5ea7994d", size = 247375, upload-time = "2025-10-15T15:13:28.923Z" },
-    { url = "https://files.pythonhosted.org/packages/65/6c/f7f59c342359a235559d2bc76b0c73cfc4bac7d61bb0df210965cb1ecffd/coverage-7.11.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10ad04ac3a122048688387828b4537bc9cf60c0bf4869c1e9989c46e45690b82", size = 249978, upload-time = "2025-10-15T15:13:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/8c/042dede2e23525e863bf1ccd2b92689692a148d8b5fd37c37899ba882645/coverage-7.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4036cc9c7983a2b1f2556d574d2eb2154ac6ed55114761685657e38782b23f52", size = 251253, upload-time = "2025-10-15T15:13:32.174Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/a9/3c58df67bfa809a7bddd786356d9c5283e45d693edb5f3f55d0986dd905a/coverage-7.11.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ab934dd13b1c5e94b692b1e01bd87e4488cb746e3a50f798cb9464fd128374b", size = 247591, upload-time = "2025-10-15T15:13:34.147Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5b/c7f32efd862ee0477a18c41e4761305de6ddd2d49cdeda0c1116227570fd/coverage-7.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59a6e5a265f7cfc05f76e3bb53eca2e0dfe90f05e07e849930fecd6abb8f40b4", size = 249411, upload-time = "2025-10-15T15:13:38.425Z" },
-    { url = "https://files.pythonhosted.org/packages/76/b5/78cb4f1e86c1611431c990423ec0768122905b03837e1b4c6a6f388a858b/coverage-7.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:df01d6c4c81e15a7c88337b795bb7595a8596e92310266b5072c7e301168efbd", size = 247303, upload-time = "2025-10-15T15:13:40.464Z" },
-    { url = "https://files.pythonhosted.org/packages/87/c9/23c753a8641a330f45f221286e707c427e46d0ffd1719b080cedc984ec40/coverage-7.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8c934bd088eed6174210942761e38ee81d28c46de0132ebb1801dbe36a390dcc", size = 247157, upload-time = "2025-10-15T15:13:42.087Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/42/6e0cc71dc8a464486e944a4fa0d85bdec031cc2969e98ed41532a98336b9/coverage-7.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a03eaf7ec24078ad64a07f02e30060aaf22b91dedf31a6b24d0d98d2bba7f48", size = 248921, upload-time = "2025-10-15T15:13:43.715Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/1c/743c2ef665e6858cccb0f84377dfe3a4c25add51e8c7ef19249be92465b6/coverage-7.11.0-cp313-cp313-win32.whl", hash = "sha256:695340f698a5f56f795b2836abe6fb576e7c53d48cd155ad2f80fd24bc63a040", size = 218526, upload-time = "2025-10-15T15:13:45.336Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/d5/226daadfd1bf8ddbccefbd3aa3547d7b960fb48e1bdac124e2dd13a2b71a/coverage-7.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:2727d47fce3ee2bac648528e41455d1b0c46395a087a229deac75e9f88ba5a05", size = 219317, upload-time = "2025-10-15T15:13:47.401Z" },
-    { url = "https://files.pythonhosted.org/packages/97/54/47db81dcbe571a48a298f206183ba8a7ba79200a37cd0d9f4788fcd2af4a/coverage-7.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:0efa742f431529699712b92ecdf22de8ff198df41e43aeaaadf69973eb93f17a", size = 217948, upload-time = "2025-10-15T15:13:49.096Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/8b/cb68425420154e7e2a82fd779a8cc01549b6fa83c2ad3679cd6c088ebd07/coverage-7.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:587c38849b853b157706407e9ebdca8fd12f45869edb56defbef2daa5fb0812b", size = 216837, upload-time = "2025-10-15T15:13:51.09Z" },
-    { url = "https://files.pythonhosted.org/packages/33/55/9d61b5765a025685e14659c8d07037247de6383c0385757544ffe4606475/coverage-7.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b971bdefdd75096163dd4261c74be813c4508477e39ff7b92191dea19f24cd37", size = 217061, upload-time = "2025-10-15T15:13:52.747Z" },
-    { url = "https://files.pythonhosted.org/packages/52/85/292459c9186d70dcec6538f06ea251bc968046922497377bf4a1dc9a71de/coverage-7.11.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:269bfe913b7d5be12ab13a95f3a76da23cf147be7fa043933320ba5625f0a8de", size = 258398, upload-time = "2025-10-15T15:13:54.45Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/e2/46edd73fb8bf51446c41148d81944c54ed224854812b6ca549be25113ee0/coverage-7.11.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dadbcce51a10c07b7c72b0ce4a25e4b6dcb0c0372846afb8e5b6307a121eb99f", size = 260574, upload-time = "2025-10-15T15:13:56.145Z" },
-    { url = "https://files.pythonhosted.org/packages/07/5e/1df469a19007ff82e2ca8fe509822820a31e251f80ee7344c34f6cd2ec43/coverage-7.11.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ed43fa22c6436f7957df036331f8fe4efa7af132054e1844918866cd228af6c", size = 262797, upload-time = "2025-10-15T15:13:58.635Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/50/de216b31a1434b94d9b34a964c09943c6be45069ec704bfc379d8d89a649/coverage-7.11.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9516add7256b6713ec08359b7b05aeff8850c98d357784c7205b2e60aa2513fa", size = 257361, upload-time = "2025-10-15T15:14:00.409Z" },
-    { url = "https://files.pythonhosted.org/packages/82/1e/3f9f8344a48111e152e0fd495b6fff13cc743e771a6050abf1627a7ba918/coverage-7.11.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb92e47c92fcbcdc692f428da67db33337fa213756f7adb6a011f7b5a7a20740", size = 260349, upload-time = "2025-10-15T15:14:02.188Z" },
-    { url = "https://files.pythonhosted.org/packages/65/9b/3f52741f9e7d82124272f3070bbe316006a7de1bad1093f88d59bfc6c548/coverage-7.11.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d06f4fc7acf3cabd6d74941d53329e06bab00a8fe10e4df2714f0b134bfc64ef", size = 258114, upload-time = "2025-10-15T15:14:03.907Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/8b/918f0e15f0365d50d3986bbd3338ca01178717ac5678301f3f547b6619e6/coverage-7.11.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:6fbcee1a8f056af07ecd344482f711f563a9eb1c2cad192e87df00338ec3cdb0", size = 256723, upload-time = "2025-10-15T15:14:06.324Z" },
-    { url = "https://files.pythonhosted.org/packages/44/9e/7776829f82d3cf630878a7965a7d70cc6ca94f22c7d20ec4944f7148cb46/coverage-7.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dbbf012be5f32533a490709ad597ad8a8ff80c582a95adc8d62af664e532f9ca", size = 259238, upload-time = "2025-10-15T15:14:08.002Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/b8/49cf253e1e7a3bedb85199b201862dd7ca4859f75b6cf25ffa7298aa0760/coverage-7.11.0-cp313-cp313t-win32.whl", hash = "sha256:cee6291bb4fed184f1c2b663606a115c743df98a537c969c3c64b49989da96c2", size = 219180, upload-time = "2025-10-15T15:14:09.786Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e1/1a541703826be7ae2125a0fb7f821af5729d56bb71e946e7b933cc7a89a4/coverage-7.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a386c1061bf98e7ea4758e4313c0ab5ecf57af341ef0f43a0bf26c2477b5c268", size = 220241, upload-time = "2025-10-15T15:14:11.471Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d1/5ee0e0a08621140fd418ec4020f595b4d52d7eb429ae6a0c6542b4ba6f14/coverage-7.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f9ea02ef40bb83823b2b04964459d281688fe173e20643870bb5d2edf68bc836", size = 218510, upload-time = "2025-10-15T15:14:13.46Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/06/e923830c1985ce808e40a3fa3eb46c13350b3224b7da59757d37b6ce12b8/coverage-7.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c770885b28fb399aaf2a65bbd1c12bf6f307ffd112d6a76c5231a94276f0c497", size = 216110, upload-time = "2025-10-15T15:14:15.157Z" },
-    { url = "https://files.pythonhosted.org/packages/42/82/cdeed03bfead45203fb651ed756dfb5266028f5f939e7f06efac4041dad5/coverage-7.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a3d0e2087dba64c86a6b254f43e12d264b636a39e88c5cc0a01a7c71bcfdab7e", size = 216395, upload-time = "2025-10-15T15:14:16.863Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/ba/e1c80caffc3199aa699813f73ff097bc2df7b31642bdbc7493600a8f1de5/coverage-7.11.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:73feb83bb41c32811973b8565f3705caf01d928d972b72042b44e97c71fd70d1", size = 247433, upload-time = "2025-10-15T15:14:18.589Z" },
-    { url = "https://files.pythonhosted.org/packages/80/c0/5b259b029694ce0a5bbc1548834c7ba3db41d3efd3474489d7efce4ceb18/coverage-7.11.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c6f31f281012235ad08f9a560976cc2fc9c95c17604ff3ab20120fe480169bca", size = 249970, upload-time = "2025-10-15T15:14:20.307Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/86/171b2b5e1aac7e2fd9b43f7158b987dbeb95f06d1fbecad54ad8163ae3e8/coverage-7.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9570ad567f880ef675673992222746a124b9595506826b210fbe0ce3f0499cd", size = 251324, upload-time = "2025-10-15T15:14:22.419Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/7e/7e10414d343385b92024af3932a27a1caf75c6e27ee88ba211221ff1a145/coverage-7.11.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8badf70446042553a773547a61fecaa734b55dc738cacf20c56ab04b77425e43", size = 247445, upload-time = "2025-10-15T15:14:24.205Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/3b/e4f966b21f5be8c4bf86ad75ae94efa0de4c99c7bbb8114476323102e345/coverage-7.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a09c1211959903a479e389685b7feb8a17f59ec5a4ef9afde7650bd5eabc2777", size = 249324, upload-time = "2025-10-15T15:14:26.234Z" },
-    { url = "https://files.pythonhosted.org/packages/00/a2/8479325576dfcd909244d0df215f077f47437ab852ab778cfa2f8bf4d954/coverage-7.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:5ef83b107f50db3f9ae40f69e34b3bd9337456c5a7fe3461c7abf8b75dd666a2", size = 247261, upload-time = "2025-10-15T15:14:28.42Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/d8/3a9e2db19d94d65771d0f2e21a9ea587d11b831332a73622f901157cc24b/coverage-7.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f91f927a3215b8907e214af77200250bb6aae36eca3f760f89780d13e495388d", size = 247092, upload-time = "2025-10-15T15:14:30.784Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/b1/bbca3c472544f9e2ad2d5116b2379732957048be4b93a9c543fcd0207e5f/coverage-7.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cdbcd376716d6b7fbfeedd687a6c4be019c5a5671b35f804ba76a4c0a778cba4", size = 248755, upload-time = "2025-10-15T15:14:32.585Z" },
-    { url = "https://files.pythonhosted.org/packages/89/49/638d5a45a6a0f00af53d6b637c87007eb2297042186334e9923a61aa8854/coverage-7.11.0-cp314-cp314-win32.whl", hash = "sha256:bab7ec4bb501743edc63609320aaec8cd9188b396354f482f4de4d40a9d10721", size = 218793, upload-time = "2025-10-15T15:14:34.972Z" },
-    { url = "https://files.pythonhosted.org/packages/30/cc/b675a51f2d068adb3cdf3799212c662239b0ca27f4691d1fff81b92ea850/coverage-7.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:3d4ba9a449e9364a936a27322b20d32d8b166553bfe63059bd21527e681e2fad", size = 219587, upload-time = "2025-10-15T15:14:37.047Z" },
-    { url = "https://files.pythonhosted.org/packages/93/98/5ac886876026de04f00820e5094fe22166b98dcb8b426bf6827aaf67048c/coverage-7.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:ce37f215223af94ef0f75ac68ea096f9f8e8c8ec7d6e8c346ee45c0d363f0479", size = 218168, upload-time = "2025-10-15T15:14:38.861Z" },
-    { url = "https://files.pythonhosted.org/packages/14/d1/b4145d35b3e3ecf4d917e97fc8895bcf027d854879ba401d9ff0f533f997/coverage-7.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:f413ce6e07e0d0dc9c433228727b619871532674b45165abafe201f200cc215f", size = 216850, upload-time = "2025-10-15T15:14:40.651Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/d1/7f645fc2eccd318369a8a9948acc447bb7c1ade2911e31d3c5620544c22b/coverage-7.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:05791e528a18f7072bf5998ba772fe29db4da1234c45c2087866b5ba4dea710e", size = 217071, upload-time = "2025-10-15T15:14:42.755Z" },
-    { url = "https://files.pythonhosted.org/packages/54/7d/64d124649db2737ceced1dfcbdcb79898d5868d311730f622f8ecae84250/coverage-7.11.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cacb29f420cfeb9283b803263c3b9a068924474ff19ca126ba9103e1278dfa44", size = 258570, upload-time = "2025-10-15T15:14:44.542Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/3f/6f5922f80dc6f2d8b2c6f974835c43f53eb4257a7797727e6ca5b7b2ec1f/coverage-7.11.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:314c24e700d7027ae3ab0d95fbf8d53544fca1f20345fd30cd219b737c6e58d3", size = 260738, upload-time = "2025-10-15T15:14:46.436Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/5f/9e883523c4647c860b3812b417a2017e361eca5b635ee658387dc11b13c1/coverage-7.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:630d0bd7a293ad2fc8b4b94e5758c8b2536fdf36c05f1681270203e463cbfa9b", size = 262994, upload-time = "2025-10-15T15:14:48.3Z" },
-    { url = "https://files.pythonhosted.org/packages/07/bb/43b5a8e94c09c8bf51743ffc65c4c841a4ca5d3ed191d0a6919c379a1b83/coverage-7.11.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e89641f5175d65e2dbb44db15fe4ea48fade5d5bbb9868fdc2b4fce22f4a469d", size = 257282, upload-time = "2025-10-15T15:14:50.236Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/e5/0ead8af411411330b928733e1d201384b39251a5f043c1612970310e8283/coverage-7.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c9f08ea03114a637dab06cedb2e914da9dc67fa52c6015c018ff43fdde25b9c2", size = 260430, upload-time = "2025-10-15T15:14:52.413Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/66/03dd8bb0ba5b971620dcaac145461950f6d8204953e535d2b20c6b65d729/coverage-7.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce9f3bde4e9b031eaf1eb61df95c1401427029ea1bfddb8621c1161dcb0fa02e", size = 258190, upload-time = "2025-10-15T15:14:54.268Z" },
-    { url = "https://files.pythonhosted.org/packages/45/ae/28a9cce40bf3174426cb2f7e71ee172d98e7f6446dff936a7ccecee34b14/coverage-7.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:e4dc07e95495923d6fd4d6c27bf70769425b71c89053083843fd78f378558996", size = 256658, upload-time = "2025-10-15T15:14:56.436Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/7c/3a44234a8599513684bfc8684878fd7b126c2760f79712bb78c56f19efc4/coverage-7.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:424538266794db2861db4922b05d729ade0940ee69dcf0591ce8f69784db0e11", size = 259342, upload-time = "2025-10-15T15:14:58.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/e6/0108519cba871af0351725ebdb8660fd7a0fe2ba3850d56d32490c7d9b4b/coverage-7.11.0-cp314-cp314t-win32.whl", hash = "sha256:4c1eeb3fb8eb9e0190bebafd0462936f75717687117339f708f395fe455acc73", size = 219568, upload-time = "2025-10-15T15:15:00.382Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/76/44ba876e0942b4e62fdde23ccb029ddb16d19ba1bef081edd00857ba0b16/coverage-7.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b56efee146c98dbf2cf5cffc61b9829d1e94442df4d7398b26892a53992d3547", size = 220687, upload-time = "2025-10-15T15:15:02.322Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/0c/0df55ecb20d0d0ed5c322e10a441775e1a3a5d78c60f0c4e1abfe6fcf949/coverage-7.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b5c2705afa83f49bd91962a4094b6b082f94aef7626365ab3f8f4bd159c5acf3", size = 218711, upload-time = "2025-10-15T15:15:04.575Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/04/642c1d8a448ae5ea1369eac8495740a79eb4e581a9fb0cbdce56bbf56da1/coverage-7.11.0-py3-none-any.whl", hash = "sha256:4b7589765348d78fb4e5fb6ea35d07564e387da2fc5efff62e0222971f155f68", size = 207761, upload-time = "2025-10-15T15:15:06.439Z" },
-]
-
-[[package]]
-name = "cryptography"
-version = "46.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
-    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
-    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
-    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
-]
-
-[[package]]
-name = "deepdiff"
-version = "8.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "orderly-set" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/19/76/36c9aab3d5c19a94091f7c6c6e784efca50d87b124bf026c36e94719f33c/deepdiff-8.6.1.tar.gz", hash = "sha256:ec56d7a769ca80891b5200ec7bd41eec300ced91ebcc7797b41eb2b3f3ff643a", size = 634054, upload-time = "2025-09-03T19:40:41.461Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/e6/efe534ef0952b531b630780e19cabd416e2032697019d5295defc6ef9bd9/deepdiff-8.6.1-py3-none-any.whl", hash = "sha256:ee8708a7f7d37fb273a541fa24ad010ed484192cd0c4ffc0fa0ed5e2d4b9e78b", size = 91378, upload-time = "2025-09-03T19:40:39.679Z" },
-]
-
-[[package]]
-name = "idna"
-version = "3.11"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
-]
-
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
-]
-
-[[package]]
-name = "jmespath"
-version = "1.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" }
-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 = "jsonpath-ng"
-version = "1.7.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "ply" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/86/08646239a313f895186ff0a4573452038eed8c86f54380b3ebac34d32fb2/jsonpath-ng-1.7.0.tar.gz", hash = "sha256:f6f5f7fd4e5ff79c785f1573b394043b39849fb2bb47bcead935d12b00beab3c", size = 37838, upload-time = "2024-10-11T15:41:42.404Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/5a/73ecb3d82f8615f32ccdadeb9356726d6cae3a4bbc840b437ceb95708063/jsonpath_ng-1.7.0-py3-none-any.whl", hash = "sha256:f3d7f9e848cba1b6da28c55b1c26ff915dc9e0b1ba7e752a53d6da8d5cbd00b6", size = 30105, upload-time = "2024-11-20T17:58:30.418Z" },
-]
-
-[[package]]
-name = "orderly-set"
-version = "5.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4a/88/39c83c35d5e97cc203e9e77a4f93bf87ec89cf6a22ac4818fdcc65d66584/orderly_set-5.5.0.tar.gz", hash = "sha256:e87185c8e4d8afa64e7f8160ee2c542a475b738bc891dc3f58102e654125e6ce", size = 27414, upload-time = "2025-07-10T20:10:55.885Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/27/fb8d7338b4d551900fa3e580acbe7a0cf655d940e164cb5c00ec31961094/orderly_set-5.5.0-py3-none-any.whl", hash = "sha256:46f0b801948e98f427b412fcabb831677194c05c3b699b80de260374baa0b1e7", size = 13068, upload-time = "2025-07-10T20:10:54.377Z" },
-]
-
-[[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 = "ply"
-version = "3.11"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130, upload-time = "2018-02-15T19:01:31.097Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" },
-]
-
-[[package]]
-name = "psutil"
-version = "7.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/89/fc/889242351a932d6183eec5df1fc6539b6f36b6a88444f1e63f18668253aa/psutil-7.1.1.tar.gz", hash = "sha256:092b6350145007389c1cfe5716050f02030a05219d90057ea867d18fe8d372fc", size = 487067, upload-time = "2025-10-19T15:43:59.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/30/f97f8fb1f9ecfbeae4b5ca738dcae66ab28323b5cfbc96cb5565f3754056/psutil-7.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:8fa59d7b1f01f0337f12cd10dbd76e4312a4d3c730a4fedcbdd4e5447a8b8460", size = 244221, upload-time = "2025-10-19T15:44:03.145Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/98/b8d1f61ebf35f4dbdbaabadf9208282d8adc820562f0257e5e6e79e67bf2/psutil-7.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:2a95104eae85d088891716db676f780c1404fc15d47fde48a46a5d61e8f5ad2c", size = 245660, upload-time = "2025-10-19T15:44:05.657Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/4a/b8015d7357fefdfe34bc4a3db48a107bae4bad0b94fb6eb0613f09a08ada/psutil-7.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:98629cd8567acefcc45afe2f4ba1e9290f579eacf490a917967decce4b74ee9b", size = 286963, upload-time = "2025-10-19T15:44:08.877Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/3c/b56076bb35303d0733fc47b110a1c9cce081a05ae2e886575a3587c1ee76/psutil-7.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92ebc58030fb054fa0f26c3206ef01c31c29d67aee1367e3483c16665c25c8d2", size = 290118, upload-time = "2025-10-19T15:44:11.897Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/af/c13d360c0adc6f6218bf9e2873480393d0f729c8dd0507d171f53061c0d3/psutil-7.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:146a704f224fb2ded2be3da5ac67fc32b9ea90c45b51676f9114a6ac45616967", size = 292587, upload-time = "2025-10-19T15:44:14.67Z" },
-    { url = "https://files.pythonhosted.org/packages/90/2d/c933e7071ba60c7862813f2c7108ec4cf8304f1c79660efeefd0de982258/psutil-7.1.1-cp37-abi3-win32.whl", hash = "sha256:295c4025b5cd880f7445e4379e6826f7307e3d488947bf9834e865e7847dc5f7", size = 243772, upload-time = "2025-10-19T15:44:16.938Z" },
-    { url = "https://files.pythonhosted.org/packages/be/f3/11fd213fff15427bc2853552138760c720fd65032d99edfb161910d04127/psutil-7.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:9b4f17c5f65e44f69bd3a3406071a47b79df45cf2236d1f717970afcb526bcd3", size = 246936, upload-time = "2025-10-19T15:44:18.663Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/8d/8a9a45c8b655851f216c1d44f68e3533dc8d2c752ccd0f61f1aa73be4893/psutil-7.1.1-cp37-abi3-win_arm64.whl", hash = "sha256:5457cf741ca13da54624126cd5d333871b454ab133999a9a103fb097a7d7d21a", size = 243944, upload-time = "2025-10-19T15:44:20.666Z" },
-]
-
-[[package]]
-name = "pycparser"
-version = "2.23"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
-]
-
-[[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.2"
-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/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
-]
-
-[[package]]
-name = "pytest-cov"
-version = "7.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "coverage" },
-    { name = "pluggy" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
-]
-
-[[package]]
-name = "requests"
-version = "2.32.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "charset-normalizer" },
-    { name = "idna" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
-]
-
-[[package]]
-name = "urllib3"
-version = "2.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
-]