fix multiple json profiles

Author: aragentum

src/gino/crud.py

@@ -222,7 +222,10 @@ def update(self, **values):
                 k = key
             if not isinstance(value, ClauseElement):
                 setattr(self._instance, key, value)
-                value = getattr(self._instance, value_from)[key]
+                if isinstance(prop, json_support.JSONProperty):
+                    value = prop.get_profile(self._instance)[key]
+                else:
+                    value = getattr(self._instance, value_from)[key]
             method(k, value)
         return self
 
@@ -448,7 +451,10 @@ async def _create(self, bind=None, timeout=DEFAULT):
         cls = type(self)
         # noinspection PyUnresolvedReferences,PyProtectedMember
         cls._check_abstract()
-        profile_keys = set(self.__profile__.keys() if self.__profile__ else [])
+        if self.__profile__:
+            profile_keys = set([k for v in self.__profile__.values() for k in v.keys()])
+        else:
+            profile_keys = []
         for key in profile_keys:
             cls.__dict__.get(key).save(self)
         # initialize default values

src/gino/json_support.py

@@ -52,8 +52,11 @@ def __delete__(self, instance):
 
     def get_profile(self, instance):
         if instance.__profile__ is None:
-            props = type(instance).__dict__
             instance.__profile__ = {}
+        if instance.__profile__.get(self.prop_name, None) is None:
+            props = type(instance).__dict__
+            current_profile = {}
+            instance.__profile__[self.prop_name] = current_profile
             for key, value in (getattr(instance, self.prop_name, None) or {}).items():
                 if key not in props:
                     raise UnknownJSONPropertyError(
@@ -70,17 +73,16 @@ def get_profile(self, instance):
                             key, self.prop_name, instance, key
                         )
                     )
-                instance.__profile__[key] = prop.decode(value)
-
-        return instance.__profile__
+                current_profile[key] = prop.decode(value)
+        return instance.__profile__.get(self.prop_name)
 
     def save(self, instance, value=NONE):
         profile = getattr(instance, self.prop_name, None)
         if profile is None:
             profile = {}
             setattr(instance, self.prop_name, profile)
         if value is NONE:
-            value = instance.__profile__[self.name]
+            value = self.get_profile(instance)[self.name]
         if not isinstance(value, sa.sql.ClauseElement):
             value = self.encode(value)
         rv = profile[self.name] = value
@@ -92,9 +94,9 @@ def reload(self, instance):
         profile = getattr(instance, self.prop_name, None) or {}
         value = profile.get(self.name, NONE)
         if value is NONE:
-            instance.__profile__.pop(self.name, None)
+            self.get_profile(instance).pop(self.name, None)
         else:
-            instance.__profile__[self.name] = self.decode(value)
+            self.get_profile(instance)[self.name] = self.decode(value)
 
     def make_expression(self, base_exp):
         return base_exp

tests/models.py

@@ -39,12 +39,16 @@ class User(db.Model):
     id = db.Column(db.BigInteger(), primary_key=True)
     nickname = db.Column("name", db.Unicode(), default=_random_name)
     profile = db.Column("props", JSONB(), nullable=False, server_default="{}")
+    parameter = db.Column("params", JSONB(), nullable=False, server_default="{}")
     type = db.Column(db.Enum(UserType), nullable=False, default=UserType.USER,)
     realname = db.StringProperty()
     age = db.IntegerProperty(default=18)
     balance = db.IntegerProperty(default=0)
     birthday = db.DateTimeProperty(default=lambda i: datetime.utcfromtimestamp(0))
     team_id = db.Column(db.ForeignKey("gino_teams.id"))
+    weight = db.IntegerProperty(prop_name='parameter')
+    height = db.IntegerProperty(default=170, prop_name='parameter')
+    bio = db.StringProperty(prop_name='parameter')
 
     @balance.after_get
     def balance(self, val):

tests/test_json.py

@@ -14,6 +14,7 @@ async def test_in_memory():
     u.age += 10
     assert u.age == 28
     assert u.balance == 0
+    assert u.height == 170
     assert isinstance(u.balance, float)
 
 
@@ -23,12 +24,13 @@ async def test_crud(bind):
 
     now = datetime.utcnow()
     now_str = now.strftime(DATETIME_FORMAT)
-    u = await User.create(nickname="fantix", birthday=now)
+    u = await User.create(nickname="fantix", birthday=now, bio="I code in Python and more.")
     u.age += 1
     assert await u.query.gino.model(None).first() == (
         1,
         "fantix",
         {"age": 18, "birthday": now_str},
+        {"bio": "I code in Python and more.", "height": 170},
         UserType.USER,
         None,
     )
@@ -38,23 +40,27 @@ async def test_crud(bind):
     assert u.birthday == now
     assert u.age == 18
     assert u.balance == 0
+    assert u.height == 170
+    assert u.bio == "I code in Python and more."
     assert isinstance(u.balance, float)
     assert await db.select([User.birthday]).where(User.id == u.id).gino.scalar() == now
 
     # In-memory update, not applying
     u.update(birthday=now - timedelta(days=3650))
 
     # Update two JSON fields, one using expression
-    await u.update(age=User.age - 2, balance=100.85).apply()
+    await u.update(age=User.age - 2, balance=100.85, height=180).apply()
 
     assert u.birthday == now - timedelta(days=3650)
     assert u.age == 16
     assert u.balance == 100
+    assert u.height == 180
     assert isinstance(u.balance, float)
     assert await u.query.gino.model(None).first() == (
         1,
         "fantix",
         dict(age=16, balance=100, birthday=now_str),
+        dict(bio="I code in Python and more.", height=180),
         UserType.USER,
         None,
     )
@@ -63,12 +69,14 @@ async def test_crud(bind):
     # Reload and test updating both JSON and regular property
     u = await User.get(u.id)
     await u.update(
-        age=User.age - 2, balance=200.15, realname="daisy", nickname="daisy.nick"
+        age=User.age - 2, balance=200.15, realname="daisy", nickname="daisy.nick", height=185, weight=75
     ).apply()
+    data = await u.query.gino.model(None).first()
     assert await u.query.gino.model(None).first() == (
         1,
         "daisy.nick",
         dict(age=14, balance=200, realname="daisy", birthday=now_str),
+        dict(bio="I code in Python and more.", height=185, weight=75),
         UserType.USER,
         None,
     )
@@ -81,6 +89,9 @@ async def test_crud(bind):
         realname="daisy",
         type=UserType.USER,
         team_id=None,
+        bio="I code in Python and more.",
+        height=185,
+        weight=75
     )
 
     # Deleting property doesn't affect database
@@ -130,12 +141,16 @@ class News(db.Model):
 # noinspection PyUnusedLocal
 async def test_reload(bind):
     u = await User.create()
-    await u.update(realname=db.cast("888", db.Unicode)).apply()
+    await u.update(realname=db.cast("888", db.Unicode), weight=75).apply()
     assert u.realname == "888"
-    await u.update(profile=None).apply()
+    assert u.weight == 75
+    await u.update(profile=None, parameter=None).apply()
     assert u.realname == "888"
+    assert u.weight == 75
     User.__dict__["realname"].reload(u)
+    User.__dict__["weight"].reload(u)
     assert u.realname is None
+    assert u.weight is None
 
 
 # noinspection PyUnusedLocal
@@ -151,29 +166,60 @@ class PropsTest(db.Model):
         obj = db.ObjectProperty()
         arr = db.ArrayProperty()
 
+        parameter = db.Column(JSONB(), nullable=False, server_default="{}")
+
+        raw_param = db.JSONProperty(prop_name='parameter')
+        bool_param = db.BooleanProperty(prop_name='parameter')
+        obj_param = db.ObjectProperty(prop_name='parameter')
+        arr_param = db.ArrayProperty(prop_name='parameter')
+
     await PropsTest.gino.create()
     try:
         t = await PropsTest.create(
-            raw=dict(a=[1, 2]), bool=True, obj=dict(x=1, y=2), arr=[3, 4, 5, 6],
+            raw=dict(a=[1, 2]),
+            bool=True,
+            obj=dict(x=1, y=2),
+            arr=[3, 4, 5, 6],
+
+            raw_param=dict(a=[3, 4]),
+            bool_param=False,
+            obj_param=dict(x=3, y=4),
+            arr_param=[7, 8, 9, 10],
         )
         assert t.obj["x"] == 1
+        assert t.obj_param["x"] == 3
         assert t.arr[-1] == 6
+        assert t.arr_param[-1] == 10
+        data = await db.select(
+            [PropsTest.profile, PropsTest.parameter, PropsTest.raw, PropsTest.bool, PropsTest.obj_param]
+        ).gino.first()
         assert await db.select(
-            [PropsTest.profile, PropsTest.raw, PropsTest.bool,]
+            [PropsTest.profile, PropsTest.parameter, PropsTest.raw, PropsTest.bool, PropsTest.obj_param]
         ).gino.first() == (
             {
                 "arr": [3, 4, 5, 6],
                 "obj": {"x": 1, "y": 2},
                 "raw": {"a": [1, 2]},
                 "bool": True,
             },
+            {
+                "arr_param": [7, 8, 9, 10],
+                "obj_param": {"x": 3, "y": 4},
+                "raw_param": {"a": [3, 4]},
+                "bool_param": False,
+            },
             dict(a=[1, 2]),
             True,
+            dict(x=3, y=4),
         )
         t.obj = dict(x=10, y=20)
+        t.obj_param = dict(x=30, y=45)
         assert t.obj["x"] == 10
+        assert t.obj_param["y"] == 45
         t.arr = [4, 5, 6, 7]
+        t.arr_param = [11, 12, 13, 14, 15]
         assert t.arr[-1] == 7
+        assert t.arr_param[-1] == 15
     finally:
         await PropsTest.gino.drop()