dbzero-modelkit 1.0.0__tar.gz → 1.1.1__tar.gz

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbzero-modelkit
-Version: 1.0.0
+Version: 1.1.1
 Summary: Reusable dbzero-backed data model utilities
 Author-email: Selltime <dev@selltime.ai>
 License-Expression: MIT

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/active.py

@@ -11,7 +11,7 @@ from dbzero_modelkit.rpc_integration import rpc as db0_rpc
 from dbzero_modelkit.time_utils import normalize_end, normalize_start
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/ActiveBase", no_default_tags=True)
 class ActiveBase:
     """Base object for models that are active only within a period of time."""
 
@@ -19,7 +19,10 @@ class ActiveBase:
         self,
         active_from: datetime | date | None = None,
         expires_on: datetime | date | None = None,
+        *,
+        prefix: str | None = None,
     ) -> None:
+        db0.set_prefix(self, prefix)
         self.active_from = active_from
         self.expires_on = expires_on
 
@@ -116,11 +119,12 @@ class ActiveBase:
         return merged_active_from, merged_expires_on
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/ActiveIndex", no_default_tags=True)
 class ActiveIndex:
     """Container indexing ActiveBase-compatible objects by active period."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, prefix: str | None = None) -> None:
+        db0.set_prefix(self, prefix)
         self.__ix_active_from = db0.index()
         self.__ix_expires_on = db0.index()
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/calendars.py

@@ -19,7 +19,7 @@ def get_date_from_month_index(base_year: int, month_index: int) -> Date:
     return Date(base_year + month_index // 12, month_index % 12 + 1, 1)
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/MonthCalendar", no_default_tags=True)
 class MonthCalendar:
     """Single sparse month view for Calendar."""
 
@@ -82,7 +82,7 @@ class MonthCalendar:
             actual_day += timedelta(days=1)
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/Calendar", no_default_tags=True)
 class Calendar:
     """Sparse date calendar with lazy month creation."""
 
@@ -101,7 +101,11 @@ class Calendar:
             else:
                 return None
         if self.__months[month_index] is None and create is True:
-            self.__months[month_index] = MonthCalendar(self, month_index)
+            self.__months[month_index] = MonthCalendar(
+                self,
+                month_index,
+                prefix=db0.get_prefix_of(self).name,
+            )
         return self.__months[month_index]
 
     def date_range(

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/language.py

@@ -7,12 +7,15 @@ from typing import Optional
 import dbzero as db0
 
 
-@db0.enum(values=["LEN", "LPL", "LGER", "LFR", "LESP"])
+@db0.enum(
+    values=["LEN", "LPL", "LGER", "LFR", "LESP"],
+    type_id="/dbzero/dbzero-modelkit/LanguageCode",
+)
 class LanguageCode:
     """Common language codes used by multi-language strings."""
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/ML_String", no_default_tags=True)
 class ML_String:
     """Store textual information in a primary language and optional translations."""
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/month_store.py

@@ -10,11 +10,18 @@ import dbzero as db0
 from dbzero_modelkit.rpc_integration import rpc as db0_rpc
 
 
-@db0.memo(no_default_tags=True)
+@db0.memo(id="/dbzero/dbzero-modelkit/MonthStore", no_default_tags=True)
 class MonthStore:
     """General-purpose container for storing one object per month."""
 
-    def __init__(self, item_type: type, base_year: int = 2025) -> None:
+    def __init__(
+        self,
+        item_type: type,
+        base_year: int = 2025,
+        *,
+        prefix: str | None = None,
+    ) -> None:
+        db0.set_prefix(self, prefix)
         self.__item_type = item_type
         self.__base_year = base_year
         self.__months = []

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/object_lock.py

@@ -8,11 +8,18 @@ from typing import Any, Iterable, Type
 import dbzero as db0
 
 
-@db0.memo
+@db0.memo(id="/dbzero/dbzero-modelkit/ObjectLock")
 class ObjectLock:
     """General-purpose lock that holds references to locked objects."""
 
-    def __init__(self, locked_objects: Any | list[Any], duration: int = 300) -> None:
+    def __init__(
+        self,
+        locked_objects: Any | list[Any],
+        duration: int = 300,
+        *,
+        prefix: str | None = None,
+    ) -> None:
+        db0.set_prefix(self, prefix)
         if not isinstance(locked_objects, list):
             locked_objects = [locked_objects]
         self.locked_objects = locked_objects

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit/queues.py

@@ -7,7 +7,7 @@ from typing import Callable, Dict, List, Optional
 import dbzero as db0
 
 
-@db0.memo
+@db0.memo(id="/dbzero/dbzero-modelkit/FQ_Item")
 class FQ_Item:  # pylint: disable=invalid-name
     """Single FIFO queue entry storing keyword arguments and its integer key."""
 
@@ -31,11 +31,12 @@ class FQ_Item:  # pylint: disable=invalid-name
         }
 
 
-@db0.memo
+@db0.memo(id="/dbzero/dbzero-modelkit/FiFoQueue")
 class FiFoQueue:
     """FIFO queue container backed by a dbzero index."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, prefix: str | None = None) -> None:
+        db0.set_prefix(self, prefix)
         self.__items = db0.index()
         self.__next_key = 0
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/dbzero_modelkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbzero-modelkit
-Version: 1.0.0
+Version: 1.1.1
 Summary: Reusable dbzero-backed data model utilities
 Author-email: Selltime <dev@selltime.ai>
 License-Expression: MIT

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dbzero-modelkit"
-version = "1.0.0"
+version = "1.1.1"
 description = "Reusable dbzero-backed data model utilities"
 readme = "README.md"
 requires-python = ">=3.11"

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_active.py

@@ -5,9 +5,50 @@ from __future__ import annotations
 from datetime import date, datetime, timedelta
 from unittest.mock import patch
 
+import dbzero as db0
+
 from dbzero_modelkit.active import ActiveBase, ActiveIndex
 
 
+def test_active_model_type_ids(db0_fixture):
+    active_base = ActiveBase()
+    active_index = ActiveIndex()
+
+    assert (
+        db0.get_type_stats(type(active_base))["type_id"]
+        == "/dbzero/dbzero-modelkit/ActiveBase"
+    )
+    assert (
+        db0.get_type_stats(type(active_index))["type_id"]
+        == "/dbzero/dbzero-modelkit/ActiveIndex"
+    )
+
+
+def test_active_models_accept_keyword_only_prefix(db0_fixture):
+    db0.open("alternate_prefix", "rw")
+
+    active_base = ActiveBase(prefix="alternate_prefix")
+    active_index = ActiveIndex(prefix="alternate_prefix")
+
+    assert db0.get_prefix_of(active_base).name == "alternate_prefix"
+    assert db0.get_prefix_of(active_index).name == "alternate_prefix"
+    assert db0.get_prefix_of(active_index.active_from_index).name == "alternate_prefix"
+    assert db0.get_prefix_of(active_index.expires_on_index).name == "alternate_prefix"
+
+
+def test_active_base_subclass_without_prefix_remains_compatible(db0_fixture):
+    @db0.memo(no_default_tags=True)
+    class TimedThing(ActiveBase):
+        def __init__(self, name: str) -> None:
+            super().__init__()
+            self.name = name
+
+    thing = TimedThing("night shift")
+
+    assert thing.name == "night shift"
+    assert thing.active is True
+
+
 class DatetimeMock:
     """Deterministic datetime replacement for active-window tests."""
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_calendars.py

@@ -11,6 +11,60 @@ import pytest
 from dbzero_modelkit.calendars import Calendar, MonthCalendar, get_month_index
 
 
+def test_calendar_model_type_ids(db0_fixture):
+    calendar = Calendar()
+    month_calendar = MonthCalendar(calendar, 0)
+
+    assert db0.get_type_stats(type(calendar))["type_id"] == "/dbzero/dbzero-modelkit/Calendar"
+    assert (
+        db0.get_type_stats(type(month_calendar))["type_id"]
+        == "/dbzero/dbzero-modelkit/MonthCalendar"
+    )
+
+
+def test_calendar_prefix_propagates_to_created_month(db0_fixture):
+    db0.open("calendar_prefix", "rw")
+    calendar = Calendar(prefix="calendar_prefix")
+
+    month = calendar.get_month(date(2025, 1, 1), create=True)
+
+    assert db0.get_prefix_of(calendar).name == "calendar_prefix"
+    assert db0.get_prefix_of(month).name == "calendar_prefix"
+
+
+def test_calendar_default_prefix_propagates_to_created_month(db0_fixture):
+    calendar = Calendar()
+
+    month = calendar.get_month(date(2025, 1, 1), create=True)
+
+    assert db0.get_prefix_of(calendar).name == "test_prefix"
+    assert db0.get_prefix_of(month).name == "test_prefix"
+
+
+def test_calendar_child_prefix_survives_reopen(tmp_path):
+    db0_path = tmp_path / "db0"
+    db0.init(str(db0_path), read_write=True)
+    db0.open("default_prefix", "rw")
+    db0.open("calendar_prefix", "rw")
+    calendar = Calendar(prefix="calendar_prefix")
+    month = calendar.get_month(date(2025, 1, 1), create=True)
+    calendar_uuid = db0.uuid(calendar)
+    month_uuid = db0.uuid(month)
+    db0.commit()
+    db0.close()
+
+    db0.init(str(db0_path), read_write=True)
+    db0.open("default_prefix", "rw")
+    db0.open("calendar_prefix", "rw")
+    persisted_calendar = db0.fetch(calendar_uuid)
+    persisted_month = persisted_calendar.get_month(date(2025, 1, 1))
+
+    assert db0.uuid(persisted_month) == month_uuid
+    assert db0.get_prefix_of(persisted_calendar).name == "calendar_prefix"
+    assert db0.get_prefix_of(persisted_month).name == "calendar_prefix"
+    db0.close()
+
+
 class MockDate:
     """Date-like object used to test invalid day validation."""
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_language.py

@@ -2,11 +2,32 @@
 
 from __future__ import annotations
 
+import inspect
+
+import dbzero as db0
 import dbzero_modelkit
 
+import dbzero_modelkit.language as language_module
 from dbzero_modelkit.language import LanguageCode, ML_String
 
 
+def test_language_model_type_ids(db0_fixture):
+    text = ML_String("Dieta standardowa", LanguageCode.LPL)
+
+    assert db0.get_type_stats(type(text))["type_id"] == "/dbzero/dbzero-modelkit/ML_String"
+    # Future: Replace this with runtime enum metadata when dbzero exposes enum
+    # type_id introspection.
+    assert "type_id=\"/dbzero/dbzero-modelkit/LanguageCode\"" in inspect.getsource(language_module)
+
+
+def test_language_models_use_requested_prefix(db0_fixture):
+    db0.open("language_prefix", "rw")
+
+    text = ML_String("Dieta standardowa", LanguageCode.LPL, prefix="language_prefix")
+
+    assert db0.get_prefix_of(text).name == "language_prefix"
+
+
 def test_language_code_enum_values(db0_fixture):
     assert hasattr(LanguageCode, "LEN")
     assert hasattr(LanguageCode, "LPL")

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_month_store.py

@@ -10,6 +10,27 @@ import pytest
 from dbzero_modelkit.month_store import MonthStore
 
 
+def test_month_store_model_type_id(db0_fixture):
+    @db0.memo
+    class TestItem:
+        pass
+
+    month_store = MonthStore(TestItem)
+
+    assert db0.get_type_stats(type(month_store))["type_id"] == "/dbzero/dbzero-modelkit/MonthStore"
+
+
+def test_month_store_accepts_keyword_only_prefix(db0_fixture):
+    @db0.memo
+    class TestItem:
+        pass
+
+    db0.open("month_store_prefix", "rw")
+    month_store = MonthStore(TestItem, prefix="month_store_prefix")
+
+    assert db0.get_prefix_of(month_store).name == "month_store_prefix"
+
+
 def test_month_store_can_be_created(db0_fixture):
     @db0.memo
     class TestItem:

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_object_lock.py

@@ -10,6 +10,45 @@ import dbzero as db0
 from dbzero_modelkit.object_lock import ObjectLock
 
 
+def test_object_lock_model_type_id(db0_fixture):
+    @db0.memo
+    class TestObj:
+        pass
+
+    lock = ObjectLock(TestObj())
+
+    assert db0.get_type_stats(type(lock))["type_id"] == "/dbzero/dbzero-modelkit/ObjectLock"
+
+
+def test_object_lock_accepts_keyword_only_prefix(db0_fixture):
+    @db0.memo
+    class TestObj:
+        pass
+
+    db0.open("lock_prefix", "rw")
+    item = TestObj()
+    lock = ObjectLock(item, prefix="lock_prefix")
+
+    assert db0.get_prefix_of(lock).name == "lock_prefix"
+    assert db0.find(item, "LOCKED")
+
+
+def test_object_lock_can_tag_object_from_different_prefix(db0_fixture):
+    @db0.memo
+    class TestObj:
+        pass
+
+    db0.open("item_prefix", "rw")
+    item = TestObj()
+    db0.open("lock_prefix", "rw")
+
+    lock = ObjectLock(item, prefix="lock_prefix")
+
+    assert db0.get_prefix_of(item).name == "item_prefix"
+    assert db0.get_prefix_of(lock).name == "lock_prefix"
+    assert db0.find(item, "LOCKED", prefix="item_prefix")
+
+
 class DatetimeMock:
     """Deterministic datetime replacement for object lock tests."""
 

{dbzero_modelkit-1.0.0 → dbzero_modelkit-1.1.1}/tests/test_queues.py

@@ -4,7 +4,34 @@ from __future__ import annotations
 
 import dbzero as db0
 
-from dbzero_modelkit.queues import FiFoQueue
+from dbzero_modelkit.queues import FQ_Item, FiFoQueue
+
+
+def test_queue_model_type_ids(db0_fixture):
+    queue = FiFoQueue()
+    item = FQ_Item(0)
+
+    assert db0.get_type_stats(type(queue))["type_id"] == "/dbzero/dbzero-modelkit/FiFoQueue"
+    assert db0.get_type_stats(type(item))["type_id"] == "/dbzero/dbzero-modelkit/FQ_Item"
+
+
+def test_fifo_queue_accepts_keyword_only_prefix(db0_fixture):
+    db0.open("queue_prefix", "rw")
+
+    queue = FiFoQueue(prefix="queue_prefix")
+
+    assert db0.get_prefix_of(queue).name == "queue_prefix"
+    assert db0.get_prefix_of(queue._FiFoQueue__items).name == "queue_prefix"
+
+
+def test_fifo_queue_items_use_queue_prefix(db0_fixture):
+    db0.open("queue_prefix", "rw")
+    queue = FiFoQueue(prefix="queue_prefix")
+
+    queue.push_back(value=1)
+    item = next(iter(queue._FiFoQueue__items.select()))
+
+    assert db0.get_prefix_of(item).name == "queue_prefix"
 
 
 def test_fifo_queue_can_be_created(db0_fixture):