jolt 0.9.419__py3-none-any.whl → 0.9.430__py3-none-any.whl

jolt/plugins/python.py

@@ -1,9 +1,12 @@
 import sys
 
+from jolt import Task
+from jolt import attributes
 from jolt import filesystem as fs
 from jolt.cache import ArtifactStringAttribute
 from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
+from jolt.error import raise_task_error_if
 
 
 class PythonVariable(ArtifactStringAttribute):
@@ -98,3 +101,137 @@ class PythonProvider(ArtifactAttributeSetProvider):
 
     def unapply(self, task, artifact):
         artifact.python.unapply(task, artifact)
+
+
+@attributes.system
+@attributes.requires("requires_python")
+class PythonEnv(Task):
+    """
+    Base class for Python virtual environment tasks.
+
+    Builds a Python virtual environment and installs specified packages.
+
+    The venv module from the Python standard library must be available in the
+    Python installation used to run the task.
+    """
+
+    abstract = True
+    """ This is an abstract base class that should be inherited by concrete tasks. """
+
+    executable = "python3"
+    """ Python executable to use for creating the virtual environment. """
+
+    requirements = []
+    """
+    List of Python packages to install in the virtual environment.
+
+    Each entry should be a string suitable for pip, e.g., "package==version".
+    """
+
+    def _verify_influence(self, deps, artifact, tools, sources=None):
+        # No influence to verify
+        return
+
+    def relocate_scripts(self, artifact, tools, frompath, topath):
+        bindir = "Scripts" if self.system == "windows" else "bin"
+
+        with tools.cwd(artifact.path, bindir):
+            for script in tools.glob("*"):
+                if script.startswith("python"):
+                    continue
+                tools.replace_in_file(script, frompath, topath)
+
+        with tools.cwd(artifact.path):
+            if not tools.exists("local/bin"):
+                return
+            with tools.cwd("local", "bin"):
+                for script in tools.glob("*"):
+                    tools.replace_in_file(script, frompath, topath)
+
+    def publish(self, artifact, tools):
+        # Create a parallel installation by copying a Python installation
+
+        # First locate the Python executable to copy
+        py_exe = tools.which(self.executable)
+        raise_task_error_if(
+            py_exe is None, self,
+            f"Python executable '{self.executable}' not found in PATH.",
+        )
+
+        # Follow symlinks to get the real executable
+        py_exe = fs.path.realpath(py_exe)
+
+        # Determine the Python home directory
+        py_home = fs.path.dirname(fs.path.dirname(py_exe))
+
+        # Determine the Python version
+        self.version_major = tools.run(
+            [py_exe, "-c", "import sys; print(\"{{}}.{{}}\".format(sys.version_info[0], sys.version_info[1]))"],
+            shell=False,
+            output_on_error=True).strip()
+
+        self.info("Python executable: {0}", py_exe)
+        self.info("Python home: {0}", py_home)
+        self.info("Python version: {0}", self.version_major)
+
+        # Copy the Python installation to the artifact path
+        with tools.cwd(py_home):
+            artifact.collect(py_exe, "bin/python3")
+            artifact.collect("lib/python3")
+            artifact.collect("lib/python{version_major}")
+            artifact.collect("lib/libpython{version_major}.*")
+
+        # Create common symlinks
+        if self.system != "windows":
+            with tools.cwd(artifact.path, "bin"):
+                tools.symlink("python3", "python")
+                tools.symlink("python3", "python{version_major}")
+
+        # Install required packages into the artifact using pip
+        with tools.environ(PYTHONHOME=artifact.path):
+            py_exe = fs.path.join(artifact.path, "bin", "python3")
+            with tools.tmpdir() as tmp, tools.cwd(tmp):
+                tools.write_file(
+                    "requirements.txt",
+                    "\n".join(self.requirements) + "\n"
+                )
+
+                pip_cmd = [
+                    py_exe,
+                    "-m",
+                    "pip",
+                    "--isolated",
+                    "--no-cache-dir",
+                    "install",
+                    "-r",
+                    "requirements.txt",
+                    "--break-system-packages",
+                ]
+                tools.run(pip_cmd, shell=False)
+
+        artifact.environ.PATH.append("bin")
+        artifact.environ.PATH.append("local/bin")
+        artifact.strings.install_prefix = artifact.path
+
+    def unpack(self, artifact, tools):
+        # Relocate the virtual environment by adjusting script paths
+        frompath = artifact.strings.install_prefix
+        topath = artifact.final_path
+        self.relocate_scripts(artifact, tools, frompath, topath)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+def requires(python=True):
+    """ Decorator to add Python requirements to a task. """
+
+    import jolt.pkgs.cpython
+
+    def decorate(cls):
+        if python:
+            cls = attributes.requires("requires_python")(cls)
+            cls.requires_python = ["cpython"]
+
+        return cls
+
+    return decorate

jolt/plugins/rust.py

@@ -0,0 +1,25 @@
+from jolt import attributes, Task
+
+
+@attributes.common_metadata()
+class Rust(Task):
+    """ Base class for Rust-based build tasks. """
+
+    abstract = True
+
+    srcdir = None
+    """
+    Source directory for the Rust project.
+
+    If None, defaults to the task work directory (joltdir).
+    """
+
+    def run(self, deps, tools):
+        self.builddir = tools.builddir(incremental=True)
+        self.installdir = tools.builddir("install")
+        with tools.cwd(self.srcdir or self.joltdir):
+            tools.run("cargo install --path . --target-dir={builddir} --root={installdir}")
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)

jolt/plugins/selfdeploy/setup.py

@@ -85,6 +85,7 @@ setup(
         "protobuf",
         "psutil",
         "pygit2",
+        "py7zr",
         "requests",
         "zstandard",
         "tqdm",

jolt/tasks.py

@@ -197,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 """
@@ -923,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.
@@ -1208,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):
         """
@@ -2689,7 +2756,7 @@ class ReportProxy(object):
             if not filterfn(error):
                 continue
             if error["location"] not in errors_by_location:
-                errors_by_location[error["location"]] = (error, [error["message"]], error["details"])
+                errors_by_location[error["location"]] = (error, [error["message"]], error.get("details", ""))
             else:
                 errors_by_location[error["location"]][1].append(error["message"])
 
@@ -2976,6 +3043,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
@@ -3038,7 +3106,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")
 
@@ -3292,24 +3360,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):

jolt/tools.py

@@ -1,3 +1,4 @@
+import py7zr
 import bz2
 import copy
 import getpass
@@ -42,6 +43,9 @@ from jolt.error import raise_error_if
 from jolt.error import raise_task_error, raise_task_error_if
 
 
+SUPPORTED_ARCHIVE_TYPES = [".tar", ".tar.bz2", ".tar.gz", ".tgz", ".tar.xz", ".tar.zst", ".zip"]
+
+
 http_session = Session()
 
 
@@ -257,6 +261,10 @@ class _CMake(object):
         self.builddir = self.tools.builddir(incremental=incremental)
         self.installdir = self.tools.builddir("install", incremental=False)
 
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
+
     def configure(self, sourcedir, *args, generator=None, **kwargs):
         sourcedir = self.tools.expand_path(sourcedir)
 
@@ -267,74 +275,85 @@ class _CMake(object):
 
         with self.tools.cwd(self.builddir):
             self.tools.run(
-                "cmake {0} -B{1} -DCMAKE_INSTALL_PREFIX={2} {3} {4}",
+                "cmake {0} {1} -DCMAKE_INSTALL_PREFIX=/jolt-prefix {1} {2} {3}",
                 sourcedir,
-                self.builddir,
-                self.installdir,
+                utils.option("-B", self.builddir),
                 utils.option("-G", generator),
                 extra_args,
                 output=True)
 
-    def build(self, release=True, *args, **kwargs):
+    def build(self, *args, config="Release", **kwargs):
         threading_args = ' -j {}'.format(kwargs.get("threads", self.tools.thread_count()))
         with self.tools.cwd(self.builddir):
-            release = "--config Release" if release else ""
-            self.tools.run("cmake --build . {0}{1}", release, threading_args, output=True)
+            self.tools.run("cmake --build . --config {0} {1}", config, threading_args, output=True)
 
-    def install(self, release=True, *args, **kwargs):
-        with self.tools.cwd(self.builddir):
-            release = "--config Release" if release else ""
-            self.tools.run("cmake --build . --target install {0}", release, output=True)
+    def install(self, target="install", config="Release", **kwargs):
+        with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
+            self.tools.run("cmake --build . --config {0} --target {1}", config, target, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, "jolt-prefix"):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = "/jolt-prefix"
 
 
 class _Meson(object):
-    def __init__(self, deps, tools):
+    def __init__(self, deps, tools, incremental=False):
         self.deps = deps
         self.tools = tools
-        self.builddir = self.tools.builddir()
-        self.installdir = self.tools.builddir("install")
+        self.builddir = self.tools.builddir(incremental=incremental)
+        self.installdir = self.tools.builddir("install", incremental=False)
+        self.prefix = "/jolt-prefix" if os.name != "nt" else "C:\\jolt-prefix"
+
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
 
     def configure(self, sourcedir, *args, **kwargs):
         sourcedir = self.tools.expand_path(sourcedir)
-        self.tools.run("meson --prefix=/ {0} {1}", sourcedir, self.builddir,
+        options = " ".join([f"-D{arg}" for arg in args]) + " "
+        options += " ".join(["-D{0}={1}".format(key, self.tools.expand(val)) for key, val in kwargs.items()])
+        self.tools.run("meson setup --prefix={0} {1} {2} {3}", self.prefix, sourcedir, self.builddir, options,
                        output=True)
 
     def build(self, *args, **kwargs):
         self.tools.run("ninja -C {0} ", self.builddir, output=True)
 
     def install(self, *args, **kwargs):
-        self.tools.run("DESTDIR={0} ninja -C {1} install",
-                       self.installdir, self.builddir,
-                       output=True)
+        with self.tools.environ(DESTDIR=self.installdir):
+            self.tools.run("ninja -C {0} install", self.builddir, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, "jolt-prefix"):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = self.prefix
 
 
 class _AutoTools(object):
-    def __init__(self, deps, tools):
+    def __init__(self, deps, tools, incremental=False):
         self.deps = deps
         self.tools = tools
-        self.builddir = self.tools.builddir()
-        self.installdir = self.tools.builddir("install")
+        self.builddir = self.tools.builddir(incremental=incremental)
+        self.installdir = self.tools.builddir("install", incremental=False)
+        self.prefix = "jolt-prefix"
 
-    def configure(self, sourcedir, *args, **kwargs):
+    def clean(self):
+        self.tools.rmtree(self.builddir, ignore_errors=True)
+        self.tools.rmtree(self.installdir, ignore_errors=True)
+
+    def configure(self, sourcedir, *args):
         sourcedir = self.tools.expand_path(sourcedir)
-        prefix = kwargs.get("prefix", "/")
 
         if not fs.path.exists(fs.path.join(sourcedir, "configure")):
             with self.tools.cwd(sourcedir):
                 self.tools.run("autoreconf -visf", output=True)
 
         with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
-            self.tools.run("{0}/configure --prefix={1} {2}",
-                           sourcedir, prefix,
+            self.tools.run("{0}/configure --prefix=/{1} {2} {3}",
+                           sourcedir,
+                           self.prefix,
                            self.tools.getenv("CONFIGURE_FLAGS", ""),
+                           " ".join(args),
                            output=True)
 
     def build(self, *args, **kwargs):
@@ -342,13 +361,14 @@ class _AutoTools(object):
             self.tools.run("make VERBOSE=yes Q= V=1 -j{0}",
                            self.tools.cpu_count(), output=True)
 
-    def install(self, target="install", **kwargs):
-        with self.tools.cwd(self.builddir), self.tools.environ(DESTDIR=self.installdir):
-            self.tools.run("make {}", target, output=True)
+    def install(self, target="install"):
+        with self.tools.cwd(self.builddir):
+            self.tools.run("make DESTDIR={} {}", self.installdir, target, output=True)
 
-    def publish(self, artifact, files='*', *args, **kwargs):
-        with self.tools.cwd(self.installdir):
-            artifact.collect(files, *args, **kwargs)
+    def publish(self, artifact, files='*', symlinks=True, *args, **kwargs):
+        with self.tools.cwd(self.installdir, self.prefix):
+            artifact.collect(files, *args, symlinks=symlinks, **kwargs)
+        artifact.strings.install_prefix = "/" + self.prefix
 
 
 class ZipFile(zipfile.ZipFile):
@@ -527,6 +547,12 @@ class Tools(object):
                         zf.write(path, zippath)
         return filename
 
+    def _make_7zfile(self, filename, fmt, rootdir):
+        self.mkdirname(filename)
+        with py7zr.SevenZipFile(filename, 'w') as archive:
+            archive.writeall(rootdir, ".")
+        return filename
+
     def _make_tarfile(self, filename, fmt, rootdir):
         self.mkdirname(filename)
         with tarfile.open(filename, 'w|%s' % fmt) as tar:
@@ -559,6 +585,7 @@ class Tools(object):
         The type of archive to create is determined by the filename extension.
         Supported formats are:
 
+        - 7z
         - tar
         - tar.bz2
         - tar.gz
@@ -594,12 +621,16 @@ class Tools(object):
             fmt = "tarbz2"
         elif filename.endswith(".tar.xz"):
             fmt = "tarxz"
+        elif filename.endswith(".7z"):
+            fmt = "7z"
         raise_task_error_if(
             not fmt, self._task,
             "unknown archive type '{0}'", fs.path.basename(filename))
         try:
             if fmt == "zip":
                 outfile = self._make_zipfile(filename, fmt, rootdir=pathname)
+            elif fmt == "7z":
+                outfile = self._make_7zfile(filename, fmt, rootdir=pathname)
             else:
                 outfile = self._make_tarfile(filename, fmt[3:], rootdir=pathname)
             if outfile != filename:
@@ -608,9 +639,9 @@ class Tools(object):
         except Exception:
             raise_task_error(self._task, "failed to create archive from directory '{0}'", pathname)
 
-    def autotools(self, deps=None):
+    def autotools(self, deps=None, incremental=False):
         """ Creates an AutoTools invokation helper """
-        return _AutoTools(deps, self)
+        return _AutoTools(deps, self, incremental=incremental)
 
     @utils.locked(lock='_builddir_lock')
     def builddir(self, name=None, incremental=False, unique=True):
@@ -895,7 +926,7 @@ class Tools(object):
                         pbar.update(len(data))
                 actual_size = self.file_size(pathname)
                 raise_error_if(
-                    size != 0 and size != actual_size,
+                    size != 0 and size > actual_size,
                     f"Downloaded file was truncated to {actual_size}/{size} bytes: {name}")
 
             return response.status_code == 200
@@ -1054,6 +1085,7 @@ class Tools(object):
 
         Supported formats are:
 
+        - 7z
         - tar
         - tar.bz2
         - tar.gz
@@ -1117,6 +1149,13 @@ class Tools(object):
                     self._extract_tarzstd(filename, filepath, files)
                 except tarfile.StreamError as e:
                     raise_task_error(self._task, "failed to extract archive '{0}': {1}", filename, str(e))
+            elif filename.endswith(".7z"):
+                with py7zr.SevenZipFile(filename, 'r') as archive:
+                    if files:
+                        for file in files:
+                            archive.extract(file, filepath)
+                    else:
+                        archive.extractall(filepath)
             else:
                 raise_task_error(self._task, "unknown archive type '{0}'", fs.path.basename(filename))
         except Exception:
@@ -1268,9 +1307,9 @@ class Tools(object):
         """
         return utils.map_concurrent(callable, iterable, max_workers)
 
-    def meson(self, deps=None):
+    def meson(self, deps=None, incremental=False):
         """ Creates a Meson invokation helper """
-        return _Meson(deps, self)
+        return _Meson(deps, self, incremental=incremental)
 
     @contextmanager
     def nixpkgs(self, nixfile=None, packages=None, pure=False, path=None, options=None):
@@ -1702,11 +1741,15 @@ class Tools(object):
             fs.makedirs(path)
             for relsrcpath, reldstpath in artifact.files.items():
                 srcpath = fs.path.normpath(fs.path.join(artifact.task.joltdir, relsrcpath))
+                srcpath = self.expand_path(srcpath)
                 dstpath = fs.path.normpath(fs.path.join(path, reldstpath))
+                dstpath = self.expand_path(dstpath)
+
                 if dstpath != fs.path.realpath(dstpath):
                     log.debug("Cannot symlink '{} -> {}', parent directory already symlinked",
                               srcpath, dstpath)
                     continue
+
                 if fs.path.isdir(dstpath):
                     files = fs.scandir(srcpath)
                     for file in files:
@@ -1716,7 +1759,8 @@ class Tools(object):
                     self.symlink(srcpath, dstpath)
 
                 # Restore missing srcfiles if they resided in a build directory
-                if srcpath.startswith(artifact.tools.buildroot) and \
+                buildroot_abs = self.expand_path(artifact.tools.buildroot)
+                if srcpath.startswith(buildroot_abs) and \
                    not fs.path.exists(srcpath):
                     fs.copy(fs.path.join(artifact.path, reldstpath), srcpath, symlinks=True)
             self.write_file(meta, artifact.path)

jolt/utils.py

@@ -219,6 +219,10 @@ class _SafeDict(object):
         value = self.values.get(key)
         if value is None:
             value = call_and_catch(getattr, self.values.get("_instance", object()), key)
+        if value is None and key == "buildroot":
+            tools = getattr(self.values.get("_instance", object()), "tools", None)
+            if tools:
+                value = tools.buildroot
         if value is None:
             value = self._envget(key)
         if type(value) is list:
@@ -238,6 +242,8 @@ class JoltFormatter(Formatter):
             return str(value).lower()
         elif conversion == "c":
             return value()
+        elif conversion == "t":
+            return str(value).title()
         elif conversion == "j":
             return " ".join(value)
         return super().convert_field(value, conversion)

jolt/version.py

@@ -1 +1 @@
-__version__ = "0.9.419"
+__version__ = "0.9.430"