entity helper: prefix all functions/attributes with underscore #29

Author: dan-obx

objectbox/box.py

@@ -27,7 +27,7 @@ def __init__(self, store: Store, entity: _Entity):
 
         self._store = store 
         self._entity = entity
-        self._c_box = obx_box(store._c_store, entity.id)
+        self._c_box = obx_box(store._c_store, entity._id)
 
     def is_empty(self) -> bool:
         is_empty = ctypes.c_bool()
@@ -50,16 +50,16 @@ def put(self, *objects):
             return self._put_one(objects[0])
 
     def _put_one(self, obj) -> int:
-        id = object_id = self._entity.get_object_id(obj)
+        id = object_id = self._entity._get_object_id(obj)
 
         if not id:
             id = obx_box_id_for_put(self._c_box, 0)
 
-        data = self._entity.marshal(obj, id)
+        data = self._entity._marshal(obj, id)
         obx_box_put(self._c_box, id, bytes(data), len(data))
 
         if id != object_id:
-            self._entity.set_object_id(obj, id)
+            self._entity._set_object_id(obj, id)
 
         return id
 
@@ -68,7 +68,7 @@ def _put_many(self, objects) -> None:
         new = {}
         ids = {}
         for k in range(len(objects)):
-            id = self._entity.get_object_id(objects[k])
+            id = self._entity._get_object_id(objects[k])
             if not id:
                 new[k] = 0
             ids[k] = id
@@ -90,7 +90,7 @@ def _put_many(self, objects) -> None:
             # we need to keep the data around until put_many is executed because obx_bytes_array_set doesn't do a copy
             data = {}
             for k in range(len(objects)):
-                data[k] = bytes(self._entity.marshal(objects[k], ids[k]))
+                data[k] = bytes(self._entity._marshal(objects[k], ids[k]))
                 key = ctypes.c_size_t(k)
 
                 # OBX_bytes_array.data[k] = data
@@ -106,7 +106,7 @@ def _put_many(self, objects) -> None:
 
         # assign new IDs on the object
         for k in new.keys():
-            self._entity.set_object_id(objects[k], ids[k])
+            self._entity._set_object_id(objects[k], ids[k])
 
     def get(self, id: int):
         with self._store.read_tx():
@@ -119,7 +119,7 @@ def get(self, id: int):
             elif code != 0:
                 raise CoreException(code)
             data = c_voidp_as_bytes(c_data, c_size.value)
-            return self._entity.unmarshal(data)
+            return self._entity._unmarshal(data)
 
     def get_all(self) -> list:
         with self._store.read_tx():
@@ -135,15 +135,15 @@ def get_all(self) -> list:
                     # OBX_bytes
                     c_bytes = c_bytes_array.data[i]
                     data = c_voidp_as_bytes(c_bytes.data, c_bytes.size)
-                    result.append(self._entity.unmarshal(data))
+                    result.append(self._entity._unmarshal(data))
 
                 return result
             finally:
                 obx_bytes_array_free(c_bytes_array_p)
 
     def remove(self, id_or_object) -> bool:
-        if isinstance(id_or_object, self._entity.user_type):
-            id = self._entity.get_object_id(id_or_object)
+        if isinstance(id_or_object, self._entity._user_type):
+            id = self._entity._get_object_id(id_or_object)
         else:
             id = id_or_object
         code : obx_err = obx_box_remove(self._c_box, id)

objectbox/model/entity.py

@@ -31,37 +31,37 @@
 # _Entity class holds model information as well as conversions between python objects and FlatBuffers (ObjectBox data)
 class _Entity(object):
     def __init__(self, user_type, uid: int = 0):
-        self.user_type = user_type
-        self.iduid = IdUid(0, uid)
+        self._user_type = user_type
+        self._iduid = IdUid(0, uid)
         self._name = user_type.__name__
-        self.last_property_iduid = IdUid(0, 0)
+        self._last_property_iduid = IdUid(0, 0)
 
-        self.properties: List[Property] = list()  # List[Property]
-        self.offset_properties = list()  # List[Property]
-        self.id_property = None
-        self.fill_properties()
+        self._properties: List[Property] = list()  # List[Property]
+        self._offset_properties = list()  # List[Property]
+        self._id_property = None
+        self._fill_properties()
         self._tl = threading.local()
 
     @property
-    def id(self) -> int:
-        return self.iduid.id
+    def _id(self) -> int:
+        return self._iduid.id
 
     @property
-    def uid(self) -> int:
-        return self.iduid.uid
+    def _uid(self) -> int:
+        return self._iduid.uid
 
-    def has_uid(self) -> bool:
-        return self.iduid.uid != 0
+    def _has_uid(self) -> bool:
+        return self._iduid.uid != 0
 
-    def on_sync(self):
+    def _on_sync(self):
         """ Method called once ID/UID are synced with the model file. """
-        assert self.iduid.is_assigned()
-        for prop in self.properties:
+        assert self._iduid.is_assigned()
+        for prop in self._properties:
             prop.on_sync()
 
     def __call__(self, **properties):
         """ The constructor of the user Entity class. """
-        object_ = self.user_type()
+        object_ = self._user_type()
         for prop_name, prop_val in properties.items():
             if not hasattr(object_, prop_name):
                 raise Exception(f"Entity {self._name} has no property \"{prop_name}\"")
@@ -70,27 +70,27 @@ def __call__(self, **properties):
 
     def __getattr__(self, name):
         """ Overload to get properties via "<Entity>.<Prop>" notation. """
-        for prop in self.properties:
-            if prop._name == name:
+        for prop in self._properties:
+            if prop.name == name:
                 return prop
         return self.__getattribute__(name)     
 
-    def fill_properties(self):
+    def _fill_properties(self):
         # TODO allow subclassing and support entities with __slots__ defined
-        variables = dict(vars(self.user_type))
+        variables = dict(vars(self._user_type))
 
         # filter only subclasses of Property
         variables = {k: v for k, v in variables.items(
         ) if issubclass(type(v), Property)}
 
         for prop_name, prop in variables.items():
             prop.name = prop_name
-            self.properties.append(prop)
+            self._properties.append(prop)
 
             if prop.is_id():
-                if self.id_property:
-                    raise Exception(f"Duplicate ID property: \"{self.id_property.name}\" and \"{prop.name}\"")
-                self.id_property = prop
+                if self._id_property:
+                    raise Exception(f"Duplicate ID property: \"{self._id_property.name}\" and \"{prop.name}\"")
+                self._id_property = prop
 
             if prop._fb_type == flatbuffers.number_types.UOffsetTFlags:
                 assert prop._ob_type in [
@@ -105,34 +105,34 @@ def fill_properties(self):
                     OBXPropertyType_DoubleVector,
                     OBXPropertyType_Flex,
                 ], "programming error - invalid type OB & FB type combination"
-                self.offset_properties.append(prop)
+                self._offset_properties.append(prop)
 
-            # print('Property {}.{}: {} (ob:{} fb:{})'.format(self.name, prop.name, prop._py_type, prop._ob_type, prop._fb_type))
+            # print('Property {}.{}: {} (ob:{} fb:{})'.format(self._name, prop.name, prop._py_type, prop._ob_type, prop._fb_type))
 
-        if not self.id_property:
+        if not self._id_property:
             raise Exception("ID property is not defined")
-        elif self.id_property._ob_type != OBXPropertyType_Long:
+        elif self._id_property._ob_type != OBXPropertyType_Long:
             raise Exception("ID property must be an int")
 
-    def get_property(self, name: str):
+    def _get_property(self, name: str):
         """ Gets the property having the given name. """
-        for prop in self.properties:
+        for prop in self._properties:
             if prop.name == name:
                 return prop
         raise Exception(f"Property \"{name}\" not found in Entity: \"{self._name}\"")
 
-    def get_property_id(self, prop: Union[int, str, Property]) -> int:
+    def _get_property_id(self, prop: Union[int, str, Property]) -> int:
         """ A convenient way to get the property ID regardless having its ID, name or Property. """
         if isinstance(prop, int):
             return prop  # We already have it!
         elif isinstance(prop, str):
-            return self.get_property(prop).id
+            return self._get_property(prop).id
         elif isinstance(prop, Property):
             return prop.id
         else:
             raise Exception(f"Unsupported Property type: {type(prop)}")
 
-    def get_value(self, object, prop: Property):
+    def _get_value(self, object, prop: Property):
         # in case value is not overwritten on the object, it's the Property object itself (= as defined in the Class)
         val = getattr(object, prop.name)
         if prop._py_type == np.ndarray:
@@ -147,22 +147,22 @@ def get_value(self, object, prop: Property):
                 return prop._py_type()  # default (empty) value for the given type
         return val
 
-    def get_object_id(self, obj) -> int:
-        return self.get_value(obj, self.id_property)
+    def _get_object_id(self, obj) -> int:
+        return self._get_value(obj, self._id_property)
 
-    def set_object_id(self, obj, id_: int):
-        setattr(obj, self.id_property.name, id_)
+    def _set_object_id(self, obj, id_: int):
+        setattr(obj, self._id_property.name, id_)
 
-    def marshal(self, object, id: int) -> bytearray:
+    def _marshal(self, object, id: int) -> bytearray:
         if not hasattr(self._tl, "builder"):
             self._tl.builder = flatbuffers.Builder(256)
         builder = self._tl.builder
         builder.Clear()
 
         # prepare some properties that need to be built in FB before starting the main object
         offsets = {}
-        for prop in self.offset_properties:
-            val = self.get_value(object, prop)
+        for prop in self._offset_properties:
+            val = self._get_value(object, prop)
             if prop._ob_type == OBXPropertyType_String:
                 offsets[prop.id] = builder.CreateString(val.encode('utf-8'))
             elif prop._ob_type == OBXPropertyType_BoolVector:
@@ -192,17 +192,17 @@ def marshal(self, object, id: int) -> bytearray:
                 assert False, "programming error - invalid type OB & FB type combination"
 
         # start the FlatBuffers object with the largest number of properties that were ever present in the Entity
-        builder.StartObject(self.last_property_iduid.id)
+        builder.StartObject(self._last_property_iduid.id)
 
         # add properties to the FB object
-        for prop in self.properties:
+        for prop in self._properties:
             prop_id = prop.id
             if prop_id in offsets:
                 val = offsets[prop_id]
                 if val:
                     builder.PrependUOffsetTRelative(val)
             else:
-                val = id if prop == self.id_property else self.get_value(object, prop)
+                val = id if prop == self._id_property else self._get_value(object, prop)
                 if prop._ob_type == OBXPropertyType_Date:
                     val = date_value_to_int(val, 1000)  # convert to milliseconds
                 elif prop._ob_type == OBXPropertyType_DateNano:
@@ -214,15 +214,15 @@ def marshal(self, object, id: int) -> bytearray:
         builder.Finish(builder.EndObject())
         return builder.Output()
 
-    def unmarshal(self, data: bytes):
+    def _unmarshal(self, data: bytes):
         pos = flatbuffers.encode.Get(flatbuffers.packer.uoffset, data, 0)
         table = flatbuffers.Table(data, pos)
 
         # initialize an empty object
-        obj = self.user_type()
+        obj = self._user_type()
 
         # fill it with the data read from FlatBuffers
-        for prop in self.properties:
+        for prop in self._properties:
             o = table.Offset(prop._fb_v_offset)
             val = None
             ob_type = prop._ob_type

objectbox/model/idsync.py

@@ -85,12 +85,12 @@ def _save_model_json(self):
 
         for entity in self.model.entities:
             entity_json = {
-                "id": str(entity.iduid),
+                "id": str(entity._iduid),
                 "name": entity._name,
-                "lastPropertyId": str(entity.last_property_iduid),
+                "lastPropertyId": str(entity._last_property_iduid),
                 "properties": []
             }
-            for prop in entity.properties:
+            for prop in entity._properties:
                 prop_json = {
                     "id": str(prop.iduid),
                     "name": prop.name,
@@ -232,8 +232,8 @@ def _sync_property(self, entity: _Entity, prop: Property, entity_json: Optional[
         else:  # Assign new ID to new property
             if not prop.has_uid():
                 prop.iduid.uid = self._generate_uid()
-            prop.iduid = IdUid(entity.last_property_iduid.id + 1, prop.iduid.uid)
-            entity.last_property_iduid = prop.iduid
+            prop.iduid = IdUid(entity._last_property_iduid.id + 1, prop.iduid.uid)
+            entity._last_property_iduid = prop.iduid
             write_json = True
 
         if prop.index is not None:
@@ -245,33 +245,33 @@ def _sync_entity(self, entity: _Entity) -> bool:
         write_json = False
 
         # entity_json = None
-        if entity.has_uid():
-            entity_json = self._find_entity_json_by_uid(entity.uid)
+        if entity._has_uid():
+            entity_json = self._find_entity_json_by_uid(entity._uid)
             if entity_json is None:
                 # User provided a UID not matching any entity, make sure it's not assigned elsewhere
-                self._validate_uid_unassigned(entity.uid)
+                self._validate_uid_unassigned(entity._uid)
             else:
                 write_json = entity._name != entity_json["name"]  # If renaming we shall update the JSON
         else:
             entity_json = self._find_entity_json_by_name(entity._name)
 
         # Write JSON if the number of properties differs (to handle removed property)
         if entity_json is not None:
-            write_json |= len(entity.properties) != len(entity_json["properties"])
+            write_json |= len(entity._properties) != len(entity_json["properties"])
 
         if entity_json is not None:  # Load existing IDs from JSON
-            entity.iduid = IdUid.from_str(entity_json["id"])
-            entity.last_property_iduid = IdUid.from_str(entity_json["lastPropertyId"])
+            entity._iduid = IdUid.from_str(entity_json["id"])
+            entity._last_property_iduid = IdUid.from_str(entity_json["lastPropertyId"])
         else:  # Assign new ID to new entity
-            if not entity.has_uid():
-                entity.iduid.uid = self._generate_uid()
-            entity.iduid = IdUid(self.model.last_entity_iduid.id + 1, entity.iduid.uid)
-            self.model.last_entity_iduid = entity.iduid
-            entity.last_property_iduid = IdUid(0, 0)
+            if not entity._has_uid():
+                entity._iduid.uid = self._generate_uid()
+            entity._iduid = IdUid(self.model.last_entity_iduid.id + 1, entity._iduid.uid)
+            self.model.last_entity_iduid = entity._iduid
+            entity._last_property_iduid = IdUid(0, 0)
             write_json = True
 
         # Load properties
-        for prop in entity.properties:
+        for prop in entity._properties:
             write_json |= self._sync_property(entity, prop, entity_json)
 
         return write_json