v0.25.1: add missing jmespath exception check

This error can happend if we search for a key and try to make a value compare and the key does not exist.
Perhaps also when they key should return a list

pyproject.toml

@@ -1,7 +1,7 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.24.2"
+version = "0.25.1"
 description = "Collection of utils for Python scripts"
 readme = "README.md"
 requires-python = ">=3.13"

src/corelibs/json_handling/jmespath_helper.py

@@ -28,6 +28,8 @@ def jmespath_search(search_data: dict[Any, Any] | list[Any], search_params: str)
         raise ValueError(f"Compile failed: {search_params}: {excp}") from excp
     except jmespath.exceptions.ParseError as excp:
         raise ValueError(f"Parse failed: {search_params}: {excp}") from excp
+    except jmespath.exceptions.JMESPathTypeError as excp:
+        raise ValueError(f"Search failed with JMESPathTypeError: {search_params}: {excp}") from excp
     except TypeError as excp:
         raise ValueError(f"Type error for search_params: {excp}") from excp
     return search_result

src/corelibs/logging_handling/log.py

@@ -598,7 +598,7 @@ class Log(LogParent):
             # log path, remove them stem (".log"), then add the datetime and add .log again
             now = datetime.now()
             # we add microseconds part to get milli seconds
-            new_stem=f"{log_path.stem}.{now.strftime('%Y-%m-%d_%H-%M-%S')}.{str(now.microsecond)[:3]}"
+            new_stem = f"{log_path.stem}.{now.strftime('%Y-%m-%d_%H-%M-%S')}.{str(now.microsecond)[:3]}"
             file_handler = logging.FileHandler(
                 filename=log_path.with_name(f"{new_stem}{log_path.suffix}"),
                 encoding="utf-8",

src/corelibs/string_handling/datetime_helpers.py

@@ -3,7 +3,9 @@ Various string based date/time helpers
 """
 
 from math import floor
-import time
+import time as time_t
+from datetime import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 
 def convert_timestamp(timestamp: float | int, show_micro: bool = True) -> str:
@@ -58,6 +60,77 @@ def create_time(timestamp: float, timestamp_format: str = "%Y-%m-%d %H:%M:%S") -
     Returns:
         str -- _description_
     """
-    return time.strftime(timestamp_format, time.localtime(timestamp))
+    return time_t.strftime(timestamp_format, time_t.localtime(timestamp))
+
+
+def get_system_timezone():
+    """Get system timezone using datetime's automatic detection"""
+    # Get current time with system timezone
+    local_time = datetime.now().astimezone()
+
+    # Extract timezone info
+    system_tz = local_time.tzinfo
+    timezone_name = str(system_tz)
+
+    return system_tz, timezone_name
+
+
+def parse_timezone_data(timezone_tz: str = '') -> ZoneInfo:
+    """
+    parses a string to get the ZoneInfo
+    If not set or not valid gets local time,
+    if that is not possible get UTC
+
+    Keyword Arguments:
+        timezone_tz {str} -- _description_ (default: {''})
+
+    Returns:
+        ZoneInfo -- _description_
+    """
+    try:
+        return ZoneInfo(timezone_tz)
+    except (ZoneInfoNotFoundError, ValueError, TypeError):
+        # use default
+        time_tz, time_tz_str = get_system_timezone()
+        if time_tz is None:
+            return ZoneInfo('UTC')
+        # TODO build proper TZ lookup
+        tz_mapping = {
+            'JST': 'Asia/Tokyo',
+            'KST': 'Asia/Seoul',
+            'IST': 'Asia/Kolkata',
+            'CST': 'Asia/Shanghai',  # Default to China for CST
+            'AEST': 'Australia/Sydney',
+            'AWST': 'Australia/Perth',
+            'EST': 'America/New_York',
+            'EDT': 'America/New_York',
+            'CDT': 'America/Chicago',
+            'MST': 'America/Denver',
+            'MDT': 'America/Denver',
+            'PST': 'America/Los_Angeles',
+            'PDT': 'America/Los_Angeles',
+            'GMT': 'UTC',
+            'UTC': 'UTC',
+            'CET': 'Europe/Berlin',
+            'CEST': 'Europe/Berlin',
+            'BST': 'Europe/London',
+        }
+        try:
+            return ZoneInfo(tz_mapping[time_tz_str])
+        except (ZoneInfoNotFoundError, IndexError) as e:
+            raise ValueError(f"No mapping for {time_tz_str}: {e}") from e
+
+
+def get_datetime_iso8601(timezone_tz: str | ZoneInfo = '', sep: str = 'T', timespec: str = 'microseconds') -> str:
+    """
+    set a datetime in the iso8601 format with microseconds
+
+    Returns:
+        str -- _description_
+    """
+    # parse if this is a string
+    if isinstance(timezone_tz, str):
+        timezone_tz = parse_timezone_data(timezone_tz)
+    return datetime.now(timezone_tz).isoformat(sep=sep, timespec=timespec)
 
 # __END__

src/corelibs/string_handling/timestamp_strings.py

@@ -25,13 +25,15 @@ class TimestampStrings:
 
     def __init__(self, time_zone: str | ZoneInfo | None = None):
         self.timestamp_now = datetime.now()
-        self.time_zone = time_zone if time_zone is not None else self.TIME_ZONE
+        # set time zone as string
+        time_zone = time_zone if time_zone is not None else self.TIME_ZONE
+        self.time_zone = str(time_zone) if not isinstance(time_zone, str) else time_zone
+        # set ZoneInfo type
         try:
-            self.timestamp_now_tz = datetime.now(
-                ZoneInfo(self.time_zone) if not isinstance(self.time_zone, ZoneInfo) else self.time_zone
-            )
+            self.time_zone_zi = ZoneInfo(self.time_zone)
         except ZoneInfoNotFoundError as e:
             raise ValueError(f'Zone could not be loaded [{self.time_zone}]: {e}') from e
+        self.timestamp_now_tz = datetime.now(self.time_zone_zi)
         self.today = self.timestamp_now.strftime('%Y-%m-%d')
         self.timestamp = self.timestamp_now.strftime("%Y-%m-%d %H:%M:%S")
         self.timestamp_tz = self.timestamp_now_tz.strftime("%Y-%m-%d %H:%M:%S %Z")

test-run/json_handling/jmespath_helper.py

@@ -39,7 +39,9 @@ def main() -> None:
         'a',
         'bar.a',
         'foo.a',
-        'baz[].aa'
+        'baz[].aa',
+        "[?\"c\" && contains(\"c\", 'b')]",
+        "[?contains(\"c\", 'b')]",
     ]
     for __jmespath in __get:
         result = jmespath_search(__set, __jmespath)

test-run/string_handling/datetime_helpers.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+"""
+date string helper test
+"""
+
+from corelibs.string_handling.datetime_helpers import get_datetime_iso8601
+
+
+def main() -> None:
+    """
+    Comment
+    """
+    print(get_datetime_iso8601())
+    print(get_datetime_iso8601('Asia/Tokyo'))
+    print(get_datetime_iso8601('UTC'))
+    print(get_datetime_iso8601('Europe/Vienna'))
+    print(get_datetime_iso8601('America/New_York'))
+    print(get_datetime_iso8601('Australia/Sydney'))
+    print(get_datetime_iso8601('invalid'))
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__

test-run/timestamp_strings/timestamp_strings.py

@@ -22,6 +22,9 @@ def main():
     print(f"TZ: {ts.time_zone} -> TS: {ts.timestamp_now_tz}")
     ts = TimestampStrings(ZoneInfo("Europe/Vienna"))
     print(f"TZ: {ts.time_zone} -> TS: {ts.timestamp_now_tz}")
+    custom_tz = 'Europe/Paris'
+    ts = TimestampStrings(time_zone=custom_tz)
+    print(f"TZ: {ts.time_zone} -> TS: {ts.timestamp_now_tz}")
 
 
 if __name__ == "__main__":

tests/unit/string_handling/test_timestamp_strings.py

@@ -3,7 +3,7 @@ PyTest: string_handling/timestamp_strings
 """
 
 from datetime import datetime
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 from zoneinfo import ZoneInfo
 import pytest
 
@@ -119,18 +119,55 @@ class TestTimestampStrings:
             assert ts2.time_zone == 'Europe/London'
             assert ts1.time_zone != ts2.time_zone
 
-    @patch('corelibs.string_handling.timestamp_strings.ZoneInfo')
-    def test_zoneinfo_called_correctly(self, mock_zoneinfo: MagicMock):
-        """Test that ZoneInfo is called with correct timezone"""
+    def test_zoneinfo_called_correctly_with_string(self):
+        """Test that ZoneInfo is called with correct timezone when passing string"""
+        with patch('corelibs.string_handling.timestamp_strings.ZoneInfo') as mock_zoneinfo:
+            with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+                mock_now = datetime(2023, 12, 25, 15, 30, 45)
+                mock_datetime.now.return_value = mock_now
+
+                custom_tz = 'Europe/Paris'
+                ts = TimestampStrings(time_zone=custom_tz)
+                assert ts.time_zone == custom_tz
+
+                mock_zoneinfo.assert_called_with(custom_tz)
+
+    def test_zoneinfo_object_parameter(self):
+        """Test that ZoneInfo objects can be passed directly as timezone parameter"""
         with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
             mock_now = datetime(2023, 12, 25, 15, 30, 45)
-            mock_datetime.now.return_value = mock_now
+            mock_now_tz = datetime(2023, 12, 25, 15, 30, 45, tzinfo=ZoneInfo('Europe/Paris'))
+            mock_datetime.now.side_effect = [mock_now, mock_now_tz]
 
-            custom_tz = 'Europe/Paris'
-            ts = TimestampStrings(time_zone=custom_tz)
-            assert ts.time_zone == custom_tz
+            # Create a ZoneInfo object
+            custom_tz_obj = ZoneInfo('Europe/Paris')
+            ts = TimestampStrings(time_zone=custom_tz_obj)
 
-            mock_zoneinfo.assert_called_with(custom_tz)
+            # The time_zone should be the ZoneInfo object itself
+            assert ts.time_zone_zi is custom_tz_obj
+            assert isinstance(ts.time_zone_zi, ZoneInfo)
+
+    def test_zoneinfo_object_vs_string_equivalence(self):
+        """Test that ZoneInfo object and string produce equivalent results"""
+        with patch('corelibs.string_handling.timestamp_strings.datetime') as mock_datetime:
+            mock_now = datetime(2023, 12, 25, 15, 30, 45)
+            mock_now_tz = datetime(2023, 12, 25, 15, 30, 45, tzinfo=ZoneInfo('Europe/Paris'))
+            mock_datetime.now.side_effect = [mock_now, mock_now_tz, mock_now, mock_now_tz]
+
+            # Test with string
+            ts_string = TimestampStrings(time_zone='Europe/Paris')
+
+            # Test with ZoneInfo object
+            ts_zoneinfo = TimestampStrings(time_zone=ZoneInfo('Europe/Paris'))
+
+            # Both should produce the same timestamp formats (though time_zone attributes will differ)
+            assert ts_string.today == ts_zoneinfo.today
+            assert ts_string.timestamp == ts_zoneinfo.timestamp
+            assert ts_string.timestamp_file == ts_zoneinfo.timestamp_file
+
+            # The time_zone attributes will be different types but represent the same timezone
+            assert str(ts_string.time_zone) == 'Europe/Paris'
+            assert isinstance(ts_zoneinfo.time_zone_zi, ZoneInfo)
 
     def test_edge_case_midnight(self):
         """Test timestamp formatting at midnight"""

uv.lock

@@ -53,7 +53,7 @@ wheels = [
 
 [[package]]
 name = "corelibs"
-version = "0.24.1"
+version = "0.25.0"
 source = { editable = "." }
 dependencies = [
     { name = "jmespath" },