jolt 0.9.172__py3-none-any.whl → 0.9.435__py3-none-any.whl

jolt/plugins/strings.py

@@ -1,31 +1,50 @@
-from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
-from jolt.cache import ArtifactStringAttribute
 
 
-class StringVariable(ArtifactStringAttribute):
-    def __init__(self, artifact, name):
-        super(StringVariable, self).__init__(artifact, name)
-        self._old_value = None
+class StringVariableSet(object):
+    """
+    A set of string variables for an artifact.
 
-    def apply(self, task, artifact):
-        pass
+    Example:
 
-    def unapply(self, task, artifact):
-        pass
+    .. code-block:: python
 
+        artifact.strings.foo = "bar"
+        print(artifact.strings.foo)
+
+    """
 
-class StringVariableSet(ArtifactAttributeSet):
     def __init__(self, artifact):
-        super(StringVariableSet, self).__init__()
-        super(ArtifactAttributeSet, self).__setattr__("_artifact", artifact)
+        super(StringVariableSet, self).__setattr__("_attributes", {})
+        super(StringVariableSet, self).__setattr__("_artifact", artifact)
+
+    def _get_attributes(self):
+        return self._attributes
+
+    def __getattr__(self, name):
+        attributes = self._get_attributes()
+        return attributes.get(name, None)
+
+    def __setattr__(self, name, value):
+        if not isinstance(value, str):
+            raise ValueError(f"Value assigned to artifact.strings.{name} must be a string, got {type(value)}")
+        attributes = self._get_attributes()
+        attributes[name] = self._artifact.tools.expand(value)
+        return value
 
-    def create(self, name):
-        return StringVariable(self._artifact, name)
+    def __dict__(self):
+        return {key: str(value) for key, value in self.items()}
+
+    def items(self):
+        return self._get_attributes().items()
 
 
 @ArtifactAttributeSetProvider.Register
 class StringVariableSetProvider(ArtifactAttributeSetProvider):
+    """
+    A provider of string variable sets.
+    """
+
     def create(self, artifact):
         setattr(artifact, "strings", StringVariableSet(artifact))
 
@@ -34,7 +53,7 @@ class StringVariableSetProvider(ArtifactAttributeSetProvider):
             return
 
         for key, value in content["strings"].items():
-            getattr(artifact.strings, key).set_value(value, expand=False)
+            setattr(artifact.strings, key, value)
 
     def format(self, artifact, content):
         if "strings" not in content:
@@ -42,9 +61,3 @@ class StringVariableSetProvider(ArtifactAttributeSetProvider):
 
         for key, value in artifact.strings.items():
             content["strings"][key] = str(value)
-
-    def apply(self, task, artifact):
-        artifact.strings.apply(task, artifact)
-
-    def unapply(self, task, artifact):
-        artifact.strings.unapply(task, artifact)

jolt/plugins/symlinks.py

@@ -18,6 +18,15 @@ class SymlinkTaskHooks(TaskHook):
         self._path = config.get("symlinks", "path", "artifacts")
         raise_error_if(not self._path, "symlinks.path not configured")
 
+    @property
+    def rootpath(self):
+        return fs.path.normpath(
+            fs.path.join(
+                fs.path.dirname(loader.JoltLoader.get().build_path),
+                self._path
+            )
+        )
+
     def task_finished(self, task):
         if not task.has_artifact():
             return
@@ -26,14 +35,12 @@ class SymlinkTaskHooks(TaskHook):
             srcpath = artifact.final_path
             if artifact.name == "main":
                 destpath = fs.path.join(
-                    loader.get_workspacedir(),
-                    self._path,
+                    self.rootpath,
                     utils.canonical(task.short_qualified_name),
                 )
             else:
                 destpath = fs.path.join(
-                    loader.get_workspacedir(),
-                    self._path,
+                    self.rootpath,
                     artifact.name + "@" + utils.canonical(task.short_qualified_name),
                 )
 

jolt/plugins/telemetry.py

@@ -1,4 +1,3 @@
-from socket import gethostname
 from requests.exceptions import RequestException
 from requests.api import post
 
@@ -38,7 +37,7 @@ class TelemetryHooks(TaskHook):
             "name": task.short_qualified_name,
             "identity": task.identity,
             "instance": task.task._instance.value,
-            "hostname": gethostname(),
+            "hostname": utils.hostname(),
             "role": "client" if client else "worker",
             "event": event,
             "routing_key": getattr(task.task, "routing_key", "default")

jolt/plugins/timeline.py

@@ -1,15 +1,25 @@
 from datetime import datetime
 import os
 
+from jolt import log
+from jolt import tools
 from jolt import utils
 from jolt.hooks import TaskHook, TaskHookFactory
-from jolt.config import get_workdir
+from jolt import config
+
+
+NAME_LOG = "Timeline"
 
 
 class TimelineHooks(TaskHook):
     def __init__(self):
+        self.path = os.path.join(
+            config.get_workdir(),
+            config.get("timeline", "path", "timeline.html")
+        )
         self.tasks = []
         self.task_ids = {}
+        self.tools = tools.Tools()
 
     def started(self, task):
         task._timeline_started = datetime.now().isoformat()
@@ -27,8 +37,7 @@ class TimelineHooks(TaskHook):
             enumerate=enumerate,
             tasks=self.tasks)
 
-        with open(os.path.join(get_workdir(), "timeline.html"), "w") as f:
-            f.write(timeline)
+        self.tools.write_file(self.path, timeline, expand=False)
 
     def deps(self, task):
         ids = []
@@ -59,4 +68,5 @@ class TimelineHooks(TaskHook):
 @TaskHookFactory.register
 class TimelineFactory(TaskHookFactory):
     def create(self, env):
+        log.verbose(NAME_LOG + " Loaded")
         return TimelineHooks()