Update module level function methods

"global" can be confusing

Author: RealOrangeOne

django_tasks/backends/base.py

@@ -10,7 +10,7 @@
 
 from django_tasks.exceptions import InvalidTaskError
 from django_tasks.task import MAX_PRIORITY, MIN_PRIORITY, Task, TaskResult
-from django_tasks.utils import is_global_function
+from django_tasks.utils import is_module_level_function
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -57,10 +57,8 @@ def validate_task(self, task: Task) -> None:
         """
         Determine whether the provided task is one which can be executed by the backend.
         """
-        if not is_global_function(task.func):
-            raise InvalidTaskError(
-                "Task function must be a globally importable function"
-            )
+        if not is_module_level_function(task.func):
+            raise InvalidTaskError("Task function must be defined at a module level")
 
         if not self.supports_async_task and iscoroutinefunction(task.func):
             raise InvalidTaskError("Backend does not support async tasks")

django_tasks/utils.py

@@ -25,7 +25,7 @@ class SerializedExceptionDict(TypedDict):
 P = ParamSpec("P")
 
 
-def is_global_function(func: Callable) -> bool:
+def is_module_level_function(func: Callable) -> bool:
     if not inspect.isfunction(func) or inspect.isbuiltin(func):
         return False
 

tests/tests/is_global_function_fixture.py

@@ -0,0 +1,27 @@
+"""
+This file is used to test function is considered module level even if it's not defined yet
+because it's covered by a decorator.
+"""
+
+from django_tasks.utils import is_module_level_function
+
+
+@is_module_level_function
+def really_module_level_function() -> None:
+    pass
+
+
+inner_func_is_module_level_function = None
+
+
+def main() -> None:
+    global inner_func_is_module_level_function
+
+    @is_module_level_function
+    def inner_func() -> None:
+        pass
+
+    inner_func_is_module_level_function = inner_func
+
+
+main()

tests/tests/is_module_level_function_fixture.py

@@ -216,7 +216,7 @@ def test_invalid_function(self) -> None:
             with self.subTest(invalid_function):
                 with self.assertRaisesMessage(
                     InvalidTaskError,
-                    "Task function must be a globally importable function",
+                    "Task function must be defined at a module level",
                 ):
                     task()(invalid_function)  # type:ignore[arg-type]
 

tests/tests/test_tasks.py

@@ -13,39 +13,43 @@
 from tests import tasks as test_tasks
 
 
-class IsGlobalFunctionTestCase(SimpleTestCase):
+class IsModuleLevelFunctionTestCase(SimpleTestCase):
     def test_builtin(self) -> None:
-        self.assertFalse(utils.is_global_function(any))
-        self.assertFalse(utils.is_global_function(isinstance))
+        self.assertFalse(utils.is_module_level_function(any))
+        self.assertFalse(utils.is_module_level_function(isinstance))
 
     def test_from_module(self) -> None:
-        self.assertTrue(utils.is_global_function(subprocess.run))
-        self.assertTrue(utils.is_global_function(subprocess.check_output))
-        self.assertTrue(utils.is_global_function(test_tasks.noop_task.func))
+        self.assertTrue(utils.is_module_level_function(subprocess.run))
+        self.assertTrue(utils.is_module_level_function(subprocess.check_output))
+        self.assertTrue(utils.is_module_level_function(test_tasks.noop_task.func))
 
     def test_private_function(self) -> None:
         def private_function() -> None:
             pass
 
-        self.assertFalse(utils.is_global_function(private_function))
+        self.assertFalse(utils.is_module_level_function(private_function))
 
     def test_coroutine(self) -> None:
-        self.assertTrue(utils.is_global_function(test_tasks.noop_task_async.func))
+        self.assertTrue(utils.is_module_level_function(test_tasks.noop_task_async.func))
 
     def test_method(self) -> None:
-        self.assertFalse(utils.is_global_function(self.test_method))
-        self.assertFalse(utils.is_global_function(self.setUp))
+        self.assertFalse(utils.is_module_level_function(self.test_method))
+        self.assertFalse(utils.is_module_level_function(self.setUp))
 
     def test_lambda(self) -> None:
-        self.assertFalse(utils.is_global_function(lambda: True))
+        self.assertFalse(utils.is_module_level_function(lambda: True))
 
     def test_uninitialised_method(self) -> None:
         # This import has to be here, so the module is loaded during the test
-        from . import is_global_function_fixture
-
-        self.assertTrue(is_global_function_fixture.really_global_function)
-        self.assertIsNotNone(is_global_function_fixture.inner_func_is_global_function)
-        self.assertFalse(is_global_function_fixture.inner_func_is_global_function)
+        from . import is_module_level_function_fixture
+
+        self.assertTrue(is_module_level_function_fixture.really_module_level_function)
+        self.assertIsNotNone(
+            is_module_level_function_fixture.inner_func_is_module_level_function
+        )
+        self.assertFalse(
+            is_module_level_function_fixture.inner_func_is_module_level_function
+        )
 
 
 class JSONNormalizeTestCase(SimpleTestCase):