py3 support, tests, docs

Author: Alexey Tsitkin

README.md

@@ -135,6 +135,32 @@ def group_finished(group_id):
     pass
 ```
 
+#### Auto Tasks
+
+This is a helper tool, for the case you wish to define one of your class method as a task, and make it seamless to all callers.
+This makes the code much simpler, and allows using classes to invoke your method directly without considering whether it's invoked async or not.
+
+This is how you would define your class:
+```python
+class MyService:
+    def __init__(self, p1=default1, ..., pN=defaultN, auto_task_service=None):
+        self._auto_task_service = auto_task_service or AutoTaskService()
+
+        self._auto_task_service.register_task(self.my_task_method)
+    
+    def my_task_method(self, *args, **kwargs):
+        ...
+
+```
+
+Notice the following:
+1. Your class needs to have defaults for all parameter in the c'tor
+2. The c'tor must have a parameter named `auto_task_service`
+3. The method shouldn't have any return value (as it's invoked async)
+
+In case you want your method to retry certain cases, you need to raise `RetryableTaskException`.
+You can provide on optional `delay` time for the retry, set `count_retries=False` in case you don't want to limit retries, or use `max_retries_func` to specify a function which will be invoked when the defined maximum number of retries is exhausted.   
+
 #### Settings
 
 The following settings can be used to fine tune django-eb-sqs. Copy them into your Django `settings.py` file.

eb_sqs/auto_tasks/base_service.py

@@ -17,7 +17,7 @@ def __init__(self):
 
     def register_task(self, method, queue_name=None, max_retries=None):
         # type: (Any, str, int) -> None
-        self._registered_func_names.append(method.func_name)
+        self._registered_func_names.append(method.__name__)
 
     def is_func_name_registered(self, func_name):
         # type: (str) -> bool

eb_sqs/auto_tasks/service.py

@@ -41,8 +41,6 @@ def _auto_task_wrapper(module_name, class_name, func_name, *args, **kwargs):
     except RetryableTaskException as exc:
         try:
             retry_kwargs = {}
-            if 'execute_inline' in kwargs:
-                retry_kwargs['execute_inline'] = kwargs['execute_inline']
 
             if exc.delay is not None:
                 retry_kwargs['delay'] = exc.delay
@@ -62,9 +60,9 @@ def _auto_task_wrapper(module_name, class_name, func_name, *args, **kwargs):
 class AutoTaskService(BaseAutoTaskService):
     def register_task(self, method, queue_name=None, max_retries=None):
         # type: (Any, str, int) -> None
-        instance = method.im_self
+        instance = method.__self__
         class_ = instance.__class__
-        func_name = method.func_name
+        func_name = method.__name__
 
         def _auto_task_wrapper_invoker(*args, **kwargs):
             if queue_name is not None:

eb_sqs/tests/auto_tasks/tests_auto_tasks.py

@@ -1,20 +1,32 @@
 from unittest import TestCase
 
-from mock import Mock
+from mock import Mock, call
 
+from eb_sqs import settings
+from eb_sqs.auto_tasks.exceptions import RetryableTaskException
 from eb_sqs.auto_tasks.service import AutoTaskService, _auto_task_wrapper
 
 
 class TestService:
     _TEST_MOCK = Mock()
+    _MAX_RETRY_NUM = 5
 
     def __init__(self, auto_task_service=None):
         self._auto_task_service = auto_task_service or AutoTaskService()
         self._auto_task_service.register_task(self.task_method)
+        self._auto_task_service.register_task(self.task_retry_method, max_retries=self._MAX_RETRY_NUM)
 
     def task_method(self, *args, **kwargs):
         self._TEST_MOCK.task_method(*args, **kwargs)
 
+    def task_retry_method(self, *args, **kwargs):
+        self._TEST_MOCK.task_retry_method(*args, **kwargs)
+
+        def max_retry_fun():
+            self._TEST_MOCK.task_max_retry_method(*args, **kwargs)
+
+        raise RetryableTaskException(Exception('Test'), max_retries_func=max_retry_fun)
+
     def non_task_method(self):
         self._TEST_MOCK.non_task_method()
 
@@ -23,13 +35,22 @@ class AutoTasksTest(TestCase):
     def setUp(self):
         self._test_service = TestService()
 
+        self._args = [5, '6']
+        self._kwargs = {'p1': 'bla', 'p2': 130}
+
+        settings.EXECUTE_INLINE = True
+
     def test_task_method(self):
-        args = [5, '6']
-        kwargs = {'p1': 'bla', 'p2': 130}
+        self._test_service.task_method(*self._args, **self._kwargs)
+
+        TestService._TEST_MOCK.task_method.assert_called_once_with(*self._args, **self._kwargs)
+
+    def test_task_retry_method(self):
+        self._test_service.task_retry_method(*self._args, **self._kwargs)
 
-        self._test_service.task_method(*args, **dict(kwargs, execute_inline=True))
+        TestService._TEST_MOCK.task_retry_method.assert_has_calls([call(*self._args, **self._kwargs)] * TestService._MAX_RETRY_NUM)
 
-        TestService._TEST_MOCK.task_method.assert_called_once_with(*args, **kwargs)
+        TestService._TEST_MOCK.task_max_retry_method.assert_called_once_with(*self._args, **self._kwargs)
 
     def test_non_task_method(self):
         _auto_task_wrapper.delay(