objectbox-api 5.0.0__py3-none-any.whl

objectbox/condition.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import sys
+from enum import Enum
+from typing import *
+
+if TYPE_CHECKING:
+    from objectbox.c import obx_qb_cond
+    from objectbox.query_builder import QueryBuilder
+    import numpy as np
+
+
+class QueryCondition:
+    def and_(self, other: QueryCondition) -> QueryCondition:
+        """*and* logic condition or using ``&`` operator"""
+        return LogicQueryCondition(self, other, LogicQueryConditionOp.AND)
+    __and__ = and_
+
+    def or_(self, other: QueryCondition) -> QueryCondition:
+        """*or* logic condition or using ``|`` operator"""
+        return LogicQueryCondition(self, other, LogicQueryConditionOp.OR)
+    __or__ = or_
+
+    def _apply_is_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.is_null(self._property_id)
+
+    def _apply_not_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.not_null(self._property_id)
+
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        """ Applies the QueryCondition to the supplied QueryBuilder.
+
+        :return:
+            The C handle for the applied condition.
+        """
+        raise NotImplementedError
+
+
+class LogicQueryConditionOp(Enum):
+    AND = 1
+    OR = 2
+
+
+class LogicQueryCondition(QueryCondition):
+    """ A QueryCondition describing a logical operation between two inner QueryCondition's (e.g. AND/OR). """
+
+    def __init__(self, cond1: QueryCondition, cond2: QueryCondition, op: LogicQueryConditionOp):
+        self._cond1 = cond1
+        self._cond2 = cond2
+        self._op = op
+
+    def _apply_conditions(self, qb: QueryBuilder) -> List[obx_qb_cond]:
+        return [self._cond1.apply(qb), self._cond2.apply(qb)]
+
+    def _apply_and(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.all(self._apply_conditions(qb))
+
+    def _apply_or(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.any(self._apply_conditions(qb))
+
+    def _apply_is_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.is_null(self._property_id)
+
+    def _apply_not_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.not_null(self._property_id)
+
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        if self._op == LogicQueryConditionOp.AND:
+            return self._apply_and(qb)
+        elif self._op == LogicQueryConditionOp.OR:
+            return self._apply_or(qb)
+        else:
+            raise Exception(f"Unknown LogicQueryCondition op: {self._op.name}")
+
+
+class PropertyQueryConditionOp(Enum):
+    EQ = 1
+    NOT_EQ = 2
+    CONTAINS = 3
+    STARTS_WITH = 4
+    ENDS_WITH = 5
+    GT = 6
+    GTE = 7
+    LT = 8
+    LTE = 9
+    BETWEEN = 10
+    NEAREST_NEIGHBOR = 11
+    CONTAINS_KEY_VALUE = 12
+    IS_NULL = 13
+    NOT_NULL = 14
+    ONE_OF = 15
+    NOT_ONE_OF = 16
+
+
+class PropertyQueryCondition(QueryCondition):
+    """
+    Query condition 
+    
+    Query conditions describe operations to be applied on a property (e.g. name == "John", age == 24)
+    """
+
+    _OP_MAP: Dict[PropertyQueryConditionOp, str] = {
+        PropertyQueryConditionOp.EQ: "_apply_eq",
+        PropertyQueryConditionOp.NOT_EQ: "_apply_not_eq",
+        PropertyQueryConditionOp.CONTAINS: "_apply_contains",
+        PropertyQueryConditionOp.STARTS_WITH: "_apply_starts_with",
+        PropertyQueryConditionOp.ENDS_WITH: "_apply_ends_with",
+        PropertyQueryConditionOp.GT: "_apply_gt",
+        PropertyQueryConditionOp.GTE: "_apply_gte",
+        PropertyQueryConditionOp.LT: "_apply_lt",
+        PropertyQueryConditionOp.LTE: "_apply_lte",
+        PropertyQueryConditionOp.BETWEEN: "_apply_between",
+        PropertyQueryConditionOp.NEAREST_NEIGHBOR: "_apply_nearest_neighbor",
+        PropertyQueryConditionOp.CONTAINS_KEY_VALUE: "_contains_key_value",
+        PropertyQueryConditionOp.IS_NULL: "_apply_is_null",
+        PropertyQueryConditionOp.NOT_NULL: "_apply_not_null",
+        PropertyQueryConditionOp.ONE_OF: "_apply_one_of",
+        PropertyQueryConditionOp.NOT_ONE_OF: "_apply_not_one_of",
+        # ... new property query conditions here ... :)
+    }
+
+    def __init__(self, property_id: int, op: PropertyQueryConditionOp, args: Dict[str, Any]):
+        if op not in self._OP_MAP:
+            raise Exception(f"Invalid PropertyQueryConditionOp: {op}")
+        op_func_name = self._OP_MAP[op]
+        if not hasattr(self, op_func_name):
+            raise Exception(f"Missing PropertyQueryCondition op function: {op_func_name} (op: {op})")
+        op_func = getattr(self, op_func_name)
+
+        self._property_id = property_id
+        self._op = op
+        self._op_func = op_func
+        self._args = args
+        self._alias = None
+
+    def alias(self, value: str):
+        """ Sets an alias for this condition to change its value(s) on the built query via
+        ``Query.set_parameter_alias()`` or ``Query.set_parameters_alias()``. """
+        self._alias = value
+        return self
+
+    def _apply_eq(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.equals_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.equals_int(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.equals_bytes(self._property_id, value)
+        else:
+            raise TypeError(f"Unsupported type for 'EQ': {type(value)}")
+
+    def _apply_not_eq(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.not_equals_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.not_equals_int(self._property_id, value)
+        else:
+            raise TypeError(f"Unsupported type for 'NOT_EQ': {type(value)}")
+
+    def _apply_contains(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        case_sensitive = self._args['case_sensitive']
+        if isinstance(value, str):
+            return qb.contains_string(self._property_id, value, case_sensitive)
+        else:
+            raise TypeError(f"Unsupported type for 'CONTAINS': {type(value)}")
+
+    def _apply_starts_with(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        case_sensitive = self._args['case_sensitive']
+        if isinstance(value, str):
+            return qb.starts_with_string(self._property_id, value, case_sensitive)
+        else:
+            raise TypeError(f"Unsupported type for 'STARTS_WITH': {type(value)}")
+
+    def _apply_ends_with(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.ends_with_string(self._property_id, value, case_sensitive)
+        else:
+            raise TypeError(f"Unsupported type for 'ENDS_WITH': {type(value)}")
+
+    def _apply_gt(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.greater_than_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.greater_than_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.greater_than_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.greater_than_bytes(self._property_id, value)
+        else:
+            raise TypeError(f"Unsupported type for 'GT': {type(value)}")
+
+    def _apply_gte(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.greater_or_equal_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.greater_or_equal_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.greater_or_equal_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.greater_or_equal_bytes(self._property_id, value)
+        else:
+            raise TypeError(f"Unsupported type for 'GTE': {type(value)}")
+
+    def _apply_lt(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.less_than_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.less_than_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.less_than_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.less_than_bytes(self._property_id, value)
+        else:
+            raise TypeError("Unsupported type for 'LT': " + str(type(value)))
+
+    def _apply_lte(self, qb: QueryBuilder) -> obx_qb_cond:
+        value = self._args['value']
+        if isinstance(value, str):
+            case_sensitive = self._args['case_sensitive']
+            return qb.less_or_equal_string(self._property_id, value, case_sensitive)
+        elif isinstance(value, int):
+            return qb.less_or_equal_int(self._property_id, value)
+        elif isinstance(value, float):
+            return qb.less_or_equal_double(self._property_id, value)
+        elif isinstance(value, bytes):
+            return qb.less_or_equal_bytes(self._property_id, value)
+        else:
+            raise TypeError(f"Unsupported type for 'LTE': {type(value)}")
+
+    def _apply_between(self, qb: QueryBuilder) -> obx_qb_cond:
+        a = self._args['a']
+        b = self._args['b']
+        if isinstance(a, int) and isinstance(b, int):
+            return qb.between_2ints(self._property_id, a, b)
+        elif isinstance(a, float) or isinstance(b, float):
+            return qb.between_2doubles(self._property_id, a, b)
+        else:
+            raise TypeError(f"Unsupported type for 'BETWEEN': {type(a)}")
+
+    def _apply_nearest_neighbor(self, qb: QueryBuilder) -> obx_qb_cond:
+        query_vector = self._args['query_vector']
+        max_result_count = self._args['max_result_count']
+
+        if len(query_vector) == 0:
+            from objectbox.exceptions import IllegalArgumentError
+            raise IllegalArgumentError("query_vector can't be empty")
+
+        is_float_vector = False
+        np = sys.modules.get("numpy")  # not imported: query_vector is no numpy array
+        is_float_vector |= np is not None and isinstance(query_vector, np.ndarray) and query_vector.dtype == np.float32
+        is_float_vector |= isinstance(query_vector, list) and type(query_vector[0]) == float
+        if is_float_vector:
+            return qb.nearest_neighbors_f32(self._property_id, query_vector, max_result_count)
+        else:
+            raise TypeError(f"Unsupported type for 'NEAREST_NEIGHBOR': {type(query_vector)}")
+
+    def _contains_key_value(self, qb: QueryBuilder) -> obx_qb_cond:
+        key = self._args['key']
+        value = self._args['value']
+        case_sensitive = self._args['case_sensitive']
+        return qb.contains_key_value(self._property_id, key, value, case_sensitive)
+
+    def _apply_is_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.is_null(self._property_id)
+
+    def _apply_not_null(self, qb: QueryBuilder) -> obx_qb_cond:
+        return qb.not_null(self._property_id)
+
+    def _apply_one_of(self, qb: QueryBuilder) -> obx_qb_cond:
+        values = self._args['values']
+        # Cannot tell strings from ints by the values (the list may be empty), so use the property kind
+        if self._args.get('string', False):
+            case_sensitive = self._args['case_sensitive']
+            return qb.in_strings(self._property_id, values, case_sensitive)
+        else:
+            return qb.in_ints(self._property_id, values)
+
+    def _apply_not_one_of(self, qb: QueryBuilder) -> obx_qb_cond:
+        values = self._args['values']
+        return qb.not_in_ints(self._property_id, values)
+
+    def apply(self, qb: QueryBuilder) -> obx_qb_cond:
+        c_cond = self._op_func(qb)
+        if self._alias is not None:
+            qb._alias_for_property(self._alias, self._property_id)
+        return c_cond

objectbox/exceptions.py

@@ -0,0 +1,238 @@
+import builtins
+from typing import Dict, Optional, Type
+
+from objectbox.c import py_str, C, DbErrorCode
+
+
+class DbError(Exception):
+    """The base class for all exceptions thrown by ObjectBox.
+    Every exception has a code attribute for identification.
+
+    Some also derive from the matching built-in exception, e.g. IllegalArgumentError is a ValueError."""
+
+    code = DbErrorCode.OBX_NO_SUCCESS  # Re-defined by derived classes
+
+    def __init__(self, message: Optional[str] = None):
+        """Creates the exception with the given message, or by default the last error message of the C library."""
+        self.message = message if message is not None else py_str(C.obx_last_error_message())
+        code = self.code
+        label = f"{code.value} ({code.name})" if isinstance(code, DbErrorCode) else str(code)
+        super().__init__(f"{label} - {self.message}")
+
+    @staticmethod
+    def from_code(code: int):
+        """Creates a DbError of the given error code."""
+        return create_db_error(code)
+
+    @staticmethod
+    def last():
+        """Creates a DbError of the last error that was generated in core."""
+        return DbError.from_code(C.obx_last_error())
+
+
+class NotFoundError(DbError):
+    """Raised when an object is not found."""
+    code = DbErrorCode.OBX_NOT_FOUND
+
+
+class NoSuccessError(DbError):
+    code = DbErrorCode.OBX_NO_SUCCESS
+
+
+class TimeoutError(DbError, builtins.TimeoutError):
+    """A timeout (also the built-in TimeoutError, which this class shadows in this module)."""
+    code = DbErrorCode.OBX_TIMEOUT
+
+
+class IllegalStateError(DbError, RuntimeError):
+    """An operation is not allowed in the current state, e.g. on a closed object (also a RuntimeError)."""
+    code = DbErrorCode.OBX_ERROR_ILLEGAL_STATE
+
+
+class IllegalArgumentError(DbError, ValueError):
+    """An argument has an invalid value (also a ValueError)."""
+    code = DbErrorCode.OBX_ERROR_ILLEGAL_ARGUMENT
+
+
+class AllocationError(DbError):
+    code = DbErrorCode.OBX_ERROR_ALLOCATION
+
+
+class NumericOverflowError(DbError):
+    code = DbErrorCode.OBX_ERROR_NUMERIC_OVERFLOW
+
+
+class FeatureNotAvailableError(DbError, RuntimeError):
+    """The feature is not available in the loaded ObjectBox library (also a RuntimeError)."""
+    code = DbErrorCode.OBX_ERROR_FEATURE_NOT_AVAILABLE
+
+
+FeatureNotAvailable = FeatureNotAvailableError
+"""Deprecated name of :class:`FeatureNotAvailableError` (the same class)."""
+
+
+class ShuttingDownError(DbError):
+    code = DbErrorCode.OBX_ERROR_SHUTTING_DOWN
+
+
+class IoError(DbError):
+    code = DbErrorCode.OBX_ERROR_IO
+
+
+class BackupFileInvalidError(DbError):
+    code = DbErrorCode.OBX_ERROR_BACKUP_FILE_INVALID
+
+
+class NoErrorInfoError(DbError):
+    code = DbErrorCode.OBX_ERROR_NO_ERROR_INFO
+
+
+class GeneralError(DbError):
+    code = DbErrorCode.OBX_ERROR_GENERAL
+
+
+class UnknownError(DbError):
+    code = DbErrorCode.OBX_ERROR_UNKNOWN
+
+
+class DbFullError(DbError):
+    code = DbErrorCode.OBX_ERROR_DB_FULL
+
+
+class MaxReadersExceededError(DbError):
+    code = DbErrorCode.OBX_ERROR_MAX_READERS_EXCEEDED
+
+
+class StoreMustShutdownError(DbError):
+    code = DbErrorCode.OBX_ERROR_STORE_MUST_SHUTDOWN
+
+
+class MaxDataSizeExceededError(DbError):
+    code = DbErrorCode.OBX_ERROR_MAX_DATA_SIZE_EXCEEDED
+
+
+class DbGeneralError(DbError):
+    code = DbErrorCode.OBX_ERROR_DB_GENERAL
+
+
+class GeneralStorageError(DbError):
+    code = DbErrorCode.OBX_ERROR_STORAGE_GENERAL
+
+
+class ConstraintViolatedError(DbError):
+    """A constraint was violated; see the subclass UniqueViolatedError."""
+    code = DbErrorCode.OBX_ERROR_CONSTRAINT_VIOLATED
+
+
+class UniqueViolatedError(ConstraintViolatedError):
+    """A unique constraint was violated (also a ConstraintViolatedError, like in Java)."""
+    code = DbErrorCode.OBX_ERROR_UNIQUE_VIOLATED
+
+
+class NonUniqueResultError(DbError):
+    code = DbErrorCode.OBX_ERROR_NON_UNIQUE_RESULT
+
+
+class PropertyTypeMismatchError(DbError):
+    code = DbErrorCode.OBX_ERROR_PROPERTY_TYPE_MISMATCH
+
+
+class IdAlreadyExistsError(DbError):
+    code = DbErrorCode.OBX_ERROR_ID_ALREADY_EXISTS
+
+
+class IdNotFoundError(DbError):
+    code = DbErrorCode.OBX_ERROR_ID_NOT_FOUND
+
+
+class TimeSeriesError(DbError):
+    code = DbErrorCode.OBX_ERROR_TIME_SERIES
+
+
+class StdIllegalArgumentError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_ILLEGAL_ARGUMENT
+
+
+class StdOutOfRangeError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_OUT_OF_RANGE
+
+
+class StdLengthError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_LENGTH
+
+
+class StdBadAllocError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_BAD_ALLOC
+
+
+class StdRangeError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_RANGE
+
+
+class StdOverflowError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_OVERFLOW
+
+
+class StdOtherError(DbError):
+    code = DbErrorCode.OBX_ERROR_STD_OTHER
+
+
+class SchemaError(DbError):
+    code = DbErrorCode.OBX_ERROR_SCHEMA
+
+
+class FileCorruptError(DbError):
+    code = DbErrorCode.OBX_ERROR_FILE_CORRUPT
+
+
+class FilePagesCorruptError(FileCorruptError):
+    """Corrupt pages of the database file (also a FileCorruptError, like in Java and Dart)."""
+    code = DbErrorCode.OBX_ERROR_FILE_PAGES_CORRUPT
+
+
+class SchemaObjectNotFoundError(DbError):
+    code = DbErrorCode.OBX_ERROR_SCHEMA_OBJECT_NOT_FOUND
+
+
+class TreeModelInvalidError(DbError):
+    code = DbErrorCode.OBX_ERROR_TREE_MODEL_INVALID
+
+
+class TreeValueTypeMismatchError(DbError):
+    code = DbErrorCode.OBX_ERROR_TREE_VALUE_TYPE_MISMATCH
+
+
+class TreePathNonUniqueError(DbError):
+    code = DbErrorCode.OBX_ERROR_TREE_PATH_NON_UNIQUE
+
+
+class TreePathIllegalError(DbError):
+    code = DbErrorCode.OBX_ERROR_TREE_PATH_ILLEGAL
+
+
+class TreeOtherError(DbError):
+    code = DbErrorCode.OBX_ERROR_TREE_OTHER
+
+
+obx_db_error_map: Dict[int, Type] = {}
+
+
+def _init_db_errror_map(base=DbError):
+    for subclass in base.__subclasses__():  # Recursively: some errors derive from others, e.g. UniqueViolatedError
+        obx_db_error_map[subclass.code] = subclass
+        _init_db_errror_map(subclass)
+
+
+_init_db_errror_map()
+
+
+def create_db_error(code: int) -> DbError:
+    if code == DbErrorCode.OBX_SUCCESS:
+        raise ValueError("Can't create a DbError for code: OBX_SUCCESS")
+    error_class = obx_db_error_map.get(code)
+    if error_class is None:  # E.g. a code of a newer C library: a DbError with that code
+        error = DbError.__new__(DbError)
+        error.code = DbErrorCode(code) if code in DbErrorCode._value2member_map_ else code
+        DbError.__init__(error)
+        return error
+    return error_class()

objectbox/experimental.py

@@ -0,0 +1,78 @@
+# Copyright 2026 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.
+
+"""Experimental features: off by default; they may change or be removed in any release."""
+
+# Marshalling objects (put): None (the generic flatbuffers.Builder), FAST_BUILDER or CODEGEN; at most one is active
+FAST_BUILDER = "fast builder"
+CODEGEN = "codegen"
+_flatbuffers_mode = None
+_flatbuffers_verify = False
+_codegen_cache_dir = None  # directory for compiled codegen (see enable_flatbuffers_codegen) or None
+
+
+def _set_flatbuffers_mode(mode: str, enabled: bool, verify: bool):
+    global _flatbuffers_mode, _flatbuffers_verify
+    if enabled:
+        _flatbuffers_mode = mode
+        _flatbuffers_verify = verify
+    elif _flatbuffers_mode == mode:
+        _flatbuffers_mode = None
+        _flatbuffers_verify = False
+
+
+def enable_fast_flatbuffers_builder(enabled: bool = True, verify: bool = False):
+    """Experimental: marshals objects (put) with a FlatBuffers builder that is precomputed per entity instead of the
+    generic flatbuffers.Builder; this is much faster, especially for many objects. It produces the same bytes.
+    Applies to all entities in this process, from the next put on.
+    Only one experimental builder is active: enabling this one replaces enable_flatbuffers_codegen();
+    disabling it (enabled=False) has no effect if the other one is active.
+
+    :param verify: additionally marshals each object with the generic builder and raises an AssertionError if the
+        bytes differ (slower than the generic builder alone; for testing).
+    """
+    _set_flatbuffers_mode(FAST_BUILDER, enabled, verify)
+
+
+def is_fast_flatbuffers_builder_enabled() -> bool:
+    return _flatbuffers_mode == FAST_BUILDER
+
+
+def enable_flatbuffers_codegen(enabled: bool = True, verify: bool = False, cache_dir: str = None):
+    """Experimental: like enable_fast_flatbuffers_builder(), but additionally generates Python code per entity
+    (compiled once per process: at the entity's first put, and for reading at its first read) that marshals its
+    objects; this is faster than the fast builder.
+    It produces the same bytes as the generic flatbuffers.Builder.
+    Reading objects (get, queries) also uses generated code, which returns the same objects as the default
+    (flatbuffers.Table), but is much faster, especially for entities with many properties.
+    Only one experimental builder is active: enabling this one replaces enable_fast_flatbuffers_builder();
+    disabling it (enabled=False) has no effect if the other one is active.
+
+    :param verify: see enable_fast_flatbuffers_builder(); for reading, each object is additionally read with
+        flatbuffers.Table and an AssertionError is raised if any property value differs.
+    :param cache_dir: optional directory to cache the compiled code in, so other processes skip compiling it
+        (~1 ms per function for an entity with 38 properties), e.g. for many short-lived processes. The generated
+        sources are written there as .py files; Python caches their bytecode as for any module (in __pycache__,
+        or under sys.pycache_prefix if set). Off by default.
+        Applies to code compiled after this call; each call sets it (None: no cache).
+        Security: only use a directory that is writable by trusted users only, as code from it is executed.
+    """
+    global _codegen_cache_dir
+    _set_flatbuffers_mode(CODEGEN, enabled, verify)
+    if enabled:
+        _codegen_cache_dir = cache_dir
+
+
+def is_flatbuffers_codegen_enabled() -> bool:
+    return _flatbuffers_mode == CODEGEN

objectbox/logger.py

@@ -0,0 +1,18 @@
+import sys
+import logging
+
+logger = logging.getLogger("objectbox")
+
+
+def setup_stdout_logger():
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.DEBUG)
+    # Output format example:
+    # 2024-04-04 10:16:46,272 [objectbox-py] [DEBUG] Creating property "id" (ID=1, UID=1001)
+    formatter = logging.Formatter('%(asctime)s [objectbox-py] [%(levelname)-5s] %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+# Not need to hook stdout as pytest will do the job. Use --log-cli-level= to set log level
+# setup_stdout_logger()

objectbox/model/__init__.py

@@ -0,0 +1,63 @@
+# 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.model.entity import *
+from objectbox.model.model import *
+from objectbox.model.properties import *
+
+__all__ = [
+    'Model',
+    'Entity',
+    'IdUid',
+    'Property',
+    'PropertyType',
+    'Id',
+    'IdUid',
+    'Bool',
+    'String',
+    'Int8',
+    'Int16',
+    'Int32',
+    'Int64',
+    'Float32',
+    'Float64',
+    'Date',
+    'DateNano',
+    'Flex',
+    'Relation',
+    'BoolVector',
+    'Int8Vector',
+    'Int16Vector',
+    'CharVector',
+    'Int32Vector',
+    'Int64Vector',
+    'Float32Vector',
+    'Float64Vector',
+    'Index',
+    'IndexType',
+    'Unique',
+    'ConflictStrategy',
+    'HnswIndex',
+    'VectorDistanceType',
+    'BoolList',
+    'Int8List',
+    'Int16List',
+    'CharList',
+    'Int32List',
+    'Int64List',
+    'Float32List',
+    'Float64List',
+    'Bytes',
+]