jolt 0.9.76__py3-none-any.whl → 0.9.429__py3-none-any.whl

jolt/hooks.py

@@ -8,6 +8,9 @@ class TaskHook(object):
     def task_created(self, task):
         pass
 
+    def task_queued(self, task):
+        pass
+
     def task_started(self, task):
         pass
 
@@ -36,6 +39,9 @@ class TaskHook(object):
     def task_failed(self, task):
         pass
 
+    def task_unstable(self, task):
+        pass
+
     def task_pruned(self, task):
         pass
 
@@ -95,6 +101,10 @@ class TaskHookRegistry(object):
         for ext in self.hooks:
             utils.call_and_catch_and_log(ext.task_created, task)
 
+    def task_queued(self, task):
+        for ext in self.hooks:
+            utils.call_and_catch_and_log(ext.task_queued, task)
+
     def task_started(self, task):
         if task.is_resource():
             return
@@ -149,6 +159,12 @@ class TaskHookRegistry(object):
         for ext in self.hooks:
             utils.call_and_catch_and_log(ext.task_failed, task)
 
+    def task_unstable(self, task):
+        if task.is_resource():
+            return
+        for ext in self.hooks:
+            utils.call_and_catch_and_log(ext.task_unstable, task)
+
     def task_pruned(self, task):
         if task.is_resource():
             return
@@ -199,7 +215,7 @@ class TaskHookRegistry(object):
 
     @contextmanager
     def task_run(self, task):
-        tasks = [task] if type(task) != list else task
+        tasks = [task] if type(task) is not list else task
         with ExitStack() as stack:
             for task in tasks:
                 if task.is_resource():
@@ -218,6 +234,14 @@ class CliHook(object):
     def cli_clean(self, *args, **kwargs):
         yield
 
+    @contextmanager
+    def cli_download(self, *args, **kwargs):
+        yield
+
+    @contextmanager
+    def cli_report(self, *args, **kwargs):
+        yield
+
 
 class CliHookFactory(object):
     @staticmethod
@@ -251,11 +275,29 @@ class CliHookRegistry(object):
                 stack.enter_context(ext.cli_clean(*args, **kwargs))
             yield
 
+    @contextmanager
+    def cli_download(self, *args, **kwargs):
+        with ExitStack() as stack:
+            for ext in self.hooks:
+                stack.enter_context(ext.cli_download(*args, **kwargs))
+            yield
+
+    @contextmanager
+    def cli_report(self, *args, **kwargs):
+        with ExitStack() as stack:
+            for ext in self.hooks:
+                stack.enter_context(ext.cli_report(*args, **kwargs))
+            yield
+
 
 def task_created(task):
     TaskHookRegistry.get().task_created(task)
 
 
+def task_queued(task):
+    TaskHookRegistry.get().task_queued(task)
+
+
 def task_started(task):
     TaskHookRegistry.get().task_started(task)
 
@@ -276,6 +318,10 @@ def task_failed(task):
     TaskHookRegistry.get().task_failed(task)
 
 
+def task_unstable(task):
+    TaskHookRegistry.get().task_unstable(task)
+
+
 def task_finished(task):
     TaskHookRegistry.get().task_finished(task)
 
@@ -342,3 +388,19 @@ def cli_clean(cmd):
         with CliHookRegistry.get().cli_clean():
             return cmd(*args, **kwargs)
     return decorator
+
+
+def cli_download(cmd):
+    @functools.wraps(cmd)
+    def decorator(*args, **kwargs):
+        with CliHookRegistry.get().cli_download():
+            return cmd(*args, **kwargs)
+    return decorator
+
+
+def cli_report(cmd):
+    @functools.wraps(cmd)
+    def decorator(*args, **kwargs):
+        with CliHookRegistry.get().cli_report():
+            return cmd(*args, **kwargs)
+    return decorator

jolt/influence.py

@@ -3,6 +3,7 @@ import hashlib
 import os
 from pathlib import Path, PurePath
 
+from jolt import config as jolt_config
 from jolt import inspection
 from jolt import utils
 from jolt import filesystem as fs
@@ -61,7 +62,7 @@ class TaskAttributeInfluence(HashInfluenceProvider):
         value = getattr(task, tools.Tools(task).expand(self._attrib), "N/A")
         try:
             value = value.__get__(task)
-            if type(value) == list and self._sort:
+            if type(value) is list and self._sort:
                 value.sort()
         except AttributeError:
             pass
@@ -146,12 +147,16 @@ class TaskSourceInfluence(HashInfluenceProvider):
             pass
 
         # Collect all functions from the class hierarchy
-        if type(obj) == type:
+        if type(obj) is type:
             funcs = [utils.getattr_safe(mro, funcname, TaskSourceInfluence._default_func)
                      for mro in obj.mro()]
-        else:
+        elif callable(obj) and hasattr(obj, "__self__"):
             funcs = [utils.getattr_safe(mro, funcname, TaskSourceInfluence._default_func)
                      for mro in obj.__class__.mro()]
+        elif callable(obj):
+            funcs = [obj]
+        else:
+            funcs = []
 
         # Calculate sha1 sum for all functions
         shasum = hashlib.sha1()
@@ -197,6 +202,71 @@ def source(name, obj=None):
     return _decorate
 
 
+class ConfigInfluence(HashInfluenceProvider):
+    name = "Config"
+
+    def __init__(self, section, key):
+        self.section = section
+        self.key = key
+
+    def get_influence(self, task):
+        value = jolt_config.get(self.section, self.key)
+        if value is None:
+            value = "<unset>"
+        return "{}.{}: {}".format(self.section, self.key, value)
+
+
+def config(section, key):
+    """ Add configuration value as hash influence.
+
+    Note that the configuration value is read at the time
+    when the task is prepared, not when it is executed.
+    This means that if the configuration value changes after
+    influence has been calculated, the task will not be re-executed.
+    This is true also in distributed mode, where the task
+    is prepared locally and executed remotely on a worker
+    where the configuration value may be different.
+
+    Args:
+        section (str): Name of the configuration section.
+        key (str): Name of the configuration key.
+
+    Example:
+    .. code-block:: python
+
+        from jolt import influence
+
+        @influence.config("jolt", "task_timeout")
+        class Example(Task):
+
+    """
+    def _decorate(cls):
+        _old_influence = cls._influence
+
+        def _influence(self, *args, **kwargs):
+            influence = _old_influence(self, *args, **kwargs)
+            influence.append(ConfigInfluence(section, key))
+            return influence
+
+        cls._influence = _influence
+        return cls
+
+    return _decorate
+
+
+def global_config(section, key):
+    """ Register a configuration influence globally.
+
+    See :py:func:`config` for more information.
+
+    Args:
+        section (str): Name of the configuration section.
+        key (str): Name of the configuration key.
+    """
+
+    HashInfluenceRegistry.get().register(ConfigInfluence(section, key))
+
+
 class TaskClassSourceInfluence(HashInfluenceProvider):
     name = "Source"
 
@@ -218,6 +288,18 @@ class TaskClassSourceInfluence(HashInfluenceProvider):
         return result
 
 
+class CallbackInfluence(HashInfluenceProvider):
+    def __init__(self, desc, fn, *args, **kwargs):
+        self.name = "Callback"
+        self.desc = desc
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+
+    def get_influence(self, task):
+        return self.desc + ": " + str(self.fn(*self.args, **self.kwargs))
+
+
 class TaskRequirementInfluence(HashInfluenceProvider):
     name = "Requirement"
 
@@ -229,6 +311,13 @@ class TaskRequirementInfluence(HashInfluenceProvider):
         return "{}: {}".format(self._identity, self._name)
 
 
+class CacheLocationInfluence(HashInfluenceProvider):
+    name = "Cache"
+
+    def get_influence(self, task):
+        return jolt_config.get_cachedir()
+
+
 @HashInfluenceRegistry.Register
 class TaskNameInfluence(HashInfluenceProvider):
     name = "Name"
@@ -586,15 +675,49 @@ def whitelist(pathname):
 class StringInfluence(HashInfluenceProvider):
     name = "String"
 
-    def __init__(self, value):
+    def __init__(self, value, selfdeploy=False):
         self.value = value
+        self.selfdeploy = selfdeploy
 
     def get_influence(self, task):
+        if not self.selfdeploy and task.name in ["jolt"]:
+            return "jolt"
         return self.value
 
 
-def global_string(string):
-    HashInfluenceRegistry.get().register(StringInfluence(string))
+def string(string, selfdeploy=False):
+    """ Add string hash influence.
+
+    Args:
+        string (str): A string that will influence the hash of the task.
+
+    Example:
+
+    .. code-block:: python
+
+            from jolt import influence
+
+            @influence.string("example")
+            class Example(Task):
+
+    """
+
+    def _decorate(cls):
+        _old_influence = cls._influence
+
+        def _influence(self, *args, **kwargs):
+            influence = _old_influence(self, *args, **kwargs)
+            influence.append(StringInfluence(string, selfdeploy=selfdeploy))
+            return influence
+
+        cls._influence = _influence
+        return cls
+
+    return _decorate
+
+
+def global_string(string, selfdeploy=False):
+    HashInfluenceRegistry.get().register(StringInfluence(string, selfdeploy=selfdeploy))
 
 
 class VersionInfluence(HashInfluenceProvider):