celery-misc 1.0.2__tar.gz → 1.0.4__tar.gz

{celery_misc-1.0.2 → celery_misc-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celery-misc
-Version: 1.0.2
+Version: 1.0.4
 Summary: Python async tools for Celery
 Author: Anton Gorinenko
 Author-email: anton.gorinenko@gmail.com

celery_misc-1.0.4/celery_misc/transactional_outbox/migrations/0002_outboxmessage_meta_data_outboxmessage_strategy.py

@@ -0,0 +1,23 @@
+# Generated by Django 6.0.3 on 2026-03-18 11:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('transactional_outbox', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='outboxmessage',
+            name='meta_data',
+            field=models.JSONField(blank=True, null=True, verbose_name='Метаданные события'),
+        ),
+        migrations.AddField(
+            model_name='outboxmessage',
+            name='strategy',
+            field=models.CharField(blank=True, help_text='Например, "celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy".', max_length=128, null=True, verbose_name='FQCN класса, реализующего стратегию отправки'),
+        ),
+    ]

celery_misc-1.0.4/celery_misc/transactional_outbox/migrations/0003_alter_outboxmessage_idempotency_key.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.0.3 on 2026-03-18 15:18
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('transactional_outbox', '0002_outboxmessage_meta_data_outboxmessage_strategy'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='outboxmessage',
+            name='idempotency_key',
+            field=models.CharField(max_length=128, verbose_name='Idempotency key'),
+        ),
+    ]

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc/transactional_outbox/models.py

@@ -6,15 +6,20 @@ from celery_misc.transactional_outbox import enums
 class OutboxMessage(models.Model):
     """ OUTBOX """
 
-    idempotency_key = models.CharField(null=False, blank=False, max_length=64, unique=True, db_index=True,
-                                       verbose_name='Idempotency key')
+    idempotency_key = models.CharField(null=False, blank=False, max_length=128, verbose_name='Idempotency key')
     aggregate_type = models.CharField(null=False, blank=False, max_length=128, verbose_name='Тип агрегата',
                                       help_text='Например, название модели данных "Order".')
     aggregate_id = models.CharField(null=False, blank=False, max_length=64, verbose_name='ID агрегата',
                                     help_text='Например, ID экземпляра модели данных "164" или "8470df44-5e62-44db-8881-bfa9606b507c".')
     event_type = models.CharField(null=False, blank=False, max_length=128, verbose_name='Тип события',
                                   help_text='Например, "order.created".')
+    strategy = models.CharField(
+        null=True, blank=True, max_length=128,
+        verbose_name='FQCN класса, реализующего стратегию отправки',
+        help_text='Например, "celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy".'
+    )
     payload = models.JSONField(null=False, blank=False, verbose_name='Данные события')
+    meta_data = models.JSONField(null=True, blank=True, verbose_name='Метаданные события')
     status = models.CharField(max_length=50, null=False, blank=False,
                               choices=enums.EventStatuses.choices,
                               default=enums.EventStatuses.PENDING,

celery_misc-1.0.4/celery_misc/transactional_outbox/outbox_utils.py

@@ -0,0 +1,125 @@
+from typing import TypeVar
+
+import uuid6
+from django.db import transaction
+from django.db.models import Model
+
+from celery_misc.transactional_outbox import models, tasks, enums
+
+T = TypeVar('T', bound=Model)
+
+
+def resend_events(event_ids: list[int]):
+    """ Повторная отправка сообщений """
+    if not event_ids:
+        raise ValueError('Event_ids is none or empty.')
+
+    models.OutboxMessage.objects.filter(id__in=event_ids).update(status=enums.EventStatuses.PENDING, sent_at=None)
+    tasks.send_events_only_ones.apply_async(kwargs={'event_ids': event_ids})
+
+
+class OutboxEvent:
+    def __init__(self, event_type: str, strategy: str | None = None):
+        """ Создание события для отправки """
+        self.event_type = event_type
+        self.payload = None
+        self.idempotency_key = None
+        self.instance = None
+        self.event_ids = None
+        self.strategy = strategy
+        self.meta_data = None
+
+        self._transaction = None
+
+    def __enter__(self):
+        self._transaction = transaction.atomic()
+        self._transaction.__enter__()
+        self._is_in_transaction = True
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        try:
+            if exc_type is None:
+                if not self.instance or not self.payload:
+                    raise ValueError(
+                        'Необходимо вызвать функцию send(instance, payload) внутри контекстного менеджера.')
+                self._create_outbox_message()
+
+            if self._transaction:
+                self._transaction.__exit__(exc_type, exc_val, exc_tb)
+        except Exception as e:
+            if self._transaction:
+                self._transaction.__exit__(type(e), e, e.__traceback__)
+            raise
+        finally:
+            self._transaction = None
+
+    def send(self, instance: T,
+             payload: dict | list[dict],
+             idempotency_key: str | list[str] | None = None,
+             meta_data: dict | list[dict] | None = None):
+        if self._transaction is None:
+            raise RuntimeError(
+                'Метод send должен вызываться внутри контекстного менеджера OutboxEvent.'
+            )
+
+        self.instance = instance
+        if not payload:
+            raise ValueError('Параметр payload пуст или не указан.')
+
+        if idempotency_key is None:
+            if not isinstance(payload, list):
+                self.idempotency_key = [str(uuid6.uuid7())]
+            else:
+                self.idempotency_key = [str(uuid6.uuid7()) for i in range(len(payload))]
+        elif not isinstance(idempotency_key, list):
+            self.idempotency_key = [idempotency_key]
+        else:
+            self.idempotency_key = idempotency_key
+
+        meta_data_len = 0
+        if meta_data:
+            if not isinstance(meta_data, list):
+                self.meta_data = [meta_data]
+            else:
+                self.meta_data = meta_data
+
+            meta_data_len = len(self.meta_data)
+
+        if not isinstance(payload, list):
+            self.payload = [self._serialize_event(payload)]
+        else:
+            self.payload = [self._serialize_event(i) for i in payload]
+
+        if len(self.payload) != len(self.idempotency_key):
+            raise ValueError('Размерности параметров idempotency_key и payload не совпадают.')
+
+        i = 0
+        for event_payload, idempotency_key in zip(self.payload, self.idempotency_key, strict=True):
+            event_payload['idempotency_key'] = idempotency_key
+            if i < meta_data_len:
+                event_payload['meta_data'] = self.meta_data[i]
+            i += 1
+
+    def _create_outbox_message(self):
+        if len(self.payload) == 1:
+            message = models.OutboxMessage.objects.create(**self.payload[0])
+            self.event_ids = [message.id]
+        else:
+            objs = [models.OutboxMessage(**payload) for payload in self.payload]
+            db_objs = models.OutboxMessage.objects.bulk_create(objs)
+            self.event_ids = [msg.id for msg in db_objs]
+
+        if self.event_ids:
+            tasks.send_events_only_ones.apply_async(kwargs={'event_ids': self.event_ids})
+
+    def _serialize_event(self, event_payload: dict) -> dict:
+        aggregate_type = str(type(self.instance).__name__)
+        aggregate_id = self.instance.id
+        return {
+            'aggregate_type': aggregate_type,
+            'aggregate_id': aggregate_id,
+            'event_type': self.event_type,
+            'payload': event_payload,
+            'strategy': self.strategy
+        }

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc/transactional_outbox/strategies.py

@@ -10,6 +10,18 @@ from celery_misc.transactional_outbox import models, enums
 logger = logging.getLogger(__name__)
 
 
+def get_pending_outbox_messages(event_ids: list[int] = None):
+    """ Получение QuerySet сообщений, ожидающих отправку """
+    pending_query_set = models.OutboxMessage.objects.filter(
+        ~Q(Q(status=enums.EventStatuses.SENT) | Q(status=enums.EventStatuses.EXPIRED))  # Не отправлено или устарело
+    )
+
+    if event_ids:
+        pending_query_set = pending_query_set.filter(id__in=event_ids)
+
+    return pending_query_set
+
+
 class BaseSendEventsStrategy(abc.ABC):
     def __init__(self, batch_size: int | None = None):
         self.batch_size = batch_size
@@ -24,7 +36,7 @@ class BaseSendEventsStrategy(abc.ABC):
         """ Дополнительная обработка запроса """
         return query_set
 
-    def send_events(self, event_ids: list[int] = None) -> list[int]:
+    def send_events(self, event_ids: list[int] = None, external_filter: Q | None = None) -> list[int]:
         """
         Отправка уведомлений во внешнюю систему, например в kafka или rabbit
         :param event_ids: список ID событий для обработки
@@ -45,13 +57,12 @@ class BaseSendEventsStrategy(abc.ABC):
             Каждый воркер берет небольшую порцию и быстро освобождает блокировки
             Другие воркеры могут сразу начать обрабатывать следующие порции
         """
-        pending_query_set = models.OutboxMessage.objects.filter(
-            ~Q(Q(status=enums.EventStatuses.SENT) | Q(status=enums.EventStatuses.EXPIRED))  # Не отправлено или устарело
-        ).order_by('created_at', 'id')
+        pending_query_set = get_pending_outbox_messages(event_ids=event_ids).order_by('created_at', 'id')
+
+        if external_filter:
+            pending_query_set = pending_query_set.filter(external_filter)
 
-        if event_ids:
-            pending_query_set = pending_query_set.filter(id__in=event_ids)
-        elif self.batch_size:
+        if self.batch_size and not event_ids:
             pending_query_set = pending_query_set[:self.batch_size]
 
         pending_query_set = self.process_base_query(pending_query_set)
@@ -88,9 +99,9 @@ class BlockBatchStrategy(BaseSendEventsStrategy, abc.ABC):
     так как создается одна длительная транзакция. Batch_size желательно уменьшить, чтобы сократить время общей блокировки.
     """
 
-    def send_events(self, event_ids: list[int] = None) -> list[int]:
+    def send_events(self, *args, **kwargs) -> list[int]:
         with transaction.atomic():
-            return super().send_events(event_ids=event_ids)
+            return super().send_events(*args, **kwargs)
 
     def process_base_query(self, query_set: QuerySet[models.OutboxMessage]):
         """ Блокировка запроса

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc/transactional_outbox/tasks.py

@@ -6,7 +6,7 @@ from django.db.models import Q
 from django.utils import timezone
 
 from celery_misc import celery_utils, utils, model_utils
-from celery_misc.transactional_outbox import settings, enums, models
+from celery_misc.transactional_outbox import settings, enums, models, strategies
 
 logger = logging.getLogger(__name__)
 
@@ -42,12 +42,27 @@ def delete_events(self, *args, **kwargs):
 def _send_events(_, event_ids: list[int] = None, suppress_events_error: bool | None = False,
                  batch_size: int | None = 50):
     """ Отправка уведомлений во внешнюю систему, например в kafka или rabbit """
-    StrategyClass = utils.load_class(settings.SEND_EVENTS_STRATEGY)
-    strategy = StrategyClass(batch_size=batch_size)
-    error_messages = strategy.send_events(event_ids=event_ids)
-    if not suppress_events_error and error_messages:
-        error_ids = ','.join([str(e) for e in error_messages])
-        raise Exception('Возникли ошибки при отправке сообщений с ID "%s".', error_ids)
+    class_strategies = list(
+        strategies.get_pending_outbox_messages(event_ids=event_ids).values_list('strategy', flat=True).distinct(
+            'strategy'))
+    for class_strategy in class_strategies:
+        if class_strategy is None:
+            external_filter = Q(strategy__isnull=True)
+            class_strategy = settings.SEND_EVENTS_STRATEGY
+        else:
+            external_filter = Q(strategy=class_strategy)
+        try:
+            StrategyClass = utils.load_class(class_strategy)
+
+            strategy = StrategyClass(batch_size=batch_size)
+            error_messages = strategy.send_events(event_ids=event_ids, external_filter=external_filter)
+
+            if not suppress_events_error and error_messages:
+                error_ids = ','.join([str(e) for e in error_messages])
+                raise Exception('Возникли ошибки при отправке сообщений с ID "%s".', error_ids)
+        except Exception as ex:
+            logger.error('Возникла ошибка при обработке стратегии "%s".', class_strategy)
+            logger.exception(ex)
 
 
 def _expiring_events(_, expiration_delta_in_hours: int | None = 12):

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc/transactional_outbox/tests/test_utils.py

@@ -1,3 +1,4 @@
+import uuid
 from datetime import timedelta
 from unittest.mock import Mock
 
@@ -10,6 +11,29 @@ from celery_misc.transactional_outbox import outbox_utils, models, enums, tasks
 pytestmark = pytest.mark.django_db
 
 
+def _validate_db_outbox_message(message_id, idempotency_key, payload,
+                                aggregate_id: int | None = 123, event_type: str | None = 'order.created',
+                                aggregate_type: str | None = 'Mock',
+                                strategy: str | None = None,
+                                meta_data: dict | None = None):
+    db_message = models.OutboxMessage.objects.filter(id=message_id).first()
+    assert db_message
+    assert db_message.idempotency_key == idempotency_key
+    assert db_message.aggregate_type == aggregate_type
+    assert db_message.aggregate_id == str(aggregate_id)
+    assert db_message.event_type == event_type
+    assert db_message.payload == payload
+    assert db_message.strategy == strategy
+
+    assert db_message.status == enums.EventStatuses.SENT
+    assert db_message.created_at is not None
+    assert db_message.sent_at is not None
+    assert db_message.error is None
+    assert db_message.meta_data == meta_data
+
+    return db_message
+
+
 @pytest.mark.parametrize('strategy', [
     'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy',
     'celery_misc.transactional_outbox.strategies.DummyBlockBatchStrategy',
@@ -20,26 +44,47 @@ def test_send_events(mocker, strategy):
     aggregate_id = 123
     event_type = 'order.created'
     payload = {'total': 100}
-    idempotency_key = 'test1234'
+    idempotency_key = str(uuid.uuid4())
+    meta_data = {
+        'test': 12345
+    }
     with outbox_utils.OutboxEvent(event_type) as outbox_guard:
         # Здесь instance будет правильно типизирован как Order
         order = Mock()
         order.id = aggregate_id
 
-        outbox_guard.send(order, payload, idempotency_key=idempotency_key)
+        outbox_guard.send(order, payload, idempotency_key=idempotency_key, meta_data=meta_data)
+    message_id = outbox_guard.event_ids[0]
+    _validate_db_outbox_message(message_id, idempotency_key, payload,
+                                aggregate_id=aggregate_id, event_type=event_type, meta_data=meta_data)
 
-    db_message = models.OutboxMessage.objects.filter(id=outbox_guard.message_id).first()
-    assert db_message
-    assert db_message.idempotency_key == idempotency_key
-    assert db_message.aggregate_type == 'Mock'
-    assert db_message.aggregate_id == str(aggregate_id)
-    assert db_message.event_type == event_type
-    assert db_message.payload == payload
 
-    assert db_message.status == enums.EventStatuses.SENT
-    assert db_message.created_at is not None
-    assert db_message.sent_at is not None
-    assert db_message.error is None
+@pytest.mark.parametrize('strategy', [
+    'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy',
+    'celery_misc.transactional_outbox.strategies.DummyBlockBatchStrategy',
+])
+def test_send_events__bulk(mocker, strategy):
+    """ Создание и отправка пакета событий  """
+    mocker.patch('celery_misc.transactional_outbox.settings.SEND_EVENTS_STRATEGY', strategy)
+    aggregate_id = 123
+    event_type = 'order.created'
+    total_count = 100
+    payload = [{'i': i} for i in range(total_count)]
+    idempotency_key = [str(uuid.uuid4()) for _ in range(total_count)]
+    meta_data = [{'meta': f'meta_{i}'} for i in range(int(total_count / 2))]
+    with outbox_utils.OutboxEvent(event_type) as outbox_guard:
+        # Здесь instance будет правильно типизирован как Order
+        order = Mock()
+        order.id = aggregate_id
+
+        outbox_guard.send(order, payload, idempotency_key=idempotency_key, meta_data=meta_data)
+
+    assert outbox_guard.event_ids
+    assert len(outbox_guard.event_ids) == total_count
+    for i, message_id in enumerate(outbox_guard.event_ids):
+        meta = meta_data[i] if i < len(meta_data) else None
+        _validate_db_outbox_message(message_id, idempotency_key[i], payload[i], aggregate_id=aggregate_id,
+                                    event_type=event_type, meta_data=meta)
 
 
 @pytest.mark.parametrize('strategy', [
@@ -64,7 +109,8 @@ def test_send_events__with_error(mocker, strategy):
 
         outbox_guard.send(order, payload, idempotency_key=idempotency_key)
 
-    db_message = models.OutboxMessage.objects.filter(id=outbox_guard.message_id).first()
+    message_id = outbox_guard.event_ids[0]
+    db_message = models.OutboxMessage.objects.filter(id=message_id).first()
     assert db_message
     assert db_message.idempotency_key == idempotency_key
     assert db_message.aggregate_type == 'Mock'
@@ -85,6 +131,7 @@ def test_send_events__with_error(mocker, strategy):
 def test_send_events__validate_status(mocker, strategy):
     """ Проверка статуса события при отправке """
     mocker.patch('celery_misc.transactional_outbox.settings.SEND_EVENTS_STRATEGY', strategy)
+
     message_kwargs = {
         'aggregate_type': 'Order',
         'aggregate_id': '123',
@@ -133,14 +180,10 @@ def test_expiring_events():
     now = timezone.now()
     expiration_date = now - timedelta(hours=25)
     objs = models.OutboxMessage.objects.bulk_create([
-        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING,
-                             created_at=now, **message_kwargs),
-        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING,
-                             created_at=now, **message_kwargs),
-        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING,
-                             created_at=now, **message_kwargs),
-        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING,
-                             created_at=now, **message_kwargs),
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING, **message_kwargs),
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING, **message_kwargs),
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING, **message_kwargs),
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING, **message_kwargs),
     ])
     event_1, expired_event_1, event_2, expired_event_2 = objs
 
@@ -173,3 +216,79 @@ def test_expiring_events():
     assert not models.OutboxMessage.objects.filter(id=event_1.id).exists()
     assert not models.OutboxMessage.objects.filter(id=expired_event_1.id).exists()
     assert not models.OutboxMessage.objects.filter(id=expired_event_2.id).exists()
+
+
+def test_send_events__with_transaction_error(mocker):
+    """ Во время создания события произошла ошибка """
+    mocker.patch('celery_misc.transactional_outbox.settings.SEND_EVENTS_STRATEGY',
+                 'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy')
+
+    try:
+        with outbox_utils.OutboxEvent('order.created') as outbox_guard:
+            # Здесь instance будет правильно типизирован как Order
+            order = models.OutboxMessage.objects.create(**{
+                'aggregate_type': 'Order',
+                'aggregate_id': '1',
+                'event_type': 'test',
+                'payload': {}
+            })
+            order_id = order.id
+            outbox_guard.send(order, {'total': 100})
+            raise Exception('Test exc')
+    except:
+        pass
+
+    assert not models.OutboxMessage.objects.filter(id=order_id).exists()
+
+
+def test_send_events__strategy(mocker):
+    """ Создание и отправка события с указанием стратегии """
+    mocker.patch('celery_misc.transactional_outbox.settings.SEND_EVENTS_STRATEGY',
+                 'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy')
+    strategy = 'celery_misc.transactional_outbox.strategies.DummyBlockBatchStrategy'
+
+    publish_message_mocker = mocker.patch(f'{strategy}.publish_message')
+    aggregate_id = 123
+    event_type = 'order.created'
+    payload = {'total': 100}
+    idempotency_key = str(uuid.uuid4())
+    meta_data = {
+        'test': 12345
+    }
+    with outbox_utils.OutboxEvent(event_type, strategy=strategy) as outbox_guard:
+        # Здесь instance будет правильно типизирован как Order
+        order = Mock()
+        order.id = aggregate_id
+
+        outbox_guard.send(order, payload, idempotency_key=idempotency_key, meta_data=meta_data)
+    message_id = outbox_guard.event_ids[0]
+    db_message = _validate_db_outbox_message(message_id, idempotency_key, payload,
+                                             aggregate_id=aggregate_id, event_type=event_type,
+                                             meta_data=meta_data, strategy=strategy)
+    publish_message_mocker.assert_called_once_with(db_message)
+
+
+def test_expiring_events__multy_strategy(mocker):
+    """ Создание и отправка нескольких событий с указанием разных стратегии """
+    mocker.patch('celery_misc.transactional_outbox.settings.SEND_EVENTS_STRATEGY',
+                 'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy')
+    publish_message_mocker_1 = mocker.patch(
+        f'celery_misc.transactional_outbox.strategies.DummyBlockBatchStrategy.publish_message')
+    publish_message_mocker_2 = mocker.patch(
+        f'celery_misc.transactional_outbox.strategies.DummyCheckStatusStrategy.publish_message')
+
+    message_kwargs = {
+        'aggregate_type': 'Order',
+        'aggregate_id': '123',
+        'event_type': 'order.created',
+        'payload': {'total': 100}
+    }
+    db_message_1, db_message_2 = models.OutboxMessage.objects.bulk_create([
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING,
+                             strategy='celery_misc.transactional_outbox.strategies.DummyBlockBatchStrategy',
+                             **message_kwargs),
+        models.OutboxMessage(idempotency_key=str(uuid6.uuid7()), status=enums.EventStatuses.PENDING, **message_kwargs),
+    ])
+    tasks.send_events.apply_async(kwargs={'event_ids': [db_message_1.id, db_message_2.id]})
+    publish_message_mocker_1.assert_called_once_with(db_message_1)
+    publish_message_mocker_2.assert_called_once_with(db_message_2)

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celery-misc
-Version: 1.0.2
+Version: 1.0.4
 Summary: Python async tools for Celery
 Author: Anton Gorinenko
 Author-email: anton.gorinenko@gmail.com

{celery_misc-1.0.2 → celery_misc-1.0.4}/celery_misc.egg-info/SOURCES.txt

@@ -38,6 +38,8 @@ celery_misc/transactional_outbox/settings.py
 celery_misc/transactional_outbox/strategies.py
 celery_misc/transactional_outbox/tasks.py
 celery_misc/transactional_outbox/migrations/0001_initial.py
+celery_misc/transactional_outbox/migrations/0002_outboxmessage_meta_data_outboxmessage_strategy.py
+celery_misc/transactional_outbox/migrations/0003_alter_outboxmessage_idempotency_key.py
 celery_misc/transactional_outbox/migrations/__init__.py
 celery_misc/transactional_outbox/tests/__init__.py
 celery_misc/transactional_outbox/tests/test_utils.py

{celery_misc-1.0.2 → celery_misc-1.0.4}/setup.py

@@ -18,7 +18,7 @@ def long_description():
 
 setuptools.setup(
     name='celery-misc',
-    version='1.0.2',
+    version='1.0.4',
     author='Anton Gorinenko',
     author_email='anton.gorinenko@gmail.com',
     description='Python async tools for Celery',

celery_misc-1.0.2/celery_misc/transactional_outbox/outbox_utils.py

@@ -1,68 +0,0 @@
-from typing import TypeVar
-
-import uuid6
-from django.db import transaction
-from django.db.models import Model
-
-from celery_misc.transactional_outbox import models, tasks, enums
-
-T = TypeVar('T', bound=Model)
-
-
-def resend_events(event_ids: list[int]):
-    """ Повторная отправка сообщений """
-    if not event_ids:
-        raise ValueError('Event_ids is none or empty.')
-
-    models.OutboxMessage.objects.filter(id__in=event_ids).update(status=enums.EventStatuses.PENDING, sent_at=None)
-    tasks.send_events_only_ones.apply_async(kwargs={'event_ids': event_ids})
-
-
-class OutboxEvent:
-    def __init__(self, event_type: str):
-        """ Создание события для отправки """
-        self.event_type = event_type
-        self.payload = None
-        self.idempotency_key = None
-        self.instance = None
-        self.message_id = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is None:
-            if not self.instance or not self.payload:
-                raise ValueError('Необходимо вызвать функцию send(instance, payload) внутри контекстного менеджера.')
-            self._create_outbox_message()
-            return True
-        return False
-
-    def send(self, instance: T, payload: dict, idempotency_key: str | None = None):
-        self.instance = instance
-        self.payload = payload
-        self.idempotency_key = idempotency_key
-
-    def _create_outbox_message(self):
-        with transaction.atomic():
-            aggregate_type = str(type(self.instance).__name__)
-            aggregate_id = self.instance.id
-            message_kwargs = {
-                'aggregate_type': aggregate_type,
-                'aggregate_id': aggregate_id,
-                'event_type': self.event_type,
-                'payload': self.payload
-            }
-
-            if self.idempotency_key:
-                message, created = models.OutboxMessage.objects.get_or_create(idempotency_key=self.idempotency_key,
-                                                                              **message_kwargs)
-            else:
-                message_kwargs['idempotency_key'] = str(uuid6.uuid7())
-                message = models.OutboxMessage.objects.create(**message_kwargs)
-                created = True
-
-        if created:
-            tasks.send_events_only_ones.apply_async(kwargs={'event_ids': [message.id]})
-
-        self.message_id = message.id