kiba-core 0.5.3.dev59__tar.gz → 0.5.3.dev60__tar.gz

{kiba_core-0.5.3.dev59 → kiba_core-0.5.3.dev60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev59
+Version: 0.5.3.dev60
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev59 → kiba_core-0.5.3.dev60}/core/util/json_util.py

@@ -1,13 +1,11 @@
-import datetime
-import json
 import typing
 from typing import Any
 
 import orjson
+import pydantic_core
 
 from core import logging
 from core.exceptions import KibaException
-from core.util import date_util
 from core.util.typing_util import Json
 
 
@@ -22,28 +20,19 @@ class JsonEncodeException(KibaException):
 _HAS_LOGGED_FOR_SERIALIZATION_ERROR = False
 
 
-class DatetimeEncoder(json.JSONEncoder):
-    def default(self, o: typing.Any) -> str:  # type: ignore[explicit-any]
-        if isinstance(o, datetime.datetime):
-            return date_util.datetime_to_string(o)
-        try:
-            return typing.cast(str, super().default(o))
-        except TypeError:
-            return str(o)
-
-
 def dumpb(obj: Any) -> bytes:  # type: ignore[explicit-any]
     global _HAS_LOGGED_FOR_SERIALIZATION_ERROR  # noqa: PLW0603
     try:
-        return orjson.dumps(obj)
+        # NOTE(krishan711): Keep UTC datetime output aligned with pydantic's ISO 8601 format.
+        return orjson.dumps(obj, option=orjson.OPT_UTC_Z)
     except TypeError as exception:
         if str(exception) == 'Integer exceeds 64-bit range':
             if not _HAS_LOGGED_FOR_SERIALIZATION_ERROR:
-                logging.warning(f'There was an error during the serialization an object: `{exception}`, falling back to json.')
+                logging.warning(f'There was an error during the serialization an object: `{exception}`, falling back to pydantic.')
                 _HAS_LOGGED_FOR_SERIALIZATION_ERROR = True
-            return json.dumps(obj, cls=DatetimeEncoder).encode('utf-8')
-        raise JsonEncodeException(message=str(exception)) from exception
-    except orjson.JSONEncodeError as exception:
+            # NOTE(krishan711): orjson is faster, but doesnt support ints bigger than 64bit
+            # so we use pydantic instead (still faster than python json)
+            return pydantic_core.to_json(obj, fallback=str, inf_nan_mode='null')
         raise JsonEncodeException(message=str(exception)) from exception
 
 
@@ -53,6 +42,8 @@ def dumps(obj: Any) -> str:  # type: ignore[explicit-any]
 
 def loads(json: str | bytes | bytearray) -> Json:
     try:
-        return orjson.loads(json)  # type: ignore[no-any-return]
-    except orjson.JSONDecodeError as exception:
+        # NOTE(krishan711): orjson is faster, but doesnt support ints bigger than 64bit
+        # so we use pydantic instead (still faster than python json)
+        return typing.cast(Json, pydantic_core.from_json(json, allow_inf_nan=False))
+    except ValueError as exception:
         raise JsonDecodeException(message=str(exception)) from exception

{kiba_core-0.5.3.dev59 → kiba_core-0.5.3.dev60}/kiba_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev59
+Version: 0.5.3.dev60
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev59 → kiba_core-0.5.3.dev60}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiba-core"
-version = "0.5.3.dev59"
+version = "0.5.3.dev60"
 description = "Kiba Labs' python utilities"
 readme = "README.md"
 requires-python = ">=3.12, <4"

{kiba_core-0.5.3.dev59 → kiba_core-0.5.3.dev60}/tests/util/test_json_util.py

@@ -1,3 +1,6 @@
+import datetime
+import math
+
 import pytest
 
 from core.util import json_util
@@ -154,9 +157,49 @@ class TestJsonUtil:
         assert isinstance(result, bytes)
         assert result == b'11111111111111111111111'
 
-    # NOTE(krishan711): not sure why this is failing
-    # def test_dumpb_and_loads_with_very_long_integer(self):
-    #     veryLongInteger = 11111111111111111111111
-    #     result = json_util.dumpb(obj=veryLongInteger)
-    #     assert isinstance(result, bytes)
-    #     assert int(json_util.loads(result)) == veryLongInteger
+    def test_dumpb_and_loads_with_very_long_integer(self):
+        veryLongInteger = 11111111111111111111111
+        result = json_util.dumpb(obj=veryLongInteger)
+        assert isinstance(result, bytes)
+        assert int(json_util.loads(result)) == veryLongInteger
+
+    def test_dumpb_with_very_long_integer_and_datetime(self):
+        veryLongInteger = 25000000000000000001
+        naiveDatetime = datetime.datetime.fromisoformat('2024-01-02T03:04:05.678901')
+        utcDatetime = datetime.datetime(2024, 1, 2, 3, 4, 5, 678901, tzinfo=datetime.UTC)
+        result = json_util.dumpb({
+            'balance': veryLongInteger,
+            'naive': naiveDatetime,
+            'utc': utcDatetime,
+        })
+        assert result == b'{"balance":25000000000000000001,"naive":"2024-01-02T03:04:05.678901","utc":"2024-01-02T03:04:05.678901Z"}'
+
+    def test_dumpb_with_utc_datetime_matches_pydantic_fallback(self):
+        utcDatetime = datetime.datetime(2024, 1, 2, 3, 4, 5, 678901, tzinfo=datetime.UTC)
+        assert json_util.dumpb(utcDatetime) == b'"2024-01-02T03:04:05.678901Z"'
+
+    def test_dumpb_with_very_long_integer_uses_pydantic_fallbacks(self):
+        veryLongInteger = 25000000000000000001
+
+        class TestObject:
+            def __str__(self):
+                return 'test-object'
+
+        result = json_util.dumpb({
+            'balance': veryLongInteger,
+            'unknown': TestObject(),
+            'not_a_number': math.nan,
+        })
+        assert result == b'{"balance":25000000000000000001,"unknown":"test-object","not_a_number":null}'
+
+    def test_loads_preserves_large_integer_type_and_precision(self):
+        value = 25000000000000000001
+        decoded = json_util.loads(str(value))
+        assert type(decoded) is int
+        assert decoded == value
+
+    def test_loads_preserves_nested_large_integer_type_and_precision(self):
+        value = 25000000000000000001
+        decoded = json_util.loads(f'{{"balance": {value}}}')
+        assert type(decoded['balance']) is int
+        assert decoded['balance'] == value