kiba-core 0.5.3.dev92__tar.gz → 0.5.3.dev94__tar.gz

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ## [Unreleased]
 
 ### Added
+- [MAJOR] Added `priority` to `SqlMessageQueue.send_message` and `send_messages` (default 0): visible messages are claimed highest priority first, then by `visibleDate`, and a duplicate send, or a retry folded into a pending duplicate, keeps the higher priority. `tbl_queue_messages` has a new `priority` column (`INTEGER NOT NULL DEFAULT 0`), so apps must add it with a migration before upgrading
 - [PATCH] Fixed `DatabaseConnectionMiddleware`'s commit when the response starts failing ("another operation is in progress") for streaming responses behind a `BaseHTTPMiddleware`: `Database.execute` and `Database.commit_context_connection` now wait for each other on the same connection
 - [MINOR] Added `Database.commit_context_connection` to commit the context connection's writes so far; anything run on it afterwards is committed when the context connection ends
 - [PATCH] Updated `DatabaseConnectionMiddleware` to commit before the response starts, so a client can't get the response and make its next request before the request's writes are visible (writes made while streaming are still committed when the request ends)

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev92
+Version: 0.5.3.dev94
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/core/queues/sql.py

@@ -52,6 +52,7 @@ QueueMessagesTable = sqlalchemy.Table(
     sqlalchemy.Column(key='startedDate', name='started_date', type_=sqlalchemy.DateTime(timezone=True), nullable=True),
     sqlalchemy.Column(key='completedDate', name='completed_date', type_=sqlalchemy.DateTime(timezone=True), nullable=True),
     sqlalchemy.Column(key='lastError', name='last_error', type_=sqlalchemy.Text, nullable=True),
+    sqlalchemy.Column(key='priority', name='priority', type_=sqlalchemy.Integer, nullable=False, server_default='0'),
     sqlalchemy.Index('tbl_queue_messages_idx_queue_name_status_visible_date', 'queueName', 'status', 'visibleDate'),
     sqlalchemy.Index('tbl_queue_messages_ux_queue_name_deduplication_id_pending', 'queueName', 'deduplicationId', unique=True, postgresql_where=_PENDING_PREDICATE, sqlite_where=_PENDING_PREDICATE),
 )
@@ -109,10 +110,10 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
             return sqlalchemy_sqlite.insert(self.table)
         raise InternalServerErrorException(message=f'SqlMessageQueue does not support dialect: {dialectName}')
 
-    async def send_message(self, message: Message, delaySeconds: int = 0) -> None:
-        await self.send_messages(messages=[message], delaySeconds=delaySeconds)
+    async def send_message(self, message: Message, delaySeconds: int = 0, priority: int = 0) -> None:
+        await self.send_messages(messages=[message], delaySeconds=delaySeconds, priority=priority)
 
-    async def send_messages(self, messages: Sequence[Message], delaySeconds: int = 0) -> None:
+    async def send_messages(self, messages: Sequence[Message], delaySeconds: int = 0, priority: int = 0) -> None:
         if not messages:
             return
         now = self.database.now()
@@ -136,13 +137,17 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
                     'status': MESSAGE_STATUS_PENDING,
                     'visibleDate': self.database.now(seconds=delaySeconds),
                     'createdDate': now,
+                    'priority': priority,
                 }
             )
         async with self.database.create_transaction() as connection:
             insertQuery = self._create_insert(dialectName=connection.dialect.name).values(rows)
             earliest = sqlalchemy.func.least if connection.dialect.name == 'postgresql' else sqlalchemy.func.min
+            highest = sqlalchemy.func.greatest if connection.dialect.name == 'postgresql' else sqlalchemy.func.max
             upsertQuery = insertQuery.on_conflict_do_update(
-                index_elements=[self.table.c.queueName, self.table.c.deduplicationId], index_where=_PENDING_PREDICATE, set_={self.table.c.visibleDate: earliest(self.table.c.visibleDate, insertQuery.excluded.visibleDate)}
+                index_elements=[self.table.c.queueName, self.table.c.deduplicationId],
+                index_where=_PENDING_PREDICATE,
+                set_={self.table.c.visibleDate: earliest(self.table.c.visibleDate, insertQuery.excluded.visibleDate), self.table.c.priority: highest(self.table.c.priority, insertQuery.excluded.priority)},
             )
             await self.database.execute(query=upsertQuery, connection=connection)
 
@@ -175,7 +180,7 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
                 .where(self.table.c.queueName == self.queueName)
                 .where(self.table.c.status.in_([MESSAGE_STATUS_PENDING, MESSAGE_STATUS_RUNNING]))
                 .where(self.table.c.visibleDate <= now)
-                .order_by(self.table.c.visibleDate, self.table.c.id)
+                .order_by(self.table.c.priority.desc(), self.table.c.visibleDate, self.table.c.id)
                 .limit(limit)
                 .with_for_update(skip_locked=True)
             )
@@ -194,7 +199,7 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
             )
             result = await self.database.execute(query=claimQuery, connection=connection)
             rows = result.mappings().all()
-        return sorted((SqlMessage.from_row(row=row, table=self.table) for row in rows), key=lambda message: message.id)
+        return [SqlMessage.from_row(row=row, table=self.table) for row in sorted(rows, key=lambda row: (-row[self.table.c.priority], row[self.table.c.id]))]
 
     def _owned_update(self, message: SqlMessage) -> sqlalchemy.Update:
         return sqlalchemy.update(self.table).where(self.table.c.id == message.id).where(self.table.c.lockToken == message.lockToken).where(self.table.c.status == MESSAGE_STATUS_RUNNING)
@@ -237,6 +242,16 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
                     await self.database.execute(query=query, connection=connection)
             except sqlalchemy.exc.IntegrityError:
                 # NOTE(krishan711): an identical message was enqueued while this one ran, so it will do the work instead
+                highest = sqlalchemy.func.greatest if connection.dialect.name == 'postgresql' else sqlalchemy.func.max
+                runningPriority = sqlalchemy.select(self.table.c.priority).where(self.table.c.id == message.id).scalar_subquery()
+                duplicateQuery = (
+                    sqlalchemy.update(self.table)
+                    .where(self.table.c.queueName == self.queueName)
+                    .where(self.table.c.deduplicationId == message.deduplicationId)
+                    .where(self.table.c.status == MESSAGE_STATUS_PENDING)
+                    .values(priority=highest(self.table.c.priority, runningPriority))
+                )
+                await self.database.execute(query=duplicateQuery, connection=connection)
                 query = self._owned_update(message=message).values(status=MESSAGE_STATUS_DEDUPLICATED, lockToken=None, completedDate=self.database.now())
                 await self.database.execute(query=query, connection=connection)
 

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/kiba_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev92
+Version: 0.5.3.dev94
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/makefile

@@ -45,11 +45,7 @@ clean:
 publish: build
 	@ uv publish
 
-GIT_LAST_TAG=$(shell git describe --tags --abbrev=0)
-GIT_COUNT=$(shell git rev-list $(GIT_LAST_TAG)..HEAD --count)
 publish-dev:
-	@ uv run version --part dev --count $(GIT_COUNT)
-	@ uv build
-	@ uv publish
+	@ uv run publish-dev
 
 .PHONY: *

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiba-core"
-version = "0.5.3.dev92"
+version = "0.5.3.dev94"
 description = "Kiba Labs' python utilities"
 readme = "README.md"
 requires-python = ">=3.12, <4"
@@ -60,7 +60,7 @@ types = [
 
 [dependency-groups]
 dev = [
-    "kiba-build==0.1.11.dev22",
+    "kiba-build==0.1.11.dev23",
 ]
 
 [project.urls]

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/tests/queues/test_sql_queue.py

@@ -116,6 +116,24 @@ async def test_duplicate_send_keeps_the_earliest_visibility(workers: tuple[SqlMe
     assert await workerA.get_message() is not None
 
 
+async def test_higher_priority_messages_are_claimed_before_older_ones(workers: tuple[SqlMessageQueue, SqlMessageQueue]):
+    workerA, _ = workers
+    await workerA.send_messages(messages=[_message(deduplicationId=None, userId=str(index)) for index in range(3)])
+    await workerA.send_message(message=_message(deduplicationId=None, userId='urgent'), priority=1)
+    messages = await workerA.get_messages(limit=2)
+    assert [message.content['userId'] for message in messages] == ['urgent', '0']
+
+
+async def test_duplicate_send_keeps_the_highest_priority(workers: tuple[SqlMessageQueue, SqlMessageQueue]):
+    workerA, _ = workers
+    await workerA.send_message(message=_message(deduplicationId=None, userId='other'))
+    await workerA.send_message(message=_message())
+    await workerA.send_message(message=_message(), priority=1)
+    await workerA.send_message(message=_message())
+    assert [(row['content']['userId'], row['priority']) for row in await _rows(queue=workerA)] == [('other', 0), ('user-1', 1)]
+    assert (await _claim(queue=workerA)).content['userId'] == 'user-1'
+
+
 async def test_processor_fails_message_even_when_notifications_fail(workers: tuple[SqlMessageQueue, SqlMessageQueue]):
     workerA, _ = workers
 
@@ -376,6 +394,15 @@ async def test_retry_is_folded_into_an_identical_pending_message(workers: tuple[
     assert [row['status'] for row in await _rows(queue=workerA)] == ['deduplicated', 'pending']
 
 
+async def test_retry_folded_into_a_lower_priority_duplicate_raises_its_priority(workers: tuple[SqlMessageQueue, SqlMessageQueue]):
+    workerA, _ = workers
+    await workerA.send_message(message=_message(), priority=1)
+    message = await _claim(queue=workerA)
+    await workerA.send_message(message=_message())
+    await workerA.retry_message(message=message)
+    assert [(row['status'], row['priority']) for row in await _rows(queue=workerA)] == [('deduplicated', 1), ('pending', 1)]
+
+
 async def test_release_hands_the_message_back_without_using_an_attempt(workers: tuple[SqlMessageQueue, SqlMessageQueue]):
     workerA, workerB = workers
     await workerA.send_message(message=_message())

{kiba_core-0.5.3.dev92 → kiba_core-0.5.3.dev94}/uv.lock

@@ -1668,7 +1668,7 @@ wheels = [
 
 [[package]]
 name = "kiba-build"
-version = "0.1.11.dev22"
+version = "0.1.11.dev23"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "asyncclick" },
@@ -1684,9 +1684,9 @@ dependencies = [
     { name = "ty" },
     { name = "wheel" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/80/bc/cb0ca252ccbb87c2255f6243ee3711fd429ce92a77731baee202fd106c7a/kiba_build-0.1.11.dev22.tar.gz", hash = "sha256:3dbbeab804930a2b1967c6e76eeacec3444f345d7074f0eb99a677f50ceea666", size = 99189, upload-time = "2026-11-02T10:21:00.658Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/6e/95194ff5f14cfd0738c753439421edae2250985e37840eed930ac06b88e1/kiba_build-0.1.11.dev23.tar.gz", hash = "sha256:17c08e9231fe5b463df132195079f0efced4dfe48cf16e5c09b0831a44b1e4e6", size = 99616, upload-time = "2026-11-05T15:32:28.417Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/ac/e5be2d28d6094d5575ea0c94084640e44cd36e8c4c0d0777ce1aef42597c/kiba_build-0.1.11.dev22-py3-none-any.whl", hash = "sha256:ee978dc3c8175d8e549867605aadbc8369e261579df31254ad1b17371a2952c7", size = 12374, upload-time = "2026-11-02T10:20:59.566Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/0c/3e341790a689c8365ad7575451ca936adb9f1c6f7ae05d98704b728c5b1d/kiba_build-0.1.11.dev23-py3-none-any.whl", hash = "sha256:03fec44ef8dc282147940771521a1e53f83dc2caf2758fdc48c78de613bfd857", size = 13128, upload-time = "2026-11-05T15:32:27.481Z" },
 ]
 
 [[package]]
@@ -1779,7 +1779,7 @@ requires-dist = [
 provides-extras = ["api", "core-api", "storage", "queues", "queue-sqs", "queue-aqs", "queue-cosmos", "database-psql", "database-sqlite", "requester", "web3", "cron", "types"]
 
 [package.metadata.requires-dev]
-dev = [{ name = "kiba-build", specifier = "==0.1.11.dev22" }]
+dev = [{ name = "kiba-build", specifier = "==0.1.11.dev23" }]
 
 [[package]]
 name = "librt"