Draft Idea For Pre Tasks To Be Context Aware

This commit introduces, in a draft state, the idea to allow tasks
that are called as a pre task for another task, to keep state
of this pre task assignment via the attribute `_is_pre_of`.

This attribute is later used when a `Call` object is created
from a `Task` instance that has said attribute set. A `Call`
created from a pre task, will add a reference to the task
that defines the current task as pre task, and said reference
will be available during the pre task's execution in the
context passed to the task.

The approach here suggested uses Pythonic patterns to avoid
changes to the class implementation as much as possible, but
rather compose the new functionality from invidivual, signle
purpose small components, such as a generic decorator, and
a descriptor component.

It can be very well the case that making a task more stateful
by tracking this pre assignment is not aligned with the design
if this library, in which case it would be better not to
add functionality that is not part of the long term view for
the library. I would be happy to contribute to this greaat
library in other ways.

Author: alejandro antillon

invoke/tasks.py

@@ -31,7 +31,15 @@
     from .config import Config
 
 T = TypeVar("T", bound=Callable)
+    
+class PreTaskDesc:
+    def __get__(self, obj, _type):
+        return obj._pre
 
+    def __set__(self, obj, value):
+        for p in value:
+            p._is_pre_of = obj
+        obj._pre = value       
 
 class Task(Generic[T]):
     """
@@ -48,6 +56,7 @@ class Task(Generic[T]):
 
     .. versionadded:: 1.0
     """
+    pre = PreTaskDesc()
 
     # TODO: store these kwarg defaults central, refer to those values both here
     # and in @task.
@@ -395,6 +404,8 @@ def __init__(
             Keyword arguments to call with, if any. Default: ``None``.
         """
         self.task = task
+        if hasattr(task, "_is_pre_of"):
+            self.make_context = _copy_attrs_to_return_val(task, "_is_pre_of")(self.make_context)
         self.called_as = called_as
         self.args = args or tuple()
         self.kwargs = kwargs or dict()
@@ -517,3 +528,17 @@ def clean_build(c):
     .. versionadded:: 1.0
     """
     return Call(task, args=args, kwargs=kwargs)
+
+def _copy_attrs_to_return_val(source, *attrs):
+    """
+    Copies attributes from a source to the return value of the decorated function
+    """
+    def _wrapper(func):
+        def _inner(*args, **kwargs):
+            target = func(*args, **kwargs)
+            for name in attrs:
+                if value:= getattr(source, name):
+                    setattr(target, name, value)
+            return target
+        return _inner
+    return _wrapper

tests/task.py

@@ -92,6 +92,33 @@ def func(c):
 
         assert func.pre == [whatever]
 
+    def task_and_pre_tasks_binding(self):
+
+        @task
+        def pre_task(c):
+            pass
+
+        @task(pre=[pre_task])
+        def my_task(c):
+            pass
+        
+        assert all([hasattr(p, "_is_pre_of") for p in my_task.pre])
+        assert pre_task._is_pre_of == my_task
+
+    def create_call_and_context_form_pre_task_has_access_to_parent_task(self):
+
+        @task
+        def pre_task(c):
+            pass
+
+        @task(pre=[pre_task])
+        def my_task(c):
+            pass
+        
+        call = Call(pre_task)
+        c = call.make_context(Config(defaults={}))
+        assert getattr(c, "_is_pre_of") == my_task
+
     def allows_star_args_as_shortcut_for_pre(self):
         @task
         def pre1(c):
@@ -442,7 +469,7 @@ def second(c, shared):
                 # Running get_arguments() is required to trigger bug or lack
                 # thereof, but also lets us do a nice safety check after.
                 helps = [x.get_arguments()[0].help for x in (first, second)]
-                assert helps == ["help", "help"]
+                assert helps == ["help", "help"]        
 
 
 # Dummy task for Call tests