jolt 0.9.123__py3-none-any.whl → 0.9.435__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
@@ -222,6 +238,10 @@ class CliHook(object):
     def cli_download(self, *args, **kwargs):
         yield
 
+    @contextmanager
+    def cli_report(self, *args, **kwargs):
+        yield
+
 
 class CliHookFactory(object):
     @staticmethod
@@ -262,11 +282,22 @@ class CliHookRegistry(object):
                 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)
 
@@ -287,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)
 
@@ -361,3 +396,11 @@ def cli_download(cmd):
         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
@@ -201,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"
 
@@ -222,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"
 
@@ -233,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"
@@ -590,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):