p1-taskqueue 0.1.3__tar.gz → 0.1.5__tar.gz

{p1_taskqueue-0.1.3 → p1_taskqueue-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.3
+Version: 0.1.5
 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.3 → p1_taskqueue-0.1.5}/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.3"
+version = "0.1.5"
 description = "A Task Queue Wrapper for Dekoruma Backend"
 authors = [
     {name = "Chalvin", email = "engineering@dekoruma.com"}

{p1_taskqueue-0.1.3 → p1_taskqueue-0.1.5}/src/p1_taskqueue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.3
+Version: 0.1.5
 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.3 → p1_taskqueue-0.1.5}/src/p1_taskqueue.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/taskqueue/libs/__init__.py
 src/taskqueue/libs/helper_test.py
 tests/test_celery_app.py
 tests/test_cmanager.py
+tests/test_return_values.py
 tests/test_test_utils.py

{p1_taskqueue-0.1.3 → p1_taskqueue-0.1.5}/src/taskqueue/cmanager.py

@@ -204,13 +204,21 @@ cm = CManager()
 # Dynamic task executors - handle function and class method execution
 @shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
 def dynamic_function_executor(self, module_path, function_name, args=None, kwargs=None, retry=None):
+    job_id = self.request.id
     try:
         module = importlib.import_module(module_path)
         function = getattr(module, function_name)
         args = args or []
         kwargs = kwargs or {}
-        return function(*args, **kwargs)
+        logger.info(
+            f"[TaskQueue] Executing dynamic function: {function_name} with args: {args} and kwargs: {kwargs}, job_id: {job_id}")
+        function(*args, **kwargs)
+        logger.info(
+            f"[TaskQueue] Dynamic function execution completed successfully, function_name: {function_name}, args: {args}, kwargs: {kwargs}, job_id: {job_id}")
+        return None
     except Exception as e:
+        logger.exception(
+            f"[TaskQueue] Error executing dynamic function: {function_name} with args: {args} and 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:
@@ -228,6 +236,7 @@ def dynamic_function_executor(self, module_path, function_name, args=None, kwarg
 
 @shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
 def dynamic_class_method_executor(self, module_path, class_name, method_name, args=None, kwargs=None, retry=None):
+    job_id = self.request.id
     try:
         module = importlib.import_module(module_path)
         class_obj = getattr(module, class_name)
@@ -235,8 +244,15 @@ def dynamic_class_method_executor(self, module_path, class_name, method_name, ar
         method = getattr(instance, method_name)
         args = args or []
         kwargs = kwargs or {}
-        return method(*args, **kwargs)
+        logger.info(
+            f"[TaskQueue] Executing dynamic class method: {method_name} with args: {args} and kwargs: {kwargs}, job_id: {job_id}")
+        method(*args, **kwargs)
+        logger.info(
+            f"[TaskQueue] Dynamic class method execution completed successfully, method_name: {method_name}, args: {args}, kwargs: {kwargs}, job_id: {job_id}")
+        return None
     except Exception as e:
+        logger.exception(
+            f"[TaskQueue] Error executing dynamic class method: {method_name} with args: {args} and 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:

{p1_taskqueue-0.1.3 → p1_taskqueue-0.1.5}/src/taskqueue/libs/helper_test.py

@@ -73,7 +73,7 @@ def celery_worker_burst(include_func_names: List[str], channel: str = "default")
                             logger.info(
                                 f"Successfully executed task: {full_func_name}")
                         else:
-                            logger.debug(
+                            logger.info(
                                 f"Skipping: {full_func_name or task_name}")
                             message.ack()
 

p1_taskqueue-0.1.5/tests/test_return_values.py

@@ -0,0 +1,83 @@
+from taskqueue.cmanager import dynamic_class_method_executor
+from taskqueue.cmanager import dynamic_function_executor
+
+
+def function_that_returns_value():
+    return "function_return_value"
+
+
+class TestClass:
+    def method_that_returns_value(self):
+        return "method_return_value"
+
+
+class TestExecutorReturnValues:
+
+    def test_dynamic_function_executor_given_function_returns_value_expect_return_none(self):
+        result = dynamic_function_executor(
+            "tests.test_return_values",
+            "function_that_returns_value",
+            [],
+            {},
+            None
+        )
+
+        assert result is None
+
+    def test_dynamic_class_method_executor_given_method_returns_value_expect_return_none(self):
+        result = dynamic_class_method_executor(
+            "tests.test_return_values",
+            "TestClass",
+            "method_that_returns_value",
+            [],
+            {},
+            None
+        )
+
+        assert result is None
+
+    def test_dynamic_function_executor_given_function_with_side_effects_expect_function_executed_and_return_none(self):
+        global function_executed
+        function_executed = False
+
+        def function_with_side_effect():
+            global function_executed
+            function_executed = True
+            return "should_be_ignored"
+
+        import sys
+        sys.modules[__name__].function_with_side_effect = function_with_side_effect
+
+        result = dynamic_function_executor(
+            "tests.test_return_values",
+            "function_with_side_effect",
+            [],
+            {},
+            None
+        )
+
+        assert function_executed
+        assert result is None
+
+    def test_dynamic_class_method_executor_given_method_with_side_effects_expect_method_executed_and_return_none(self):
+        class TestClassWithSideEffect:
+            def __init__(self):
+                self.method_executed = False
+
+            def method_with_side_effect(self):
+                self.method_executed = True
+                return "should_be_ignored"
+
+        import sys
+        sys.modules[__name__].TestClassWithSideEffect = TestClassWithSideEffect
+
+        result = dynamic_class_method_executor(
+            "tests.test_return_values",
+            "TestClassWithSideEffect",
+            "method_with_side_effect",
+            [],
+            {},
+            None
+        )
+
+        assert result is None