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

jolt/tasks.py

@@ -10,8 +10,10 @@ import platform
 from threading import RLock
 import subprocess
 from os import environ
+from os import sys as os_sys
 import sys
 import unittest as ut
+from urllib.parse import urlparse
 import uuid
 import re
 import traceback
@@ -20,12 +22,13 @@ from jolt import filesystem as fs
 from jolt import log
 from jolt import utils
 from jolt.cache import ArtifactAttributeSetProvider
-from jolt.error import raise_error, raise_error_if, raise_task_error, raise_task_error_if
+from jolt.error import raise_error_if, raise_task_error, raise_task_error_if
 from jolt.error import raise_unreported_task_error_if
-from jolt.error import JoltError, JoltCommandError
+from jolt.error import JoltError, JoltCommandError, LoggedJoltError
 from jolt.expires import Immediately
 from jolt.influence import FileInfluence, TaintInfluenceProvider
 from jolt.influence import TaskClassSourceInfluence
+from jolt.influence import CallbackInfluence
 from jolt.influence import attribute as attribute_influence
 from jolt.influence import environ as environ_influence
 from jolt.influence import source as source_influence
@@ -134,7 +137,7 @@ class Parameter(object):
         self.name = name
 
     def __init__(self, default=None, values=None, required=True,
-                 const=False, influence=True, help=None):
+                 const=False, influence=True, help=None, valuesfn=None):
         """
         Creates a new parameter.
 
@@ -142,6 +145,10 @@ class Parameter(object):
             default (str, optional): An optional default value.
             values (list, optional): A list of accepted values. An
                 assertion is raised if an unlisted value is assigned to the parameter.
+            valuesfn (func, optional); A function that validates the assigned value.
+                If both values and valuesfn are specified, the values list is validated
+                first. The function is passed the assigned value and should return.
+                boolean value. If the function returns False, a ParameterValueError is raised.
             required (boolean, optional): If required, the parameter must be assigned
                 a value before the task can be executed. The default is ``True``.
             const (boolean, optional): If const is True, the parameter is immutable
@@ -163,6 +170,7 @@ class Parameter(object):
         self._default = default
         self._value = default
         self._accepted_values = values
+        self._accepted_values_fn = valuesfn
         self._required = required
         self._const = const
         self._influence = influence
@@ -189,7 +197,7 @@ class Parameter(object):
         def highlight(value):
             return colors.bright(value) if self._is_default(value) else colors.dim(value)
 
-        return "[{}]".format(", ".join([highlight(value) for value in accepted])) if accepted else ""
+        return "[{}]".format(", ".join([highlight(str(value)) for value in accepted])) if accepted else ""
 
     def __str__(self):
         """ Returns the parameter value as a string """
@@ -198,6 +206,8 @@ class Parameter(object):
     def _validate(self, value, what=None):
         if self._accepted_values is not None and value not in self._accepted_values:
             raise ParameterValueError(self, value, what=what)
+        if self._accepted_values_fn is not None and not self._accepted_values_fn(value):
+            raise ParameterValueError(self, value, what=what)
 
     def get_default(self):
         """ Get the default value of the parameter.
@@ -435,7 +445,7 @@ class IntParameter(Parameter):
     """
 
     def __init__(self, default=None, min=None, max=None, values=None, required=True, const=False,
-                 influence=True, help=None):
+                 influence=True, help=None, valuesfn=None):
         """
         Creates a new parameter.
 
@@ -483,7 +493,8 @@ class IntParameter(Parameter):
             required=required,
             const=const,
             influence=influence,
-            help=help)
+            help=help,
+            valuesfn=valuesfn)
 
     def _validate(self, value, what=None):
         if self._min is not None and value < self._min:
@@ -687,6 +698,10 @@ class ListParameter(Parameter):
             for item in value:
                 if item not in self._accepted_values:
                     raise ParameterValueError(self, item, what=what)
+        if self._accepted_values_fn is not None:
+            for item in value:
+                if not self._accepted_values_fn(item):
+                    raise ParameterValueError(self, item, what=what)
 
     def get_value(self):
         return "+".join(self._value)
@@ -768,6 +783,7 @@ class TaskRegistry(object):
         self.env = env
         self.tasks = {}
         self.instances = {}
+        self._workspace_resources = []
 
     @staticmethod
     def get(*args, **kwargs):
@@ -776,6 +792,21 @@ class TaskRegistry(object):
         return TaskRegistry._instance
 
     def add_task_class(self, cls):
+        """
+        Add a task class to the registry.
+
+        The class is decorated to require workspace resources.
+        """
+
+        registry = self
+
+        def _workspace_resources(self):
+            return registry._workspace_resources
+
+        if not issubclass(cls, WorkspaceResource):
+            cls = attributes.requires("_workspace_resources")(cls)
+            cls._workspace_resources = property(_workspace_resources)
+
         self.tasks[cls.name] = cls
 
     def add_task(self, task, extra_params):
@@ -784,6 +815,13 @@ class TaskRegistry(object):
         full_name = utils.format_task_name(name, params)
         self.instances[full_name] = task
 
+    def require_workspace_resource(self, taskname):
+        name, _ = utils.parse_task_name(taskname)
+        task = self.get_task_class(name)
+        raise_task_error_if(task is None, name, "Resource not found")
+        raise_task_error_if(not issubclass(task, WorkspaceResource), name, "Not a workspace resource")
+        self._workspace_resources.append(taskname)
+
     def get_task_class(self, name):
         return self.tasks.get(name)
 
@@ -803,12 +841,17 @@ class TaskRegistry(object):
         if cls:
             task = cls(parameters=params, manifest=manifest, buildenv=buildenv)
             task = self.instances.get(task.qualified_name, task)
-            self.instances[task.qualified_name] = task
-            self.instances[full_name] = task
+            if not isinstance(task, Resource) or isinstance(task, WorkspaceResource):
+                self.instances[task.qualified_name] = task
+                self.instances[full_name] = task
             return task
 
         raise_task_error_if(not task, full_name, "No such task")
 
+    def has_task(self, name):
+        name, params = utils.parse_task_name(name)
+        return self.tasks.get(name) is not None
+
     def set_default_parameters(self, task):
         name, params = utils.parse_task_name(task)
 
@@ -880,6 +923,14 @@ class TaskGenerator(object):
 
 
 class attributes:
+    @staticmethod
+    def arch(cls):
+        """ Return the architecture name (x86_64, arm64, etc.). """
+
+        cls._arch = Export(lambda t: platform.machine().lower().replace("amd64", "x86_64"))
+        cls.arch = property(lambda t: t._arch.value)
+        return cls
+
     @staticmethod
     def artifact(name, session=False):
         """Decorator adding an additional artifact to a task.
@@ -916,7 +967,7 @@ class attributes:
             @functools.wraps(cls._artifacts)
             def _artifacts(self, cache, node):
                 artifacts = _old_artifacts(self, cache, node)
-                artifacts += [cache.get_artifact(node, name, session=session)]
+                artifacts += [cache.get_artifact(node, name, session=session or isinstance(cls, Resource))]
                 return artifacts
 
             cls._artifacts = _artifacts
@@ -924,6 +975,145 @@ class attributes:
 
         return decorate
 
+    @staticmethod
+    def artifact_upload(uri, name="main", condition=None):
+        """
+        Decorator to add uploading of an artifact to a server.
+
+        Upon successful completion of the task, the resulting
+        artifact uploaded to the specified URI. The URI should
+        be in the format `protocol://user:password@host/path`.
+
+        The following protocols are supported:
+
+          - `http://`
+          - `https://`
+          - `file://`
+
+        Local path are also supported in which case the artifact
+        is copied to the specified location.
+
+        If the path ends with a slash, the artifact is treated as
+        a directory and copied into the root of the directory.
+
+        If the path ends with a supported archive extension, the
+        artifact is archived and optionally compressed before being
+        copied. See :func:`jolt.Tools.archive` for supported archive
+        and compression formats.
+
+        Usernames and passwords are optional. If omitted, the
+        artifact is uploaded anonymously. Environment variables
+        can be used to store sensitive information, such as
+        passwords. Specify the environment variable name in the
+        URI as `protocol://{environ[USER]}:{environ[PASS]}@host/path`.
+
+        The upload can be conditioned on the return value of a
+        function. The function is passed the task instance as
+        an argument and should return a boolean value. If the
+        function returns ``False``, the upload is skipped. The value
+        of the condition influences the hash of the task.
+
+        Args:
+            condition (str): Condition function to evaluate before
+                uploading the artifact. The function is passed the
+                task instance as an argument and should return a
+                boolean value. By default, the artifact is always
+                uploaded.
+            name (str): Name of the artifact to upload.
+            uri (str): Destination URI for the artifact.
+
+        Example:
+
+            .. literalinclude:: ../examples/artifacts/upload.jolt
+                :language: python
+                :caption: examples/artifacts/upload.jolt
+        """
+
+        def decorate(cls):
+            if name == "main":
+                old_publish = cls.publish
+            else:
+                old_publish = getattr(cls, "publish_" + name, None)
+
+            raise_error_if(old_publish is None, f"Cannot upload artifact '{name}' from task '{cls.name or cls.__name__.lower()}', it does not exist")
+
+            def upload_file(self, tools, cwd, src, dst):
+                with tools.cwd(cwd):
+                    tools.upload(src, dst + src)
+
+            def copy_file(self, tools, cwd, src, dst):
+                with tools.cwd(cwd):
+                    tools.copy(src, dst + src)
+
+            def list_files(self, artifact, tools):
+                with tools.cwd(artifact.path):
+                    for path in tools.glob("**"):
+                        # Skip directories
+                        if tools.isdir(path):
+                            continue
+                        yield artifact.path, path
+
+            def archive_files(self, artifact, tools, filename):
+                out = tools.builddir(artifact.identity)
+                with tools.cwd(out):
+                    tools.archive(artifact.path, filename)
+                    yield out, filename
+
+            @functools.wraps(cls.publish)
+            def publish(self, artifact, tools):
+                old_publish(self, artifact, tools)
+
+                if condition and not bool(condition(self)):
+                    return
+
+                # Expand keywords
+                uri_exp = tools.expand(uri)
+
+                # Parse URI to determine protocol
+                uri_parsed = urlparse(uri_exp)
+                if uri_parsed.scheme in ["http", "https"]:
+                    action = upload_file
+                elif uri_parsed.scheme in ["", "file"]:
+                    uri_exp = uri_parsed.path
+                    action = copy_file
+                else:
+                    raise_task_error(self, f"Unsupported protocol '{uri_parsed.scheme}' in URI '{uri_exp}'")
+
+                if uri_exp.endswith("/"):
+                    generator = list_files
+                else:
+                    generator = functools.partial(archive_files, filename=fs.path.basename(uri_parsed.path))
+                    uri_exp = fs.path.dirname(uri_exp) + "/"
+
+                if action is copy_file:
+                    uri_exp = tools.expand_path(uri_exp) + "/"
+
+                for cwd, file in generator(self, artifact, tools):
+                    action(self, tools, cwd, file, uri_exp)
+
+            if name == "main":
+                setattr(cls, "publish", publish)
+            else:
+                setattr(cls, "publish_" + name, publish)
+
+            if condition:
+                old_init = cls.__init__
+
+                @functools.wraps(cls.__init__)
+                def new_init(self, *args, **kwargs):
+                    old_init(self, *args, **kwargs)
+
+                    def make_bool(fn, *args, **kwargs):
+                        return bool(fn(*args, **kwargs))
+
+                    self.influence.append(CallbackInfluence(f"Upload {name}", make_bool, condition, self))
+
+                cls.__init__ = new_init
+
+            return cls
+
+        return decorate
+
     @staticmethod
     def attribute(alias, target, influence=True, default=False):
         """
@@ -1026,6 +1216,65 @@ class attributes:
             return utils.concat_attributes("_publish_files", attrib)(cls)
         return decorate
 
+    @staticmethod
+    def common_metadata(aclocal=True, cmake=True, cxxinfo=True, path=True, pkgconfig=True):
+        """
+        Decorator adding common metadata to published artifacts.
+
+        The decorator adds common environment variables and C/C++ build information
+        to the published artifact:
+
+            - Adds `bin/` to `PATH` environment variable if it exists.
+            - Adds `lib/` and `lib64/` to C++ library paths if they exist.
+            - Adds `include/` to C++ include paths if it exists.
+            - Adds `lib/pkgconfig/`, `lib64/pkgconfig/` and `share/pkgconfig/` to
+              `PKG_CONFIG_PATH` environment variable if `.pc` files are found.
+              The `prefix` variable in `.pc` files is relocated to allow
+              installation in arbitrary locations.
+            - Adds `lib/cmake/`, `lib64/cmake/` and `share/cmake/` to
+              `CMAKE_PREFIX_PATH` environment variable if they exist.
+            - Adds `share/aclocal/` to `ACLOCAL_PATH` environment variable if it exists.
+
+        """
+        def decorate(cls):
+            _old_publish = cls.publish
+
+            @functools.wraps(cls.publish)
+            def publish(self, artifact, tools):
+                _old_publish(self, artifact, tools)
+
+                with tools.cwd(artifact.path):
+                    if path and tools.exists("bin"):
+                        artifact.environ.PATH.append("bin")
+
+                    pcdirs = set()
+
+                    for pcpath in tools.glob("lib/pkgconfig/*.pc") + tools.glob("lib64/pkgconfig/*.pc") + tools.glob("share/pkgconfig/*.pc"):
+                        pcdirs.add(fs.path.dirname(pcpath))
+                        tools.replace_in_file(pcpath, artifact.strings.install_prefix, "${{pcfiledir}}/../..")
+                    for pcpath in tools.glob("lib/*/pkgconfig/*.pc") + tools.glob("lib64/*/pkgconfig/*.pc"):
+                        pcdirs.add(fs.path.dirname(pcpath))
+                        tools.replace_in_file(pcpath, artifact.strings.install_prefix, "${{pcfiledir}}/../../..")
+
+                    for pcdir in pcdirs:
+                        artifact.environ.PKG_CONFIG_PATH.append(pcdir)
+
+                    if cmake and tools.exists("lib/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+                    if cmake and tools.exists("lib64/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+                    if cmake and tools.exists("share/cmake"):
+                        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+
+                    if aclocal and tools.exists("share/aclocal"):
+                        artifact.environ.ACLOCAL_PATH.append("share/aclocal")
+
+            cls.publish = publish
+
+            return cls
+
+        return decorate
+
     @staticmethod
     def requires(attrib):
         """
@@ -1112,7 +1361,7 @@ class attributes:
         return _decorate
 
     @staticmethod
-    def platform(cls, attrib):
+    def platform(attrib):
         """
         Decorates a task with an alternative ``platform`` attribute.
 
@@ -1136,6 +1385,40 @@ class attributes:
         cls.system = property(lambda t: t._system.value)
         return cls
 
+    @staticmethod
+    def timeout(seconds):
+        """
+        Decorator setting a timeout for a task.
+
+        The timeout applies to the task's run method. A JoltTimeoutError
+        is raised if the task does not complete within the specified time.
+
+        Args:
+            seconds (int): Timeout in seconds.
+
+        Example:
+
+        .. code-block:: python
+
+            @attributes.timeout(5)
+            class Example(Task):
+                def run(self, deps, tools):
+                    time.sleep(10)
+
+        """
+        def decorate(cls):
+            _old_run = cls.run
+
+            @functools.wraps(cls.run)
+            def run(self, deps, tools):
+                with tools.timeout(seconds):
+                    _old_run(self, deps, tools)
+
+            cls.run = run
+            return cls
+
+        return decorate
+
 
 class TaskBase(object):
     """ Task base class. """
@@ -1219,6 +1502,9 @@ class TaskBase(object):
     joltproject = None
     """ Name of project this task belongs to. """
 
+    local = False
+    """ A local task is only executed on the local node where the build is initiated. """
+
     name = None
     """ Name of the task. Derived from class name if not set. """
 
@@ -1293,6 +1579,14 @@ class TaskBase(object):
     execution requests, the instance ID won't be.
     """
 
+    @property
+    def instance(self):
+        return str(self._instance.value)
+
+    @instance.setter
+    def instance(self, value):
+        self._instance.assign(value)
+
     def __init__(self, parameters=None, manifest=None, buildenv=None, **kwargs):
         self._identity = None
         self._report = _JoltTask()
@@ -1334,7 +1628,7 @@ class TaskBase(object):
     def _apply_protobuf(self, buildenv):
         if buildenv is None:
             return
-        task = buildenv.tasks.get(self.short_qualified_name)
+        task = buildenv.tasks.get(self.exported_name)
         if not task:
             return
         if task.identity:
@@ -1410,6 +1704,9 @@ class TaskBase(object):
                 "Required parameter '{0}' has not been set", key)
 
     def _verify_influence(self, deps, artifact, tools, sources=None):
+        if "configurationrepository" in self.name:
+            breakpoint()
+
         # Verify that any transformed sources are influencing
         sources = set(map(tools.expand_path, sources or []))
 
@@ -1426,29 +1723,29 @@ class TaskBase(object):
                 return not fs.is_relative_to(fname, rootpath)
             return _filter
 
+        # Ignore any files in build directories
+        sources = filter(_subpath_filter(tools.expand_path(tools.buildroot)), sources)
+
         for _, dep in deps.items():
             deptask = dep.task
             if isinstance(deptask, FileInfluence):
                 # Resource dependencies may cover the influence implicitly
                 deppath = self.tools.expand_path(str(deptask.path))
-                sources = set(filter(lambda d: not deptask.is_influenced_by(self, d), sources))
+                sources = filter(lambda d, dt=deptask: not dt.is_influenced_by(self, d), sources)
             else:
                 # Ignore any files in artifacts
                 deppath = self.tools.expand_path(dep.path)
-                sources = set(filter(_subpath_filter(deppath), sources))
-
-        # Ignore any files in build directories
-        sources = filter(_subpath_filter(tools.expand_path(tools.buildroot)), sources)
-        sources = set(sources)
+                sources = filter(_subpath_filter(deppath), sources)
 
         for ip in self.influence:
             if not isinstance(ip, FileInfluence):
                 continue
-            ok = [source for source in sources if ip.is_influenced_by(self, source)]
-            sources.difference_update(ok)
+            sources = {source for source in sources if not ip.is_influenced_by(self, source)}
+
         for source in sources:
             log.warning("Missing influence: {} ({})", source, self.name)
-        raise_task_error_if(sources, self, "Task is missing source influence")
+
+        raise_task_error_if(set(sources), self, "Task is missing source influence")
 
     def _get_export_objects(self):
         return self._exports
@@ -1489,6 +1786,16 @@ class TaskBase(object):
             self.name,
             self._get_explicitly_set_parameters())
 
+    @property
+    def exported_name(self):
+        if hasattr(self, "_exported_name"):
+            return self._exported_name
+        return self.short_qualified_name
+
+    @exported_name.setter
+    def exported_name(self, name):
+        self._exported_name = name
+
     def expand(self, string_or_list, *args, **kwargs):
         """ Expands keyword arguments/macros in a format string.
 
@@ -2353,7 +2660,7 @@ class Runner(Task):
         for task, artifact in deps.items():
             if not artifact.task.is_cacheable():
                 continue
-            if artifact.strings.executable.get_value() is None:
+            if artifact.strings.executable is None:
                 self.verbose("No executable found in task artifact for '{}'", task)
                 continue
             with tools.cwd(artifact.path):
@@ -2376,6 +2683,10 @@ class ErrorProxy(object):
     def type(self):
         return self._error.type
 
+    @type.setter
+    def type(self, value):
+        self._error.type = value
+
     @property
     def details(self):
         return self._error.details
@@ -2391,11 +2702,21 @@ class ErrorProxy(object):
 
 class ReportProxy(object):
     def __init__(self, task, report):
+        from jolt import config
         self._task = task
         self._report = report
+        self._max_errors = config.getint("jolt", "task_max_errors", 100)
 
     def add_error(self, type, location, message, details=""):
         """ Add an error to the build report. """
+        if len(self.errors) >= self._max_errors:
+            if not hasattr(self._report, "truncated"):
+                error = self._report.create_error()
+                error.type = "Error"
+                error.message = "Too many errors, list truncated"
+                self._report.truncated = True
+            return None
+
         error = self._report.create_error()
         error.type = type
         error.location = location
@@ -2416,11 +2737,8 @@ class ReportProxy(object):
         """
         for match in re.finditer(regex, logbuf, re.MULTILINE):
             error = match.groupdict()
-            self.add_error(
-                type,
-                error.get("location", ""),
-                error.get("message", ""),
-                error.get("details", ""))
+            if not self.add_error(type, error.get("location", ""), error.get("message", ""), error.get("details", "")):
+                break
 
     def add_regex_errors_with_file(self, type, regex, logbuf, reldir, filterfn=lambda n: True):
         """
@@ -2441,25 +2759,29 @@ class ReportProxy(object):
             if not filterfn(error):
                 continue
             if error["location"] not in errors_by_location:
-                errors_by_location[error["location"]] = (error, [error["message"]])
+                errors_by_location[error["location"]] = (error, [error["message"]], error.get("details", ""))
             else:
                 errors_by_location[error["location"]][1].append(error["message"])
 
-        for error, msgs in errors_by_location.values():
+        for error, msgs, details in errors_by_location.values():
             message = "\n".join(utils.unique_list(msgs))
-            with self._task.tools.cwd(reldir):
-                try:
-                    details = self._task.tools.read_file(error["file"])
-                    details = details.splitlines()
-                    details = str(error["line"]) + ": " + details[int(error["line"]) - 1]
-                except Exception:
-                    details = ""
+            if not details:
+                with self._task.tools.cwd(self._task.tools.wsroot):
+                    try:
+                        details = self._task.tools.read_file(error["file"])
+                        details = details.splitlines()
+                        details = str(error["line"]) + ": " + details[int(error["line"]) - 1]
+                    except Exception:
+                        details = ""
 
             location = error.get("location", "")
             if location:
-                location = self._task.tools.expand_relpath(location, self._task.joltdir)
+                with self._task.tools.cwd(self._task.tools.wsroot):
+                    location = self._task.tools.expand_path(location)
+                location = self._task.tools.expand_relpath(location, self._task.tools.wsroot)
 
-            self.add_error(type, location, message, details)
+            if not self.add_error(type, location, message, details):
+                break
 
     def add_exception(self, exc, errtype=None, location=None):
         """
@@ -2498,10 +2820,26 @@ class ReportProxy(object):
     def errors(self):
         return [ErrorProxy(error) for error in self._report.errors]
 
+    @errors.setter
+    def errors(self, errlist):
+        assert all(isinstance(err, ErrorProxy) for err in errlist), "Invalid error list"
+        self._report.clear_errors()
+        for err in errlist:
+            self.add_error(err.type, err.location, err.message, err.details)
+
     @property
     def manifest(self):
         return self._report
 
+    def raise_for_status(self, log_details=False, log_error=False):
+        for error in self.errors:
+            if log_error:
+                log.error("{}: {}", error.type, error.message, context=self._task.identity[:7])
+            if log_details:
+                for line in error.details.splitlines():
+                    log.transfer(line, context=self._task.identity[:7])
+            raise LoggedJoltError(JoltError(f"{error.type}: {error.message}"))
+
 
 class Resource(Task):
     """
@@ -2515,14 +2853,18 @@ class Resource(Task):
 
     """
 
-    cacheable = False
-
     abstract = True
     """ An abstract resource class indended to be subclassed. """
 
+    release_on_error = False
+    """ Call release if an exception occurs during acquire. """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    def _artifacts(self, cache, node):
+        return [cache.get_artifact(node, "main", session=True)]
+
     def is_runnable(self):
         return False
 
@@ -2586,13 +2928,21 @@ class WorkspaceResource(Resource):
         raise_task_error_if(len(self.requires) > 0, self,
                             "Workspace resource is not allowed to have requirements")
 
-    def acquire(self, **kwargs):
+    def acquire(self, *args, **kwargs):
         return self.acquire_ws()
 
-    def release(self, **kwargs):
+    def release(self, *args, **kwargs):
         return self.release_ws()
 
-    def acquire_ws(self):
+    def prepare_ws_for(self, task):
+        """ Called to prepare the workspace for a task.
+
+        An implementor overrides this method in a subclass. The method
+        is called before the task influence is calculated and the workspace
+        resource is acquired.
+        """
+
+    def acquire_ws(self, force=False):
         """ Called to acquire the resource.
 
         An implementor overrides this method in a subclass. The acquired
@@ -2696,6 +3046,7 @@ class Download(Task):
     Once downloaded, archives are extracted and all of their files are published.
     If the file is not an archive it is published as is. Recognized archive extensions are:
 
+        - .7z
         - .tar
         - .tar.bz2
         - .tar.gz
@@ -2758,7 +3109,7 @@ class Download(Task):
         return fs.posixpath.basename(url.path) or "file"
 
     def run(self, deps, tools):
-        supported_formats = [".tar", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".zip"]
+        supported_formats = [".7z", ".tar", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".zip"]
 
         raise_task_error_if(not self.url, self, "No URL(s) specified")
 
@@ -2855,7 +3206,8 @@ class Script(Task):
         doc = self.__doc__.split("---", 1)
         script = doc[1] if len(doc) > 1 else doc[0]
         script = script.splitlines()
-        script = [line[4:] for line in script]
+        if os_sys.version_info < (3, 13):
+            script = [line[4:] for line in script]
         script = "\n".join(script)
         script = script.lstrip()
         if not script.startswith("#!"):
@@ -2982,7 +3334,7 @@ class Test(Task):
     Abstract test tasks can't be executed and won't be listed.
     """
 
-    pattern = Parameter(required=False, help="Test-case filter wildcard.")
+    filter = Parameter(required=False, help="Test-case filter wildcard.")
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -3011,24 +3363,21 @@ class Test(Task):
         """
         raise_error_if(type(args) is not list, "Test.parameterized() expects a list as argument")
 
-        class partialmethod(functools.partialmethod):
-            def __init__(self, index, func, *args):
-                super().__init__(func, *args)
-                self.__index = index
-
-            def __get__(self, obj, cls=None):
-                retval = super().__get__(obj, cls)
-                retval.__name__ = f"{self.func.__name__}[{self.__index}]"
-                retval.__doc__ = self.func.__doc__
-                return retval
+        def make_method(index, func, *args):
+            def testmethod(self):
+                return func(self, *args)
+            testmethod.__name__ = f"{func.__name__}[{index}]"
+            testmethod.__doc__ = func.__doc__
+            return testmethod
 
         def decorate(method):
             frame = sys._getframe().f_back.f_locals
             for index, arg in enumerate(args):
-                testmethod = partialmethod(index, method, *utils.as_list(arg))
+                testmethod = make_method(index, method, *utils.as_list(arg))
                 name = f"{method.__name__}[{index}]"
                 frame[name] = testmethod
             return None
+
         return decorate
 
     def setup(self, deps, tools):
@@ -3137,7 +3486,7 @@ class Test(Task):
     def run(self, deps, tools):
         testsuite = ut.TestSuite()
         for test in self._get_test_names():
-            if self.pattern.is_unset() or fnmatch.fnmatch(test, str(self.pattern)):
+            if self.filter.is_unset() or fnmatch.fnmatch(test, str(self.filter)):
                 testfunc = getattr(self, test)
                 if not testfunc:
                     continue
@@ -3158,7 +3507,7 @@ class Test(Task):
 
 
 @ArtifactAttributeSetProvider.Register
-class ResourceAttributeSetProvider(ArtifactAttributeSetProvider):
+class WorkspaceResourceAttributeSetProvider(ArtifactAttributeSetProvider):
     def create(self, artifact):
         pass
 
@@ -3170,63 +3519,30 @@ class ResourceAttributeSetProvider(ArtifactAttributeSetProvider):
 
     def apply(self, task, artifact):
         resource = artifact.task
-        if isinstance(resource, Resource):
-            from inspect import signature
-
-            if not hasattr(resource, "_run_env"):
-                raise_error("Internal scheduling error, resource has not been prepared: {}", task.short_qualified_name)
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
 
-            deps = resource._run_env
-            deps.__enter__()
-            sig = signature(resource.acquire)
-            try:
-                ba = sig.bind_partial(artifact=artifact, deps=deps, tools=resource.tools, owner=task)
-                acquire = resource.acquire
-            except Exception:
-                ba = sig.bind_partial(artifact, deps, resource.tools)
-                acquire = utils.deprecated(resource.acquire)
+        resource.deps = node.cache.get_context(node)
+        resource.deps.__enter__()
 
-            try:
-                if not isinstance(resource, WorkspaceResource):
-                    ts = utils.duration()
-                    log.info(colors.blue("Resource acquisition started ({})"),
-                             resource.short_qualified_name)
-                acquire(*ba.args, **ba.kwargs)
-                if not isinstance(resource, WorkspaceResource):
-                    log.info(colors.green("Resource acquisition finished after {} ({})"),
-                             ts, resource.short_qualified_name)
-            except Exception as e:
-                if not isinstance(resource, WorkspaceResource):
-                    log.error("Resource acquisition failed after {} ({})",
-                              ts, resource.short_qualified_name)
-                raise e
+        try:
+            resource.acquire(artifact=artifact, deps=resource.deps, tools=resource.tools, owner=task)
+        except (KeyboardInterrupt, Exception) as e:
+            if resource.release_on_error:
+                with utils.ignore_exception():
+                    self.unapply(task, artifact)
+            raise e
 
     def unapply(self, task, artifact):
         resource = artifact.task
-        if isinstance(resource, Resource):
-            from inspect import signature
+        node = artifact.get_node()
+        if not node.is_workspace_resource():
+            return
 
-            deps = resource._run_env
-            sig = signature(resource.release)
-            try:
-                ba = sig.bind_partial(artifact=artifact, deps=deps, tools=resource.tools, owner=task)
-                release = resource.release
-            except Exception:
-                ba = sig.bind_partial(artifact, deps, resource.tools)
-                release = utils.deprecated(resource.release)
+        try:
+            resource.release(artifact=artifact, deps=resource.deps, tools=resource.tools, owner=task)
+        except Exception as e:
+            raise e
 
-            try:
-                if not isinstance(resource, WorkspaceResource):
-                    ts = utils.duration()
-                    log.info(colors.blue("Resource release started ({})"),
-                             resource.short_qualified_name)
-                release(*ba.args, **ba.kwargs)
-                if not isinstance(resource, WorkspaceResource):
-                    log.info(colors.green("Resource release finished after {} ({})"),
-                             ts, resource.short_qualified_name)
-            except Exception as e:
-                if not isinstance(resource, WorkspaceResource):
-                    log.error("Resource release failed after {} ({})",
-                              ts, resource.short_qualified_name)
-                raise e
-            deps.__exit__(None, None, None)
+        resource.deps.__exit__(None, None, None)