small improvements and handle mod_enum actions

Author: Jeroen van der Heijden

README.md

@@ -657,19 +657,9 @@ When adding a new brick, for example using the following code:
             color value: #f00
 ```
 
-If you do not care about having defined the `Color` class, then you can drop this class and change the
-color specification to the plain string `"Enum"`. For example:
+If you do not care about the whole `Color` class, then you can just create an empty class like this:
 
 ```python
-class Brick(Thing):
-    color = 'Enum'
-
-    def on_init(self, *args, **kwars):
-        super().on_init(*args, **kwars)
-        print(f'''
-        Init Brick:
-            id: {self.id()}
-            color name: {self.color.name}
-            color value: {self.color.value}
-        ''')
+class Color(Enum):
+    pass
 ```

thingsdb/model/collection.py

@@ -6,6 +6,7 @@
 from .eventhandler import EventHandler
 from .thing import Thing
 from .enum import Enum
+from .prop import Prop
 
 
 class Collection(Thing):
@@ -24,6 +25,9 @@ def __init__(self, name=None):
         self._id = None
         self._types = {}  # mapping where keys are type_id
         self._enums = {}  # mapping where keys are enum_id
+        self._conv_any = Prop.get_conv('any', klass=Thing, collection=self)
+        self._conv_thing = Prop.get_conv('thing', klass=Thing, collection=self)
+
         for p in self._props.values():
             p.unpack(self)
 
@@ -138,16 +142,42 @@ def _set_procedure(self, data):
     def _update_type(self, data):
         self._types[data['type_id']] = tuple(k[0] for k in data['fields'])
 
-    def _update_type_add(self, data):
+    def _upd_type_add(self, data):
         self._types[data['type_id']] += data['name'],
 
-    def _update_type_del(self, data):
+    def _upd_type_del(self, data):
         type_id, name = data['type_id'], data['name']
         t = self._types[type_id]
-        self._types[type_id] = tuple(p for p in t if p != name)
+        idx = t.index(name)
+        t = list(t)
+        try:
+            t[idx] = t.pop()  # swap remove
+        except IndexError:
+            pass
+        self._types[type_id] = tuple(t)
+
+    def _upd_type_ren(self, data):
+        type_id, name, to = data['type_id'], data['name'], data['to']
+        t = self._types[type_id]
+        idx = t.index(name)
+        t = list(t)
+        t[idx] = to
+        self._types[type_id] = tuple(t)
 
     def _update_enum(self, data):
-        Enum._update_enum(self._enums, data)
+        Enum._update_enum(self._enums, data, convert=self._conv_any)
+
+    def _upd_enum_add(self, data):
+        Enum._upd_enum_add(self._enums, data, convert=self._conv_any)
+
+    def _upd_enum_del(self, data):
+        Enum._upd_enum_del(self._enums, data)
+
+    def _upd_enum_mod(self, data):
+        Enum._upd_enum_mod(self._enums, data, convert=self._conv_any)
+
+    def _upd_enum_ren(self, data):
+        Enum._upd_enum_ren(self._enums, data)
 
     def _get_enum_member(self, enum_id, idx):
         enum = self._enums[enum_id]

thingsdb/model/enum.py

@@ -20,9 +20,9 @@ def __init_subclass__(cls, **kwargs):
         _enums_lookup[cls._name] = cls
 
     @staticmethod
-    def _update_enum(enums, data):
+    def _update_enum(enums, data, convert):
         name = data['name']
-        members = tuple(Member(name, k, v) for k, v in data['members'])
+        members = [Member(name, k, convert(v)) for k, v in data['members']]
 
         enum = _enums_lookup.get(name)
         if enum is not None:
@@ -32,6 +32,53 @@ def _update_enum(enums, data):
 
         enums[data['enum_id']] = members
 
+    @staticmethod
+    def _upd_enum_add(enums, data, convert):
+        members = enums[data['enum_id']]
+        name = members[0]._enum_name
+        member = Member(name, data['name'], convert(data['value']))
+        members.append(member)
+
+        enum = _enums_lookup.get(name)
+        if enum is not None:
+            setattr(enum, member.name, member)
+
+    @staticmethod
+    def _upd_enum_del(enums, data):
+        members = enums[data['enum_id']]
+        name = members[0]._enum_name
+
+        enum = _enums_lookup.get(name)
+        if enum is not None:
+            member = members[data['index']]
+            delattr(enum, member.name)
+
+        try:
+            # swap remove the index
+            members[data['index']] = members.pop()
+        except IndexError:
+            pass
+
+    @staticmethod
+    def _upd_enum_mod(enums, data, convert):
+        members = enums[data['enum_id']]
+        name = members[0]._enum_name
+        member = members[data['index']]
+        member._value = convert(data['value'])
+
+    @staticmethod
+    def _upd_enum_ren(enums, data):
+        members = enums[data['enum_id']]
+        name = members[0]._enum_name
+        member = members[data['index']]
+
+        enum = _enums_lookup.get(name)
+        if enum is not None:
+            delattr(enum, member.name)
+            setattr(enum, data['name'], member)
+
+        member._name = data['name']
+
     @classmethod
     async def _new_type(cls, client, collection):
         if cls._visited > 0:

thingsdb/model/prop.py

@@ -72,12 +72,9 @@ def unpack(self, collection):
         if spec == 'Thing' and cb_type is None:
             spec, kwargs['watch'] = 'thing', True
 
-        if spec == 'Enum' and cb_type is None:
-            self.vconv = self.get_conv('enum', collection=collection)
-        else:
-            self.vconv = self.get_conv(
-                spec, is_nillable, **kwargs
-                if spec == 'any' or spec == 'thing' else {})
+        self.vconv = self.get_conv(
+            spec, is_nillable, **kwargs
+            if spec == 'any' or spec == 'thing' else {})
 
         if self.vconv is None:
             assert callable(cb_type), \

thingsdb/model/thing.py

@@ -44,18 +44,13 @@ class Thing(ThingHash):
     __AS_TYPE__ = True
 
     _props = dict()
-    _any = None
-    _thing = None
     _type_name = None  # Only set when __AS_TYPE__ is True
     _visited = 0  # For build, 0=not visited, 1=new_type, 2=set_type, 3=build
 
     def __init__(self, collection, id: int):
         super().__init__(id)
-        cls = self.__class__
         self._event_id = 0
         self._collection = collection
-        cls._any = Prop.get_conv('any', klass=Thing, collection=collection)
-        cls._thing = Prop.get_conv('thing', klass=Thing, collection=collection)
         collection._register(self)
 
     def __init_subclass__(cls):
@@ -134,7 +129,7 @@ def _job_add(self, pair):
                 f'while the property is of type `{type(set_)}`')
             return
 
-        convert = prop.nconv if prop else cls._thing
+        convert = prop.nconv if prop else self.collection._conv_thing
         try:
             set_.update((convert(item) for item in v))
         except Exception as e:
@@ -177,14 +172,16 @@ def _job_remove(self, pair):
 
     def _job_set(self, pairs):
         cls = self.__class__
+
         for k, v in pairs.items():
             prop = cls._props.get(k)
             if prop:
                 convert = prop.vconv
             elif cls.__STRICT__:
                 continue
             else:
-                convert = cls._any(v)
+                convert = self.collection._conv_any
+
             try:
                 v = convert(v)
             except Exception as e:
@@ -219,7 +216,7 @@ def _job_splice(self, pair):
             return
 
         index, count, *items = v
-        convert = prop.nconv if prop else cls._any
+        convert = prop.nconv if prop else self.collection._conv_any
         try:
             arr[index:index+count] = (convert(item) for item in items)
         except (TypeError, ValueError) as e:
@@ -235,15 +232,27 @@ def _job_del_type(self, data):
         pass
 
     def _job_mod_type_add(self, data):
-        self._collection._update_type_add(data)
+        self._collection._upd_type_add(data)
 
     def _job_mod_type_del(self, data):
-        self._collection._update_type_del(data)
+        self._collection._upd_type_del(data)
 
     def _job_mod_type_mod(self, data):
         # we do not care about the specification so simply ignore this event
         pass
 
+    def _job_mod_enum_add(self, data):
+        self._collection._upd_enum_add(data)
+
+    def _job_mod_enum_del(self, data):
+        self._collection._upd_enum_del(data)
+
+    def _job_mod_enum_mod(self, data):
+        self._collection._upd_enum_mod(data)
+
+    def _job_mod_enum_ren(self, data):
+        self._collection._upd_enum_ren(data)
+
     def _job_new_procedure(self, data):
         self._collection._set_procedure(data)
 
@@ -268,6 +277,10 @@ def _job_set_type(self, data):
         'mod_type_add': _job_mod_type_add,
         'mod_type_del': _job_mod_type_del,
         'mod_type_mod': _job_mod_type_mod,
+        'mod_enum_add': _job_mod_enum_add,
+        'mod_enum_del': _job_mod_enum_del,
+        'mod_enum_mod': _job_mod_enum_mod,
+        'mod_enum_ren': _job_mod_enum_ren,
         'new_procedure': _job_new_procedure,
         'new_type': _job_new_type,
         'set_type': _job_set_type,

thingsdb/version.py

@@ -1 +1 @@
-__version__ = '0.6.0'
+__version__ = '0.6.1'