p1-taskqueue 0.1.13__tar.gz → 0.1.15__tar.gz

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.13
+Version: 0.1.15
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "p1-taskqueue"
 # DO NOT CHANGE THIS VERSION - it gets automatically replaced by CI/CD with the git tag version
-version = "0.1.13"
+version = "0.1.15"
 description = "A Task Queue Wrapper for Dekoruma Backend"
 authors = [
     {name = "Chalvin", email = "engineering@dekoruma.com"}

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/src/p1_taskqueue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.13
+Version: 0.1.15
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/src/taskqueue/celery_app.py

@@ -4,6 +4,7 @@ Reads configuration from Django settings and auto-configures queues with DLQ.
 """
 import logging
 
+from amqp.exceptions import PreconditionFailed
 from celery import Celery
 from kombu import Exchange
 from kombu import Queue
@@ -67,6 +68,9 @@ def setup_queues(app, settings, celery_config):
         queue_names = ['default', 'high', 'low']
     dlq_name_prefix = getattr(settings, 'TASKQUEUE_DLQ_NAME_PREFIX', 'dlq')
 
+    logger.info(
+        f"[TaskQueue] Configuring app: {app_name}, queues: {queue_names}")
+
     main_exchange = Exchange(app_name, type='direct')
     dlx_exchange = Exchange(f'{app_name}.dlx', type='direct')
 
@@ -74,22 +78,28 @@ def setup_queues(app, settings, celery_config):
 
     for queue_name in queue_names:
         dlq_name = f'{dlq_name_prefix}.{queue_name}'
+        dlx_name = f'{app_name}.dlx'
+
+        queue_args = {
+            'x-dead-letter-exchange': dlx_name,
+            'x-dead-letter-routing-key': dlq_name
+        }
 
         queue = Queue(
             queue_name,
             main_exchange,
             routing_key=queue_name,
-            queue_arguments={
-                'x-dead-letter-exchange': f'{app_name}.dlx',
-                'x-dead-letter-routing-key': dlq_name
-            }
+            queue_arguments=queue_args
         )
         queues.append(queue)
+        logger.info(
+            f"[TaskQueue] Queue '{queue_name}' configured with DLX: {dlx_name}, DLQ routing key: {dlq_name}")
 
     for queue_name in queue_names:
         dlq_name = f'{dlq_name_prefix}.{queue_name}'
         dlq = Queue(dlq_name, dlx_exchange, routing_key=dlq_name)
         queues.append(dlq)
+        logger.info(f"[TaskQueue] DLQ '{dlq_name}' configured")
 
     celery_config.update({
         'task_default_queue': 'default',
@@ -100,14 +110,36 @@ def setup_queues(app, settings, celery_config):
 
     try:
         with app.connection_or_acquire() as conn:
-            main_exchange.declare(channel=conn.default_channel)
-            dlx_exchange.declare(channel=conn.default_channel)
+            channel = conn.default_channel
+
+            try:
+                main_exchange.declare(channel=channel)
+                logger.info(f"[TaskQueue] Exchange declared: {app_name}")
+            except PreconditionFailed:
+                logger.info(f"[TaskQueue] Exchange already exists: {app_name}")
+
+            try:
+                dlx_exchange.declare(channel=channel)
+                logger.info(
+                    f"[TaskQueue] DLX Exchange declared: {app_name}.dlx")
+            except PreconditionFailed:
+                logger.info(
+                    f"[TaskQueue] DLX Exchange already exists: {app_name}.dlx")
 
             for queue in queues:
-                queue.declare(channel=conn.default_channel)
+                try:
+                    queue.declare(channel=channel)
+                    logger.info(f"[TaskQueue] Queue declared: {queue.name}")
+                except PreconditionFailed:
+                    logger.info(
+                        f"[TaskQueue] Queue already exists with different config: {queue.name}. Using existing queue.")
+                except Exception as e:
+                    logger.warning(
+                        f"[TaskQueue] Failed to declare queue {queue.name}: {e}")
+
     except Exception as e:
         logger.warning(
-            f"[TaskQueue] Failed to declare queues: {str(e.__class__.__name__)} {e}")
+            f"[TaskQueue] Failed to setup queues: {str(e.__class__.__name__)} {e}")
 
 
 celery_app = create_celery_app()

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/src/taskqueue/libs/helper_test.py

@@ -70,6 +70,19 @@ def celery_worker_burst(include_func_names: List[str], channel: str = "default")
                             method_name = task_kwargs.get('method_name', '')
                             if module_path and class_name and method_name:
                                 full_func_name = f"{module_path}.{class_name}.{method_name}"
+                        elif task_name.endswith("callable_executor"):
+                            callable_obj = task_kwargs.get('callable_obj')
+                            if callable_obj:
+                                module_path = getattr(
+                                    callable_obj, '__module__', '')
+                                func_name = getattr(
+                                    callable_obj, '__name__', '')
+                                if hasattr(callable_obj, '__self__'):
+                                    class_name = callable_obj.__self__.__class__.__name__
+                                    if module_path and class_name and func_name:
+                                        full_func_name = f"{module_path}.{class_name}.{func_name}"
+                                elif module_path and func_name:
+                                    full_func_name = f"{module_path}.{func_name}"
 
                         should_execute = full_func_name in included_set if full_func_name else False
 
@@ -136,6 +149,19 @@ def get_queued_tasks(channel: str = "default"):
                             method_name = task_kwargs.get('method_name', '')
                             if module_path and class_name and method_name:
                                 full_func_name = f"{module_path}.{class_name}.{method_name}"
+                        elif task_name and task_name.endswith("callable_executor"):
+                            callable_obj = task_kwargs.get('callable_obj')
+                            if callable_obj:
+                                module_path = getattr(
+                                    callable_obj, '__module__', '')
+                                func_name = getattr(
+                                    callable_obj, '__name__', '')
+                                if hasattr(callable_obj, '__self__'):
+                                    class_name = callable_obj.__self__.__class__.__name__
+                                    if module_path and class_name and func_name:
+                                        full_func_name = f"{module_path}.{class_name}.{func_name}"
+                                elif module_path and func_name:
+                                    full_func_name = f"{module_path}.{func_name}"
 
                         queued_tasks.append({
                             'task_name': task_name,

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/tests/test_helper_test_functions.py

@@ -140,6 +140,86 @@ class TestHelperTest:
         assert result[0]['kwargs']['class_name'] == 'MyClass'
         assert result[0]['kwargs']['method_name'] == 'my_method'
 
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_get_queued_tasks_given_callable_executor_function_expect_correct_parsing(self, mock_loads, mock_current_app):
+        # Use a real function instead of mocking
+        def my_function():
+            pass
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.callable_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+
+        mock_loads.return_value = [[], {
+            'callable_obj': my_function,
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        result = get_queued_tasks('default')
+
+        assert len(result) == 1
+        assert result[0]['task_name'] == 'taskqueue.cmanager.callable_executor'
+        assert result[0]['full_func_name'] == 'tests.test_helper_test_functions.my_function'
+        assert result[0]['args'] == []
+        assert result[0]['kwargs']['callable_obj'] == my_function
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_get_queued_tasks_given_callable_executor_method_expect_correct_parsing(self, mock_loads, mock_current_app):
+        # Use a real class and method instead of mocking
+        class MyClass:
+            def my_method(self):
+                pass
+
+        instance = MyClass()
+        bound_method = instance.my_method
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.callable_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+
+        mock_loads.return_value = [[], {
+            'callable_obj': bound_method,
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        result = get_queued_tasks('default')
+
+        assert len(result) == 1
+        assert result[0]['task_name'] == 'taskqueue.cmanager.callable_executor'
+        assert result[0]['full_func_name'] == 'tests.test_helper_test_functions.MyClass.my_method'
+        assert result[0]['args'] == []
+        assert result[0]['kwargs']['callable_obj'] == bound_method
+
     @patch('taskqueue.libs.helper_test.get_queued_tasks')
     def test_is_task_in_queue_given_task_exists_expect_true(self, mock_get_queued_tasks):
         mock_get_queued_tasks.return_value = [

{p1_taskqueue-0.1.13 → p1_taskqueue-0.1.15}/tests/test_test_utils.py

@@ -88,7 +88,8 @@ class TestCeleryWorkerBurst:
         mock_message.ack.assert_called_once()
         mock_task.apply.assert_called_once_with(
             args=[],
-            kwargs={'module_path': 'module.submodule', 'function_name': 'test_function', 'args': [], 'kwargs': {}}
+            kwargs={'module_path': 'module.submodule',
+                    'function_name': 'test_function', 'args': [], 'kwargs': {}}
         )
 
     @patch('taskqueue.libs.helper_test.current_app')
@@ -130,7 +131,8 @@ class TestCeleryWorkerBurst:
         mock_message.ack.assert_called_once()
         mock_task.apply.assert_called_once_with(
             args=[],
-            kwargs={'module_path': 'module.submodule', 'class_name': 'TestClass', 'method_name': 'test_method', 'args': [], 'kwargs': {}, 'init_args': [], 'init_kwargs': {}}
+            kwargs={'module_path': 'module.submodule', 'class_name': 'TestClass',
+                    'method_name': 'test_method', 'args': [], 'kwargs': {}, 'init_args': [], 'init_kwargs': {}}
         )
 
     @patch('taskqueue.libs.helper_test.current_app')
@@ -292,3 +294,100 @@ class TestCeleryWorkerBurst:
                 "Failed to process task taskqueue.cmanager.dynamic_function_executor: Exception: Task execution failed"
             )
             mock_message.ack.assert_called_once()
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_celery_worker_burst_given_callable_executor_function_expect_execution(self, mock_loads, mock_current_app):
+        def test_function():
+            pass
+
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.callable_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.callable_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            [], {'callable_obj': test_function, 'args': [], 'kwargs': {}}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('taskqueue.libs.helper_test.logger') as mock_logger:
+            celery_worker_burst(
+                ['tests.test_test_utils.test_function'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: tests.test_test_utils.test_function")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: tests.test_test_utils.test_function")
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_called_once_with(
+            args=[],
+            kwargs={'callable_obj': test_function,
+                    'args': [], 'kwargs': {}}
+        )
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_celery_worker_burst_given_callable_executor_method_expect_execution(self, mock_loads, mock_current_app):
+        class TestClass:
+            def test_method(self):
+                pass
+
+        instance = TestClass()
+        bound_method = instance.test_method
+
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.callable_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.callable_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            [], {'callable_obj': bound_method, 'args': [], 'kwargs': {}}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('taskqueue.libs.helper_test.logger') as mock_logger:
+            celery_worker_burst(
+                ['tests.test_test_utils.TestClass.test_method'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: tests.test_test_utils.TestClass.test_method")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: tests.test_test_utils.TestClass.test_method")
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_called_once_with(
+            args=[],
+            kwargs={'callable_obj': bound_method, 'args': [], 'kwargs': {}}
+        )