v0.35.2: Sync miss for Log file format change

The previous filename:pid has been removed, the filename is part of the pathname.
No need for double filename info and wasting space in the log line.

README.md

@@ -10,6 +10,7 @@ This is a pip package that can be installed into any project and covers the foll
 - 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
@@ -26,6 +27,7 @@ This is a pip package that can be installed into any project and covers the foll
 - 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)
@@ -50,7 +52,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
@@ -58,15 +60,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
@@ -99,7 +101,7 @@ uv run test-run/<script>
 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,7 +1,7 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.31.0"
+version = "0.35.2"
 description = "Collection of utils for Python scripts"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,10 +17,9 @@ dependencies = [
 
 # MARK: build target
 [[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
 
 # MARK: build system
 [build-system]
@@ -63,12 +62,13 @@ 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/*",

src/corelibs/datetime_handling/datetime_helpers.py

@@ -159,10 +159,14 @@ def parse_flexible_date(
 
     # Try different parsing methods
     parsers: list[Callable[[str], datetime]] = [
-        # ISO 8601 format
+        # ISO 8601 format, also with missing "T"
         lambda x: datetime.fromisoformat(x),  # pylint: disable=W0108
+        lambda x: datetime.fromisoformat(x.replace(' ', 'T')),  # pylint: disable=W0108
         # Simple date format
         lambda x: datetime.strptime(x, "%Y-%m-%d"),
+        # datetime without T
+        lambda x: datetime.strptime(x, "%Y-%m-%d %H:%M:%S"),
+        lambda x: datetime.strptime(x, "%Y-%m-%d %H:%M:%S.%f"),
         # 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"),

src/corelibs/email_handling/send_email.py

@@ -0,0 +1,199 @@
+"""
+Send email wrapper
+"""
+
+import smtplib
+from email.message import EmailMessage
+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():
+                _subject = _subject.replace(f"{{{{{key}}}}}", value)
+                _body = _body.replace(f"{{{{{key}}}}}", value)
+            # 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
+            # push to array for sening
+            msg.append(msg_email)
+        return msg
+
+    def send_email_list(
+        self,
+        email: 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)
+        # loop over messages and then over recievers
+        for msg in email:
+            if combined_send is True:
+                msg["To"] = ", ".join(receivers)
+                if not self.settings.get('test'):
+                    if smtp is not None:
+                        smtp.send_message(msg, msg["From"], receivers)
+                else:
+                    self.log.info(f"[EMAIL] Test, not sending email\n{msg}")
+            else:
+                for receiver in receivers:
+                    # send to
+                    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/file_handling/file_bom_encoding.py

@@ -0,0 +1,75 @@
+"""
+File check if BOM encoded, needed for CSV load
+"""
+
+from pathlib import Path
+from typing import TypedDict
+
+
+class BomEncodingInfo(TypedDict):
+    """BOM encoding info"""
+    has_bom: bool
+    bom_type: str | None
+    encoding: str | None
+    bom_length: int
+    bom_pattern: bytes | None
+
+
+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_encoded_info(file_path)['has_bom']
+
+
+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
+    """
+    try:
+        # Read first 1024 bytes for analysis
+        with open(file_path, 'rb') as f:
+            header = f.read(4)
+
+        bom_patterns = {
+            b'\xef\xbb\xbf': ('UTF-8', 'utf-8', 3),
+            b'\xff\xfe\x00\x00': ('UTF-32 LE', 'utf-32-le', 4),
+            b'\x00\x00\xfe\xff': ('UTF-32 BE', 'utf-32-be', 4),
+            b'\xff\xfe': ('UTF-16 LE', 'utf-16-le', 2),
+            b'\xfe\xff': ('UTF-16 BE', 'utf-16-be', 2),
+        }
+
+        for bom_pattern, (encoding_name, encoding, length) in bom_patterns.items():
+            if header.startswith(bom_pattern):
+                return {
+                    'has_bom': True,
+                    'bom_type': encoding_name,
+                    'encoding': encoding,
+                    'bom_length': length,
+                    'bom_pattern': bom_pattern
+                }
+
+        return {
+            'has_bom': False,
+            'bom_type': None,
+            'encoding': None,
+            'bom_length': 0,
+            'bom_pattern': None
+        }
+    except Exception as e:
+        raise ValueError(f"Error checking BOM encoding: {e}") from e
+
+
+# __END__

src/corelibs/logging_handling/log.py

@@ -28,6 +28,8 @@ class LogSettings(TypedDict):
     per_run_log: bool
     console_enabled: bool
     console_color_output_enabled: bool
+    console_format_type: str
+    console_iso_precision: str
     add_start_info: bool
     add_end_info: bool
     log_queue: 'Queue[str] | None'
@@ -39,6 +41,18 @@ class LoggerInit(TypedDict):
     log_queue: 'Queue[str] | None'
 
 
+# show log title, file, function and line number types
+CONSOLE_FORMAT_TYPE_NORMAL = 'normal'
+# show file and line number only
+CONSOLE_FORMAT_TYPE_CONDENSED = 'condensed'
+# only show timestamp, log level and message
+CONSOLE_FORMAT_TYPE_MINIMAL = 'minimal'
+# for console ISO time format
+CONSOLE_ISO_TIME_SECONDS = 'seconds'
+CONSOLE_ISO_TIME_MILLISECONDS = 'milliseconds'
+CONSOLE_ISO_TIME_MICROSECONDS = 'microseconds'
+
+
 # MARK: Custom color filter
 class CustomConsoleFormatter(logging.Formatter):
     """
@@ -56,6 +70,21 @@ class CustomConsoleFormatter(logging.Formatter):
         LoggingLevel.EXCEPTION.name: Colors.magenta_bright,  # will never be written to console
     }
 
+    # def formatTime(self, record: logging.LogRecord, datefmt: str | None = None):
+    #     """
+    #     Set timestamp in ISO8601 format
+
+    #     Arguments:
+    #         record {logging.LogRecord} -- _description_
+
+    #     Keyword Arguments:
+    #         datefmt {str | None} -- _description_ (default: {None})
+
+    #     Returns:
+    #         _type_ -- _description_
+    #     """
+    #     return datetime.fromtimestamp(record.created).astimezone().isoformat(sep=' ', timespec='milliseconds')
+
     def format(self, record: logging.LogRecord) -> str:
         """
         set the color highlight
@@ -409,6 +438,9 @@ 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": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": True,
         "add_end_info": False,
         "log_queue": None,
@@ -461,8 +493,11 @@ class Log(LogParent):
         if self.log_settings['console_enabled']:
             # console
             self.add_handler('stream_handler', self.__create_console_handler(
-                'stream_handler', self.log_settings['log_level_console'])
-            )
+                'stream_handler',
+                self.log_settings['log_level_console'],
+                console_format_type=self.log_settings['console_format_type'],
+                console_iso_precision=self.log_settings['console_iso_precision']
+            ))
         # add other handlers,
         if other_handlers is not None:
             for handler_key, handler in other_handlers.items():
@@ -518,6 +553,27 @@ 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
+        default_log_settings['console_format_type'] = cast('str', log_settings.get(
+            'console_format_type', self.DEFAULT_LOG_SETTINGS['console_format_type']
+        ))
+        # if not valid
+        if default_log_settings['console_format_type'] not in [
+            CONSOLE_FORMAT_TYPE_NORMAL,
+            CONSOLE_FORMAT_TYPE_CONDENSED,
+            CONSOLE_FORMAT_TYPE_MINIMAL,
+        ]:
+            default_log_settings['console_format_type'] = self.DEFAULT_LOG_SETTINGS['console_format_type']
+        # check console iso time precision
+        default_log_settings['console_iso_precision'] = cast('str', log_settings.get(
+            'console_iso_precision', self.DEFAULT_LOG_SETTINGS['console_iso_precision']
+        ))
+        if default_log_settings['console_iso_precision'] not in [
+            CONSOLE_ISO_TIME_SECONDS,
+            CONSOLE_ISO_TIME_MILLISECONDS,
+            CONSOLE_ISO_TIME_MICROSECONDS,
+        ]:
+            default_log_settings['console_iso_precision'] = self.DEFAULT_LOG_SETTINGS['console_iso_precision']
         # check log queue
         __setting = log_settings.get('log_queue', self.DEFAULT_LOG_SETTINGS['log_queue'])
         if __setting is not None:
@@ -554,7 +610,10 @@ class Log(LogParent):
     # 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: str = CONSOLE_FORMAT_TYPE_NORMAL,
+        console_iso_precision: str = CONSOLE_ISO_TIME_MILLISECONDS
     ) -> logging.StreamHandler[TextIO]:
         # console logger
         if not self.validate_log_level(log_level_console):
@@ -562,18 +621,42 @@ class Log(LogParent):
         console_handler = logging.StreamHandler()
         # format layouts
         format_string = (
-            '[%(asctime)s.%(msecs)03d] '
+            # '[%(asctime)s.%(msecs)03d] '
+            '[%(asctime)s] '
             '[%(name)s] '
             '[%(filename)s:%(funcName)s:%(lineno)d] '
             '<%(levelname)s> '
             '%(message)s'
         )
+        if console_format_type == CONSOLE_FORMAT_TYPE_CONDENSED:
+            format_string = (
+                '[%(asctime)s] '
+                '[%(filename)s:%(lineno)d] '
+                '<%(levelname)s> '
+                '%(message)s'
+            )
+        elif console_format_type == CONSOLE_FORMAT_TYPE_MINIMAL:
+            format_string = (
+                '[%(asctime)s] '
+                '<%(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"PREC: {console_iso_precision}")
+        # this one needs lambda self, ...
+        # logging.Formatter.formatTime = (
+        formatter_console.formatTime = (
+            lambda record, datefmt=None:
+                datetime
+                .fromtimestamp(record.created)
+                .astimezone()
+                .isoformat(sep="T", timespec=console_iso_precision)
+        )
         console_handler.set_name(handler_name)
         console_handler.setLevel(log_level_console.name)
         # do not show exceptions logs on console
@@ -614,13 +697,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 +712,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)

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.file_handling.file_bom_encoding import is_bom_encoded, is_bom_encoded_info
+from corelibs.debug_handling.dump_data import dump_data
+
+
+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/dict_helpers.py

@@ -5,7 +5,7 @@ Iterator helper testing
 from typing import Any
 from corelibs.debug_handling.dump_data import dump_data
 from corelibs.iterator_handling.dict_mask import mask
-from corelibs.iterator_handling.dict_helper import set_entry
+from corelibs.iterator_handling.dict_helpers import set_entry
 
 
 def __mask():

test-run/logging_handling/log.py

@@ -6,7 +6,7 @@ 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.logging_handling.log import Log, Logger, CONSOLE_FORMAT_TYPE_MINIMAL, CONSOLE_ISO_TIME_MICROSECONDS
 from corelibs.debug_handling.debug_helpers import exception_stack, call_stack
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -24,7 +24,10 @@ def main():
             # "log_level_console": None,
             "log_level_file": 'DEBUG',
             # "console_color_output_enabled": False,
-            "per_run_log": True
+            "per_run_log": True,
+            # Set console log type
+            "console_format_type": CONSOLE_FORMAT_TYPE_MINIMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MICROSECONDS,
         }
     )
     logn = Logger(log.get_logger_settings())

tests/unit/datetime_handling/test_datetime_helpers.py

@@ -275,6 +275,53 @@ class TestParseFlexibleDate:
         assert isinstance(result, datetime)
         assert result.tzinfo is not None
 
+    def test_parse_flexible_date_missing_t_with_timezone_shift(self):
+        """Test parse_flexible_date with timezone shift"""
+        result = parse_flexible_date('2023-12-25 15: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_space_separated_datetime(self):
+        """Test parse_flexible_date with space-separated datetime format"""
+        result = parse_flexible_date('2023-12-25 15: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_space_separated_with_microseconds(self):
+        """Test parse_flexible_date with space-separated datetime and microseconds"""
+        result = parse_flexible_date('2023-12-25 15:30:45.123456')
+        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
+        assert result.microsecond == 123456
+
+    def test_parse_flexible_date_t_separated_datetime(self):
+        """Test parse_flexible_date with T-separated datetime (alternative ISO 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_t_separated_with_microseconds(self):
+        """Test parse_flexible_date with T-separated datetime and microseconds"""
+        result = parse_flexible_date('2023-12-25T15:30:45.123456')
+        assert isinstance(result, datetime)
+        assert result.year == 2023
+        assert result.microsecond == 123456
+
     def test_parse_flexible_date_invalid_format(self):
         """Test parse_flexible_date with invalid format returns None"""
         result = parse_flexible_date('invalid-date')

tests/unit/file_handling/test_file_bom_encoding.py

@@ -0,0 +1,538 @@
+"""
+PyTest: file_handling/file_bom_encoding
+"""
+
+from pathlib import Path
+import pytest
+
+from corelibs.file_handling.file_bom_encoding import (
+    is_bom_encoded,
+    is_bom_encoded_info,
+    BomEncodingInfo,
+)
+
+
+class TestIsBomEncoded:
+    """Test suite for is_bom_encoded function"""
+
+    def test_utf8_bom_file(self, tmp_path: Path):
+        """Test detection of UTF-8 BOM encoded file"""
+        test_file = tmp_path / "utf8_bom.txt"
+        # UTF-8 BOM: EF BB BF
+        content = b'\xef\xbb\xbfHello, World!'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+        assert isinstance(result, bool)
+
+    def test_utf16_le_bom_file(self, tmp_path: Path):
+        """Test detection of UTF-16 LE BOM encoded file"""
+        test_file = tmp_path / "utf16_le_bom.txt"
+        # UTF-16 LE BOM: FF FE
+        content = b'\xff\xfeH\x00e\x00l\x00l\x00o\x00'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+    def test_utf16_be_bom_file(self, tmp_path: Path):
+        """Test detection of UTF-16 BE BOM encoded file"""
+        test_file = tmp_path / "utf16_be_bom.txt"
+        # UTF-16 BE BOM: FE FF
+        content = b'\xfe\xff\x00H\x00e\x00l\x00l\x00o'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+    def test_utf32_le_bom_file(self, tmp_path: Path):
+        """Test detection of UTF-32 LE BOM encoded file"""
+        test_file = tmp_path / "utf32_le_bom.txt"
+        # UTF-32 LE BOM: FF FE 00 00
+        content = b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+    def test_utf32_be_bom_file(self, tmp_path: Path):
+        """Test detection of UTF-32 BE BOM encoded file"""
+        test_file = tmp_path / "utf32_be_bom.txt"
+        # UTF-32 BE BOM: 00 00 FE FF
+        content = b'\x00\x00\xfe\xff\x00\x00\x00H\x00\x00\x00e'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+    def test_no_bom_ascii_file(self, tmp_path: Path):
+        """Test detection of ASCII file without BOM"""
+        test_file = tmp_path / "ascii.txt"
+        content = b'Hello, World!'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_no_bom_utf8_file(self, tmp_path: Path):
+        """Test detection of UTF-8 file without BOM"""
+        test_file = tmp_path / "utf8_no_bom.txt"
+        content = 'Hello, 世界!'.encode('utf-8')
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_empty_file(self, tmp_path: Path):
+        """Test detection on empty file"""
+        test_file = tmp_path / "empty.txt"
+        test_file.write_bytes(b'')
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_binary_file_no_bom(self, tmp_path: Path):
+        """Test detection on binary file without BOM"""
+        test_file = tmp_path / "binary.bin"
+        content = bytes(range(256))
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_partial_bom_pattern(self, tmp_path: Path):
+        """Test file with partial BOM pattern that shouldn't match"""
+        test_file = tmp_path / "partial_bom.txt"
+        # Only first two bytes of UTF-8 BOM
+        content = b'\xef\xbbHello'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_false_positive_bom_pattern(self, tmp_path: Path):
+        """Test file that contains BOM-like bytes but not at the start"""
+        test_file = tmp_path / "false_positive.txt"
+        content = b'Hello\xef\xbb\xbfWorld'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_nonexistent_file(self, tmp_path: Path):
+        """Test that function raises error for non-existent file"""
+        test_file = tmp_path / "nonexistent.txt"
+
+        with pytest.raises(ValueError, match="Error checking BOM encoding"):
+            is_bom_encoded(test_file)
+
+    def test_very_small_file(self, tmp_path: Path):
+        """Test file smaller than largest BOM pattern (4 bytes)"""
+        test_file = tmp_path / "small.txt"
+        content = b'Hi'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is False
+
+    def test_exactly_bom_size_utf8(self, tmp_path: Path):
+        """Test file that is exactly the size of UTF-8 BOM"""
+        test_file = tmp_path / "exact_bom.txt"
+        content = b'\xef\xbb\xbf'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+    def test_exactly_bom_size_utf32(self, tmp_path: Path):
+        """Test file that is exactly the size of UTF-32 BOM"""
+        test_file = tmp_path / "exact_bom_utf32.txt"
+        content = b'\xff\xfe\x00\x00'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded(test_file)
+        assert result is True
+
+
+class TestIsBomEncodedInfo:
+    """Test suite for is_bom_encoded_info function"""
+
+    def test_utf8_bom_info(self, tmp_path: Path):
+        """Test detailed info for UTF-8 BOM encoded file"""
+        test_file = tmp_path / "utf8_bom.txt"
+        content = b'\xef\xbb\xbfHello, UTF-8!'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert isinstance(result, dict)
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-8'
+        assert result['encoding'] == 'utf-8'
+        assert result['bom_length'] == 3
+        assert result['bom_pattern'] == b'\xef\xbb\xbf'
+
+    def test_utf16_le_bom_info(self, tmp_path: Path):
+        """Test detailed info for UTF-16 LE BOM encoded file"""
+        test_file = tmp_path / "utf16_le_bom.txt"
+        content = b'\xff\xfeH\x00e\x00l\x00l\x00o\x00'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-16 LE'
+        assert result['encoding'] == 'utf-16-le'
+        assert result['bom_length'] == 2
+        assert result['bom_pattern'] == b'\xff\xfe'
+
+    def test_utf16_be_bom_info(self, tmp_path: Path):
+        """Test detailed info for UTF-16 BE BOM encoded file"""
+        test_file = tmp_path / "utf16_be_bom.txt"
+        content = b'\xfe\xff\x00H\x00e\x00l\x00l\x00o'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-16 BE'
+        assert result['encoding'] == 'utf-16-be'
+        assert result['bom_length'] == 2
+        assert result['bom_pattern'] == b'\xfe\xff'
+
+    def test_utf32_le_bom_info(self, tmp_path: Path):
+        """Test detailed info for UTF-32 LE BOM encoded file"""
+        test_file = tmp_path / "utf32_le_bom.txt"
+        content = b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-32 LE'
+        assert result['encoding'] == 'utf-32-le'
+        assert result['bom_length'] == 4
+        assert result['bom_pattern'] == b'\xff\xfe\x00\x00'
+
+    def test_utf32_be_bom_info(self, tmp_path: Path):
+        """Test detailed info for UTF-32 BE BOM encoded file"""
+        test_file = tmp_path / "utf32_be_bom.txt"
+        content = b'\x00\x00\xfe\xff\x00\x00\x00H\x00\x00\x00e'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-32 BE'
+        assert result['encoding'] == 'utf-32-be'
+        assert result['bom_length'] == 4
+        assert result['bom_pattern'] == b'\x00\x00\xfe\xff'
+
+    def test_no_bom_info(self, tmp_path: Path):
+        """Test detailed info for file without BOM"""
+        test_file = tmp_path / "no_bom.txt"
+        content = b'Hello, World!'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is False
+        assert result['bom_type'] is None
+        assert result['encoding'] is None
+        assert result['bom_length'] == 0
+        assert result['bom_pattern'] is None
+
+    def test_empty_file_info(self, tmp_path: Path):
+        """Test detailed info for empty file"""
+        test_file = tmp_path / "empty.txt"
+        test_file.write_bytes(b'')
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is False
+        assert result['bom_type'] is None
+        assert result['encoding'] is None
+        assert result['bom_length'] == 0
+        assert result['bom_pattern'] is None
+
+    def test_bom_precedence_utf32_vs_utf16(self, tmp_path: Path):
+        """Test that UTF-32 LE BOM takes precedence over UTF-16 LE when both match"""
+        test_file = tmp_path / "precedence.txt"
+        # UTF-32 LE BOM starts with UTF-16 LE BOM pattern
+        content = b'\xff\xfe\x00\x00Additional content'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        # Should detect UTF-32 LE, not UTF-16 LE
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-32 LE'
+        assert result['encoding'] == 'utf-32-le'
+        assert result['bom_length'] == 4
+        assert result['bom_pattern'] == b'\xff\xfe\x00\x00'
+
+    def test_return_type_validation(self, tmp_path: Path):
+        """Test that return type matches BomEncodingInfo TypedDict"""
+        test_file = tmp_path / "test.txt"
+        test_file.write_bytes(b'Test content')
+
+        result = is_bom_encoded_info(test_file)
+
+        # Check all required keys are present
+        required_keys = {'has_bom', 'bom_type', 'encoding', 'bom_length', 'bom_pattern'}
+        assert set(result.keys()) == required_keys
+
+        # Check types
+        assert isinstance(result['has_bom'], bool)
+        assert result['bom_type'] is None or isinstance(result['bom_type'], str)
+        assert result['encoding'] is None or isinstance(result['encoding'], str)
+        assert isinstance(result['bom_length'], int)
+        assert result['bom_pattern'] is None or isinstance(result['bom_pattern'], bytes)
+
+    def test_nonexistent_file_error(self, tmp_path: Path):
+        """Test that function raises ValueError for non-existent file"""
+        test_file = tmp_path / "nonexistent.txt"
+
+        with pytest.raises(ValueError) as exc_info:
+            is_bom_encoded_info(test_file)
+
+        assert "Error checking BOM encoding" in str(exc_info.value)
+
+    def test_directory_instead_of_file(self, tmp_path: Path):
+        """Test that function raises error when given a directory"""
+        test_dir = tmp_path / "test_dir"
+        test_dir.mkdir()
+
+        with pytest.raises(ValueError, match="Error checking BOM encoding"):
+            is_bom_encoded_info(test_dir)
+
+    def test_large_file_with_bom(self, tmp_path: Path):
+        """Test BOM detection on large file (only first 4 bytes matter)"""
+        test_file = tmp_path / "large_bom.txt"
+        # UTF-8 BOM followed by large content
+        content = b'\xef\xbb\xbf' + b'A' * 100000
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-8'
+        assert result['encoding'] == 'utf-8'
+
+    def test_bom_detection_priority_order(self, tmp_path: Path):
+        """Test that BOM patterns are checked in the correct priority order"""
+        # The function should check longer patterns first to avoid false matches
+        test_cases = [
+            (b'\xff\xfe\x00\x00', 'UTF-32 LE'),  # 4 bytes
+            (b'\x00\x00\xfe\xff', 'UTF-32 BE'),  # 4 bytes
+            (b'\xff\xfe', 'UTF-16 LE'),           # 2 bytes
+            (b'\xfe\xff', 'UTF-16 BE'),           # 2 bytes
+            (b'\xef\xbb\xbf', 'UTF-8'),           # 3 bytes
+        ]
+
+        for i, (bom_bytes, expected_type) in enumerate(test_cases):
+            test_file = tmp_path / f"priority_test_{i}.txt"
+            content = bom_bytes + b'Content'
+            test_file.write_bytes(content)
+
+            result = is_bom_encoded_info(test_file)
+            assert result['bom_type'] == expected_type
+            assert result['bom_pattern'] == bom_bytes
+
+    def test_csv_file_with_utf8_bom(self, tmp_path: Path):
+        """Test CSV file with UTF-8 BOM (common use case mentioned in docstring)"""
+        test_file = tmp_path / "data.csv"
+        content = b'\xef\xbb\xbf"Name","Age","City"\n"John",30,"New York"\n"Jane",25,"Tokyo"'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is True
+        assert result['bom_type'] == 'UTF-8'
+        assert result['encoding'] == 'utf-8'
+        assert result['bom_length'] == 3
+
+    def test_csv_file_without_bom(self, tmp_path: Path):
+        """Test CSV file without BOM"""
+        test_file = tmp_path / "data_no_bom.csv"
+        content = b'"Name","Age","City"\n"John",30,"New York"\n"Jane",25,"Tokyo"'
+        test_file.write_bytes(content)
+
+        result = is_bom_encoded_info(test_file)
+
+        assert result['has_bom'] is False
+        assert result['bom_type'] is None
+        assert result['encoding'] is None
+        assert result['bom_length'] == 0
+
+
+class TestBomEncodingInfo:
+    """Test suite for BomEncodingInfo TypedDict"""
+
+    def test_typed_dict_structure(self):
+        """Test that BomEncodingInfo has correct structure"""
+        # This is a type check - in actual usage, mypy would validate this
+        sample_info: BomEncodingInfo = {
+            'has_bom': True,
+            'bom_type': 'UTF-8',
+            'encoding': 'utf-8',
+            'bom_length': 3,
+            'bom_pattern': b'\xef\xbb\xbf'
+        }
+
+        assert sample_info['has_bom'] is True
+        assert sample_info['bom_type'] == 'UTF-8'
+        assert sample_info['encoding'] == 'utf-8'
+        assert sample_info['bom_length'] == 3
+        assert sample_info['bom_pattern'] == b'\xef\xbb\xbf'
+
+    def test_typed_dict_none_values(self):
+        """Test TypedDict with None values"""
+        sample_info: BomEncodingInfo = {
+            'has_bom': False,
+            'bom_type': None,
+            'encoding': None,
+            'bom_length': 0,
+            'bom_pattern': None
+        }
+
+        assert sample_info['has_bom'] is False
+        assert sample_info['bom_type'] is None
+        assert sample_info['encoding'] is None
+        assert sample_info['bom_length'] == 0
+        assert sample_info['bom_pattern'] is None
+
+
+class TestIntegration:
+    """Integration tests for BOM encoding detection"""
+
+    def test_is_bom_encoded_uses_info_function(self, tmp_path: Path):
+        """Test that is_bom_encoded uses is_bom_encoded_info internally"""
+        test_file = tmp_path / "integration.txt"
+        content = b'\xef\xbb\xbfIntegration test'
+        test_file.write_bytes(content)
+
+        # Both functions should return consistent results
+        simple_result = is_bom_encoded(test_file)
+        detailed_result = is_bom_encoded_info(test_file)
+
+        assert simple_result == detailed_result['has_bom']
+        assert simple_result is True
+
+    def test_multiple_file_bom_detection_workflow(self, tmp_path: Path):
+        """Test a workflow of detecting BOM across multiple files"""
+        files = {
+            'utf8_bom.csv': b'\xef\xbb\xbf"data","value"\n"test",123',
+            'utf16_le.txt': b'\xff\xfeH\x00e\x00l\x00l\x00o\x00',
+            'no_bom.txt': b'Plain ASCII text',
+            'empty.txt': b'',
+        }
+
+        results = {}
+        detailed_results = {}
+
+        for filename, content in files.items():
+            file_path = tmp_path / filename
+            file_path.write_bytes(content)
+
+            results[filename] = is_bom_encoded(file_path)
+            detailed_results[filename] = is_bom_encoded_info(file_path)
+
+        # Verify results
+        assert results['utf8_bom.csv'] is True
+        assert results['utf16_le.txt'] is True
+        assert results['no_bom.txt'] is False
+        assert results['empty.txt'] is False
+
+        # Verify detailed results match simple results
+        for filename in files:
+            assert results[filename] == detailed_results[filename]['has_bom']
+
+        # Verify specific encoding details
+        assert detailed_results['utf8_bom.csv']['encoding'] == 'utf-8'
+        assert detailed_results['utf16_le.txt']['encoding'] == 'utf-16-le'
+        assert detailed_results['no_bom.txt']['encoding'] is None
+
+    def test_csv_loading_workflow(self, tmp_path: Path):
+        """Test BOM detection workflow for CSV loading (main use case)"""
+        # Create CSV files with and without BOM
+        csv_with_bom = tmp_path / "data_with_bom.csv"
+        csv_without_bom = tmp_path / "data_without_bom.csv"
+
+        # CSV with UTF-8 BOM
+        bom_content = b'\xef\xbb\xbf"Name","Age"\n"Alice",30\n"Bob",25'
+        csv_with_bom.write_bytes(bom_content)
+
+        # CSV without BOM
+        no_bom_content = b'"Name","Age"\n"Charlie",35\n"Diana",28'
+        csv_without_bom.write_bytes(no_bom_content)
+
+        # Simulate CSV loading workflow
+        files_to_process = [csv_with_bom, csv_without_bom]
+        processing_info: list[dict[str, str | bool | int]] = []
+
+        for csv_file in files_to_process:
+            bom_info = is_bom_encoded_info(csv_file)
+
+            file_info: dict[str, str | bool | int] = {
+                'file': csv_file.name,
+                'has_bom': bom_info['has_bom'],
+                'encoding': bom_info['encoding'] or 'default',
+                'skip_bytes': bom_info['bom_length']
+            }
+            processing_info.append(file_info)
+
+        # Verify workflow results
+        assert len(processing_info) == 2
+
+        bom_file_info = next(info for info in processing_info if info['file'] == 'data_with_bom.csv')
+        no_bom_file_info = next(info for info in processing_info if info['file'] == 'data_without_bom.csv')
+
+        assert bom_file_info['has_bom'] is True
+        assert bom_file_info['encoding'] == 'utf-8'
+        assert bom_file_info['skip_bytes'] == 3
+
+        assert no_bom_file_info['has_bom'] is False
+        assert no_bom_file_info['encoding'] == 'default'
+        assert no_bom_file_info['skip_bytes'] == 0
+
+    def test_error_handling_consistency(self, tmp_path: Path):
+        """Test that both functions handle errors consistently"""
+        nonexistent_file = tmp_path / "does_not_exist.txt"
+
+        # Both functions should raise ValueError for non-existent files
+        with pytest.raises(ValueError):
+            is_bom_encoded(nonexistent_file)
+
+        with pytest.raises(ValueError):
+            is_bom_encoded_info(nonexistent_file)
+
+    def test_all_supported_bom_types(self, tmp_path: Path):
+        """Test detection of all supported BOM types"""
+        bom_test_cases = [
+            ('utf8', b'\xef\xbb\xbf', 'UTF-8', 'utf-8', 3),
+            ('utf16_le', b'\xff\xfe', 'UTF-16 LE', 'utf-16-le', 2),
+            ('utf16_be', b'\xfe\xff', 'UTF-16 BE', 'utf-16-be', 2),
+            ('utf32_le', b'\xff\xfe\x00\x00', 'UTF-32 LE', 'utf-32-le', 4),
+            ('utf32_be', b'\x00\x00\xfe\xff', 'UTF-32 BE', 'utf-32-be', 4),
+        ]
+
+        for name, bom_bytes, expected_type, expected_encoding, expected_length in bom_test_cases:
+            test_file = tmp_path / f"{name}_test.txt"
+            content = bom_bytes + b'Test content'
+            test_file.write_bytes(content)
+
+            # Test simple function
+            assert is_bom_encoded(test_file) is True
+
+            # Test detailed function
+            info = is_bom_encoded_info(test_file)
+            assert info['has_bom'] is True
+            assert info['bom_type'] == expected_type
+            assert info['encoding'] == expected_encoding
+            assert info['bom_length'] == expected_length
+            assert info['bom_pattern'] == bom_bytes
+
+
+# __END__

tests/unit/iterator_handling/test_dict_helpers.py

@@ -6,7 +6,7 @@ iterator_handling.dict_helper tests
 
 from typing import Any
 import pytest
-from corelibs.iterator_handling.dict_helper import (
+from corelibs.iterator_handling.dict_helpers import (
     delete_keys_from_set,
     build_dict,
     set_entry,

tests/unit/logging_handling/log_testing/test_log_1_settings_parsing_spacers_parameters.py

@@ -11,6 +11,12 @@ from corelibs.logging_handling.log import (
     Log,
     LogParent,
     LogSettings,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_FORMAT_TYPE_CONDENSED,
+    CONSOLE_FORMAT_TYPE_MINIMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
+    CONSOLE_ISO_TIME_SECONDS,
+    CONSOLE_ISO_TIME_MICROSECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -33,6 +39,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,
@@ -99,6 +107,143 @@ class TestLogSettingsParsing:
         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_normal(self, tmp_log_path: Path):
+        """Test parsing with console_format_type set to normal"""
+        settings: dict[str, Any] = {
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == CONSOLE_FORMAT_TYPE_NORMAL
+
+    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": CONSOLE_FORMAT_TYPE_CONDENSED,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == CONSOLE_FORMAT_TYPE_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": CONSOLE_FORMAT_TYPE_MINIMAL,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == CONSOLE_FORMAT_TYPE_MINIMAL
+
+    def test_parse_console_format_type_invalid(self, tmp_log_path: Path):
+        """Test parsing with invalid console_format_type falls back to default"""
+        settings: dict[str, Any] = {
+            "console_format_type": "invalid_format",
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        # Should fall back to default
+        assert log.log_settings["console_format_type"] == Log.DEFAULT_LOG_SETTINGS["console_format_type"]
+
+    def test_parse_console_iso_precision_seconds(self, tmp_log_path: Path):
+        """Test parsing with console_iso_precision set to seconds"""
+        settings: dict[str, Any] = {
+            "console_iso_precision": CONSOLE_ISO_TIME_SECONDS,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_iso_precision"] == CONSOLE_ISO_TIME_SECONDS
+
+    def test_parse_console_iso_precision_milliseconds(self, tmp_log_path: Path):
+        """Test parsing with console_iso_precision set to milliseconds"""
+        settings: dict[str, Any] = {
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_iso_precision"] == CONSOLE_ISO_TIME_MILLISECONDS
+
+    def test_parse_console_iso_precision_microseconds(self, tmp_log_path: Path):
+        """Test parsing with console_iso_precision set to microseconds"""
+        settings: dict[str, Any] = {
+            "console_iso_precision": CONSOLE_ISO_TIME_MICROSECONDS,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_iso_precision"] == CONSOLE_ISO_TIME_MICROSECONDS
+
+    def test_parse_console_iso_precision_invalid(self, tmp_log_path: Path):
+        """Test parsing with invalid console_iso_precision falls back to default"""
+        settings: dict[str, Any] = {
+            "console_iso_precision": "invalid_precision",
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        # Should fall back to default
+        assert log.log_settings["console_iso_precision"] == Log.DEFAULT_LOG_SETTINGS["console_iso_precision"]
+
+    def test_parse_both_console_settings_valid(self, tmp_log_path: Path):
+        """Test parsing with both console_format_type and console_iso_precision set"""
+        settings: dict[str, Any] = {
+            "console_format_type": CONSOLE_FORMAT_TYPE_CONDENSED,
+            "console_iso_precision": CONSOLE_ISO_TIME_MICROSECONDS,
+        }
+        log = Log(
+            log_path=tmp_log_path,
+            log_name="test",
+            log_settings=settings  # type: ignore
+        )
+
+        assert log.log_settings["console_format_type"] == CONSOLE_FORMAT_TYPE_CONDENSED
+        assert log.log_settings["console_iso_precision"] == CONSOLE_ISO_TIME_MICROSECONDS
+
+    def test_parse_both_console_settings_invalid(self, tmp_log_path: Path):
+        """Test parsing with both console settings invalid falls back to defaults"""
+        settings: dict[str, Any] = {
+            "console_format_type": "invalid_format",
+            "console_iso_precision": "invalid_precision",
+        }
+        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_format_type"] == Log.DEFAULT_LOG_SETTINGS["console_format_type"]
+        assert log.log_settings["console_iso_precision"] == Log.DEFAULT_LOG_SETTINGS["console_iso_precision"]
+
 
 # MARK: Test Spacer Constants
 class TestSpacerConstants:
@@ -160,6 +305,8 @@ class TestParametrized:
         ("per_run_log", True, "not_bool"),
         ("console_enabled", False, 123),
         ("console_color_output_enabled", True, None),
+        ("console_format_type", CONSOLE_FORMAT_TYPE_NORMAL, "invalid_format"),
+        ("console_iso_precision", CONSOLE_ISO_TIME_MILLISECONDS, "invalid_precision"),
         ("add_start_info", False, []),
         ("add_end_info", True, {}),
     ])

tests/unit/logging_handling/log_testing/test_log_2_basic_handling.py

@@ -13,6 +13,8 @@ from corelibs.logging_handling.log import (
     LogParent,
     LogSettings,
     CustomConsoleFormatter,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -35,6 +37,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,
@@ -169,6 +173,8 @@ class TestLogInitialization:
             "per_run_log": False,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": None,
@@ -190,6 +196,8 @@ class TestLogInitialization:
             "per_run_log": True,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": None,
@@ -256,6 +264,8 @@ class TestLogInitialization:
             "per_run_log": False,
             "console_enabled": True,
             "console_color_output_enabled": True,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_3_custom_console_formatter.py

@@ -11,6 +11,8 @@ from corelibs.logging_handling.log import (
     Log,
     LogSettings,
     CustomConsoleFormatter,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -33,6 +35,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_4_custom_handler_filter.py

@@ -11,6 +11,8 @@ from corelibs.logging_handling.log import (
     Log,
     LogSettings,
     CustomHandlerFilter,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -33,6 +35,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_5_handler_management.py

@@ -11,6 +11,8 @@ from corelibs.logging_handling.log import (
     Log,
     LogParent,
     LogSettings,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -33,6 +35,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,
@@ -61,6 +65,8 @@ class TestHandlerManagement:
             "per_run_log": False,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_6_logger.py

@@ -10,6 +10,8 @@ from corelibs.logging_handling.log import (
     Log,
     Logger,
     LogSettings,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -32,6 +34,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_7_edge_cases.py

@@ -10,6 +10,8 @@ import pytest
 from corelibs.logging_handling.log import (
     Log,
     LogSettings,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -32,6 +34,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,
@@ -88,6 +92,8 @@ class TestEdgeCases:
             "per_run_log": False,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": True,  # Enable end info
             "log_queue": None,

tests/unit/logging_handling/log_testing/test_log_99_queue_listener.py

@@ -12,6 +12,8 @@ import pytest
 from corelibs.logging_handling.log import (
     Log,
     LogSettings,
+    CONSOLE_FORMAT_TYPE_NORMAL,
+    CONSOLE_ISO_TIME_MILLISECONDS,
 )
 from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel
 
@@ -34,6 +36,8 @@ def basic_log_settings() -> LogSettings:
         "per_run_log": False,
         "console_enabled": True,
         "console_color_output_enabled": False,
+        "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+        "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
         "add_start_info": False,
         "add_end_info": False,
         "log_queue": None,
@@ -68,6 +72,8 @@ class TestQueueListener:
             "per_run_log": False,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": mock_queue,  # type: ignore
@@ -103,6 +109,8 @@ class TestQueueListener:
             "per_run_log": False,
             "console_enabled": False,
             "console_color_output_enabled": False,
+            "console_format_type": CONSOLE_FORMAT_TYPE_NORMAL,
+            "console_iso_precision": CONSOLE_ISO_TIME_MILLISECONDS,
             "add_start_info": False,
             "add_end_info": False,
             "log_queue": mock_queue,  # type: ignore

uv.lock

@@ -4,11 +4,11 @@ requires-python = ">=3.13"
 
 [[package]]
 name = "certifi"
-version = "2025.10.5"
+version = "2025.11.12"
 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" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" }
 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" },
+    { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" },
 ]
 
 [[package]]
@@ -108,7 +108,7 @@ wheels = [
 
 [[package]]
 name = "corelibs"
-version = "0.31.0"
+version = "0.35.2"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },
@@ -143,63 +143,63 @@ dev = [
 
 [[package]]
 name = "coverage"
-version = "7.11.0"
+version = "7.11.3"
 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" }
+sdist = { url = "https://files.pythonhosted.org/packages/d2/59/9698d57a3b11704c7b89b21d69e9d23ecf80d538cabb536c8b63f4a12322/coverage-7.11.3.tar.gz", hash = "sha256:0f59387f5e6edbbffec2281affb71cdc85e0776c1745150a3ab9b6c1d016106b", size = 815210, upload-time = "2025-11-10T00:13:17.18Z" }
 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" },
+    { url = "https://files.pythonhosted.org/packages/6d/f6/d8572c058211c7d976f24dab71999a565501fb5b3cdcb59cf782f19c4acb/coverage-7.11.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84b892e968164b7a0498ddc5746cdf4e985700b902128421bb5cec1080a6ee36", size = 216694, upload-time = "2025-11-10T00:11:34.296Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/f6/b6f9764d90c0ce1bce8d995649fa307fff21f4727b8d950fa2843b7b0de5/coverage-7.11.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f761dbcf45e9416ec4698e1a7649248005f0064ce3523a47402d1bff4af2779e", size = 217065, upload-time = "2025-11-10T00:11:36.281Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8d/a12cb424063019fd077b5be474258a0ed8369b92b6d0058e673f0a945982/coverage-7.11.3-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1410bac9e98afd9623f53876fae7d8a5db9f5a0ac1c9e7c5188463cb4b3212e2", size = 248062, upload-time = "2025-11-10T00:11:37.903Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/9c/dab1a4e8e75ce053d14259d3d7485d68528a662e286e184685ea49e71156/coverage-7.11.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:004cdcea3457c0ea3233622cd3464c1e32ebba9b41578421097402bee6461b63", size = 250657, upload-time = "2025-11-10T00:11:39.509Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/89/a14f256438324f33bae36f9a1a7137729bf26b0a43f5eda60b147ec7c8c7/coverage-7.11.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f067ada2c333609b52835ca4d4868645d3b63ac04fb2b9a658c55bba7f667d3", size = 251900, upload-time = "2025-11-10T00:11:41.372Z" },
+    { url = "https://files.pythonhosted.org/packages/04/07/75b0d476eb349f1296486b1418b44f2d8780cc8db47493de3755e5340076/coverage-7.11.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:07bc7745c945a6d95676953e86ba7cebb9f11de7773951c387f4c07dc76d03f5", size = 248254, upload-time = "2025-11-10T00:11:43.27Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/4b/0c486581fa72873489ca092c52792d008a17954aa352809a7cbe6cf0bf07/coverage-7.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8bba7e4743e37484ae17d5c3b8eb1ce78b564cb91b7ace2e2182b25f0f764cb5", size = 250041, upload-time = "2025-11-10T00:11:45.274Z" },
+    { url = "https://files.pythonhosted.org/packages/af/a3/0059dafb240ae3e3291f81b8de00e9c511d3dd41d687a227dd4b529be591/coverage-7.11.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fbffc22d80d86fbe456af9abb17f7a7766e7b2101f7edaacc3535501691563f7", size = 248004, upload-time = "2025-11-10T00:11:46.93Z" },
+    { url = "https://files.pythonhosted.org/packages/83/93/967d9662b1eb8c7c46917dcc7e4c1875724ac3e73c3cb78e86d7a0ac719d/coverage-7.11.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:0dba4da36730e384669e05b765a2c49f39514dd3012fcc0398dd66fba8d746d5", size = 247828, upload-time = "2025-11-10T00:11:48.563Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/1c/5077493c03215701e212767e470b794548d817dfc6247a4718832cc71fac/coverage-7.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ae12fe90b00b71a71b69f513773310782ce01d5f58d2ceb2b7c595ab9d222094", size = 249588, upload-time = "2025-11-10T00:11:50.581Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/a5/77f64de461016e7da3e05d7d07975c89756fe672753e4cf74417fc9b9052/coverage-7.11.3-cp313-cp313-win32.whl", hash = "sha256:12d821de7408292530b0d241468b698bce18dd12ecaf45316149f53877885f8c", size = 219223, upload-time = "2025-11-10T00:11:52.184Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1c/ec51a3c1a59d225b44bdd3a4d463135b3159a535c2686fac965b698524f4/coverage-7.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:6bb599052a974bb6cedfa114f9778fedfad66854107cf81397ec87cb9b8fbcf2", size = 220033, upload-time = "2025-11-10T00:11:53.871Z" },
+    { url = "https://files.pythonhosted.org/packages/01/ec/e0ce39746ed558564c16f2cc25fa95ce6fc9fa8bfb3b9e62855d4386b886/coverage-7.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:bb9d7efdb063903b3fdf77caec7b77c3066885068bdc0d44bc1b0c171033f944", size = 218661, upload-time = "2025-11-10T00:11:55.597Z" },
+    { url = "https://files.pythonhosted.org/packages/46/cb/483f130bc56cbbad2638248915d97b185374d58b19e3cc3107359715949f/coverage-7.11.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:fb58da65e3339b3dbe266b607bb936efb983d86b00b03eb04c4ad5b442c58428", size = 217389, upload-time = "2025-11-10T00:11:57.59Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ae/81f89bae3afef75553cf10e62feb57551535d16fd5859b9ee5a2a97ddd27/coverage-7.11.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8d16bbe566e16a71d123cd66382c1315fcd520c7573652a8074a8fe281b38c6a", size = 217742, upload-time = "2025-11-10T00:11:59.519Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6e/a0fb897041949888191a49c36afd5c6f5d9f5fd757e0b0cd99ec198a324b/coverage-7.11.3-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a8258f10059b5ac837232c589a350a2df4a96406d6d5f2a09ec587cbdd539655", size = 259049, upload-time = "2025-11-10T00:12:01.592Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b6/d13acc67eb402d91eb94b9bd60593411799aed09ce176ee8d8c0e39c94ca/coverage-7.11.3-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4c5627429f7fbff4f4131cfdd6abd530734ef7761116811a707b88b7e205afd7", size = 261113, upload-time = "2025-11-10T00:12:03.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/07/a6868893c48191d60406df4356aa7f0f74e6de34ef1f03af0d49183e0fa1/coverage-7.11.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:465695268414e149bab754c54b0c45c8ceda73dd4a5c3ba255500da13984b16d", size = 263546, upload-time = "2025-11-10T00:12:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/24/e5/28598f70b2c1098332bac47925806353b3313511d984841111e6e760c016/coverage-7.11.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4ebcddfcdfb4c614233cff6e9a3967a09484114a8b2e4f2c7a62dc83676ba13f", size = 258260, upload-time = "2025-11-10T00:12:07.137Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/58/58e2d9e6455a4ed746a480c4b9cf96dc3cb2a6b8f3efbee5efd33ae24b06/coverage-7.11.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:13b2066303a1c1833c654d2af0455bb009b6e1727b3883c9964bc5c2f643c1d0", size = 261121, upload-time = "2025-11-10T00:12:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/17/57/38803eefb9b0409934cbc5a14e3978f0c85cb251d2b6f6a369067a7105a0/coverage-7.11.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d8750dd20362a1b80e3cf84f58013d4672f89663aee457ea59336df50fab6739", size = 258736, upload-time = "2025-11-10T00:12:11.195Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/f94683167156e93677b3442be1d4ca70cb33718df32a2eea44a5898f04f6/coverage-7.11.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ab6212e62ea0e1006531a2234e209607f360d98d18d532c2fa8e403c1afbdd71", size = 257625, upload-time = "2025-11-10T00:12:12.843Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ed/42d0bf1bc6bfa7d65f52299a31daaa866b4c11000855d753857fe78260ac/coverage-7.11.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a6b17c2b5e0b9bb7702449200f93e2d04cb04b1414c41424c08aa1e5d352da76", size = 259827, upload-time = "2025-11-10T00:12:15.128Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/76/5682719f5d5fbedb0c624c9851ef847407cae23362deb941f185f489c54e/coverage-7.11.3-cp313-cp313t-win32.whl", hash = "sha256:426559f105f644b69290ea414e154a0d320c3ad8a2bb75e62884731f69cf8e2c", size = 219897, upload-time = "2025-11-10T00:12:17.274Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e0/1da511d0ac3d39e6676fa6cc5ec35320bbf1cebb9b24e9ee7548ee4e931a/coverage-7.11.3-cp313-cp313t-win_amd64.whl", hash = "sha256:90a96fcd824564eae6137ec2563bd061d49a32944858d4bdbae5c00fb10e76ac", size = 220959, upload-time = "2025-11-10T00:12:19.292Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/9d/e255da6a04e9ec5f7b633c54c0fdfa221a9e03550b67a9c83217de12e96c/coverage-7.11.3-cp313-cp313t-win_arm64.whl", hash = "sha256:1e33d0bebf895c7a0905fcfaff2b07ab900885fc78bba2a12291a2cfbab014cc", size = 219234, upload-time = "2025-11-10T00:12:21.251Z" },
+    { url = "https://files.pythonhosted.org/packages/84/d6/634ec396e45aded1772dccf6c236e3e7c9604bc47b816e928f32ce7987d1/coverage-7.11.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fdc5255eb4815babcdf236fa1a806ccb546724c8a9b129fd1ea4a5448a0bf07c", size = 216746, upload-time = "2025-11-10T00:12:23.089Z" },
+    { url = "https://files.pythonhosted.org/packages/28/76/1079547f9d46f9c7c7d0dad35b6873c98bc5aa721eeabceafabd722cd5e7/coverage-7.11.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fe3425dc6021f906c6325d3c415e048e7cdb955505a94f1eb774dafc779ba203", size = 217077, upload-time = "2025-11-10T00:12:24.863Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/71/6ad80d6ae0d7cb743b9a98df8bb88b1ff3dc54491508a4a97549c2b83400/coverage-7.11.3-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4ca5f876bf41b24378ee67c41d688155f0e54cdc720de8ef9ad6544005899240", size = 248122, upload-time = "2025-11-10T00:12:26.553Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1d/784b87270784b0b88e4beec9d028e8d58f73ae248032579c63ad2ac6f69a/coverage-7.11.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9061a3e3c92b27fd8036dafa26f25d95695b6aa2e4514ab16a254f297e664f83", size = 250638, upload-time = "2025-11-10T00:12:28.555Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/26/b6dd31e23e004e9de84d1a8672cd3d73e50f5dae65dbd0f03fa2cdde6100/coverage-7.11.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:abcea3b5f0dc44e1d01c27090bc32ce6ffb7aa665f884f1890710454113ea902", size = 251972, upload-time = "2025-11-10T00:12:30.246Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ef/f9c64d76faac56b82daa036b34d4fe9ab55eb37f22062e68e9470583e688/coverage-7.11.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:68c4eb92997dbaaf839ea13527be463178ac0ddd37a7ac636b8bc11a51af2428", size = 248147, upload-time = "2025-11-10T00:12:32.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/5b666f90a8f8053bd264a1ce693d2edef2368e518afe70680070fca13ecd/coverage-7.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:149eccc85d48c8f06547534068c41d69a1a35322deaa4d69ba1561e2e9127e75", size = 249995, upload-time = "2025-11-10T00:12:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/7b/871e991ffb5d067f8e67ffb635dabba65b231d6e0eb724a4a558f4a702a5/coverage-7.11.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:08c0bcf932e47795c49f0406054824b9d45671362dfc4269e0bc6e4bff010704", size = 247948, upload-time = "2025-11-10T00:12:36.341Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/8b/ce454f0af9609431b06dbe5485fc9d1c35ddc387e32ae8e374f49005748b/coverage-7.11.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:39764c6167c82d68a2d8c97c33dba45ec0ad9172570860e12191416f4f8e6e1b", size = 247770, upload-time = "2025-11-10T00:12:38.167Z" },
+    { url = "https://files.pythonhosted.org/packages/61/8f/79002cb58a61dfbd2085de7d0a46311ef2476823e7938db80284cedd2428/coverage-7.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3224c7baf34e923ffc78cb45e793925539d640d42c96646db62dbd61bbcfa131", size = 249431, upload-time = "2025-11-10T00:12:40.354Z" },
+    { url = "https://files.pythonhosted.org/packages/58/cc/d06685dae97468ed22999440f2f2f5060940ab0e7952a7295f236d98cce7/coverage-7.11.3-cp314-cp314-win32.whl", hash = "sha256:c713c1c528284d636cd37723b0b4c35c11190da6f932794e145fc40f8210a14a", size = 219508, upload-time = "2025-11-10T00:12:42.231Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/ed/770cd07706a3598c545f62d75adf2e5bd3791bffccdcf708ec383ad42559/coverage-7.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:c381a252317f63ca0179d2c7918e83b99a4ff3101e1b24849b999a00f9cd4f86", size = 220325, upload-time = "2025-11-10T00:12:44.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ac/6a1c507899b6fb1b9a56069954365f655956bcc648e150ce64c2b0ecbed8/coverage-7.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:3e33a968672be1394eded257ec10d4acbb9af2ae263ba05a99ff901bb863557e", size = 218899, upload-time = "2025-11-10T00:12:46.18Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/58/142cd838d960cd740654d094f7b0300d7b81534bb7304437d2439fb685fb/coverage-7.11.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:f9c96a29c6d65bd36a91f5634fef800212dff69dacdb44345c4c9783943ab0df", size = 217471, upload-time = "2025-11-10T00:12:48.392Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2c/2f44d39eb33e41ab3aba80571daad32e0f67076afcf27cb443f9e5b5a3ee/coverage-7.11.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2ec27a7a991d229213c8070d31e3ecf44d005d96a9edc30c78eaeafaa421c001", size = 217742, upload-time = "2025-11-10T00:12:50.182Z" },
+    { url = "https://files.pythonhosted.org/packages/32/76/8ebc66c3c699f4de3174a43424c34c086323cd93c4930ab0f835731c443a/coverage-7.11.3-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:72c8b494bd20ae1c58528b97c4a67d5cfeafcb3845c73542875ecd43924296de", size = 259120, upload-time = "2025-11-10T00:12:52.451Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/78a3302b9595f331b86e4f12dfbd9252c8e93d97b8631500888f9a3a2af7/coverage-7.11.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:60ca149a446da255d56c2a7a813b51a80d9497a62250532598d249b3cdb1a926", size = 261229, upload-time = "2025-11-10T00:12:54.667Z" },
+    { url = "https://files.pythonhosted.org/packages/07/59/1a9c0844dadef2a6efac07316d9781e6c5a3f3ea7e5e701411e99d619bfd/coverage-7.11.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb5069074db19a534de3859c43eec78e962d6d119f637c41c8e028c5ab3f59dd", size = 263642, upload-time = "2025-11-10T00:12:56.841Z" },
+    { url = "https://files.pythonhosted.org/packages/37/86/66c15d190a8e82eee777793cabde730640f555db3c020a179625a2ad5320/coverage-7.11.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac5d5329c9c942bbe6295f4251b135d860ed9f86acd912d418dce186de7c19ac", size = 258193, upload-time = "2025-11-10T00:12:58.687Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/c7/4a4aeb25cb6f83c3ec4763e5f7cc78da1c6d4ef9e22128562204b7f39390/coverage-7.11.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e22539b676fafba17f0a90ac725f029a309eb6e483f364c86dcadee060429d46", size = 261107, upload-time = "2025-11-10T00:13:00.502Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/91/b986b5035f23cf0272446298967ecdd2c3c0105ee31f66f7e6b6948fd7f8/coverage-7.11.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:2376e8a9c889016f25472c452389e98bc6e54a19570b107e27cde9d47f387b64", size = 258717, upload-time = "2025-11-10T00:13:02.747Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c7/6c084997f5a04d050c513545d3344bfa17bd3b67f143f388b5757d762b0b/coverage-7.11.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4234914b8c67238a3c4af2bba648dc716aa029ca44d01f3d51536d44ac16854f", size = 257541, upload-time = "2025-11-10T00:13:04.689Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c5/38e642917e406930cb67941210a366ccffa767365c8f8d9ec0f465a8b218/coverage-7.11.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0b4101e2b3c6c352ff1f70b3a6fcc7c17c1ab1a91ccb7a33013cb0782af9820", size = 259872, upload-time = "2025-11-10T00:13:06.559Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/67/5e812979d20c167f81dbf9374048e0193ebe64c59a3d93d7d947b07865fa/coverage-7.11.3-cp314-cp314t-win32.whl", hash = "sha256:305716afb19133762e8cf62745c46c4853ad6f9eeba54a593e373289e24ea237", size = 220289, upload-time = "2025-11-10T00:13:08.635Z" },
+    { url = "https://files.pythonhosted.org/packages/24/3a/b72573802672b680703e0df071faadfab7dcd4d659aaaffc4626bc8bbde8/coverage-7.11.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9245bd392572b9f799261c4c9e7216bafc9405537d0f4ce3ad93afe081a12dc9", size = 221398, upload-time = "2025-11-10T00:13:10.734Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4e/649628f28d38bad81e4e8eb3f78759d20ac173e3c456ac629123815feb40/coverage-7.11.3-cp314-cp314t-win_arm64.whl", hash = "sha256:9a1d577c20b4334e5e814c3d5fe07fa4a8c3ae42a601945e8d7940bab811d0bd", size = 219435, upload-time = "2025-11-10T00:13:12.712Z" },
+    { url = "https://files.pythonhosted.org/packages/19/8f/92bdd27b067204b99f396a1414d6342122f3e2663459baf787108a6b8b84/coverage-7.11.3-py3-none-any.whl", hash = "sha256:351511ae28e2509c8d8cae5311577ea7dd511ab8e746ffc8814a0896c3d33fbe", size = 208478, upload-time = "2025-11-10T00:13:14.908Z" },
 ]
 
 [[package]]
@@ -347,28 +347,28 @@ wheels = [
 
 [[package]]
 name = "psutil"
-version = "7.1.2"
+version = "7.1.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/ec/7b8e6b9b1d22708138630ef34c53ab2b61032c04f16adfdbb96791c8c70c/psutil-7.1.2.tar.gz", hash = "sha256:aa225cdde1335ff9684708ee8c72650f6598d5ed2114b9a7c5802030b1785018", size = 487424, upload-time = "2025-10-25T10:46:34.931Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/d9/b56cc9f883140ac10021a8c9b0f4e16eed1ba675c22513cdcbce3ba64014/psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0cc5c6889b9871f231ed5455a9a02149e388fffcb30b607fb7a8896a6d95f22e", size = 238575, upload-time = "2025-10-25T10:46:38.728Z" },
-    { url = "https://files.pythonhosted.org/packages/36/eb/28d22de383888deb252c818622196e709da98816e296ef95afda33f1c0a2/psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8e9e77a977208d84aa363a4a12e0f72189d58bbf4e46b49aae29a2c6e93ef206", size = 239297, upload-time = "2025-10-25T10:46:41.347Z" },
-    { url = "https://files.pythonhosted.org/packages/89/5d/220039e2f28cc129626e54d63892ab05c0d56a29818bfe7268dcb5008932/psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d9623a5e4164d2220ecceb071f4b333b3c78866141e8887c072129185f41278", size = 280420, upload-time = "2025-10-25T10:46:44.122Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/7a/286f0e1c167445b2ef4a6cbdfc8c59fdb45a5a493788950cf8467201dc73/psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:364b1c10fe4ed59c89ec49e5f1a70da353b27986fa8233b4b999df4742a5ee2f", size = 283049, upload-time = "2025-10-25T10:46:47.095Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/cc/7eb93260794a42e39b976f3a4dde89725800b9f573b014fac142002a5c98/psutil-7.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:f101ef84de7e05d41310e3ccbdd65a6dd1d9eed85e8aaf0758405d022308e204", size = 248713, upload-time = "2025-10-25T10:46:49.573Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/1a/0681a92b53366e01f0a099f5237d0c8a2f79d322ac589cccde5e30c8a4e2/psutil-7.1.2-cp313-cp313t-win_arm64.whl", hash = "sha256:20c00824048a95de67f00afedc7b08b282aa08638585b0206a9fb51f28f1a165", size = 244644, upload-time = "2025-10-25T10:46:51.924Z" },
-    { url = "https://files.pythonhosted.org/packages/56/9e/f1c5c746b4ed5320952acd3002d3962fe36f30524c00ea79fdf954cc6779/psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e09cfe92aa8e22b1ec5e2d394820cf86c5dff6367ac3242366485dfa874d43bc", size = 238640, upload-time = "2025-10-25T10:46:54.089Z" },
-    { url = "https://files.pythonhosted.org/packages/32/ee/fd26216a735395cc25c3899634e34aeb41fb1f3dbb44acc67d9e594be562/psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fa6342cf859c48b19df3e4aa170e4cfb64aadc50b11e06bb569c6c777b089c9e", size = 239303, upload-time = "2025-10-25T10:46:56.932Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/cd/7d96eaec4ef7742b845a9ce2759a2769ecce4ab7a99133da24abacbc9e41/psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:625977443498ee7d6c1e63e93bacca893fd759a66c5f635d05e05811d23fb5ee", size = 281717, upload-time = "2025-10-25T10:46:59.116Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/1a/7f0b84bdb067d35fe7fade5fff888408688caf989806ce2d6dae08c72dd5/psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a24bcd7b7f2918d934af0fb91859f621b873d6aa81267575e3655cd387572a7", size = 284575, upload-time = "2025-10-25T10:47:00.944Z" },
-    { url = "https://files.pythonhosted.org/packages/de/05/7820ef8f7b275268917e0c750eada5834581206d9024ca88edce93c4b762/psutil-7.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:329f05610da6380982e6078b9d0881d9ab1e9a7eb7c02d833bfb7340aa634e31", size = 249491, upload-time = "2025-10-25T10:47:03.174Z" },
-    { url = "https://files.pythonhosted.org/packages/db/9a/58de399c7cb58489f08498459ff096cd76b3f1ddc4f224ec2c5ef729c7d0/psutil-7.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:7b04c29e3c0c888e83ed4762b70f31e65c42673ea956cefa8ced0e31e185f582", size = 244880, upload-time = "2025-10-25T10:47:05.228Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/89/b9f8d47ddbc52d7301fc868e8224e5f44ed3c7f55e6d0f54ecaf5dd9ff5e/psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c9ba5c19f2d46203ee8c152c7b01df6eec87d883cfd8ee1af2ef2727f6b0f814", size = 237244, upload-time = "2025-10-25T10:47:07.086Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/7a/8628c2f6b240680a67d73d8742bb9ff39b1820a693740e43096d5dcb01e5/psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:2a486030d2fe81bec023f703d3d155f4823a10a47c36784c84f1cc7f8d39bedb", size = 238101, upload-time = "2025-10-25T10:47:09.523Z" },
-    { url = "https://files.pythonhosted.org/packages/30/28/5e27f4d5a0e347f8e3cc16cd7d35533dbce086c95807f1f0e9cd77e26c10/psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3efd8fc791492e7808a51cb2b94889db7578bfaea22df931424f874468e389e3", size = 258675, upload-time = "2025-10-25T10:47:11.082Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/5c/79cf60c9acf36d087f0db0f82066fca4a780e97e5b3a2e4c38209c03d170/psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2aeb9b64f481b8eabfc633bd39e0016d4d8bbcd590d984af764d80bf0851b8a", size = 260203, upload-time = "2025-10-25T10:47:13.226Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/03/0a464404c51685dcb9329fdd660b1721e076ccd7b3d97dee066bcc9ffb15/psutil-7.1.2-cp37-abi3-win_amd64.whl", hash = "sha256:8e17852114c4e7996fe9da4745c2bdef001ebbf2f260dec406290e66628bdb91", size = 246714, upload-time = "2025-10-25T10:47:15.093Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/32/97ca2090f2f1b45b01b6aa7ae161cfe50671de097311975ca6eea3e7aabc/psutil-7.1.2-cp37-abi3-win_arm64.whl", hash = "sha256:3e988455e61c240cc879cb62a008c2699231bf3e3d061d7fce4234463fd2abb4", size = 243742, upload-time = "2025-10-25T10:47:17.302Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" },
+    { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" },
+    { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" },
+    { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" },
+    { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" },
+    { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" },
 ]
 
 [[package]]
@@ -391,7 +391,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "8.4.2"
+version = "9.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -400,9 +400,9 @@ dependencies = [
     { 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" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125, upload-time = "2025-11-12T13:05:09.333Z" }
 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" },
+    { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668, upload-time = "2025-11-12T13:05:07.379Z" },
 ]
 
 [[package]]