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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.5
+Version: 0.1.7
 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.5 → p1_taskqueue-0.1.7}/src/taskqueue/__init__.py

@@ -7,6 +7,7 @@ __author__ = "Chalvin"
 __email__ = "engineering@dekoruma.com"
 
 from .cmanager import cm
+from .cmanager import taskqueue_class
 from .celery_app import celery_app
 
-__all__ = ["cm", "celery_app"]
+__all__ = ["cm", "celery_app", "taskqueue_class"]

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

@@ -28,6 +28,26 @@ def _is_class_method(func: Any) -> bool:
     )
 
 
+def taskqueue_class(cls):
+    """Decorator to automatically capture init arguments for taskqueue."""
+    original_init = cls.__init__
+    
+    def wrapped_init(self, *args, **kwargs):
+        self._taskqueue_init_args = list(args)
+        self._taskqueue_init_kwargs = dict(kwargs)
+        original_init(self, *args, **kwargs)
+    
+    cls.__init__ = wrapped_init
+    return cls
+
+
+def _extract_init_args_from_instance(instance: Any) -> Tuple[list, dict]:
+    """Extract init arguments from instance."""
+    init_args = getattr(instance, '_taskqueue_init_args', [])
+    init_kwargs = getattr(instance, '_taskqueue_init_kwargs', {})
+    return init_args, init_kwargs
+
+
 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
@@ -62,10 +82,20 @@ def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple
         module_path = klass.__module__
         class_name = klass.__name__
         method_name = func.__name__
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        
         task_name = "taskqueue.cmanager.dynamic_class_method_executor"
-        task_args = [module_path, class_name,
-                     method_name, list(args), dict(func_kwargs)]
-        task_kwargs: Dict[str, Any] = {}
+        task_args = []
+        task_kwargs: Dict[str, Any] = {
+            "module_path": module_path,
+            "class_name": class_name,
+            "method_name": method_name,
+            "args": list(args),
+            "kwargs": dict(func_kwargs),
+            "init_args": init_args,
+            "init_kwargs": init_kwargs,
+        }
         return task_name, task_args, task_kwargs
 
     module_path = getattr(func, "__module__", None)
@@ -75,8 +105,13 @@ def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple
             "Unsupported callable type for Celery enqueue. Provide a module-level function or a class method.")
 
     task_name = "taskqueue.cmanager.dynamic_function_executor"
-    task_args = [module_path, function_name, list(args), dict(func_kwargs)]
-    task_kwargs = {}
+    task_args = []
+    task_kwargs = {
+        "module_path": module_path,
+        "function_name": function_name,
+        "args": list(args),
+        "kwargs": dict(func_kwargs),
+    }
     return task_name, task_args, task_kwargs
 
 
@@ -160,17 +195,18 @@ class CManager:
             task_name, task_args, task_kwargs = _build_dynamic_task_call(
                 func, *func_args, **func_kwargs)
 
-            self._send_task(task_name, task_args, task_kwargs, queue_kwargs)
+            task_id = self._send_task(task_name, task_args,
+                                      task_kwargs, queue_kwargs)
 
-            logger.info('[_enqueue_op_base %s] Submit Celery Task SUCCESS, task_name: %s args: %s, kwargs: %s' % (
-                enqueue_op_type, task_name, task_args, task_kwargs))
+            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))
 
         except Exception as e:
             logger.exception('[_enqueue_op_base %s] Submit Celery Task FAILED, error: %s, args: %s, kwargs: %s' % (
                 enqueue_op_type, str(e), args, kwargs))
             raise e
 
-    def _send_task(self, task_name: str, task_args: list, task_kwargs: dict, queue_kwargs: Dict[str, Any]) -> None:
+    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()
 
         queue_name = queue_kwargs.pop("channel", None)
@@ -194,8 +230,9 @@ class CManager:
         else:
             task_kwargs_with_retry["retry"] = retry_policy
 
-        celery_app.send_task(task_name, args=task_args,
-                             kwargs=task_kwargs_with_retry, **send_opts)
+        task = celery_app.send_task(task_name, args=task_args,
+                                    kwargs=task_kwargs_with_retry, **send_opts)
+        return str(task.id)
 
 
 cm = CManager()
@@ -203,7 +240,7 @@ 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):
+def dynamic_function_executor(self, module_path=None, function_name=None, args=None, kwargs=None, retry=None):
     job_id = self.request.id
     try:
         module = importlib.import_module(module_path)
@@ -235,12 +272,14 @@ 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):
+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:
         module = importlib.import_module(module_path)
         class_obj = getattr(module, class_name)
-        instance = class_obj()
+        init_args = init_args or []
+        init_kwargs = init_kwargs or {}
+        instance = class_obj(*init_args, **init_kwargs)
         method = getattr(instance, method_name)
         args = args or []
         kwargs = kwargs or {}

{p1_taskqueue-0.1.5 → p1_taskqueue-0.1.7}/tests/test_cmanager.py

@@ -10,7 +10,7 @@ from taskqueue.cmanager import _split_function_and_queue_kwargs
 from taskqueue.cmanager import CManager
 from taskqueue.cmanager import K_DEFAULT_RETRY_COUNTDOWN
 from taskqueue.cmanager import K_MAX_RETRY_COUNT
-# Import the functions and classes to test
+from taskqueue.cmanager import taskqueue_class
 
 
 class TestClass:
@@ -27,6 +27,56 @@ class TestClass:
         pass
 
 
+@taskqueue_class
+class TestClassWithInit:
+
+    def __init__(self, name, age=0, **kwargs):
+        self.name = name
+        self.age = age
+        self.kwargs = kwargs
+
+    def process(self):
+        return f"Processing {self.name}, age {self.age}"
+
+    def process_with_args(self, message):
+        return f"{message}: {self.name}, age {self.age}"
+
+
+@taskqueue_class
+class TestClassWithVarArgs:
+
+    def __init__(self, name, *args, **kwargs):
+        self.name = name
+        self.args = args
+        self.kwargs = kwargs
+
+    def process(self):
+        return f"Processing {self.name} with {len(self.args)} args"
+
+
+@taskqueue_class
+class TestClassWithComplexInit:
+
+    def __init__(self, required, optional=10, *extra, **options):
+        self.required = required
+        self.optional = optional
+        self.extra = extra
+        self.options = options
+
+    def calculate(self):
+        return sum([self.required, self.optional] + list(self.extra))
+
+
+@taskqueue_class
+class TestClassWithDifferentParamNames:
+
+    def __init__(self, cognito_form_reimbursement_dict):
+        self.data = cognito_form_reimbursement_dict
+
+    def process(self):
+        return f"Processing data: {self.data}"
+
+
 def test_function():
     """Test function for testing function detection."""
 
@@ -117,9 +167,13 @@ class TestBuildDynamicTaskCall:
         )
 
         assert task_name == "taskqueue.cmanager.dynamic_function_executor"
-        assert task_args == ['tests.test_cmanager',
-                             'test_function', [1, 2], {'key': 'value'}]
-        assert task_kwargs == {}
+        assert task_args == []
+        assert task_kwargs == {
+            'module_path': 'tests.test_cmanager',
+            'function_name': 'test_function',
+            'args': [1, 2],
+            'kwargs': {'key': 'value'}
+        }
 
     def test__build_dynamic_task_call_given_bound_method_expect_class_method_executor_task(self):
         instance = TestClass()
@@ -128,9 +182,16 @@ class TestBuildDynamicTaskCall:
         )
 
         assert task_name == "taskqueue.cmanager.dynamic_class_method_executor"
-        assert task_args == ['tests.test_cmanager',
-                             'TestClass', 'test_method', [1, 2], {'key': 'value'}]
-        assert task_kwargs == {}
+        assert task_args == []
+        assert task_kwargs == {
+            'module_path': 'tests.test_cmanager',
+            'class_name': 'TestClass',
+            'method_name': 'test_method',
+            'args': [1, 2],
+            'kwargs': {'key': 'value'},
+            'init_args': [],
+            'init_kwargs': {}
+        }
 
     def test__build_dynamic_task_call_given_function_without_module_expect_raise_value_error(self):
         mock_func = Mock()
@@ -306,3 +367,176 @@ class TestDynamicTaskExecutors:
                 mock_self, "invalid_module", "test_function",
                 retry={"max_retries": K_MAX_RETRY_COUNT}
             )
+
+
+class TestExtractInitArgs:
+
+    def test_extract_init_args_from_instance_given_instance_with_init_args_expect_args_extracted(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClassWithInit("John", age=25)
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == ["John"]
+        assert init_kwargs == {"age": 25}
+
+    def test_extract_init_args_from_instance_given_kwargs_only_expect_extracted(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClassWithInit("Jane", age=30)
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == ["Jane"]
+        assert init_kwargs == {"age": 30}
+
+    def test_extract_init_args_from_instance_given_no_init_expect_empty(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClass()
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == []
+        assert init_kwargs == {}
+
+    def test_extract_init_args_from_instance_given_var_args_expect_captured(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClassWithVarArgs("Alice", "extra1", "extra2", city="NYC")
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == ["Alice", "extra1", "extra2"]
+        assert init_kwargs == {"city": "NYC"}
+
+    def test_extract_init_args_from_instance_given_var_kwargs_expect_captured(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClassWithInit("Bob", age=30, city="LA", country="USA")
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == ["Bob"]
+        assert init_kwargs == {"age": 30, "city": "LA", "country": "USA"}
+
+    def test_extract_init_args_from_instance_given_complex_init_expect_all_captured(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        instance = TestClassWithComplexInit(5, 15, 20, 25, multiplier=2, debug=True)
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == [5, 15, 20, 25]
+        assert init_kwargs == {"multiplier": 2, "debug": True}
+
+    def test_extract_init_args_from_instance_given_different_param_names_expect_works(self):
+        from taskqueue.cmanager import _extract_init_args_from_instance
+        from collections import OrderedDict
+        
+        test_dict = OrderedDict([("key1", "value1"), ("key2", "value2")])
+        instance = TestClassWithDifferentParamNames(test_dict)
+        
+        init_args, init_kwargs = _extract_init_args_from_instance(instance)
+        assert init_args == [test_dict]
+        assert init_kwargs == {}
+
+
+class TestTaskqueueClassDecorator:
+
+    def test_taskqueue_class_decorator_given_class_expect_init_args_captured(self):
+        instance = TestClassWithInit("John", age=25)
+        
+        assert hasattr(instance, '_taskqueue_init_args')
+        assert hasattr(instance, '_taskqueue_init_kwargs')
+        assert instance._taskqueue_init_args == ["John"]
+        assert instance._taskqueue_init_kwargs == {"age": 25}
+
+    def test_taskqueue_class_decorator_given_different_param_names_expect_captured(self):
+        from collections import OrderedDict
+        test_dict = OrderedDict([("key1", "value1")])
+        instance = TestClassWithDifferentParamNames(test_dict)
+        
+        assert instance._taskqueue_init_args == [test_dict]
+        assert instance._taskqueue_init_kwargs == {}
+        assert instance.data == test_dict
+
+
+class TestBuildDynamicTaskCallWithInitArgs:
+
+    def test__build_dynamic_task_call_given_instance_with_init_args_expect_init_args_passed(self):
+        instance = TestClassWithInit("John", age=25)
+        task_name, task_args, task_kwargs = _build_dynamic_task_call(
+            instance.process, "arg1", key='value'
+        )
+
+        assert task_name == "taskqueue.cmanager.dynamic_class_method_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'module_path': 'tests.test_cmanager',
+            'class_name': 'TestClassWithInit',
+            'method_name': 'process',
+            'args': ['arg1'],
+            'kwargs': {'key': 'value'},
+            'init_args': ['John'],
+            'init_kwargs': {'age': 25}
+        }
+
+    def test__build_dynamic_task_call_given_instance_without_decorator_expect_empty_defaults(self):
+        instance = TestClass()
+        task_name, task_args, task_kwargs = _build_dynamic_task_call(
+            instance.test_method, 1, 2, key='value'
+        )
+
+        assert task_name == "taskqueue.cmanager.dynamic_class_method_executor"
+        assert task_args == []
+        assert task_kwargs == {
+            'module_path': 'tests.test_cmanager',
+            'class_name': 'TestClass',
+            'method_name': 'test_method',
+            'args': [1, 2],
+            'kwargs': {'key': 'value'},
+            'init_args': [],
+            'init_kwargs': {}
+        }
+
+
+class TestDynamicClassMethodExecutorWithInitArgs:
+    """Tests for dynamic_class_method_executor with init args."""
+
+    def test_dynamic_class_method_executor_given_init_args_expect_instance_created_with_args(self):
+        from taskqueue.cmanager import dynamic_class_method_executor
+        
+        result = dynamic_class_method_executor(
+            module_path="tests.test_cmanager",
+            class_name="TestClassWithInit",
+            method_name="process",
+            args=[],
+            kwargs={},
+            init_args=["Alice"],
+            init_kwargs={"age": 35},
+            retry=None
+        )
+        
+        assert result is None
+
+    def test_dynamic_class_method_executor_given_no_init_args_expect_backward_compatible(self):
+        from taskqueue.cmanager import dynamic_class_method_executor
+        
+        result = dynamic_class_method_executor(
+            module_path="tests.test_cmanager",
+            class_name="TestClass",
+            method_name="test_method",
+            args=[],
+            kwargs={},
+            init_args=None,
+            init_kwargs=None,
+            retry=None
+        )
+        
+        assert result is None
+
+    def test_dynamic_class_method_executor_given_var_args_and_kwargs_expect_works(self):
+        from taskqueue.cmanager import dynamic_class_method_executor
+        
+        result = dynamic_class_method_executor(
+            module_path="tests.test_cmanager",
+            class_name="TestClassWithVarArgs",
+            method_name="process",
+            args=[],
+            kwargs={},
+            init_args=["Bob", "extra1", "extra2"],
+            init_kwargs={"city": "NYC", "country": "USA"},
+            retry=None
+        )
+        
+        assert result is None