compressedfhir 1.0.6__tar.gz → 1.0.8__tar.gz

{compressedfhir-1.0.6/compressedfhir.egg-info → compressedfhir-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compressedfhir
-Version: 1.0.6
+Version: 1.0.8
 Summary: Stores FHIR JSON resources in compressed form in memory
 Home-page: https://github.com/icanbwell/compressed-fhir
 Author: Imran Qureshi

compressedfhir-1.0.8/VERSION

@@ -0,0 +1 @@
+1.0.8

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -429,6 +429,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         Returns the raw dictionary.  Deserializes if necessary.
         Note that this dictionary preserves the python types so it is not FHIR friendly.
+        For example, datetime will be represented as a datetime object instead of iso format string per FHIR.
         Use dict() if you want a FHIR friendly version.
 
         Returns:
@@ -437,12 +438,14 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         if self._working_dict:
             return self._working_dict
         else:
-            # if the working dict is not None, return it but don't store it in the self._working_dict to keep memory low
+            # if the working dict is None, create and return it but don't store it
+            # in the self._working_dict to keep memory low
             return self.create_working_dict()
 
     def dict(self) -> OrderedDict[K, V]:
         """
         Convert to a FHIR friendly dictionary where the python types like datetime are converted to string versions
+        For example, datetime will be represented as a iso format string per FHIR instead of a python datetime object.
 
         Returns:
             FHIR friendly dictionary
@@ -585,6 +588,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         # Create a new instance with the same storage mode
         new_instance = CompressedDict(
+            # we use raw_dict() instead of dict() so we can preserve python data types like datetime
             initial_dict=copy.deepcopy(self.raw_dict()),
             storage_mode=self._storage_mode,
             properties_to_cache=self._properties_to_cache,

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py

@@ -1,4 +1,4 @@
-from datetime import datetime, date
+from datetime import datetime, date, time
 from decimal import Decimal
 from typing import Type, Any, Dict, Optional
 import pytest
@@ -40,7 +40,22 @@ class TestCustomObject:
             {"__type__": "datetime", "iso": "2023-01-01T00:00:00+00:00"},
             datetime,
         ),
+        (
+            "datetime",
+            {
+                "__type__": "datetime",
+                "iso": "2023-01-01T00:00:00-08:00",
+                "tzinfo": "Pacific/Honolulu",
+            },
+            datetime,
+        ),
         ("date", {"__type__": "date", "iso": "2023-01-01"}, date),
+        ("time", {"__type__": "time", "iso": "14:30:15"}, time),
+        (
+            "time",
+            {"__type__": "time", "iso": "14:30:15", "tzinfo": "Pacific/Honolulu"},
+            time,
+        ),
         ("decimal", {"__type__": "decimal", "value": "3.14"}, Decimal),
         ("complex", {"__type__": "complex", "real": 3, "imag": 4}, complex),
         ("bytes", {"__type__": "bytes", "value": "test"}, bytes),

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/json_serializers/test/test_type_preservation_encoder.py

@@ -1,6 +1,9 @@
-from datetime import datetime, timezone, date
+import logging
+from datetime import datetime, timezone, date, time
 from decimal import Decimal
+from logging import Logger
 from typing import Type, Any
+from zoneinfo import ZoneInfo
 
 import pytest
 
@@ -24,7 +27,14 @@ class TestCustomObject:
     "input_type, input_value, expected_type",
     [
         (datetime, datetime(2023, 1, 1, tzinfo=timezone.utc), "datetime"),
+        (
+            datetime,
+            datetime(2023, 1, 1, tzinfo=ZoneInfo("Pacific/Honolulu")),
+            "datetime",
+        ),
         (date, date(2023, 1, 1), "date"),
+        (time, time(14, 30, 15), "time"),
+        (time, time(14, 30, 15, tzinfo=ZoneInfo("Pacific/Honolulu")), "time"),
         (Decimal, Decimal("3.14"), "decimal"),
         (complex, 3 + 4j, "complex"),
         (bytes, b"test", "bytes"),
@@ -37,9 +47,11 @@ def test_complex_type_serialization(
     """
     Test serialization of various complex types
     """
+    logger: Logger = logging.getLogger(__name__)
     encoder = TypePreservationEncoder()
     serialized = encoder.default(input_value)
 
+    logger.info(serialized)
     assert isinstance(serialized, dict)
     assert serialized.get("__type__") == expected_type
 

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py

@@ -1,9 +1,10 @@
 import logging
 from collections import OrderedDict
-from datetime import datetime, timezone, date
+from datetime import datetime, timezone, date, time
 from decimal import Decimal
 from logging import Logger
 from typing import Any
+from zoneinfo import ZoneInfo
 
 from compressedfhir.utilities.json_serializers.type_preservation_serializer import (
     TypePreservationSerializer,
@@ -26,8 +27,12 @@ def test_complex_data_serialization() -> None:
     Test serialization and deserialization of complex data
     """
     complex_data = {
+        "timestamp_no_tz": datetime.now(),
         "timestamp": datetime.now(timezone.utc),
+        "timestamp_pst": datetime.now(ZoneInfo("Pacific/Honolulu")),
         "today": date.today(),
+        "my_time": time(14, 30, 15),
+        "my_time_pst": time(14, 30, 15, tzinfo=ZoneInfo("Pacific/Honolulu")),
         "precise_value": Decimal("3.14159"),
         "complex_number": 3 + 4j,
         "byte_data": b"Hello",
@@ -42,13 +47,29 @@ def test_complex_data_serialization() -> None:
     deserialized = TypePreservationSerializer.deserialize(serialized)
 
     # Verify types
+    assert isinstance(deserialized, OrderedDict)
+    assert isinstance(deserialized["timestamp_no_tz"], datetime)
+    assert deserialized["timestamp_no_tz"] == complex_data["timestamp_no_tz"]
     assert isinstance(deserialized["timestamp"], datetime)
+    assert deserialized["timestamp"] == complex_data["timestamp"]
+    assert isinstance(deserialized["timestamp_pst"], datetime)
+    assert deserialized["timestamp_pst"] == complex_data["timestamp_pst"]
     assert isinstance(deserialized["today"], date)
+    assert deserialized["today"] == complex_data["today"]
+    assert isinstance(deserialized["my_time"], time)
+    assert deserialized["my_time"] == complex_data["my_time"]
+    assert isinstance(deserialized["my_time_pst"], time)
+    assert deserialized["my_time_pst"] == complex_data["my_time_pst"]
     assert isinstance(deserialized["precise_value"], Decimal)
+    assert deserialized["precise_value"] == complex_data["precise_value"]
     assert isinstance(deserialized["complex_number"], complex)
+    assert deserialized["complex_number"] == complex_data["complex_number"]
     assert isinstance(deserialized["byte_data"], bytes)
+    assert deserialized["byte_data"] == complex_data["byte_data"]
     assert isinstance(deserialized["unique_items"], set)
+    assert deserialized["unique_items"] == complex_data["unique_items"]
     assert isinstance(deserialized["custom_obj"], TestCustomObject)
+    assert deserialized["custom_obj"] == complex_data["custom_obj"]
 
 
 def test_nested_complex_data() -> None:

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/json_serializers/type_preservation_decoder.py

@@ -1,9 +1,10 @@
 import logging
 from collections import OrderedDict
-from datetime import datetime, date
+from datetime import datetime, date, time
 from decimal import Decimal
 from logging import Logger
 from typing import Any, Dict, Callable, Optional, Union, cast, List
+from zoneinfo import ZoneInfo
 
 
 class TypePreservationDecoder:
@@ -46,9 +47,33 @@ class TypePreservationDecoder:
                 return date.fromisoformat(d["iso"])
             return cast(date, d)
 
+        def time_decoder(d: Union[str, Dict[str, Any]]) -> time:
+            if isinstance(d, str):
+                return time.fromisoformat(d)
+            elif isinstance(d, dict) and "iso" in d:
+                # Extract ISO time string
+                iso_time: str = d["iso"]
+
+                # Parse time from ISO format
+                parsed_time = time.fromisoformat(iso_time)
+
+                # Add timezone if specified
+                tz_info = d.get("tzinfo")
+                if tz_info:
+                    try:
+                        tz_aware_time = parsed_time.replace(tzinfo=ZoneInfo(tz_info))
+                        return tz_aware_time
+                    except Exception as e:
+                        raise ValueError(f"Invalid timezone: {tz_info}") from e
+                else:
+                    # If no timezone info, return naive time
+                    return parsed_time
+            return cast(time, d)
+
         default_decoders: Dict[str, Callable[[Any], Any]] = {
             "datetime": datetime_decoder,
             "date": date_decoder,
+            "time": time_decoder,
             "decimal": lambda d: Decimal(d["value"] if isinstance(d, dict) else d),
             "complex": lambda d: complex(d["real"], d["imag"])
             if isinstance(d, dict)

{compressedfhir-1.0.6 → compressedfhir-1.0.8}/compressedfhir/utilities/json_serializers/type_preservation_encoder.py

@@ -1,6 +1,6 @@
 import json
 from collections.abc import Callable
-from datetime import datetime, date
+from datetime import datetime, date, time
 from decimal import Decimal
 from typing import Any, Dict, Type
 
@@ -17,6 +17,11 @@ class TypePreservationEncoder(json.JSONEncoder):
             "tzinfo": str(dt.tzinfo) if dt.tzinfo else None,
         },
         date: lambda d: {"__type__": "date", "iso": d.isoformat()},
+        time: lambda t: {
+            "__type__": "time",
+            "iso": t.isoformat(),
+            "tzinfo": str(t.tzinfo) if t.tzinfo else None,
+        },
         Decimal: lambda d: {"__type__": "decimal", "value": str(d)},
         complex: lambda c: {"__type__": "complex", "real": c.real, "imag": c.imag},
         bytes: lambda b: {"__type__": "bytes", "value": b.decode("latin-1")},

{compressedfhir-1.0.6 → compressedfhir-1.0.8/compressedfhir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compressedfhir
-Version: 1.0.6
+Version: 1.0.8
 Summary: Stores FHIR JSON resources in compressed form in memory
 Home-page: https://github.com/icanbwell/compressed-fhir
 Author: Imran Qureshi

compressedfhir-1.0.6/VERSION

@@ -1 +0,0 @@
-1.0.6