Merge branch 'decimal128field' of github.com:jschlyter/mongoengine into clone_jschlyter_decimal128

Author: bagerard

mongoengine/fields.py

@@ -12,6 +12,7 @@
 import gridfs
 import pymongo
 from bson import SON, Binary, DBRef, ObjectId
+from bson.decimal128 import Decimal128, create_decimal128_context
 from bson.int64 import Int64
 from pymongo import ReturnDocument
 
@@ -95,6 +96,7 @@
     "MultiLineStringField",
     "MultiPolygonField",
     "GeoJsonBaseField",
+    "Decimal128Field",
 )
 
 RECURSIVE_REFERENCE_CONSTANT = "self"
@@ -2650,3 +2652,51 @@ def to_mongo(self, document):
             )
         else:
             return super().to_mongo(document)
+
+
+class Decimal128Field(BaseField):
+
+    DECIMAL_CONTEXT = create_decimal128_context()
+
+    def __init__(self, min_value=None, max_value=None, **kwargs):
+        self.min_value = min_value
+        self.max_value = max_value
+        super().__init__(**kwargs)
+
+    """
+        128-bit decimal-based floating-point field capable of emulating decimal
+        rounding with exact precision. Stores the value as a `Decimal128`
+        intended for monetary data, such as financial, tax, and scientific
+        computations.
+    """
+
+    def to_mongo(self, value):
+        if value is None:
+            return None
+        if isinstance(value, Decimal128):
+            return value
+        if not isinstance(value, decimal.Decimal):
+            with decimal.localcontext(self.DECIMAL_CONTEXT) as ctx:
+                value = ctx.create_decimal(value)
+        return Decimal128(value)
+
+    def to_python(self, value):
+        if value is None:
+            return None
+        return self.to_mongo(value).to_decimal()
+
+    def validate(self, value):
+        if not isinstance(value, Decimal128):
+            try:
+                value = Decimal128(value)
+            except (TypeError, ValueError, decimal.InvalidOperation) as exc:
+                self.error("Could not convert value to Decimal128: %s" % exc)
+
+        if self.min_value is not None and value.to_decimal() < self.min_value:
+            self.error("Decimal value is too small")
+
+        if self.max_value is not None and value.to_decimal() > self.max_value:
+            self.error("Decimal value is too large")
+
+    def prepare_query_value(self, op, value):
+        return super().prepare_query_value(op, self.to_mongo(value))

tests/fields/test_decimal128_field.py

@@ -0,0 +1,131 @@
+import json
+import random
+from decimal import Decimal
+
+import pytest
+from bson.decimal128 import Decimal128
+
+from mongoengine import *
+from tests.utils import MongoDBTestCase, get_as_pymongo
+
+
+class Decimal128Document(Document):
+    dec128_fld = Decimal128Field()
+    dec128_min_0 = Decimal128Field(min_value=0)
+    dec128_max_100 = Decimal128Field(max_value=100)
+
+
+def generate_test_cls() -> Document:
+    Decimal128Document.drop_collection()
+    Decimal128Document(dec128_fld=None).save()
+    Decimal128Document(dec128_fld=Decimal(1)).save()
+    return Decimal128Document
+
+
+class TestDecimal128Field(MongoDBTestCase):
+    def test_decimal128_validation_good(self):
+        """Ensure that invalid values cannot be assigned."""
+
+        doc = Decimal128Document()
+
+        doc.dec128_fld = Decimal(0)
+        doc.validate()
+
+        doc.dec128_fld = Decimal(50)
+        doc.validate()
+
+        doc.dec128_fld = Decimal(110)
+        doc.validate()
+
+        doc.dec128_fld = Decimal(110)
+        doc.validate()
+
+    def test_decimal128_validation_invalid(self):
+        """Ensure that invalid values cannot be assigned."""
+
+        doc = Decimal128Document()
+
+        doc.dec128_fld = "ten"
+
+        with pytest.raises(ValidationError):
+            doc.validate()
+
+    def test_decimal128_validation_min(self):
+        """Ensure that out of bounds values cannot be assigned."""
+
+        doc = Decimal128Document()
+
+        doc.dec128_min_0 = Decimal(50)
+        doc.validate()
+
+        doc.dec128_min_0 = Decimal(-1)
+        with pytest.raises(ValidationError):
+            doc.validate()
+
+    def test_decimal128_validation_max(self):
+        """Ensure that out of bounds values cannot be assigned."""
+
+        doc = Decimal128Document()
+
+        doc.dec128_max_100 = Decimal(50)
+        doc.validate()
+
+        doc.dec128_max_100 = Decimal(101)
+        with pytest.raises(ValidationError):
+            doc.validate()
+
+    def test_eq_operator(self):
+        cls = generate_test_cls()
+        assert 1 == cls.objects(dec128_fld=1.0).count()
+        assert 0 == cls.objects(dec128_fld=2.0).count()
+
+    def test_ne_operator(self):
+        cls = generate_test_cls()
+        assert 1 == cls.objects(dec128_fld__ne=None).count()
+        assert 1 == cls.objects(dec128_fld__ne=1).count()
+        assert 1 == cls.objects(dec128_fld__ne=1.0).count()
+
+    def test_gt_operator(self):
+        cls = generate_test_cls()
+        assert 1 == cls.objects(dec128_fld__gt=0.5).count()
+
+    def test_lt_operator(self):
+        cls = generate_test_cls()
+        assert 1 == cls.objects(dec128_fld__lt=1.5).count()
+
+    def test_storage(self):
+        # from int
+        model = Decimal128Document(dec128_fld=100).save()
+        assert get_as_pymongo(model) == {
+            "_id": model.id,
+            "dec128_fld": Decimal128("100"),
+        }
+
+        # from float
+        model = Decimal128Document(dec128_fld=100.0).save()
+        assert get_as_pymongo(model) == {
+            "_id": model.id,
+            "dec128_fld": Decimal128("100"),
+        }
+
+        # from Decimal
+        model = Decimal128Document(dec128_fld=Decimal(100)).save()
+        assert get_as_pymongo(model) == {
+            "_id": model.id,
+            "dec128_fld": Decimal128("100"),
+        }
+
+        # from Decimal128
+        model = Decimal128Document(dec128_fld=Decimal128("100")).save()
+        assert get_as_pymongo(model) == {
+            "_id": model.id,
+            "dec128_fld": Decimal128("100"),
+        }
+
+    def test_json(self):
+        Decimal128Document.drop_collection()
+        f = str(random.random())
+        Decimal128Document(dec128_fld=f).save()
+        json_str = Decimal128Document.objects.to_json()
+        array = json.loads(json_str)
+        assert array[0]["dec128_fld"] == {"$numberDecimal": str(f)}