kiba-core 0.5.3.dev62__tar.gz → 0.5.3.dev64__tar.gz

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/CHANGELOG.md

@@ -8,6 +8,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ## [Unreleased]
 
 ### Added
+- [MAJOR] Added abstract `MessageQueue.get_message_count` (implemented for SQS, AQS, SQL and Cosmos queues) for the number of messages waiting to be processed
+- [MAJOR] Added abstract `MessageQueue.get_inflight_message_count` (implemented for SQS, SQL and Cosmos queues; AQS raises `NotImplementedError` as Azure does not expose it) for the number of messages currently being processed
 - [MAJOR] Reworked `route` to compose JSON or streaming transport, application-resolved authorization, and rate limiting
 - [MAJOR] Replaced authorization-decorator sequences with named `RouteAuthResolver` policies
 - [MINOR] Added `authJwt`, `authBasic`, and `originIp` to `KibaApiRequest`

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/PKG-INFO

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

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/api/authorizer.py

@@ -135,6 +135,19 @@ async def authorize_static_token_request[ApiRequest: BaseModel](request: KibaApi
         raise ForbiddenException(message='AUTH_INVALID')
 
 
+async def authorize_static_header_request[ApiRequest: BaseModel](
+    request: KibaApiRequest[ApiRequest],
+    *,
+    headerName: str,
+    token: str,
+) -> None:
+    providedToken = request.headers.get(headerName)
+    if providedToken is None:
+        raise ForbiddenException(message='AUTH_NOT_PROVIDED')
+    if not hmac.compare_digest(providedToken, token):
+        raise ForbiddenException(message='AUTH_INVALID')
+
+
 def authorize_token[ApiRequest: BaseModel](  # type: ignore[explicit-any]
     authorizer: TokenAuthorizer,
     *,

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/queues/aqs.py

@@ -80,3 +80,12 @@ class AqsMessageQueue(MessageQueue[AqsMessage]):
         if not self._aqsClient:
             raise InternalServerErrorException('You need to call .connect() before trying to delete messages')
         await self._aqsClient.delete_message(message=message.aqsId, pop_receipt=message.popReceipt)
+
+    async def get_message_count(self) -> int:
+        if not self._aqsClient:
+            raise InternalServerErrorException('You need to call .connect() before trying to count messages')
+        properties = await self._aqsClient.get_queue_properties()
+        return int(properties.approximate_message_count or 0)
+
+    async def get_inflight_message_count(self) -> int:
+        raise NotImplementedError('Azure Storage Queues do not expose an in-flight message count')

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/queues/cosmos.py

@@ -188,3 +188,27 @@ class CosmosMessageQueue(MessageQueue[CosmosMessage]):
             ],
             partition_key=self.queueName,
         )
+
+    async def get_message_count(self) -> int:
+        counts = self.container.query_items(
+            query='SELECT COUNT(1) AS messageCount FROM c WHERE c.itemType = @itemType AND c.queueName = @queueName AND c.visibleDate <= @now',
+            parameters=[
+                {'name': '@itemType', 'value': 'message'},
+                {'name': '@queueName', 'value': self.queueName},
+                {'name': '@now', 'value': time.time()},
+            ],
+            partition_key=self.queueName,
+        )
+        return sum([int(item['messageCount']) async for item in counts])
+
+    async def get_inflight_message_count(self) -> int:
+        counts = self.container.query_items(
+            query='SELECT COUNT(1) AS messageCount FROM c WHERE c.itemType = @itemType AND c.queueName = @queueName AND c.leaseId != null AND c.visibleDate > @now',
+            parameters=[
+                {'name': '@itemType', 'value': 'message'},
+                {'name': '@queueName', 'value': self.queueName},
+                {'name': '@now', 'value': time.time()},
+            ],
+            partition_key=self.queueName,
+        )
+        return sum([int(item['messageCount']) async for item in counts])

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/queues/message_queue.py

@@ -33,3 +33,11 @@ class MessageQueue[MessageType: Message](ABC):
     @abc.abstractmethod
     async def delete_message(self, message: MessageType) -> None:
         raise NotImplementedError
+
+    @abc.abstractmethod
+    async def get_message_count(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def get_inflight_message_count(self) -> int:
+        raise NotImplementedError

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/queues/sql.py

@@ -163,3 +163,13 @@ class SqlMessageQueue(MessageQueue[SqlMessage]):
         async with self.database.create_transaction() as connection:
             deleteQuery = sqlalchemy.delete(self.table).where(self.table.c.id == message.id).where(self.table.c.lockToken == message.lockToken)
             await self.database.execute(query=deleteQuery, connection=connection)  # type: ignore[arg-type]
+
+    async def get_message_count(self) -> int:
+        countQuery = sqlalchemy.select(sqlalchemy.func.count()).select_from(self.table).where(self.table.c.queueName == self.queueName).where(self.table.c.visibleDate <= date_util.datetime_from_now())
+        result = await self.database.execute(query=countQuery)
+        return int(result.scalar_one())
+
+    async def get_inflight_message_count(self) -> int:
+        countQuery = sqlalchemy.select(sqlalchemy.func.count()).select_from(self.table).where(self.table.c.queueName == self.queueName).where(self.table.c.lockToken.is_not(None)).where(self.table.c.visibleDate > date_util.datetime_from_now())
+        result = await self.database.execute(query=countQuery)
+        return int(result.scalar_one())

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/core/queues/sqs.py

@@ -96,3 +96,15 @@ class SqsMessageQueue(MessageQueue[SqsMessage]):
         if not self._sqsClient:
             raise InternalServerErrorException('You need to call .connect() before trying to delete messages')
         await self._sqsClient.delete_message(QueueUrl=self.queueUrl, ReceiptHandle=message.receiptHandle)
+
+    async def get_message_count(self) -> int:
+        if not self._sqsClient:
+            raise InternalServerErrorException('You need to call .connect() before trying to count messages')
+        response = await self._sqsClient.get_queue_attributes(QueueUrl=self.queueUrl, AttributeNames=['ApproximateNumberOfMessages'])
+        return int(response['Attributes']['ApproximateNumberOfMessages'])
+
+    async def get_inflight_message_count(self) -> int:
+        if not self._sqsClient:
+            raise InternalServerErrorException('You need to call .connect() before trying to count messages')
+        response = await self._sqsClient.get_queue_attributes(QueueUrl=self.queueUrl, AttributeNames=['ApproximateNumberOfMessagesNotVisible'])
+        return int(response['Attributes']['ApproximateNumberOfMessagesNotVisible'])

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/kiba_core.egg-info/PKG-INFO

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

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiba-core"
-version = "0.5.3.dev62"
+version = "0.5.3.dev64"
 description = "Kiba Labs' python utilities"
 readme = "README.md"
 requires-python = ">=3.12, <4"

{kiba_core-0.5.3.dev62 → kiba_core-0.5.3.dev64}/tests/api/test_authorizer.py

@@ -7,7 +7,7 @@ from starlette.routing import Route
 from starlette.testclient import TestClient
 
 from core.api.api_request import KibaApiRequest
-from core.api.authorizer import Authorizer, SignatureAuthorizer, StaticTokenAuthorizer, authorize_bearer_jwt, authorize_signature, authorize_token
+from core.api.authorizer import Authorizer, SignatureAuthorizer, StaticTokenAuthorizer, authorize_bearer_jwt, authorize_signature, authorize_static_header_request, authorize_token
 from core.api.json_route import json_route
 from core.api.middleware.exception_handling_middleware import ExceptionHandlingMiddleware
 from core.api.streaming_json_route import streaming_json_route
@@ -133,6 +133,18 @@ def token_streaming_client():
     return TestClient(app, raise_server_exceptions=False)
 
 
+@pytest.fixture
+def static_header_json_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    async def protected_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        await authorize_static_header_request(request=request, headerName='X-Test-Webhook-Secret', token=VALID_STATIC_TOKEN)
+        return SimpleResponse(result=request.data.value)
+
+    app = Starlette(routes=[Route('/protected', protected_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
 # --- authorize_bearer_jwt + json_route ---
 
 def test_jwt_json_no_auth_header_returns_403(jwt_json_client):
@@ -235,6 +247,24 @@ def test_token_json_valid_token_returns_200(token_json_client):
     assert response.json()['result'] == 'hello'
 
 
+# --- authorize_static_header_request + json_route ---
+
+def test_static_header_json_no_secret_returns_403(static_header_json_client):
+    response = static_header_json_client.post('/protected', json={'value': 'hello'})
+    assert response.status_code == 403
+
+
+def test_static_header_json_invalid_secret_returns_403(static_header_json_client):
+    response = static_header_json_client.post('/protected', json={'value': 'hello'}, headers={'X-Test-Webhook-Secret': 'wrong-token'})
+    assert response.status_code == 403
+
+
+def test_static_header_json_valid_secret_returns_200(static_header_json_client):
+    response = static_header_json_client.post('/protected', json={'value': 'hello'}, headers={'X-Test-Webhook-Secret': VALID_STATIC_TOKEN})
+    assert response.status_code == 200
+    assert response.json()['result'] == 'hello'
+
+
 # --- authorize_token + streaming_json_route ---
 
 def test_token_streaming_no_auth_header_returns_403(token_streaming_client):