kiba-core 0.5.3.dev49__tar.gz → 0.5.3.dev51__tar.gz

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/CHANGELOG.md

@@ -32,6 +32,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - [MINOR] Added `call` and `multicall` to `EthClientInterface`
 - [MINOR] Truncate discord notification messages to fit api
 - [MINOR] Added `blockNumber` to `EthClient.multicall` function
+- [MINOR] Added `SqlMessageQueue` and `CosmosMessageQueue` to support database backed queues
 
 ### Changed
 

kiba_core-0.5.3.dev51/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: kiba-core
+Version: 0.5.3.dev51
+Summary: Kiba Labs' python utilities
+Project-URL: repository, https://github.com/kibalabs/core-py
+Requires-Python: <4,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: orjson>=3.11.9
+Provides-Extra: api
+Requires-Dist: fastapi>=0.139.1; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.51.0; extra == "api"
+Provides-Extra: core-api
+Requires-Dist: starlette>=1.3.1; extra == "core-api"
+Requires-Dist: uvicorn[standard]>=0.51.0; extra == "core-api"
+Provides-Extra: storage
+Requires-Dist: aiobotocore>=3.7.0; extra == "storage"
+Provides-Extra: queues
+Requires-Dist: aiobotocore>=3.7.0; extra == "queues"
+Provides-Extra: queue-sqs
+Requires-Dist: aiobotocore>=3.7.0; extra == "queue-sqs"
+Provides-Extra: queue-aqs
+Requires-Dist: azure-storage-queue[aio]>=12.17.0; extra == "queue-aqs"
+Provides-Extra: queue-cosmos
+Requires-Dist: azure-cosmos>=4.16.2; extra == "queue-cosmos"
+Provides-Extra: database-psql
+Requires-Dist: sqlalchemy[asyncio]>=2.0.51; extra == "database-psql"
+Requires-Dist: asyncpg>=0.31.0; extra == "database-psql"
+Provides-Extra: database-sqlite
+Requires-Dist: sqlalchemy[asyncio]>=2.0.51; extra == "database-sqlite"
+Requires-Dist: aiosqlite>=0.22.1; extra == "database-sqlite"
+Provides-Extra: requester
+Requires-Dist: httpx>=0.28.1; extra == "requester"
+Provides-Extra: web3
+Requires-Dist: web3>=7.16.0; extra == "web3"
+Provides-Extra: types
+Requires-Dist: types-aiobotocore[essential]>=3.7.0; extra == "types"
+Requires-Dist: types-aiofiles>=25.1.0.20260518; extra == "types"
+
+# Core-Py

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/core/queues/aqs.py

@@ -12,7 +12,7 @@ from core.queues.model import Message
 from core.util import list_util
 
 
-class AqsMessage(Message):  # type: ignore[explicit-any]
+class AqsMessage(Message):
     aqsId: str
     popReceipt: str | None
 
@@ -25,6 +25,7 @@ class AqsMessage(Message):  # type: ignore[explicit-any]
             requestId=message.requestId,
             postCount=message.postCount,
             postDate=message.postDate,
+            deduplicationId=message.deduplicationId,
             aqsId=aqsMessage.id,
             popReceipt=aqsMessage.pop_receipt,
         )

kiba_core-0.5.3.dev51/core/queues/cosmos.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import time
+import uuid
+from collections.abc import Sequence
+from typing import Any
+
+from azure.core import MatchConditions
+from azure.cosmos import exceptions as cosmos_exceptions
+from azure.cosmos.aio import ContainerProxy
+
+from core.queues.message_queue import MessageQueue
+from core.queues.model import Message
+from core.util.typing_util import JsonObject
+
+
+class CosmosMessage(Message):
+    id: str
+    leaseId: str
+    etag: str
+
+    @classmethod
+    def from_item(cls, item: JsonObject) -> CosmosMessage:
+        message = Message.model_validate(
+            {
+                'command': item['command'],
+                'content': item['content'],
+                'requestId': item.get('requestId'),
+                'postCount': item.get('postCount'),
+                'postDate': item.get('postDate'),
+                'deduplicationId': item.get('deduplicationId'),
+            }
+        )
+        return cls(
+            command=message.command,
+            content=message.content,
+            requestId=message.requestId,
+            postCount=message.postCount,
+            postDate=message.postDate,
+            deduplicationId=message.deduplicationId,
+            id=str(item['id']),
+            leaseId=str(item['leaseId']),
+            etag=str(item['_etag']),
+        )
+
+
+class CosmosMessageQueue(MessageQueue[CosmosMessage]):
+    def __init__(self, container: ContainerProxy, queueName: str, pollIntervalSeconds: float = 1.0) -> None:
+        self.container = container
+        self.queueName = queueName
+        self.pollIntervalSeconds = pollIntervalSeconds
+
+    async def connect(self) -> None:
+        # The caller supplies a shared ContainerProxy and owns CosmosClient lifecycle.
+        return None
+
+    async def disconnect(self) -> None:
+        # The caller supplies a shared ContainerProxy and owns CosmosClient lifecycle.
+        return None
+
+    @staticmethod
+    def _item_body(message: Message, queueName: str, itemId: str, visibleDate: float, createdDate: float) -> dict[str, Any]:  # type: ignore[explicit-any]
+        return {
+            'id': itemId,
+            'itemType': 'message',
+            'queueName': queueName,
+            'command': message.command,
+            'content': message.content,
+            'requestId': message.requestId,
+            'postCount': message.postCount,
+            'postDate': message.postDate.isoformat() if message.postDate else None,
+            'deduplicationId': message.deduplicationId,
+            'leaseId': None,
+            'visibleDate': visibleDate,
+            'createdDate': createdDate,
+        }
+
+    async def send_message(self, message: Message, delaySeconds: int = 0) -> None:
+        await self.send_messages(messages=[message], delaySeconds=delaySeconds)
+
+    async def send_messages(self, messages: Sequence[Message], delaySeconds: int = 0) -> None:
+        if not messages:
+            return
+        now = time.time()
+        visibleDate = now + delaySeconds
+        for message in messages:
+            message.prepare_for_send()
+            itemId = uuid.uuid4().hex
+            item = self._item_body(message=message, queueName=self.queueName, itemId=itemId, visibleDate=visibleDate, createdDate=now)
+            if message.deduplicationId is None:
+                # The SDK derives the create partition key from the body's queueName field.
+                await self.container.create_item(body=item)
+                continue
+
+            deduplicationKey = f'{self.queueName}:{message.deduplicationId}'
+            deduplicationItemId = f'dedup-{hashlib.sha256(deduplicationKey.encode()).hexdigest()}'
+            deduplicationItem = {
+                'id': deduplicationItemId,
+                'itemType': 'deduplication',
+                'queueName': self.queueName,
+                'deduplicationId': message.deduplicationId,
+                'messageId': itemId,
+            }
+            try:
+                await self.container.execute_item_batch(
+                    batch_operations=[
+                        ('create', (deduplicationItem,)),
+                        ('create', (item,)),
+                    ],
+                    partition_key=self.queueName,
+                )
+            except cosmos_exceptions.CosmosBatchOperationError as exception:
+                if exception.error_index != 0 or exception.status_code != 409:  # noqa: PLR2004
+                    raise
+
+    async def get_message(self, expectedProcessingSeconds: int = 300, longPollSeconds: int = 0) -> CosmosMessage | None:
+        messages = await self.get_messages(limit=1, expectedProcessingSeconds=expectedProcessingSeconds, longPollSeconds=longPollSeconds)
+        return messages[0] if messages else None
+
+    async def get_messages(self, limit: int = 1, expectedProcessingSeconds: int = 300, longPollSeconds: int = 0) -> list[CosmosMessage]:
+        if limit <= 0:
+            return []
+        deadline = time.monotonic() + longPollSeconds
+        while True:
+            messages = await self._claim_messages(limit=limit, expectedProcessingSeconds=expectedProcessingSeconds)
+            if messages or time.monotonic() >= deadline:
+                return messages
+            await asyncio.sleep(min(self.pollIntervalSeconds, max(deadline - time.monotonic(), 0)))
+
+    async def _claim_messages(self, limit: int, expectedProcessingSeconds: int) -> list[CosmosMessage]:
+        now = time.time()
+        query = 'SELECT * FROM c WHERE c.itemType = @itemType AND c.queueName = @queueName AND c.visibleDate <= @now ORDER BY c.createdDate'
+        candidates = self.container.query_items(
+            query=query,
+            parameters=[
+                {'name': '@itemType', 'value': 'message'},
+                {'name': '@queueName', 'value': self.queueName},
+                {'name': '@now', 'value': now},
+            ],
+            partition_key=self.queueName,
+            # Read ahead so ETag conflicts caused by concurrent workers do not unnecessarily
+            # under-fill this batch; candidates that another worker claims are skipped.
+            max_item_count=max(limit * 2, 10),
+        )
+        messages: list[CosmosMessage] = []
+        async for candidate in candidates:
+            item = {key: value for key, value in candidate.items() if not key.startswith('_')}
+            leaseId = uuid.uuid4().hex
+            item['leaseId'] = leaseId
+            item['visibleDate'] = now + expectedProcessingSeconds
+            try:
+                claimedItem = await self.container.replace_item(
+                    item=candidate['id'],
+                    body=item,
+                    etag=candidate['_etag'],
+                    match_condition=MatchConditions.IfNotModified,
+                    # The async SDK derives this from the body, but explicitly pass it in
+                    # request options so the replace is targeted to this logical partition.
+                    request_options={'partitionKey': self.queueName},
+                )
+            except cosmos_exceptions.CosmosHttpResponseError as exception:
+                if exception.status_code == 412:  # noqa: PLR2004
+                    continue
+                raise
+            messages.append(CosmosMessage.from_item(item=claimedItem))
+            if len(messages) >= limit:
+                break
+        return messages
+
+    async def delete_message(self, message: CosmosMessage) -> None:
+        if message.deduplicationId is None:
+            await self.container.delete_item(
+                item=message.id,
+                partition_key=self.queueName,
+                etag=message.etag,
+                match_condition=MatchConditions.IfNotModified,
+            )
+            return
+
+        deduplicationKey = f'{self.queueName}:{message.deduplicationId}'
+        deduplicationItemId = f'dedup-{hashlib.sha256(deduplicationKey.encode()).hexdigest()}'
+        await self.container.execute_item_batch(
+            batch_operations=[
+                ('delete', (message.id,), {'if_match_etag': message.etag}),
+                ('delete', (deduplicationItemId,)),
+            ],
+            partition_key=self.queueName,
+        )

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/core/queues/model.py

@@ -1,22 +1,24 @@
 from __future__ import annotations
 
 import datetime
+import hashlib
 import typing
 import uuid
-from typing import Any
 
 from pydantic import BaseModel
 from pydantic.fields import ModelPrivateAttr
 
 from core.util import date_util
+from core.util.typing_util import JsonObject
 
 
-class Message(BaseModel):  # type: ignore[explicit-any]
+class Message(BaseModel):
     command: str
-    content: dict[str, Any]  # type: ignore[explicit-any]
+    content: JsonObject
     requestId: str | None
     postCount: int | None
     postDate: datetime.datetime | None
+    deduplicationId: str | None = None
 
     def prepare_for_send(self) -> None:
         self.requestId = self.requestId or str(uuid.uuid4()).replace('-', '')
@@ -31,6 +33,10 @@ class MessageContent(BaseModel):
     def get_command(cls) -> str:
         return typing.cast(str, typing.cast(ModelPrivateAttr, cls._COMMAND).get_default())
 
+    def get_deduplication_id(self) -> str | None:
+        payload = f'{self.get_command()}:{self.model_dump_json()}'
+        return hashlib.sha256(payload.encode()).hexdigest()
+
     def to_message(self) -> Message:
         return Message(
             command=self.get_command(),
@@ -38,4 +44,10 @@ class MessageContent(BaseModel):
             requestId=None,
             postCount=None,
             postDate=None,
+            deduplicationId=self.get_deduplication_id(),
         )
+
+
+class NonDeduplicatedMessageContent(MessageContent):
+    def get_deduplication_id(self) -> str | None:
+        return None

kiba_core-0.5.3.dev51/core/queues/sql.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from collections.abc import Mapping
+from collections.abc import Sequence
+from typing import Any
+
+import sqlalchemy
+from sqlalchemy.dialects import postgresql as sqlalchemy_psql
+
+from core.queues.message_queue import MessageQueue
+from core.queues.model import Message
+from core.store.database import Database
+from core.util import date_util
+
+# NOTE: this table is owned here (not in the consuming app's schema.py) so it can ship with
+# core-py. To include it in an app's own alembic-tracked metadata (so autogenerate creates the
+# table), call `QueueMessagesTable.to_metadata(appMetadata)` from the app's schema module.
+QueueMessagesMetadata = sqlalchemy.MetaData()
+
+QueueMessagesTable = sqlalchemy.Table(
+    'tbl_queue_messages',
+    QueueMessagesMetadata,
+    sqlalchemy.Column(key='id', name='id', type_=sqlalchemy.Integer, autoincrement=True, primary_key=True, nullable=False),
+    sqlalchemy.Column(key='createdDate', name='created_date', type_=sqlalchemy.DateTime(timezone=True), nullable=False),
+    sqlalchemy.Column(key='queueName', name='queue_name', type_=sqlalchemy.Text, nullable=False),
+    sqlalchemy.Column(key='command', name='command', type_=sqlalchemy.Text, nullable=False),
+    sqlalchemy.Column(key='content', name='content', type_=sqlalchemy.JSON().with_variant(sqlalchemy_psql.JSONB(), 'postgresql'), nullable=False),
+    sqlalchemy.Column(key='requestId', name='request_id', type_=sqlalchemy.Text, nullable=True),
+    sqlalchemy.Column(key='postCount', name='post_count', type_=sqlalchemy.Integer, nullable=True),
+    sqlalchemy.Column(key='postDate', name='post_date', type_=sqlalchemy.DateTime(timezone=True), nullable=True),
+    sqlalchemy.Column(key='deduplicationId', name='deduplication_id', type_=sqlalchemy.Text, nullable=True),
+    sqlalchemy.Column(key='lockToken', name='lock_token', type_=sqlalchemy.Text, nullable=True),
+    sqlalchemy.Column(key='visibleDate', name='visible_date', type_=sqlalchemy.DateTime(timezone=True), nullable=False, index=True),
+    sqlalchemy.UniqueConstraint('queueName', 'deduplicationId', name='tbl_queue_messages_ux_queue_name_deduplication_id'),
+)
+
+
+class SqlMessage(Message):
+    id: int
+    lockToken: str
+
+    @staticmethod
+    def _get_row_value(row: Mapping[str, Any], key: str, databaseKey: str) -> Any:  # type: ignore[explicit-any]
+        if key in row:
+            return row[key]
+        return row[databaseKey]
+
+    @classmethod
+    def from_row(cls, row: Mapping[str, Any]) -> SqlMessage:  # type: ignore[explicit-any]
+        return cls(
+            id=cls._get_row_value(row, 'id', 'id'),
+            command=cls._get_row_value(row, 'command', 'command'),
+            content=cls._get_row_value(row, 'content', 'content'),
+            requestId=cls._get_row_value(row, 'requestId', 'request_id'),
+            postCount=cls._get_row_value(row, 'postCount', 'post_count'),
+            postDate=cls._get_row_value(row, 'postDate', 'post_date'),
+            deduplicationId=cls._get_row_value(row, 'deduplicationId', 'deduplication_id'),
+            lockToken=cls._get_row_value(row, 'lockToken', 'lock_token'),
+        )
+
+
+class SqlMessageQueue(MessageQueue[SqlMessage]):
+    def __init__(self, database: Database, queueName: str, table: sqlalchemy.Table = QueueMessagesTable, pollIntervalSeconds: float = 1.0) -> None:
+        self.database = database
+        self.queueName = queueName
+        self.table = table
+        self.pollIntervalSeconds = pollIntervalSeconds
+
+    async def connect(self) -> None:
+        pass
+
+    async def disconnect(self) -> None:
+        pass
+
+    def _is_deduplication_conflict(self, exception: sqlalchemy.exc.IntegrityError) -> bool:
+        deduplicationConstraintName = next(
+            (constraint.name for constraint in self.table.constraints if isinstance(constraint, sqlalchemy.UniqueConstraint) and {column.key for column in constraint.columns} == {'queueName', 'deduplicationId'}),
+            None,
+        )
+        original = exception.orig
+        originalConstraintName = getattr(original, 'constraint_name', None)
+        if originalConstraintName is None:
+            originalConstraintName = getattr(getattr(original, 'diag', None), 'constraint_name', None)
+        if deduplicationConstraintName is not None:
+            constraintName = str(deduplicationConstraintName)
+            if originalConstraintName == constraintName:
+                return True
+            errorMessage = str(original)
+            if constraintName in errorMessage:
+                return True
+        errorMessage = str(original)
+        sqliteColumns = f'{self.table.name}.{self.table.c.queueName.name}, {self.table.name}.{self.table.c.deduplicationId.name}'
+        return 'unique constraint failed:' in errorMessage.lower() and sqliteColumns in errorMessage
+
+    async def send_message(self, message: Message, delaySeconds: int = 0) -> None:
+        await self.send_messages(messages=[message], delaySeconds=delaySeconds)
+
+    async def send_messages(self, messages: Sequence[Message], delaySeconds: int = 0) -> None:
+        if not messages:
+            return
+        now = date_util.datetime_from_now()
+        visibleDate = date_util.datetime_from_now(seconds=delaySeconds)
+        async with self.database.create_transaction() as connection:
+            for message in messages:
+                message.prepare_for_send()
+                insertQuery = self.table.insert().values(
+                    queueName=self.queueName,
+                    command=message.command,
+                    content=message.content,
+                    requestId=message.requestId,
+                    postCount=message.postCount,
+                    postDate=message.postDate,
+                    deduplicationId=message.deduplicationId,
+                    lockToken=None,
+                    visibleDate=visibleDate,
+                    createdDate=now,
+                )
+                if message.deduplicationId is not None:
+                    # A message with the same (queueName, deduplicationId) may already be queued;
+                    # the unique constraint on those columns rejects it. Use a SAVEPOINT so that
+                    # failure only rolls back this one insert, not the whole batch's transaction.
+                    try:
+                        async with connection.begin_nested():
+                            await self.database.execute(query=insertQuery, connection=connection)  # type: ignore[arg-type]
+                    except sqlalchemy.exc.IntegrityError as exception:
+                        if not self._is_deduplication_conflict(exception):
+                            raise
+                else:
+                    await self.database.execute(query=insertQuery, connection=connection)  # type: ignore[arg-type]
+
+    async def get_message(self, expectedProcessingSeconds: int = 300, longPollSeconds: int = 0) -> SqlMessage | None:
+        messages = await self.get_messages(limit=1, expectedProcessingSeconds=expectedProcessingSeconds, longPollSeconds=longPollSeconds)
+        return messages[0] if messages else None
+
+    async def get_messages(self, limit: int = 1, expectedProcessingSeconds: int = 300, longPollSeconds: int = 0) -> list[SqlMessage]:
+        deadline = time.monotonic() + longPollSeconds
+        while True:
+            messages = await self._claim_messages(limit=limit, expectedProcessingSeconds=expectedProcessingSeconds)
+            if messages or time.monotonic() >= deadline:
+                return messages
+            await asyncio.sleep(min(self.pollIntervalSeconds, max(deadline - time.monotonic(), 0)))
+
+    async def _claim_messages(self, limit: int, expectedProcessingSeconds: int) -> list[SqlMessage]:
+        now = date_util.datetime_from_now()
+        newVisibleDate = date_util.datetime_from_now(seconds=expectedProcessingSeconds)
+        async with self.database.create_transaction() as connection:
+            selectQuery = sqlalchemy.select(self.table).where(self.table.c.queueName == self.queueName).where(self.table.c.visibleDate <= now).order_by(self.table.c.id).limit(limit).with_for_update(skip_locked=True)
+            result = await self.database.execute(query=selectQuery, connection=connection)
+            rows = result.mappings().all()
+            messages: list[SqlMessage] = []
+            for row in rows:
+                lockToken = str(uuid.uuid4())
+                updateQuery = sqlalchemy.update(self.table).where(self.table.c.id == row['id']).values(lockToken=lockToken, visibleDate=newVisibleDate)
+                await self.database.execute(query=updateQuery, connection=connection)  # type: ignore[arg-type]
+                messages.append(SqlMessage.from_row(row={**row, 'lockToken': lockToken}))
+            return messages
+
+    async def delete_message(self, message: SqlMessage) -> None:
+        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]

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/core/queues/sqs.py

@@ -22,7 +22,7 @@ else:
     RawSqsMessageTypeDef = Any
 
 
-class SqsMessage(Message):  # type: ignore[explicit-any]
+class SqsMessage(Message):
     receiptHandle: str
 
     @classmethod
@@ -34,6 +34,7 @@ class SqsMessage(Message):  # type: ignore[explicit-any]
             requestId=message.requestId,
             postCount=message.postCount,
             postDate=message.postDate,
+            deduplicationId=message.deduplicationId,
             receiptHandle=sqsMessage['ReceiptHandle'],
         )
 

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/core/util/date_util.py

@@ -29,6 +29,11 @@ def datetime_from_now(days: int = 0, seconds: float = 0, milliseconds: int = 0,
 
 
 def datetime_from_string(dateString: str, dateFormat: str = JSON_DATE_FORMAT) -> datetime.datetime:
+    try:
+        dt = datetime.datetime.fromisoformat(dateString)
+        return dt.astimezone(datetime.UTC) if dt.tzinfo is not None else dt.replace(tzinfo=datetime.UTC)
+    except (TypeError, ValueError):
+        pass
     try:
         dt = datetime.datetime.strptime(dateString, dateFormat).replace(tzinfo=datetime.UTC)
     except (TypeError, ValueError) as exception:

kiba_core-0.5.3.dev51/kiba_core.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: kiba-core
+Version: 0.5.3.dev51
+Summary: Kiba Labs' python utilities
+Project-URL: repository, https://github.com/kibalabs/core-py
+Requires-Python: <4,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: orjson>=3.11.9
+Provides-Extra: api
+Requires-Dist: fastapi>=0.139.1; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.51.0; extra == "api"
+Provides-Extra: core-api
+Requires-Dist: starlette>=1.3.1; extra == "core-api"
+Requires-Dist: uvicorn[standard]>=0.51.0; extra == "core-api"
+Provides-Extra: storage
+Requires-Dist: aiobotocore>=3.7.0; extra == "storage"
+Provides-Extra: queues
+Requires-Dist: aiobotocore>=3.7.0; extra == "queues"
+Provides-Extra: queue-sqs
+Requires-Dist: aiobotocore>=3.7.0; extra == "queue-sqs"
+Provides-Extra: queue-aqs
+Requires-Dist: azure-storage-queue[aio]>=12.17.0; extra == "queue-aqs"
+Provides-Extra: queue-cosmos
+Requires-Dist: azure-cosmos>=4.16.2; extra == "queue-cosmos"
+Provides-Extra: database-psql
+Requires-Dist: sqlalchemy[asyncio]>=2.0.51; extra == "database-psql"
+Requires-Dist: asyncpg>=0.31.0; extra == "database-psql"
+Provides-Extra: database-sqlite
+Requires-Dist: sqlalchemy[asyncio]>=2.0.51; extra == "database-sqlite"
+Requires-Dist: aiosqlite>=0.22.1; extra == "database-sqlite"
+Provides-Extra: requester
+Requires-Dist: httpx>=0.28.1; extra == "requester"
+Provides-Extra: web3
+Requires-Dist: web3>=7.16.0; extra == "web3"
+Provides-Extra: types
+Requires-Dist: types-aiobotocore[essential]>=3.7.0; extra == "types"
+Requires-Dist: types-aiofiles>=25.1.0.20260518; extra == "types"
+
+# Core-Py

{kiba_core-0.5.3.dev49 → kiba_core-0.5.3.dev51}/kiba_core.egg-info/SOURCES.txt

@@ -43,9 +43,11 @@ core/notifications/notification_client.py
 core/notifications/slack_client.py
 core/queues/__init__.py
 core/queues/aqs.py
+core/queues/cosmos.py
 core/queues/message_queue.py
 core/queues/message_queue_processor.py
 core/queues/model.py
+core/queues/sql.py
 core/queues/sqs.py
 core/requester/__init__.py
 core/requester/requester.py

kiba_core-0.5.3.dev51/kiba_core.egg-info/requires.txt

@@ -0,0 +1,44 @@
+aiofiles>=25.1.0
+pydantic>=2.13.4
+orjson>=3.11.9
+
+[api]
+fastapi>=0.139.1
+uvicorn[standard]>=0.51.0
+
+[core-api]
+starlette>=1.3.1
+uvicorn[standard]>=0.51.0
+
+[database-psql]
+sqlalchemy[asyncio]>=2.0.51
+asyncpg>=0.31.0
+
+[database-sqlite]
+sqlalchemy[asyncio]>=2.0.51
+aiosqlite>=0.22.1
+
+[queue-aqs]
+azure-storage-queue[aio]>=12.17.0
+
+[queue-cosmos]
+azure-cosmos>=4.16.2
+
+[queue-sqs]
+aiobotocore>=3.7.0
+
+[queues]
+aiobotocore>=3.7.0
+
+[requester]
+httpx>=0.28.1
+
+[storage]
+aiobotocore>=3.7.0
+
+[types]
+types-aiobotocore[essential]>=3.7.0
+types-aiofiles>=25.1.0.20260518
+
+[web3]
+web3>=7.16.0