p1-taskqueue 0.1.12__tar.gz → 0.1.14__tar.gz

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.12
+Version: 0.1.14
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
@@ -19,6 +19,7 @@ Requires-Dist: kombu>=5.5.4
 Requires-Dist: django>=4.0.0
 Requires-Dist: django-celery-results>=2.6.0
 Requires-Dist: django-celery-beat>=2.8.1
+Requires-Dist: requests>=2.32.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/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.12"
+version = "0.1.14"
 description = "A Task Queue Wrapper for Dekoruma Backend"
 authors = [
     {name = "Chalvin", email = "engineering@dekoruma.com"}
@@ -26,6 +26,7 @@ dependencies = [
     "django>=4.0.0",
     "django-celery-results>=2.6.0",
     "django-celery-beat>=2.8.1",
+    "requests>=2.32.3",
 ]
 
 [project.optional-dependencies]

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/src/p1_taskqueue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.12
+Version: 0.1.14
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
@@ -19,6 +19,7 @@ Requires-Dist: kombu>=5.5.4
 Requires-Dist: django>=4.0.0
 Requires-Dist: django-celery-results>=2.6.0
 Requires-Dist: django-celery-beat>=2.8.1
+Requires-Dist: requests>=2.32.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/src/p1_taskqueue.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/p1_taskqueue.egg-info/top_level.txt
 src/taskqueue/__init__.py
 src/taskqueue/celery_app.py
 src/taskqueue/cmanager.py
+src/taskqueue/slack_notifier.py
 src/taskqueue/libs/__init__.py
 src/taskqueue/libs/helper_test.py
 tests/test_celery_app.py

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/src/p1_taskqueue.egg-info/requires.txt

@@ -4,6 +4,7 @@ kombu>=5.5.4
 django>=4.0.0
 django-celery-results>=2.6.0
 django-celery-beat>=2.8.1
+requests>=2.32.3
 
 [dev]
 pytest>=7.0.0

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/src/taskqueue/celery_app.py

@@ -2,10 +2,14 @@
 Celery application setup for TaskQueue.
 Reads configuration from Django settings and auto-configures queues with DLQ.
 """
+import logging
+
 from celery import Celery
 from kombu import Exchange
 from kombu import Queue
 
+logger = logging.getLogger(__name__)
+
 
 def get_django_settings():
     """Get Django settings, fail fast if not properly configured."""
@@ -63,7 +67,6 @@ def setup_queues(app, settings, celery_config):
         queue_names = ['default', 'high', 'low']
     dlq_name_prefix = getattr(settings, 'TASKQUEUE_DLQ_NAME_PREFIX', 'dlq')
 
-    # Create exchanges
     main_exchange = Exchange(app_name, type='direct')
     dlx_exchange = Exchange(f'{app_name}.dlx', type='direct')
 
@@ -95,5 +98,16 @@ def setup_queues(app, settings, celery_config):
         'task_queues': tuple(queues),
     })
 
+    try:
+        with app.connection_or_acquire() as conn:
+            main_exchange.declare(channel=conn.default_channel)
+            dlx_exchange.declare(channel=conn.default_channel)
+
+            for queue in queues:
+                queue.declare(channel=conn.default_channel)
+    except Exception as e:
+        logger.warning(
+            f"[TaskQueue] Failed to declare queues: {str(e.__class__.__name__)} {e}")
+
 
 celery_app = create_celery_app()

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/src/taskqueue/cmanager.py

@@ -1,13 +1,13 @@
 import importlib
 import inspect
 import logging
-from datetime import datetime
-from datetime import timedelta
 from typing import Any
 from typing import Dict
 from typing import Tuple
 
 from celery import shared_task
+from celery.exceptions import Reject
+from taskqueue.slack_notifier import SlackbotManager
 
 # Setup logger
 logger = logging.getLogger(__name__)
@@ -50,7 +50,8 @@ def _extract_init_args_from_instance(instance: Any) -> Tuple[list, dict]:
 def _split_function_and_queue_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
     # To prevent confusion whether a kwargs is for function or queue kwargs(i.e celery options and on_commit),
     # ignore confusing kwargs while give warning
-    supported_queue_keys = {"channel", "retry", "on_commit", "job_timeout"}
+    supported_queue_keys = {"channel", "retry",
+                            "on_commit", "job_timeout", "use_legacy_executor"}
     ignored_non_function_keys = {
         "queue", "countdown", "eta", "expires", "priority", "task_id", "routing_key",
         "serializer", "compression", "headers", "link", "link_error", "retry_policy",
@@ -74,6 +75,17 @@ def _split_function_and_queue_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str,
     return func_kwargs, queue_kwargs
 
 
+def _build_callable_task_call(func: Any, func_args: tuple, func_kwargs: dict) -> Tuple[str, list, dict]:
+    task_name = "taskqueue.cmanager.callable_executor"
+    task_args = []
+    task_kwargs = {
+        "callable_obj": func,
+        "args": list(func_args),
+        "kwargs": dict(func_kwargs),
+    }
+    return task_name, task_args, task_kwargs
+
+
 def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple[str, list, dict]:
     if _is_class_method(func):
         instance = getattr(func, "__self__")
@@ -155,47 +167,21 @@ class CManager:
             'enqueue_op_type', K_ENQUEUE_OP_TYPE_ENQUEUE)
 
         try:
-            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE:
-                if not args:
-                    raise ValueError(
-                        "enqueue requires a callable as the first positional argument")
-                func = args[0]
-                func_args = args[1:]
-
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
-                if len(args) < 2:
-                    raise ValueError(
-                        "enqueue_at requires (eta_datetime, func, *func_args)")
-                eta: datetime = args[0]
-                func = args[1]
-                func_args = args[2:]
-
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
-                if len(args) < 2:
-                    raise ValueError(
-                        "enqueue_in requires (countdown_delta, func, *func_args)")
-                delta: timedelta = args[0]
-                func = args[1]
-                func_args = args[2:]
-            else:
-                raise ValueError(
-                    f"Unknown enqueue operation type: {enqueue_op_type}")
-
-            func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(
-                kwargs)
+            func, func_args, func_kwargs, queue_options = self._parse_enqueue_args(
+                enqueue_op_type, args, kwargs)
 
-            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
-                queue_kwargs = dict(queue_kwargs)
-                queue_kwargs["eta"] = eta
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
-                queue_kwargs = dict(queue_kwargs)
-                queue_kwargs["countdown"] = int(delta.total_seconds())
+            use_legacy_executor = queue_options.pop(
+                'use_legacy_executor', True)
 
-            task_name, task_args, task_kwargs = _build_dynamic_task_call(
-                func, *func_args, **func_kwargs)
+            if use_legacy_executor:
+                task_name, task_args, task_kwargs = _build_dynamic_task_call(
+                    func, *func_args, **func_kwargs)
+            else:
+                task_name, task_args, task_kwargs = _build_callable_task_call(
+                    func, func_args, func_kwargs)
 
             task_id = self._send_task(task_name, task_args,
-                                      task_kwargs, queue_kwargs)
+                                      task_kwargs, queue_options)
 
             logger.info('[_enqueue_op_base %s] Submit Celery Task SUCCESS, task_name: %s args: %s, kwargs: %s, task_id: %s' % (
                 enqueue_op_type, task_name, task_args, task_kwargs, task_id))
@@ -205,6 +191,46 @@ class CManager:
                 enqueue_op_type, str(e), args, kwargs))
             raise e
 
+    def _parse_enqueue_args(self, enqueue_op_type: str, args: tuple, kwargs: dict) -> Tuple[Any, tuple, dict, dict]:
+        """Parse enqueue arguments and return func, func_args, func_kwargs, and queue_options."""
+        if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE:
+            if not args:
+                raise ValueError(
+                    "enqueue requires a callable as the first positional argument")
+            func = args[0]
+            func_args = args[1:]
+            eta, delta = None, None
+
+        elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
+            if len(args) < 2:
+                raise ValueError(
+                    "enqueue_at requires (eta_datetime, func, *func_args)")
+            eta = args[0]
+            func = args[1]
+            func_args = args[2:]
+            delta = None
+
+        elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
+            if len(args) < 2:
+                raise ValueError(
+                    "enqueue_in requires (countdown_delta, func, *func_args)")
+            delta = args[0]
+            func = args[1]
+            func_args = args[2:]
+            eta = None
+        else:
+            raise ValueError(
+                f"Unknown enqueue operation type: {enqueue_op_type}")
+
+        func_kwargs, queue_options = _split_function_and_queue_kwargs(kwargs)
+
+        if eta is not None:
+            queue_options["eta"] = eta
+        elif delta is not None:
+            queue_options["countdown"] = int(delta.total_seconds())
+
+        return func, func_args, func_kwargs, queue_options
+
     def _send_task(self, task_name: str, task_args: list, task_kwargs: dict, queue_kwargs: Dict[str, Any]) -> str:
         celery_app = self._get_celery_app()
 
@@ -237,7 +263,54 @@ class CManager:
 cm = CManager()
 
 
-@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
+def callable_executor(self, callable_obj=None, args=None, kwargs=None, retry=None):
+    job_id = self.request.id
+    try:
+        args = args or []
+        kwargs = kwargs or {}
+        callable_name = getattr(callable_obj, '__name__', str(callable_obj))
+
+        logger.info(
+            f"[TaskQueue] Executing callable: {callable_name} with args: {args} and kwargs: {kwargs}, job_id: {job_id}")
+
+        callable_obj(*args, **kwargs)
+
+        logger.info(
+            f"[TaskQueue] Callable execution completed successfully, callable: {callable_name}, args: {args}, kwargs: {kwargs}, job_id: {job_id}")
+        return None
+    except Exception as e:
+        logger.exception(
+            f"[TaskQueue] Error executing callable: {callable_name}, args: {args}, kwargs: {kwargs}, error_class: {e.__class__.__name__}, error: {e}, job_id: {job_id}")
+
+        current_retries = getattr(self.request, 'retries', 0) or 0
+        max_retries = self.max_retries or K_MAX_RETRY_COUNT
+        if isinstance(retry, dict) and 'max_retries' in retry:
+            max_retries = retry['max_retries']
+
+        if current_retries >= max_retries:
+            logger.error(
+                f"[TaskQueue] Max retries ({max_retries}) reached for callable: {callable_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {callable_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
+
+        countdown = K_DEFAULT_RETRY_COUNTDOWN
+        if isinstance(retry, dict) and 'countdown' in retry:
+            countdown = retry['countdown']
+
+        raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)
+
+
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
 def dynamic_function_executor(self, module_path=None, function_name=None, args=None, kwargs=None, retry=None):
     job_id = self.request.id
     try:
@@ -261,8 +334,18 @@ def dynamic_function_executor(self, module_path=None, function_name=None, args=N
 
         if current_retries >= max_retries:
             logger.error(
-                f"[TaskQueue] Max retries ({max_retries}) reached for function: {function_name}, marking task as FAILED, job_id: {job_id}")
-            raise
+                f"[TaskQueue] Max retries ({max_retries}) reached for function: {function_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {function_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
 
         countdown = K_DEFAULT_RETRY_COUNTDOWN
         if isinstance(retry, dict) and 'countdown' in retry:
@@ -271,7 +354,7 @@ def dynamic_function_executor(self, module_path=None, function_name=None, args=N
         raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)
 
 
-@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
 def dynamic_class_method_executor(self, module_path=None, class_name=None, method_name=None, args=None, kwargs=None, init_args=None, init_kwargs=None, retry=None):
     job_id = self.request.id
     try:
@@ -299,8 +382,18 @@ def dynamic_class_method_executor(self, module_path=None, class_name=None, metho
 
         if current_retries >= max_retries:
             logger.error(
-                f"[TaskQueue] Max retries ({max_retries}) reached for method: {method_name}, marking task as FAILED, job_id: {job_id}")
-            raise
+                f"[TaskQueue] Max retries ({max_retries}) reached for method: {method_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {class_name}.{method_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
 
         countdown = K_DEFAULT_RETRY_COUNTDOWN
         if isinstance(retry, dict) and 'countdown' in retry:

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/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.14/src/taskqueue/slack_notifier.py

@@ -0,0 +1,51 @@
+"""
+Slack notification for TaskQueue.
+"""
+import json
+import logging
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class SlackbotManager:
+
+    @classmethod
+    def send_message(cls, message: str) -> None:
+        try:
+            from django.conf import settings
+        except ImportError:
+            return
+
+        if not getattr(settings, 'TASKQUEUE_SLACK_ENABLED', False):
+            return
+
+        hook_url = getattr(settings, 'TASKQUEUE_SLACK_HOOK_URL', None)
+        if not hook_url:
+            return
+
+        channel = getattr(
+            settings, 'TASKQUEUE_SLACK_CHANNEL_NAME', '#tech-automation')
+        username = getattr(
+            settings, 'TASKQUEUE_SLACK_USERNAME', 'TaskQueueBot')
+        icon_emoji = getattr(
+            settings, 'TASKQUEUE_SLACK_ICON_EMOJI', ':robot_face:')
+
+        is_staging = getattr(settings, 'IS_RUN_IN_STAGING_ENV', False)
+        if is_staging:
+            message = '[STAGING] ' + message
+
+        try:
+            requests.post(
+                hook_url,
+                data=json.dumps({
+                    'channel': channel,
+                    'username': username,
+                    'text': message,
+                    'icon_emoji': icon_emoji,
+                }),
+                headers={"Content-Type": "application/json"}
+            )
+        except Exception as e:
+            logger.exception('[TaskQueue Slack] Error: %s', str(e))

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/tests/test_cmanager.py

@@ -1,9 +1,11 @@
 from datetime import datetime
 from datetime import timedelta
+from typing import Any
 from unittest.mock import Mock
 from unittest.mock import patch
 
 import pytest
+from taskqueue.cmanager import _build_callable_task_call
 from taskqueue.cmanager import _build_dynamic_task_call
 from taskqueue.cmanager import _is_class_method
 from taskqueue.cmanager import _split_function_and_queue_kwargs
@@ -159,6 +161,149 @@ class TestSplitFunctionAndQueueKwargs:
         assert queue_kwargs == {}
 
 
+class TestParseEnqueueArgs:
+
+    def test__parse_enqueue_args_given_basic_enqueue_expect_correct_parsing(self):
+        cm = CManager()
+        args = (test_function, 1, 2, 3)
+        kwargs = {
+            'user_id': 123,
+            'data': 'test',
+            'channel': 'high',
+            'retry': {'max_retries': 5}
+        }
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == (1, 2, 3)
+        assert func_kwargs == {'user_id': 123, 'data': 'test'}
+        assert queue_options == {
+            'channel': 'high',
+            'retry': {'max_retries': 5}
+        }
+        assert 'eta' not in queue_options
+        assert 'countdown' not in queue_options
+
+    def test__parse_enqueue_args_given_enqueue_at_expect_eta_in_queue_options(self):
+        cm = CManager()
+        eta = datetime(2025, 12, 31, 23, 59, 59)
+        args = (eta, test_function, 'arg1', 'arg2')
+        kwargs = {
+            'user_id': 456,
+            'channel': 'default'
+        }
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue_at', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == ('arg1', 'arg2')
+        assert func_kwargs == {'user_id': 456}
+        assert queue_options['eta'] == eta
+        assert queue_options['channel'] == 'default'
+        assert 'countdown' not in queue_options
+
+    def test__parse_enqueue_args_given_enqueue_in_expect_countdown_in_queue_options(self):
+        cm = CManager()
+        delta = timedelta(seconds=300)
+        args = (delta, test_function, 'arg1')
+        kwargs = {
+            'data': {'key': 'value'},
+            'retry': {'max_retries': 3}
+        }
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue_in', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == ('arg1',)
+        assert func_kwargs == {'data': {'key': 'value'}}
+        assert queue_options['countdown'] == 300
+        assert queue_options['retry'] == {'max_retries': 3}
+        assert 'eta' not in queue_options
+
+    def test__parse_enqueue_args_given_no_func_args_expect_empty_tuple(self):
+        cm = CManager()
+        args = (test_function,)
+        kwargs = {'user_id': 789}
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == ()
+        assert func_kwargs == {'user_id': 789}
+
+    def test__parse_enqueue_args_given_no_kwargs_expect_empty_dicts(self):
+        cm = CManager()
+        args = (test_function, 1, 2)
+        kwargs = {}
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == (1, 2)
+        assert func_kwargs == {}
+        assert queue_options == {}
+
+    def test__parse_enqueue_args_given_no_args_expect_value_error(self):
+        cm = CManager()
+        args = ()
+        kwargs = {}
+
+        with pytest.raises(ValueError, match="enqueue requires a callable as the first positional argument"):
+            cm._parse_enqueue_args('enqueue', args, kwargs)
+
+    def test__parse_enqueue_args_given_enqueue_at_insufficient_args_expect_value_error(self):
+        cm = CManager()
+        args = (datetime.now(),)
+        kwargs = {}
+
+        with pytest.raises(ValueError, match="enqueue_at requires \\(eta_datetime, func, \\*func_args\\)"):
+            cm._parse_enqueue_args('enqueue_at', args, kwargs)
+
+    def test__parse_enqueue_args_given_enqueue_in_insufficient_args_expect_value_error(self):
+        cm = CManager()
+        args = (timedelta(seconds=60),)
+        kwargs = {}
+
+        with pytest.raises(ValueError, match="enqueue_in requires \\(countdown_delta, func, \\*func_args\\)"):
+            cm._parse_enqueue_args('enqueue_in', args, kwargs)
+
+    def test__parse_enqueue_args_given_unknown_op_type_expect_value_error(self):
+        cm = CManager()
+        args = (test_function,)
+        kwargs = {}
+
+        with pytest.raises(ValueError, match="Unknown enqueue operation type: invalid_op"):
+            cm._parse_enqueue_args('invalid_op', args, kwargs)
+
+    def test__parse_enqueue_args_given_use_legacy_executor_expect_in_queue_options(self):
+        cm = CManager()
+        args = (test_function, 1, 2)
+        kwargs = {
+            'use_legacy_executor': False,
+            'user_id': 123
+        }
+
+        func, func_args, func_kwargs, queue_options = cm._parse_enqueue_args(
+            'enqueue', args, kwargs
+        )
+
+        assert func == test_function
+        assert func_args == (1, 2)
+        assert func_kwargs == {'user_id': 123}
+        assert queue_options['use_legacy_executor'] is False
+
+
 class TestBuildDynamicTaskCall:
 
     def test__build_dynamic_task_call_given_function_expect_function_executor_task(self):
@@ -357,12 +502,11 @@ class TestDynamicTaskExecutors:
 
         from taskqueue.cmanager import dynamic_function_executor
 
-        # Mock the request object to simulate max retries reached
         mock_self = Mock()
         mock_self.request.retries = K_MAX_RETRY_COUNT
         mock_self.max_retries = K_MAX_RETRY_COUNT
 
-        with pytest.raises(Exception):  # Reject should be raised
+        with pytest.raises(Exception):
             dynamic_function_executor(
                 mock_self, "invalid_module", "test_function",
                 retry={"max_retries": K_MAX_RETRY_COUNT}
@@ -542,3 +686,243 @@ class TestDynamicClassMethodExecutorWithInitArgs:
         )
 
         assert result is None
+
+
+class TestBuildCallableTaskCall:
+
+    def test__build_callable_task_call_given_function_expect_callable_executor_task(self) -> None:
+        task_name, task_args, task_kwargs = _build_callable_task_call(
+            test_function, (1, 2), {'key': 'value'}
+        )
+
+        assert task_name == "taskqueue.cmanager.callable_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'callable_obj': test_function,
+            'args': [1, 2],
+            'kwargs': {'key': 'value'}
+        }
+
+    def test__build_callable_task_call_given_lambda_expect_callable_executor_task(self) -> None:
+        def lambda_func(x):
+            return x * 2
+
+        task_name, task_args, task_kwargs = _build_callable_task_call(
+            lambda_func, (5,), {}
+        )
+
+        assert task_name == "taskqueue.cmanager.callable_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'callable_obj': lambda_func,
+            'args': [5],
+            'kwargs': {}
+        }
+
+    def test__build_callable_task_call_given_bound_method_expect_callable_executor_task(self) -> None:
+        instance = SampleClass()
+        task_name, task_args, task_kwargs = _build_callable_task_call(
+            instance.test_method, (1, 2), {'key': 'value'}
+        )
+
+        assert task_name == "taskqueue.cmanager.callable_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'callable_obj': instance.test_method,
+            'args': [1, 2],
+            'kwargs': {'key': 'value'}
+        }
+
+    def test__build_callable_task_call_given_no_args_expect_empty_lists(self) -> None:
+        task_name, task_args, task_kwargs = _build_callable_task_call(
+            test_function, (), {}
+        )
+
+        assert task_name == "taskqueue.cmanager.callable_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'callable_obj': test_function,
+            'args': [],
+            'kwargs': {}
+        }
+
+    def test_callable_executor_given_function_expect_function_executed(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        assert hasattr(callable_executor, 'delay')
+        assert hasattr(callable_executor, 'apply_async')
+
+    def test_callable_executor_given_simple_function_expect_success(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        call_tracker = []
+
+        def simple_func(x, y):
+            call_tracker.append((x, y))
+            return x + y
+
+        result = callable_executor(
+            callable_obj=simple_func,
+            args=[3, 5],
+            kwargs={},
+            retry=None
+        )
+
+        assert result is None
+        assert call_tracker == [(3, 5)]
+
+    def test_callable_executor_given_function_with_kwargs_expect_success(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        call_tracker: list[tuple[str, int]] = []
+
+        def func_with_kwargs(name: str, age: int = 0) -> None:
+            call_tracker.append((name, age))
+
+        result = callable_executor(
+            callable_obj=func_with_kwargs,
+            args=["Alice"],
+            kwargs={"age": 30},
+            retry=None
+        )
+
+        assert result is None
+        assert call_tracker == [("Alice", 30)]
+
+    def test_callable_executor_given_lambda_expect_success(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        result_tracker: list[int] = []
+
+        def lambda_func(x, y):
+            return result_tracker.append(x * y)
+
+        result = callable_executor(
+            callable_obj=lambda_func,
+            args=[4, 5],
+            kwargs={},
+            retry=None
+        )
+
+        assert result is None
+        assert result_tracker == [20]
+
+    def test_callable_executor_given_bound_method_expect_success(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        instance = SampleClassWithInit("TestUser", age=25)
+
+        result = callable_executor(
+            callable_obj=instance.process,
+            args=[],
+            kwargs={},
+            retry=None
+        )
+
+        assert result is None
+
+    def test_callable_executor_given_bound_method_with_args_expect_success(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        instance = SampleClassWithInit("TestUser", age=25)
+
+        result = callable_executor(
+            callable_obj=instance.process_with_args,
+            args=["Hello"],
+            kwargs={},
+            retry=None
+        )
+
+        assert result is None
+
+    def test_callable_executor_given_none_args_expect_default_to_empty(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        call_tracker: list[str] = []
+
+        def no_args_func() -> None:
+            call_tracker.append("called")
+
+        result = callable_executor(
+            callable_obj=no_args_func,
+            args=None,
+            kwargs=None,
+            retry=None
+        )
+
+        assert result is None
+        assert call_tracker == ["called"]
+
+    def test_callable_executor_given_callable_with_side_effects_expect_side_effects_executed(self) -> None:
+        from taskqueue.cmanager import callable_executor
+
+        side_effects: dict[str, int] = {"counter": 0}
+
+        def increment_counter(amount: int) -> None:
+            side_effects["counter"] += amount
+
+        callable_executor(
+            callable_obj=increment_counter,
+            args=[5],
+            kwargs={},
+            retry=None
+        )
+
+        assert side_effects["counter"] == 5
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_given_use_legacy_executor_false_expect_callable_executor(self, mock_send_task: Any, mock_logger: Any) -> None:
+        cm = CManager()
+        cm.enqueue(test_function, 1, 2, key='value',
+                   use_legacy_executor=False)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.callable_executor"
+
+        task_kwargs = call_args[0][2]
+        assert 'callable_obj' in task_kwargs
+        assert task_kwargs['callable_obj'] == test_function
+        assert task_kwargs['args'] == [1, 2]
+        assert task_kwargs['kwargs'] == {'key': 'value'}
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_given_use_legacy_executor_true_expect_dynamic_executor(self, mock_send_task: Any, mock_logger: Any) -> None:
+        cm = CManager()
+        cm.enqueue(test_function, 1, 2, key='value',
+                   use_legacy_executor=True)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.dynamic_function_executor"
+
+        task_kwargs = call_args[0][2]
+        assert 'module_path' in task_kwargs
+        assert 'function_name' in task_kwargs
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_given_no_use_legacy_executor_expect_default_to_true(self, mock_send_task: Any, mock_logger: Any) -> None:
+        cm = CManager()
+        cm.enqueue(test_function, 1, 2)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.dynamic_function_executor"
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_given_bound_method_with_callable_executor_expect_success(self, mock_send_task: Any, mock_logger: Any) -> None:
+        cm = CManager()
+        instance = SampleClassWithInit("Test", age=20)
+
+        cm.enqueue(instance.process, use_legacy_executor=False)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.callable_executor"
+
+        task_kwargs = call_args[0][2]
+        assert task_kwargs['callable_obj'] == instance.process

{p1_taskqueue-0.1.12 → p1_taskqueue-0.1.14}/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.12 → p1_taskqueue-0.1.14}/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': {}}
+        )