objectbox-api 5.0.0__py3-none-any.whl

objectbox/model/idsync.py

@@ -0,0 +1,401 @@
+import os
+import random
+from typing import *
+from objectbox.logger import logger
+from objectbox.model.model import Model
+from objectbox.model.entity import _Entity, camel_case
+from objectbox.model.properties import Property, Index, HnswIndex, Relation
+from objectbox.model.iduid import IdUid
+
+MODEL_PARSER_VERSION = 5
+MODEL_VERSION = 5  # Of the model JSON format; like the other ObjectBox languages (e.g. objectbox-generator checks it)
+
+# Lists of the UIDs of removed entities, properties, indexes and relations, like in the model JSON of the other
+# ObjectBox languages: they must not be used again, and e.g. the objectbox-generator (Go, C++) checks "last" IDs
+# against them.
+_RETIRED_KEYS = ("retiredEntityUids", "retiredIndexUids", "retiredPropertyUids", "retiredRelationUids")
+
+# Top-level fields of the model JSON that Python does not manage, e.g. written by another ObjectBox language for a
+# shared file; kept as they are when the file is written
+_KEPT_KEYS = ("lastRelationId", "lastSequenceId", "modelVersion", "version")
+
+
+class IdSync:
+    """
+    Synchronizes a model with the IDs from model JSON file.
+    After syncing, the model will have all IDs assigned.
+    The JSON file is written (from scratch) based on the model.
+    """
+
+    def __init__(self, model: Model, model_json_filepath: str):
+        self.model = model
+        if len(model.entities) == 0:
+            raise ValueError("A valid model must have at least one entity")
+
+        self.model_filepath = model_json_filepath
+        self.model_json = None
+
+        self._assigned_uids: Set[int] = set()
+        self._retired_uids: Set[int] = set()
+        self._retired: Dict[str, List[int]] = {key: [] for key in _RETIRED_KEYS}  # In order, as written to the JSON
+        self._matched_uids: Set[int] = set()  # Of JSON entities, properties and indexes matched with the model
+        self._entity_json_by_uid: Dict[int, Dict[str, Any]] = {}  # Matched JSON entity by its UID
+        # How an unassigned "last" ID is written: "0:0" (like Java), or "" if the loaded JSON does so (like the
+        # objectbox-generator for Go and C++, which rejects "0:0")
+        self._unassigned_str = "0:0"
+
+        self._load_model_json()
+
+    def _load_model_json(self):
+        import json
+        from os import path
+
+        if not path.exists(self.model_filepath):
+            logger.debug(f"Model file not found: {self.model_filepath}")
+            return
+
+        with open(self.model_filepath, "rt") as model_file:
+            self.model_json = json.load(model_file)
+        logger.debug(f"Syncing model with model file: {self.model_filepath}")
+        if any(self.model_json.get(key) == "" for key in ("lastEntityId", "lastIndexId", "lastRelationId")):
+            self._unassigned_str = ""
+
+        self._load_assigned_uids()
+
+    def _load_assigned_uids(self):
+        for key in _RETIRED_KEYS:
+            for uid in self.model_json.get(key) or []:
+                uid = int(uid)
+                if uid not in self._retired_uids:
+                    self._retired[key].append(uid)
+                    self._retired_uids.add(uid)
+        self._assigned_uids |= self._retired_uids
+
+        for entity_json in self.model_json["entities"]:
+            entity_uid = IdUid.from_str(entity_json["id"]).uid
+            if entity_uid in self._assigned_uids:
+                raise ValueError(f"An entity's UID {entity_uid} has already been used elsewhere")
+            self._assigned_uids.add(entity_uid)
+
+            for prop_json in entity_json["properties"]:
+                prop_uid = IdUid.from_str(prop_json["id"]).uid
+                if prop_uid in self._assigned_uids:
+                    raise ValueError(f"A property's UID {prop_uid} has already been used elsewhere")
+                self._assigned_uids.add(prop_uid)
+
+                if "indexId" in prop_json:
+                    index_uid = IdUid.from_str(prop_json["indexId"]).uid
+                    if index_uid in self._assigned_uids:
+                        raise ValueError(f"An index's UID {index_uid} has already been used elsewhere")
+                    self._assigned_uids.add(index_uid)
+
+            # Standalone relations (e.g. ToMany in Java, Dart) are not supported in Python, but kept in the JSON
+            for relation_json in entity_json.get("relations") or []:
+                self._assigned_uids.add(IdUid.from_str(relation_json["id"]).uid)
+
+    def _iduid_str(self, iduid: IdUid) -> str:
+        return str(iduid) if iduid.is_assigned() else self._unassigned_str
+
+    def _save_model_json(self):
+        """ Replaces model JSON with the serialized model whose ID/UIDs are assigned. """
+
+        # model.validate_ids_assigned()
+
+        model_json = {
+            "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
+            "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
+            "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
+            "modelVersionParserMinimum": MODEL_PARSER_VERSION,
+            "entities": [],
+            "lastEntityId": self._iduid_str(self.model.last_entity_iduid),
+            "lastIndexId": self._iduid_str(self.model.last_index_iduid),
+            "lastRelationId": self._iduid_str(self.model.last_relation_iduid),
+            "modelVersion": MODEL_VERSION,
+            "version": 1
+        }
+        if self.model_json is not None:
+            for key in _KEPT_KEYS:
+                if key in self.model_json:
+                    model_json[key] = self.model_json[key]
+        model_json.update(self._retired)
+
+        for entity in self.model.entities:
+            entity_json = {
+                "id": str(entity._iduid),
+                "name": entity._name,
+                "lastPropertyId": str(entity._last_property_iduid),
+                "properties": []
+            }
+            if entity._flags != 0:
+                entity_json["flags"] = entity._flags  # E.g. Sync enabled; like the model JSON of other ObjectBox APIs
+            for prop in entity._properties:
+                prop_json = {
+                    "id": str(prop.iduid),
+                    "name": prop._db_name,
+                    "type": prop._ob_type,
+                }
+                if prop._flags != 0:
+                    prop_json["flags"] = prop._flags
+                if prop.index is not None:
+                    prop_json["indexId"] = str(prop.index.iduid)
+                if isinstance(prop, Relation):
+                    prop_json["relationTarget"] = prop._target_name
+                entity_json["properties"].append(prop_json)
+            loaded_entity_json = self._entity_json_by_uid.get(entity._uid)
+            if loaded_entity_json is not None and "relations" in loaded_entity_json:
+                entity_json["relations"] = loaded_entity_json["relations"]  # Kept, see _load_assigned_uids()
+            model_json["entities"].append(entity_json)
+
+        import json
+        with open(self.model_filepath, "w") as model_file:
+            model_file.write(json.dumps(model_json, indent=2))  # Pretty
+
+    # *** Sync ***
+
+    def _find_entity_json_by_uid(self, uid: int) -> Optional[Dict[str, Any]]:
+        """ Finds entity JSON by UID. """
+        if self.model_json is None:
+            return None
+        # TODO put entities in a dict (e.g. while/after loading) for faster lookup
+        for entity_json in self.model_json["entities"]:
+            if IdUid.from_str(entity_json["id"]).uid == uid:
+                return entity_json
+        return None
+
+    def _find_entity_json_by_name(self, entity_name: str) -> Optional[Dict[str, Any]]:
+        """ Finds entity JSON by name. """
+        if self.model_json is None:
+            return None
+        # TODO put entities in a dict (e.g. while/after loading) for faster lookup
+        for entity_json in self.model_json["entities"]:
+            if entity_json["name"] == entity_name:
+                return entity_json
+        return None
+
+    def _find_property_json_by_uid(self, entity_json: Dict[str, Any], uid: int) -> Optional[Dict[str, Any]]:
+        """ Finds entity property JSON by property UID. """
+        # TODO put properties in a multi-dict (e.g. while/after loading) for faster lookup
+        for prop_json in entity_json["properties"]:
+            if IdUid.from_str(prop_json["id"]).uid == uid:
+                return prop_json
+        return None
+
+    def _find_property_json_by_name(self, entity_json: Dict[str, Any], prop_name: str) -> Optional[Dict[str, Any]]:
+        """ Finds entity property JSON by property name. """
+        # TODO put properties in a multi-dict (e.g. while/after loading) for faster lookup
+        for prop_json in entity_json["properties"]:
+            if prop_json["name"] == prop_name:
+                return prop_json
+        return None
+
+    def _generate_uid(self) -> int:
+        while True:
+            generated_uid = random.getrandbits(63) + 1  # 0 would be invalid
+            if generated_uid not in self._assigned_uids:
+                break
+        self._assigned_uids.add(generated_uid)
+        return generated_uid
+
+    def _validate_uid_unassigned(self, uid: int):
+        """ Validates that a user supplied UID is not assigned for any other entity/property/index.
+        Raises a ValueError if the UID is already assigned elsewhere.
+        """
+        if uid in self._retired_uids:
+            raise ValueError(f"User supplied UID {uid} was used by a removed entity, property or index; "
+                             f"UIDs must not be used again (see the retired UIDs in the model JSON file)")
+        if uid in self._assigned_uids:
+            raise ValueError(f"User supplied UID {uid} is already assigned elsewhere")
+
+    def _validate_matching_prop(self, entity: _Entity, prop: Property, prop_json: Dict[str, Any]):
+        """ Validates that the given property matches the JSON property. """
+        try:
+            # Don't check name equality as the property could be matched by UID (rename)
+            # if validate_name and prop.name != prop_json["name"]:
+            #    raise ValueError(f"name {prop.name} != name {prop_json['name']} (in JSON)")
+            # Flags (e.g. the index type or an assignable ID) and the index may change: the database is updated
+            # when the store is opened, and the JSON file is rewritten.
+            if prop._ob_type != prop_json["type"]:
+                raise ValueError(f"OBX type {prop._ob_type} != OBX type {prop_json['type']} (in JSON)")
+        except ValueError as error:
+            raise ValueError(f"Property {entity._name}.{prop.name} mismatches property found in JSON file: {error}")
+
+    def _sync_index(self, entity: _Entity, prop: Property, prop_json: Optional[Dict[str, Any]]) -> bool:
+        assert prop.index is not None
+        index = prop.index
+
+        write_json = False
+
+        # Fetch index ID/UID from JSON file
+        iduid_json = None
+        if (prop_json is not None) and ("indexId" in prop_json):
+            iduid_json = IdUid.from_str(prop_json["indexId"])
+
+        # User provided a UID not matching index's, make sure it's not assigned elsewhere
+        if index.has_uid() and (iduid_json is not None) and (index.uid != iduid_json.uid):
+            self._validate_uid_unassigned(index.uid)
+
+        # Generate UID only if not supplied by the user, and index isn't found in JSON
+        if not index.has_uid() and iduid_json is None:
+            index.iduid.uid = self._generate_uid()
+
+        if (iduid_json is not None) and (not index.has_uid() or index.iduid.uid == iduid_json.uid):  # Load
+            index.iduid = IdUid.from_str(prop_json["indexId"])
+            self._matched_uids.add(index.iduid.uid)
+        else:  # Assign new ID to new index
+            index.iduid = IdUid(self.model.last_index_iduid.id + 1, index.uid)
+            self.model.last_index_iduid = index.iduid
+            write_json = True
+
+        return write_json
+
+    def _sync_property(self, entity: _Entity, prop: Property, entity_json: Optional[Dict[str, Any]]) -> bool:
+        write_json = False
+
+        prop_json = None
+        if prop.has_uid():
+            if entity_json is not None:
+                prop_json = self._find_property_json_by_uid(entity_json, prop.uid)
+            if prop_json is None:
+                # User provided a UID not matching any property (within the entity), make sure it's not assigned
+                # elsewhere
+                self._validate_uid_unassigned(prop.uid)
+            else:
+                write_json = prop._db_name != prop_json["name"]  # If renaming we shall update the JSON
+        else:
+            if entity_json is not None:
+                prop_json = self._find_property_json_by_name(entity_json, prop._db_name)
+                if prop_json is None:
+                    # The other form of the name, e.g. the Python name stored before 5.0 (no camelCase conversion);
+                    # matching it renames the property, keeping its data
+                    other_name = prop.name if prop._db_name != prop.name else camel_case(prop.name)
+                    if other_name != prop._db_name:
+                        prop_json = self._find_property_json_by_name(entity_json, other_name)
+                        write_json = prop_json is not None
+
+        if prop_json is not None:  # Load existing IDs from JSON
+            # Property was matched with a JSON property (either by UID or by name), make sure they're equal
+            self._validate_matching_prop(entity, prop, prop_json)
+            write_json |= prop._flags != prop_json.get("flags", 0)
+            write_json |= (prop.index is not None) != ("indexId" in prop_json)
+            prop.iduid = IdUid.from_str(prop_json["id"])
+            self._matched_uids.add(prop.iduid.uid)
+        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
+            write_json = True
+
+        if prop.index is not None:
+            write_json |= self._sync_index(entity, prop, prop_json)
+
+        return write_json
+
+    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_json is None:
+                # User provided a UID not matching any entity, make sure it's not assigned elsewhere
+                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"])
+
+        if entity_json is not None:  # Load existing IDs from JSON
+            entity._iduid = IdUid.from_str(entity_json["id"])
+            self._matched_uids.add(entity._uid)
+            self._entity_json_by_uid[entity._uid] = entity_json
+            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)
+            write_json = True
+
+        # Load properties
+        for prop in entity._properties:
+            write_json |= self._sync_property(entity, prop, entity_json)
+
+        return write_json
+
+    def _retire(self, key: str, uid: int) -> bool:
+        if uid == 0 or uid in self._retired_uids:
+            return False
+        self._retired[key].append(uid)
+        self._retired_uids.add(uid)
+        return True
+
+    def _retire_unmatched(self) -> bool:
+        """ Retires the UIDs of the JSON entities, properties and indexes not matched with the model (i.e. removed),
+        including all of a removed entity (also its relations), like the other ObjectBox languages.
+        Returns True if any UIDs were retired. """
+        if self.model_json is None:
+            return False
+        retired = False
+        for entity_json in self.model_json["entities"]:
+            entity_uid = IdUid.from_str(entity_json["id"]).uid
+            entity_removed = entity_uid not in self._matched_uids
+            if entity_removed:
+                retired |= self._retire("retiredEntityUids", entity_uid)
+                for relation_json in entity_json.get("relations") or []:
+                    retired |= self._retire("retiredRelationUids", IdUid.from_str(relation_json["id"]).uid)
+            for prop_json in entity_json["properties"]:
+                prop_uid = IdUid.from_str(prop_json["id"]).uid
+                if entity_removed or prop_uid not in self._matched_uids:
+                    retired |= self._retire("retiredPropertyUids", prop_uid)
+                if "indexId" in prop_json:
+                    index_uid = IdUid.from_str(prop_json["indexId"]).uid
+                    if entity_removed or index_uid not in self._matched_uids:
+                        retired |= self._retire("retiredIndexUids", index_uid)
+        return retired
+
+    def sync(self) -> bool:
+        """ Syncs the provided model with the model JSON file.
+        Returns True if the model JSON was written. """
+
+        self.model._validate()  # before writing the JSON
+
+        if self.model_json is not None:
+            self.model.last_entity_iduid = IdUid.from_str(self.model_json["lastEntityId"])
+            self.model.last_index_iduid = IdUid.from_str(self.model_json["lastIndexId"])
+            # self.model.last_relation_iduid =
+
+        write_json = False
+
+        # Write JSON if the number of entities differs (to handle removed entity)
+        if self.model_json is not None:
+            write_json |= len(self.model_json["entities"]) != len(self.model.entities)
+
+        for entity in self.model.entities:
+            write_json |= self._sync_entity(entity)
+
+        write_json |= self._retire_unmatched()
+
+        if write_json:
+            logger.info(f"Model changed, writing model.json: {self.model_filepath}")
+            self._save_model_json()
+
+        self.model.on_sync()  # Notify model synced
+
+        return write_json
+
+
+def sync_model(model: Model, model_filepath: str = "objectbox-model.json") -> bool:
+    """ Syncs the provided model with the model JSON file.
+    Returns True if changes were made and the model JSON was written. """
+
+    id_sync = IdSync(model, model_filepath)
+    written = id_sync.sync()
+    model._synced_json_file = os.path.realpath(model_filepath)
+    model._synced_json_file_given = model_filepath
+    return written

objectbox/model/iduid.py

@@ -0,0 +1,32 @@
+class IdUid:
+    __slots__ = 'id', 'uid'
+
+    def __init__(self, id_: int, uid: int):
+        self.id = id_
+        self.uid = uid
+
+    def is_assigned(self):
+        """ Checks that both ID and UID are assigned. Shall be true after the model is synced. """
+        return self.id != 0 and self.uid != 0
+
+    def __bool__(self):
+        return self.is_assigned()
+
+    def __eq__(self, rhs: 'IdUid'):
+        return self.id == rhs.id and self.uid == rhs.uid
+
+    def __str__(self):
+        return f"{self.id}:{self.uid}"
+
+    @staticmethod
+    def from_str(str_: str):
+        """ Parses IdUid from a string formatted like: "id:uid"; an empty string (e.g. "lastIndexId" written by
+        the C++ and Go generators if there is none) is unassigned, like "0:0". """
+        if str_ == "":
+            return IdUid.unassigned()
+        tmp = str_.split(":")
+        return IdUid(int(tmp[0]), int(tmp[1]))
+
+    @staticmethod
+    def unassigned():
+        return IdUid(0, 0)

objectbox/model/model.py

@@ -0,0 +1,158 @@
+# Copyright 2019-2024 ObjectBox Ltd. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from objectbox.logger import logger
+from objectbox.c import *
+from objectbox.model.iduid import IdUid
+from objectbox.model.entity import _Entity
+from objectbox.model.properties import *
+
+
+class Model:
+    """
+    Database schema 
+    
+    A model specifies available entities in the database. Amongst others it uses this information to supports migration over time.
+    """
+    def __init__(self):
+        self.entities: List[_Entity] = []
+
+        self.last_entity_iduid = IdUid(0, 0)
+        self.last_index_iduid = IdUid(0, 0)
+        self.last_relation_iduid = IdUid(0, 0)
+
+        self._c_model = None
+
+        # Model JSON file (real path) this model's IDs were synced with; None if not synced (yet).
+        # Used by Store to skip syncing again, e.g. when opening many stores with the same model.
+        self._synced_json_file: Optional[str] = None
+        self._synced_json_file_given: Optional[str] = None  # ...as given (not resolved), for a quick comparison
+
+    def on_sync(self):
+        """ Method called once ID/UID are synced with the model file. """
+        for entity in self.entities:
+            entity._on_sync()
+
+    def entity(self, entity: _Entity):
+        if not isinstance(entity, _Entity):
+            raise TypeError(f"The given type is not an Entity: {type(entity)}. "
+                            f"Ensure to have an @Entity annotation on the class.")
+        for other_entity in self.entities:  # Linear search (we should't have many entities)
+            if entity._name == other_entity._name:
+                raise ValueError(f"Duplicate entity: \"{entity._name}\"")
+        self.entities.append(entity)
+        self._synced_json_file = None  # Changed model; must be synced again
+        self._synced_json_file_given = None
+
+    def validate_ids_assigned(self):
+        # TODO validate last_relation_iduid
+        has_entities = len(self.entities) > 0
+        has_indices = False
+        for entity in self.entities:
+            has_properties = len(entity._properties) > 0
+            if not entity._iduid.is_assigned():
+                raise ValueError(f"Entity \"{entity._name}\" ID/UID not assigned")
+            for prop in entity._properties:
+                if not prop.iduid.is_assigned():
+                    raise ValueError(f"Property \"{entity._name}.{prop.name}\" ID/UID not assigned")
+                if prop.index is not None:
+                    has_indices = True
+                    if not prop.index.iduid.is_assigned():
+                        raise ValueError(f"Property index \"{entity._name}.{prop.name}\" ID/UID not assigned")
+            if has_properties and not entity._last_property_iduid.is_assigned():
+                raise ValueError(f"Entity \"{entity._name}\" last property ID/UID not assigned")
+        if has_entities and not self.last_entity_iduid.is_assigned():
+            raise ValueError("Last entity ID/UID not assigned")
+        if has_indices and not self.last_index_iduid.is_assigned():
+            raise ValueError("Last index ID/UID not assigned")
+
+    def _validate(self):
+        """ Validates what can only be checked with all entities (and their flags) defined. """
+        self._validate_relation_targets()
+        self._validate_unique()
+
+    def _validate_unique(self):
+        for entity in self.entities:
+            unique = [prop for prop in entity._properties if prop.unique is not None]
+            replace = [prop.name for prop in unique if prop.unique.on_conflict == ConflictStrategy.REPLACE]
+            if len(replace) > 1:
+                raise ValueError(f"Entity {entity._name}: ConflictStrategy.REPLACE can only be used for one property, "
+                                 f"but is used for {', '.join(replace)}")
+            if entity._flags & OBXEntityFlags.SYNC_ENABLED:
+                not_replace = [prop.name for prop in unique if prop.unique.on_conflict != ConflictStrategy.REPLACE]
+                if not_replace:
+                    raise ValueError(f"Sync entity {entity._name}: unique properties must use "
+                                     f"Unique(ConflictStrategy.REPLACE), but {', '.join(not_replace)} do(es) not")
+
+    def _validate_relation_targets(self):
+        names = {entity._name for entity in self.entities}
+        for entity in self.entities:
+            for prop in entity._properties:
+                if isinstance(prop, Relation) and prop._target_name not in names:
+                    raise ValueError(f"Relation {entity._name}.{prop.name} targets entity \"{prop._target_name}\", "
+                                     f"which is not in the model")
+
+    def _set_hnsw_params(self, index: HnswIndex):
+        if index.dimensions is not None:
+            obx_model_property_index_hnsw_dimensions(self._c_model, index.dimensions)
+        if index.neighbors_per_node is not None:
+            obx_model_property_index_hnsw_neighbors_per_node(self._c_model, index.neighbors_per_node)
+        if index.indexing_search_count is not None:
+            obx_model_property_index_hnsw_indexing_search_count(self._c_model, index.indexing_search_count)
+        if index.flags is not None:
+            obx_model_property_index_hnsw_flags(self._c_model, index.flags)
+        if index.distance_type is not None:
+            obx_model_property_index_hnsw_distance_type(self._c_model, index.distance_type)
+        if index.reparation_backlink_probability is not None:
+            obx_model_property_index_hnsw_reparation_backlink_probability(self._c_model,
+                                                                          index.reparation_backlink_probability)
+        if index.vector_cache_hint_size_kb is not None:
+            obx_model_property_index_hnsw_vector_cache_hint_size_kb(self._c_model, index.vector_cache_hint_size_kb)
+
+    def _create_index(self, index: Union[Index, HnswIndex]):
+        if isinstance(index, HnswIndex):
+            self._set_hnsw_params(index)
+        obx_model_property_index_id(self._c_model, index.id, index.uid)
+
+    def _create_property(self, prop: Property):
+        obx_model_property(self._c_model, c_str(prop._db_name), prop._ob_type, prop.id, prop.uid)
+        if prop._flags != 0:
+            obx_model_property_flags(self._c_model, prop._flags)
+        if isinstance(prop, Relation):
+            obx_model_property_relation(self._c_model, c_str(prop._target_name), prop.index.id, prop.index.uid)
+        elif prop.index is not None:
+            self._create_index(prop.index)
+
+    def _create_entity(self, entity: _Entity):
+        obx_model_entity(self._c_model, c_str(entity._name), entity._id, entity._uid)
+        obx_model_entity_flags(self._c_model, entity._flags)
+        for prop in entity._properties:
+            self._create_property(prop)
+        obx_model_entity_last_property_id(self._c_model, entity._last_property_iduid.id, entity._last_property_iduid.uid)
+
+    def _create_c_model(self) -> obx_model:  # Called by StoreOptions
+        """ Creates the OBX model by invoking the C API.
+        Before calling this method, IDs/UIDs must be assigned either manually or via sync_model(). """
+        self._validate()
+        self._c_model = obx_model()
+        for entity in self.entities:
+            self._create_entity(entity)
+        if self.last_relation_iduid:
+            obx_model_last_relation_id(self._c_model, self.last_relation_iduid.id, self.last_relation_iduid.uid)
+        if self.last_index_iduid:
+            obx_model_last_index_id(self._c_model, self.last_index_iduid.id, self.last_index_iduid.uid)
+        if self.last_entity_iduid:
+            obx_model_last_entity_id(self._c_model, self.last_entity_iduid.id, self.last_entity_iduid.uid)
+        return self._c_model