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

jolt/plugins/meson.py

@@ -0,0 +1,61 @@
+from jolt import Task, attributes
+
+
+@attributes.common_metadata()
+class Meson(Task):
+    """ Base class for Meson-based build tasks. """
+
+    abstract = True
+    """ This is an abstract base class that should be inherited by concrete tasks. """
+
+    incremental = True
+    """
+    Whether to use incremental builds.
+    If True, the build directories are preserved between runs.
+    """
+
+    options = []
+    """
+    Additional options to pass to the `meson` command.
+    """
+
+    srcdir = None
+    """
+    Source directory for the Meson project.
+
+    If None, defaults to the task work directory (joltdir).
+    """
+
+    def clean(self, tools):
+        at = tools.meson(incremental=self.incremental)
+        at.clean()
+
+    def run(self, deps, tools):
+        self.deps = deps
+        options = tools.expand(self.options)
+        at = tools.meson(deps, incremental=self.incremental)
+        at.configure(self.srcdir or self.joltdir, *options)
+        at.build()
+        at.install()
+
+    def publish(self, artifact, tools):
+        at = tools.meson(incremental=self.incremental)
+        at.publish(artifact)
+
+
+def requires(meson=True, ninja=True):
+    """ Decorator to add Meson and Ninja requirements to a task. """
+
+    import jolt.pkgs.meson
+    import jolt.pkgs.ninja
+
+    def decorate(cls):
+        if meson:
+            cls = attributes.requires("requires_meson")(cls)
+            cls.requires_meson = ["meson"]
+        if ninja:
+            cls = attributes.requires("requires_ninja")(cls)
+            cls.requires_ninja = ["ninja"]
+        return cls
+
+    return decorate

jolt/plugins/ninja-compdb.py

@@ -115,7 +115,7 @@ def get_task_artifacts(task):
 
 class CompDBHooks(TaskHook):
     def __init__(self):
-        self._depfiles = config.getboolean("ninja-compdb", "depfiles", True)
+        self._depfiles = config.getboolean("ninja-compdb", "depfiles", False)
 
     def publish_compdb(self, artifact, tools):
         with tools.cwd(self.outdir):
@@ -226,34 +226,37 @@ def compdb(ctx, task, default):
 
     """
 
-    manifest = ctx.obj["manifest"]
     options = JoltOptions(default=default)
     acache = cache.ArtifactCache.get(options)
     TaskHookRegistry.get(options)
     executors = scheduler.ExecutorRegistry.get(options)
     registry = TaskRegistry.get()
     strategy = scheduler.DownloadStrategy(executors, acache)
-    queue = scheduler.TaskQueue(strategy, acache, {})
+    queue = scheduler.TaskQueue()
 
     for params in default:
         registry.set_default_parameters(params)
 
-    gb = graph.GraphBuilder(registry, acache, manifest, options, progress=True)
+    gb = graph.GraphBuilder(registry, acache, options, progress=True)
     dag = gb.build(task)
 
     try:
         with log.progress("Progress", dag.number_of_tasks(), " tasks", estimates=False, debug=False) as progress:
+            in_progress = set()
+
             while dag.has_tasks() or not queue.empty():
-                leafs = dag.select(lambda graph, task: task.is_ready())
+                leafs = dag.select(lambda graph, task: task.is_ready() and task not in in_progress)
 
                 # Order the tasks by their weights to improve build times
                 leafs.sort(key=lambda x: x.weight)
 
                 while leafs:
                     task = leafs.pop()
-                    queue.submit(task)
+                    executor = strategy.create_executor({}, task)
+                    queue.submit(executor)
+                    in_progress.add(task)
 
-                task, error = queue.wait()
+                task, _ = queue.wait()
 
                 # Materialize workspace resources so that
                 # source code is available to the debugger.
@@ -272,6 +275,7 @@ def compdb(ctx, task, default):
         log.warning("Interrupted by user")
         try:
             queue.abort()
+            executors.shutdown()
             sys.exit(1)
         except KeyboardInterrupt:
             print()

jolt/plugins/ninja.py

@@ -4,6 +4,7 @@ import copy
 import functools
 from ninja import ninja_syntax as ninja
 import os
+import platform
 import re
 import sys
 
@@ -21,6 +22,12 @@ from jolt.error import raise_task_error_if
 from jolt.error import JoltError, JoltCommandError
 
 
+c_standard_default = 17
+cxx_standard_default = 17
+c_standards_list = [90, 99, 11, 17, 23]
+cxx_standards_list = [98, 11, 14, 17, 20, 23, 26]
+
+
 class CompileError(JoltError):
     def __init__(self, error):
         if error:
@@ -100,8 +107,8 @@ class attributes:
                     self.info("Collecting coverage data into {covdatadir}")
 
                     for _, artifact in deps.items():
-                        if str(artifact.paths.coverage_data):
-                            tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                        if artifact.paths.coverage_data:
+                            tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
                     with tools.environ(GCOV_PREFIX=self.covdatadir):
                         yield
@@ -196,8 +203,8 @@ class attributes:
                     if not hasattr(self, "covdatadir"):
                         self.covdatadir = tools.builddir("coverage-data")
                         for _, artifact in deps.items():
-                            if str(artifact.paths.coverage_data):
-                                tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                            if artifact.paths.coverage_data:
+                                tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
                     with tools.cwd(self.covdatadir):
                         datafiles = tools.glob("**/*.gcda")
@@ -359,8 +366,8 @@ class attributes:
                     if not hasattr(self, "covdatadir"):
                         self.covdatadir = tools.builddir("coverage-data")
                         for _, artifact in deps.items():
-                            if str(artifact.paths.coverage_data):
-                                tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                            if artifact.paths.coverage_data:
+                                tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
                     reportdir = tools.builddir("coverage-report-lcov")
                     htmldir = tools.builddir("coverage-report-lcov-html")
@@ -412,7 +419,7 @@ class attributes:
 
                     reports = []
                     for _, artifact in deps.items():
-                        if str(artifact.paths.coverage_report_lcov):
+                        if artifact.paths.coverage_report_lcov:
                             reports.append(str(artifact.paths.coverage_report_lcov))
                     if reports:
                         filtered_reports = []
@@ -751,6 +758,54 @@ class ProjectVariable(Variable):
         return "PV: default={},attrib={}".format(self._default, self._attrib)
 
 
+class StdVariable(Variable):
+    def __init__(self, lang, flagfmt, values, supported=None, default=None):
+        self._lang = lang
+        self._flagfmt = flagfmt
+        self._values = values
+        self._supported = supported or values
+        self._default = default
+
+    def create(self, project, writer, deps, tools):
+        value = getattr(project, self.name, self._default) or self._default
+        if not value:
+            return
+        raise_task_error_if(
+            type(value) is not int,
+            project,
+            f"Illegal {self._lang} language standard: '{value}'. Expected integer."
+        )
+        raise_task_error_if(
+            value not in self._values,
+            project,
+            f"Illegal {self._lang} language standard: '{value}'. Expected one of: {', '.join([str(v) for v in self._values])}"
+        )
+
+        if value not in self._supported:
+            new_value = min(self._supported, key=lambda n: abs(n - value))
+            project.warning(f"{self._lang}{value} is not supported. Using {self._lang}{new_value} instead.")
+            value = new_value
+
+        writer.variable(self.name, self._flagfmt.format(value))
+
+
+class OptimizationVariable(Variable):
+    def __init__(self, default, values, name=None):
+        self.name = name
+        self._default = default
+        self._values = values
+        assert type(values) is dict, "Optimization values must be dict with compiler flag mapping"
+
+    def create(self, project, writer, deps, tools):
+        value = str(getattr(project, "optimize", self._default))
+        raise_task_error_if(
+            value not in self._values,
+            project,
+            f"Illegal value assigned to 'optimize' ({value}). Expected: 'none', 'debug', 'size', or 'release'."
+        )
+        writer.variable(self.name, self._values[value])
+
+
 class SharedLibraryVariable(Variable):
     def __init__(self, name=None, default=None):
         self.name = name
@@ -1153,7 +1208,8 @@ class Skip(Rule):
 
 @task_attributes.system
 class MakeDirectory(Rule):
-    command_linux = "mkdir -p $out"
+    command_darwin = "mkdir -p $out"
+    command_linux = command_darwin
     command_windows = "if not exist $out mkdir $out"
 
     def __init__(self, name):
@@ -1539,7 +1595,17 @@ class GNUToolchain(Toolchain):
     cxxwrap = EnvironmentVariable(default="")
     flatc = ToolEnvironmentVariable(default="flatc", envname="FLATC", abspath=True)
     protoc = ToolEnvironmentVariable(default="protoc", envname="PROTOC", abspath=True)
-
+    strip = ToolEnvironmentVariable(default="strip", envname="STRIP", abspath=True)
+
+    cstd = StdVariable("C", "-std=c{}", values=c_standards_list, default=c_standard_default)
+    cxxstd = StdVariable("C++", "-std=c++{}", values=cxx_standards_list, default=cxx_standard_default)
+    optflag = OptimizationVariable(default="release", values={
+        "none": "-O0",
+        "debug": "-Og",
+        "size": "-Os",
+        "release": "-O2",
+        None: "-O0",
+    })
     asflags = EnvironmentVariable(default="")
     cflags = EnvironmentVariable(default="")
     cxxflags = EnvironmentVariable(default="")
@@ -1570,7 +1636,7 @@ class GNUToolchain(Toolchain):
     mkdir_debug = MakeDirectory(name="$outdir_rel/.debug")
 
     compile_pch = GNUCompiler(
-        command="$cxxwrap $cxx -x c++-header $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$cxxwrap $cxx -x c++-header $cxxstd $optflag $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[GNUPCHVariables.pch_ext],
@@ -1579,7 +1645,7 @@ class GNUToolchain(Toolchain):
         variables={"desc": "[PCH] {in_base}{in_ext}"})
 
     compile_c = GNUCompiler(
-        command="$ccwrap $cc -x c $pch_flags $cflags $shared_flags $imported_cflags $extra_cflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$ccwrap $cc -x c $cstd $pch_flags $optflag $cflags $shared_flags $imported_cflags $extra_cflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[".c"],
@@ -1589,7 +1655,7 @@ class GNUToolchain(Toolchain):
         implicit=["$cc_path"])
 
     compile_cxx = GNUCompiler(
-        command="$cxxwrap $cxx -x c++ $pch_flags $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$cxxwrap $cxx -x c++ $cxxstd $pch_flags $optflag $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[".cc", ".cpp", ".cxx"],
@@ -1658,6 +1724,55 @@ class GNUToolchain(Toolchain):
         suffix=".a")
 
 
+class BSDArchiver(Rule):
+    def __init__(self, *args, **kwargs):
+        super(BSDArchiver, self).__init__(*args, aggregate=True, **kwargs)
+
+    def build(self, project, writer, infiles, implicit=None, order_only=None):
+        writer._objects = infiles
+        project._binaries, _ = self._out(project, project.binary)
+        file_list = FileListWriter("objects", project._binaries)
+        file_list.build(project, writer, infiles)
+        super().build(project, writer, infiles, implicit=writer.depimports, order_only=order_only)
+
+    def get_influence(self, task):
+        return "BSDArchiver" + super().get_influence(task)
+
+
+class DarwinGNUToolchain(GNUToolchain):
+    libtool = ToolEnvironmentVariable(default="libtool", envname="LIBTOOL", abspath=True)
+    dsymutil = ToolEnvironmentVariable(default="dsymutil", envname="DSYMUTIL", abspath=True)
+
+    linker = GNULinker(
+        command=" && ".join([
+            "$ld $ldflags $imported_ldflags $extra_ldflags $covflags $libpaths @$outdir_rel/objects.list -o $out $libraries",
+            "$dsymutil $out -o $outdir_rel/.debug/$binary.dSYM",
+            "$strip $out",
+        ]),
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/{binary}"],
+        variables={"desc": "[LINK] {binary}"},
+        implicit=["$ld_path", "$dsymutil_path", "$strip_path", "$outdir_rel/.debug"])
+
+    dynlinker = GNULinker(
+        command=" && ".join([
+            "$ld $ldflags -shared $imported_ldflags $extra_ldflags $covflags $libpaths @$outdir_rel/objects.list -o $out $libraries",
+            "$dsymutil $out -o $outdir_rel/.debug/$binary.dSYM",
+            "$strip $out",
+        ]),
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/lib{binary}.so"],
+        variables={"desc": "[LINK] {binary}"},
+        implicit=["$ld_path", "$dsymutil_path", "$strip_path", "$outdir_rel/.debug"])
+
+    archiver = BSDArchiver(
+        command="$libtool -static -o $out @$outdir_rel/objects.list && $ranlib $out",
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/lib{binary}.a"],
+        variables={"desc": "[AR] lib{binary}.a"},
+        implicit=["$libtool_path", "$ranlib_path"])
+
+
 class MinGWToolchain(GNUToolchain):
     linker = GNULinker(
         command=" && ".join([
@@ -1686,6 +1801,62 @@ class MSVCArchiver(Rule):
         return "MSVCArchiver" + super().get_influence(task)
 
 
+class MSVCCRT(Variable):
+    def __init__(self, default="/MD", flagsfn=None):
+        self.default = default
+        self.flagsfn = flagsfn
+
+    def _combine(self, project, crt1, crt2):
+        if crt1 is None:
+            return crt2
+        if crt2 is None:
+            return crt1
+        raise_task_error_if(crt1 != crt2, project, "Mismatching Windows CRT library types (/MT vs /MD)")
+        return crt1
+
+    def _select_flag(self, flags):
+        """ Look for /Mxx flag in the list of flags """
+        if flags is None:
+            return None
+        if "Static" in flags:
+            return "/MT"
+        if "StaticDebug" in flags:
+            return "/MTd"
+        if "Dynamic" in flags:
+            return "/MD"
+        if "DynamicDebug" in flags:
+            return "/MDd"
+        if "/MT" in flags:
+            return "/MT"
+        if "/MTd" in flags:
+            return "/MTd"
+        if "/MD" in flags:
+            return "/MD"
+        if "/MDd" in flags:
+            return "/MDd"
+        return None
+
+    def _select_dep_flags(self, project, dep):
+        crt = self._select_flag(dep.cxxinfo.asflags.items())
+        if hasattr(dep.cxxinfo, "crt"):
+            crt = self._combine(project, crt, self._select_flag([str(dep.cxxinfo.crt)]))
+        crt = self._combine(project, crt, self._select_flag(dep.cxxinfo.cflags.items()))
+        return self._combine(project, crt, self._select_flag(dep.cxxinfo.cxxflags.items()))
+
+    def create(self, project, writer, deps, tools):
+        crt = self._select_flag(getattr(project, "crt", None))
+        crt = self._combine(project, crt, self._select_flag(project._asflags()))
+        crt = self._combine(project, crt, self._select_flag(project._cflags()))
+        crt = self._combine(project, crt, self._select_flag(project._cxxflags()))
+        for _, artifact in deps.items():
+            crt = self._combine(project, crt, self._select_dep_flags(project, artifact))
+        writer.variable(self.name, crt or self.default)
+
+    @utils.cached.instance
+    def get_influence(self, task):
+        return "CRT"
+
+
 MSVCCompiler = GNUCompiler
 MSVCLinker = GNULinker
 MSVCDepImporter = GNUDepImporter
@@ -1695,9 +1866,10 @@ class MSVCToolchain(Toolchain):
     hh = Skip(infiles=[".h", ".hh", ".hpp", ".hxx"])
     bin = Skip(infiles=[".dll", ".exe"])
 
-    builddir = ProjectVariable(attrib="outdir")
     joltdir = ProjectVariable()
+    builddir = ProjectVariable(attrib="outdir")
     outdir = ProjectVariable()
+    outdir_rel = ProjectVariable()
     binary = ProjectVariable()
 
     cl = ToolEnvironmentVariable(default="cl", envname="cl_exe", abspath=True)
@@ -1706,13 +1878,25 @@ class MSVCToolchain(Toolchain):
     flatc = ToolEnvironmentVariable(default="flatc", envname="FLATC", abspath=True)
     protoc = ToolEnvironmentVariable(default="protoc", envname="PROTOC", abspath=True)
 
+    cstd = StdVariable("C", "/std:c{}", values=c_standards_list, supported=[11, 17], default=c_standard_default)
+    cxxstd = StdVariable("C++", "/std:c++{}", values=cxx_standards_list, supported=[14, 17, 20], default=cxx_standard_default)
+    optflag = OptimizationVariable(default="speed", values={
+        "none": "/Od",
+        "debug": "/Od /Zi",
+        "size": "/O1",
+        "release": "/O2 /DNDEBUG",
+        None: "/0d",
+    })
+    win32flags = Variable("/DWIN32 /D_WINDOWS /D_WIN32_WINNT=0x0601 /EHsc")
     asflags = EnvironmentVariable(default="")
-    cflags = EnvironmentVariable(default="/EHsc")
-    cxxflags = EnvironmentVariable(default="/EHsc")
+    cflags = EnvironmentVariable(default="")
+    cxxflags = EnvironmentVariable(default="")
     fbflags = EnvironmentVariable(default="")
     ldflags = EnvironmentVariable(default="")
     protoflags = EnvironmentVariable(default="")
 
+    crt = MSVCCRT()
+
     extra_asflags = ProjectVariable(attrib="asflags")
     extra_cflags = ProjectVariable(attrib="cflags")
     extra_cxxflags = ProjectVariable(attrib="cxxflags")
@@ -1727,26 +1911,26 @@ class MSVCToolchain(Toolchain):
     libraries = Libraries(suffix=".lib")
 
     compile_asm = MSVCCompiler(
-        command="$cl /nologo /showIncludes $asflags $extra_asflags $macros $incpaths /c /Tc$in /Fo$out",
+        command="$cl /nologo /showIncludes $crt $win32flags $asflags $extra_asflags $macros $incpaths /c /Tc$in /Fo$out",
         deps="msvc",
         infiles=[".asm", ".s", ".S"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[ASM] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
     compile_c = MSVCCompiler(
-        command="$cl /nologo /showIncludes $cxxflags $extra_cxxflags $macros $incpaths /c /Tc$in /Fo$out",
+        command="$cl /nologo /showIncludes $cstd $crt $win32flags $optflag $cflags $extra_cflags $macros $incpaths /c /Tc$in /Fo$out",
         deps="msvc",
         infiles=[".c"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[C] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
     compile_cxx = MSVCCompiler(
-        command="$cl /nologo /showIncludes $cxxflags $extra_cxxflags $macros $incpaths /c /Tp$in /Fo$out",
+        command="$cl /nologo /showIncludes $cxxstd $crt $win32flags $optflag $cxxflags $extra_cxxflags $macros $incpaths /c /Tp$in /Fo$out",
         deps="msvc",
         infiles=[".cc", ".cpp", ".cxx"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[CXX] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
@@ -1774,11 +1958,15 @@ class MSVCToolchain(Toolchain):
 
 _toolchains = {
     GNUToolchain: GNUToolchain(),
+    DarwinGNUToolchain: DarwinGNUToolchain(),
     MSVCToolchain: MSVCToolchain(),
 }
 
-if os.name == "nt":
+_system = platform.system()
+if _system == "Windows":
     toolchain = _toolchains[MSVCToolchain]
+elif _system == "Darwin":
+    toolchain = _toolchains[DarwinGNUToolchain]
 else:
     toolchain = _toolchains[GNUToolchain]
 
@@ -1818,9 +2006,23 @@ class CXXProject(Task):
     cflags = []
     """ A list of compiler flags used when compiling C files. """
 
+    cstd = None
+    """
+    C language standard to use (int). Default: 17
+
+    If the chosen standard is not supported, the nearest supported standard is selected.
+    """
+
     cxxflags = []
     """ A list of compiler flags used when compiling C++ files. """
 
+    cxxstd = None
+    """
+    C++ language standard to use (int). Default: 17
+
+    If the chosen standard is not supported, the nearest supported standard is selected.
+    """
+
     depimports = []
     """ List of implicit dependencies """
 
@@ -1839,6 +2041,18 @@ class CXXProject(Task):
     macros = []
     """ List of preprocessor macros to set """
 
+    optimize = "release"
+    """
+    Compiler optimization level.
+
+    Supported values are:
+
+        - "none" / None
+        - "debug"
+        - "size"
+        - "release"
+    """
+
     sources = []
     """ A list of sources to compile.
 
@@ -2266,7 +2480,10 @@ if __name__ == "__main__":
         except JoltCommandError as e:
             self.buildlog = "\n".join(e.stdout)
             report = self._report_errors(self.buildlog)
-            raise CompileError(self._first_reported_error(report))
+            error = self._first_reported_error(report)
+            if error:
+                raise CompileError(error)
+            raise e
 
         if bool(getattr(self, "coverage", False)):
             self.covdatadir = tools.builddir("coverage-data")
@@ -2280,8 +2497,8 @@ if __name__ == "__main__":
                         pass
             if self.selfsustained:
                 for _, artifact in deps.items():
-                    if str(artifact.paths.coverage_data):
-                        tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                    if artifact.paths.coverage_data:
+                        tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
     def publish(self, artifact, tools):
         if bool(getattr(self, "coverage", False)):
@@ -2351,13 +2568,15 @@ if __name__ == "__main__":
             # LLVM linker errors
             report.add_regex_errors(
                 "Linker Error",
-                r"^(?P<location>ld(\.lld)?): (error|warning): (?P<message>.*)",
+                r"^(?P<location>(.*?)ld(\.lld)?): (error|warning): (?P<message>.*)",
                 logbuffer)
 
             return report
 
     def _first_reported_error(self, report):
         """ Returns the first reported error or None if no errors were reported. """
+        if report is None:
+            return None
         for error in report.errors:
             return error
 

jolt/plugins/paths.py

@@ -16,6 +16,12 @@ class PathVariable(ArtifactStringAttribute):
     def unapply(self, task, artifact):
         pass
 
+    def __bool__(self):
+        return bool(str(self))
+
+    def __eq__(self, value: str) -> bool:
+        return str(self) == str(value)
+
     def __str__(self):
         if self._value is None:
             return ""
@@ -30,6 +36,10 @@ class PathVariableSet(ArtifactAttributeSet):
     def create(self, name):
         return PathVariable(self._artifact, name)
 
+    def __getattr__(self, name):
+        attributes = self._get_attributes()
+        return attributes.get(name, None)
+
 
 @ArtifactAttributeSetProvider.Register
 class PathVariableSetProvider(ArtifactAttributeSetProvider):
@@ -41,7 +51,7 @@ class PathVariableSetProvider(ArtifactAttributeSetProvider):
             return
 
         for key, value in content["paths"].items():
-            getattr(artifact.paths, key).set_value(value, expand=False)
+            setattr(artifact.paths, key, value)
 
     def format(self, artifact, content):
         if "paths" not in content: