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

jolt/log.py

@@ -26,9 +26,10 @@ from jolt.error import JoltError
 from jolt import filesystem as fs
 from jolt import colors
 from jolt import common_pb2 as common_pb
+from jolt import utils
 
 
-current_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
+current_time = datetime.now().strftime("%Y-%m-%dT%H%M%S.%f")
 logpath = config.get_logpath()
 logfile = fs.path.join(logpath, f"{current_time}.log")
 logcount = config.getint("jolt", "logcount", os.environ.get("JOLT_LOGCOUNT", 100))
@@ -40,15 +41,15 @@ if not fs.path.exists(dirpath):
 
 ################################################################################
 
-ERROR = common_pb.LogLevel.ERROR
-WARNING = common_pb.LogLevel.WARNING
-INFO = common_pb.LogLevel.INFO
-VERBOSE = common_pb.LogLevel.VERBOSE
-DEBUG = common_pb.LogLevel.DEBUG
-EXCEPTION = common_pb.LogLevel.EXCEPTION
-STDOUT = common_pb.LogLevel.STDOUT
-STDERR = common_pb.LogLevel.STDERR
-SILENCE = STDERR + 1
+ERROR = common_pb.LogLevel.ERROR + 1
+WARNING = common_pb.LogLevel.WARNING + 1
+INFO = common_pb.LogLevel.INFO + 1
+VERBOSE = common_pb.LogLevel.VERBOSE + 1
+DEBUG = common_pb.LogLevel.DEBUG + 1
+EXCEPTION = common_pb.LogLevel.EXCEPTION + 1
+STDOUT = common_pb.LogLevel.STDOUT + 1
+STDERR = common_pb.LogLevel.STDERR + 1
+SILENCE = STDERR + 2
 
 logging.addLevelName(VERBOSE, "VERBOSE")
 logging.addLevelName(STDOUT, "STDOUT")
@@ -142,13 +143,37 @@ class TqdmStream(object):
         getattr(self.stream, 'flush', lambda: None)()
 
 
+class ThreadPrefix(logging.LoggerAdapter):
+    thread_prefix = {}
+
+    def process(self, msg, kwargs):
+        tid = threading.current_thread()
+        if tid in self.thread_prefix:
+            msg = f"[{self.thread_prefix[tid]}] {msg}"
+        return msg, kwargs
+
+    def set_thread_prefix(self, prefix):
+        tid = threading.current_thread()
+        self.thread_prefix[tid] = prefix
+
+    def clear_thread_prefix(self):
+        tid = threading.current_thread()
+        if tid in self.thread_prefix:
+            del self.thread_prefix[tid]
+
+
 # silence root logger
 _root = logging.getLogger()
 _root.setLevel(logging.CRITICAL)
 
-# create jolt logger
+# create jolt logger and protect it's methods against interrupts
 _logger = logging.getLogger('jolt')
-_logger.setLevel(DEBUG)
+_logger.setLevel(EXCEPTION)
+_logger.handle = utils.delay_interrupt(_logger.handle)
+_logger.log = utils.delay_interrupt(_logger.log)
+_logger.addHandler = utils.delay_interrupt(_logger.addHandler)
+_logger.removeHandler = utils.delay_interrupt(_logger.removeHandler)
+
 
 _console_formatter = ConsoleFormatter('[{levelname:>7}] {message}', '{message}')
 
@@ -158,17 +183,18 @@ else:
     _stdout = logging.StreamHandler(sys.stdout)
 _stdout.setFormatter(_console_formatter)
 _stdout.addFilter(Filter(lambda r: r.levelno < ERROR))
+_stdout.addFilter(Filter(lambda r: r.levelno != EXCEPTION))
 
 if sys.stdout.isatty() and sys.stderr.isatty():
     _stderr = logging.StreamHandler(TqdmStream(sys.stdout))
 else:
     _stderr = logging.StreamHandler(sys.stderr)
 _stderr.setFormatter(_console_formatter)
-_stderr.addFilter(Filter(lambda r: r.levelno >= ERROR))
-_stderr.addFilter(Filter(lambda r: r.levelno != EXCEPTION))
+_stderr.addFilter(Filter(lambda r: r.levelno >= ERROR or r.levelno == EXCEPTION))
 
 _logger.addHandler(_stdout)
 _logger.addHandler(_stderr)
+_logger_frontend = ThreadPrefix(_logger, {})
 
 _file_formatter = Formatter('{asctime} [{levelname:>7}] {message}')
 
@@ -183,7 +209,7 @@ def start_file_log():
             os.unlink(file)
 
     _file = logging.FileHandler(logfile)
-    _file.setLevel(DEBUG)
+    _file.setLevel(EXCEPTION)
     _file.setFormatter(_file_formatter)
     _logger.addHandler(_file)
 
@@ -206,35 +232,35 @@ def log(level, message, created=None, context=None, prefix=False):
 
 
 def info(fmt, *args, **kwargs):
-    _logger.log(INFO, fmt, *args, **kwargs)
+    _logger_frontend.log(INFO, fmt, *args, **kwargs)
 
 
 def warning(fmt, *args, **kwargs):
-    _logger.log(WARNING, fmt, *args, **kwargs)
+    _logger_frontend.log(WARNING, fmt, *args, **kwargs)
 
 
 def verbose(fmt, *args, **kwargs):
-    _logger.log(VERBOSE, fmt, *args, **kwargs)
+    _logger_frontend.log(VERBOSE, fmt, *args, **kwargs)
 
 
 def debug(fmt, *args, **kwargs):
-    _logger.log(DEBUG, fmt, *args, **kwargs)
+    _logger_frontend.log(DEBUG, fmt, *args, **kwargs)
 
 
 def error(fmt, *args, **kwargs):
-    _logger.log(ERROR, fmt, *args, **kwargs)
+    _logger_frontend.log(ERROR, fmt, *args, **kwargs)
 
 
 def stdout(line, **kwargs):
     line = line.replace("{", "{{")
     line = line.replace("}", "}}")
-    _logger.log(STDOUT, line, extra=kwargs)
+    _logger_frontend.log(STDOUT, line, extra=kwargs)
 
 
 def stderr(line, **kwargs):
     line = line.replace("{", "{{")
     line = line.replace("}", "}}")
-    _logger.log(STDERR, line, extra=kwargs)
+    _logger_frontend.log(STDERR, line, extra=kwargs)
 
 
 def format_exception_msg(exc):
@@ -264,10 +290,17 @@ def format_exception_msg(exc):
             te.stack[-1].name)
 
 
-def exception(exc=None):
+def exception(exc=None, error=True):
     if exc:
-        _logger.error(format_exception_msg(exc))
-        backtrace = traceback.format_exc().splitlines()
+        if error:
+            _logger_frontend.log(ERROR, format_exception_msg(exc))
+
+        tb = traceback.format_exception(type(exc), value=exc, tb=exc.__traceback__)
+        installdir = fs.path.dirname(__file__)
+        if any(map(lambda frame: installdir not in frame, tb[1:-1])):
+            while len(tb) > 2 and installdir in tb[1]:
+                del tb[1]
+        backtrace = "".join(tb).splitlines()
     else:
         backtrace = traceback.format_exc().splitlines()
 
@@ -275,7 +308,7 @@ def exception(exc=None):
         line = line.replace("{", "{{")
         line = line.replace("}", "}}")
         line = line.strip()
-        _logger.log(EXCEPTION, line)
+        _logger_frontend.log(EXCEPTION, line)
 
 
 def transfer(line, context):
@@ -295,7 +328,7 @@ def transfer(line, context):
     elif line.startswith("[ EXCEPT]"):
         outline1 = outline1.replace("{", "{{")
         outline1 = outline1.replace("}", "}}")
-        _logger.log(EXCEPTION, outline1)
+        _logger_frontend.log(EXCEPTION, outline1)
     elif line.startswith("[ STDERR]"):
         stderr(outline1, prefix=True)
     elif line.startswith("[ STDOUT]"):
@@ -325,17 +358,36 @@ class _Progress(object):
     def update(self, *args, **kwargs):
         pass
 
+    def refresh(self, *args, **kwargs):
+        pass
+
+    def reset(self, *args, **kwargs):
+        pass
+
+    def set_description(self, *args, **kwargs):
+        pass
+
 
 def progress_log(desc, count, unit):
     return _Progress(desc)
 
 
 def progress(desc, count, unit, estimates=True, debug=False):
-    bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}]' \
-                 if not estimates else None
+    if count:
+        bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}]' \
+                     if not estimates else None
+    else:
+        bar_format = '{desc}{n_fmt}{unit} [{elapsed}]'
     if not debug and is_interactive() and not is_verbose():
-        p = tqdm.tqdm(total=count, unit=unit, unit_scale=True, bar_format=bar_format, dynamic_ncols=True)
-        p.set_description("[   INFO] " + desc)
+        class ProgressTqdm(tqdm.tqdm):
+            def __init__(self, *args, **kwargs):
+                super(ProgressTqdm, self).__init__(*args, **kwargs)
+
+            def set_description(self, desc=None, refresh=True):
+                return super().set_description("[   INFO] " + desc, refresh)
+
+        p = ProgressTqdm(total=count, unit=unit, unit_scale=True, bar_format=bar_format, dynamic_ncols=True)
+        p.set_description(desc)
         return p
     return progress_log(desc, count, unit)
 
@@ -343,18 +395,53 @@ def progress(desc, count, unit, estimates=True, debug=False):
 _level = INFO
 
 
+def level_to_pb(level):
+    """ Convert a log level to a protobuf enum value. """
+    return level - 1
+
+
+def pb_to_level(level):
+    """ Convert a protobuf enum value to a log level. """
+    return level + 1
+
+
 def set_level(level):
+    """ Set the log level for terminal output. """
+
+    if level not in [
+        DEBUG,
+        ERROR,
+        EXCEPTION,
+        INFO,
+        SILENCE,
+        STDERR,
+        STDOUT,
+        VERBOSE,
+        WARNING,
+    ]:
+        raise ValueError("invalid log level")
+
     global _level
     _level = level
     _stdout.setLevel(level)
     _stderr.setLevel(level)
 
 
+def set_level_pb(level):
+    """ Set the log level from a protobuf enum value. """
+    set_level(pb_to_level(level))
+
+
 def get_level():
     global _level
     return _level
 
 
+def get_level_pb():
+    """ Get the log level as a protobuf enum value. """
+    return level_to_pb(_level)
+
+
 def set_worker():
     _console_formatter.enable_prefixes()
 
@@ -434,6 +521,15 @@ def map_thread(thread_from, thread_to):
         _thread_map.unmap(tid)
 
 
+@contextmanager
+def thread_prefix(prefix):
+    try:
+        _logger_frontend.set_thread_prefix(prefix)
+        yield
+    finally:
+        _logger_frontend.clear_thread_prefix()
+
+
 class _LogStream(object):
     def __init__(self):
         self.buf = ""

jolt/manifest.py

@@ -113,7 +113,9 @@ class _JoltNetworkParameter(SubElement):
 @Attribute("stderr", child=True, zlib=True)
 @Attribute("result", child=True)
 @Attribute("duration", child=True)
+@Attribute("name")
 @Attribute("workspace")
+@Attribute("build")
 @Attribute("version")
 @Composition(_JoltRecipe, "recipe")
 @Composition(_JoltTask, "task")
@@ -127,8 +129,10 @@ class JoltManifest(ElementTree):
         self._elem = self.getroot()
         self.path = None
 
-    @property
-    def joltdir(self):
+    def is_valid(self):
+        return self.path is not None
+
+    def get_workspace_path(self):
         if self.path is None:
             return None
         joltdir = fs.path.dirname(self.path)
@@ -136,6 +140,13 @@ class JoltManifest(ElementTree):
             joltdir = fs.path.normpath(fs.path.join(joltdir, self.workspace))
         return joltdir
 
+    def get_workspace_name(self):
+        if self.name:
+            return self.name
+        if self.path is None:
+            return None
+        return fs.path.basename(fs.path.dirname(self.path))
+
     @property
     def attrib(self):
         return self.getroot().attrib
@@ -230,47 +241,3 @@ class JoltManifest(ElementTree):
         for manifest_task in self.tasks:
             self._identities[manifest_task.name] = manifest_task.identity
         return self._identities
-
-    @staticmethod
-    def export(task):
-        manifest = JoltManifest()
-        ManifestExtensionRegistry.export_manifest(manifest, task)
-        return manifest
-
-    def process_import(self):
-        ManifestExtensionRegistry.import_manifest(self)
-
-
-class ManifestExtensionRegistry(object):
-    extensions = []
-
-    @staticmethod
-    def add(extension, priority=0):
-        ManifestExtensionRegistry.extensions.append((extension, priority))
-        ManifestExtensionRegistry.extensions.sort(key=lambda x: x[1])
-
-    @staticmethod
-    def export_manifest(manifest, task):
-        for extension, _ in ManifestExtensionRegistry.extensions:
-            extension.export_manifest(manifest, task)
-
-    @staticmethod
-    def import_manifest(manifest):
-        for extension, _ in ManifestExtensionRegistry.extensions:
-            extension.import_manifest(manifest)
-
-    @staticmethod
-    def import_protobuf(pb):
-        for extension, _ in ManifestExtensionRegistry.extensions:
-            extension.import_protobuf(pb)
-
-
-class ManifestExtension(object):
-    def export_manifest(self, manifest, task):
-        pass
-
-    def import_manifest(self, manifest):
-        pass
-
-    def import_protobuf(self, pb):
-        pass

jolt/options.py

@@ -1,15 +1,39 @@
 
 class JoltOptions(object):
+    """ Jolt options that control the behavior of builds. """
+
+    debug = False
+    """ Enable debug mode. Break into debugger on exceptions. """
+
+    download = True
+    """ Enable downloading of remote artifacts, both session and persistent. """
+
+    download_session = True
+    """ Enable downloading of remote session artifacts. """
+
+    keep_going = False
+    """ Keep going with the build after a task fails. """
+
+    local = False
+    """ Disable network access. """
+
+    network = False
+    """ Distribute tasks to workers. """
+
+    upload = True
+    """ Enable uploading of artifacts. """
+
+    worker = False
+    """ Running as a worker. """
+
+    salt = None
+    """ Salt for hashing (--salt). """
+
+    jobs = 1
+    """ Number of concurrent local tasks to run (1). """
+
+    mute = False
+    """ Mute task output, until a task fails. """
+
     def __init__(self, **kwargs):
-        self.debug = False
-        self.default = []
-        self.download = True
-        self.keep_going = False
-        self.local = False
-        self.network = False
-        self.upload = True
-        self.worker = False
-        self.salt = None
-        self.jobs = 1
-        self.mute = False
         self.__dict__.update(kwargs)

jolt/pkgs/abseil.py

@@ -0,0 +1,42 @@
+from jolt import attributes, BooleanParameter, Parameter, Task
+from jolt.plugins import cmake, git
+from jolt.tasks import TaskRegistry
+import os
+
+
+@attributes.requires("requires_git")
+@attributes.system
+@cmake.requires()
+@cmake.use_ninja()
+class Abseil(cmake.CMake):
+    """ Abseil C++ Common Libraries """
+
+    name = "abseil"
+    version = Parameter("20250814.1")
+    shared = BooleanParameter(False, help="Build shared libraries")
+    requires_git = ["git:url=https://github.com/abseil/abseil-cpp.git,rev={version}"]
+    srcdir = "{git[abseil-cpp]}"
+    options = [
+        "ABSL_MSVC_STATIC_RUNTIME=OFF",
+        "BUILD_SHARED_LIBS={shared[ON,OFF]}",
+        "CMAKE_CXX_STANDARD=17",
+    ]
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.cxxinfo.crt = "Dynamic"
+        artifact.cxxinfo.incpaths.append("include")
+        artifact.cxxinfo.libpaths.append("lib")
+        if self.shared:
+            artifact.environ.LD_LIBRARY_PATH.append("lib")
+
+        with tools.cwd(artifact.path, "lib"):
+            for libfile in tools.glob("*.lib"):
+                libname, _ = os.path.splitext(libfile)
+                artifact.cxxinfo.libraries.append(libname)
+            for libfile in tools.glob("lib*.a"):
+                libname, _ = os.path.splitext(libfile)
+                artifact.cxxinfo.libraries.append(libname[3:])
+
+
+TaskRegistry.get().add_task_class(Abseil)

jolt/pkgs/asio.py

@@ -0,0 +1,25 @@
+from jolt import attributes, Parameter
+from jolt.plugins import cmake, git, autotools, pkgconfig
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@autotools.requires()
+@pkgconfig.requires()
+@pkgconfig.to_cxxinfo("asio")
+class Asio(autotools.Autotools):
+    name = "asio"
+    version = Parameter("1.36.0", help="asio version.")
+    requires_git = ["git:url=https://github.com/chriskohlhoff/asio.git,rev=asio-{_version}"]
+    srcdir = "{git[asio]}/asio"
+
+    @property
+    def _version(self):
+        return str(self.version).replace(".", "-")
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        artifact.environ.CMAKE_PREFIX_PATH.append(".")
+
+
+TaskRegistry.get().add_task_class(Asio)

jolt/pkgs/autoconf.py

@@ -0,0 +1,41 @@
+from jolt import attributes, Parameter
+from jolt.pkgs import help2man, m4, texinfo
+from jolt.plugins import git, autotools
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_help2man")
+@attributes.requires("requires_m4")
+@attributes.requires("requires_texinfo")
+class Autoconf(autotools.Autotools):
+    name = "autoconf"
+    version = Parameter("2.72", help="Autoconf version.")
+    requires_git = ["fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/autoconf/autoconf-{version}.tar.gz"]
+    requires_help2man = ["help2man"]
+    requires_m4 = ["m4"]
+    requires_texinfo = ["texinfo"]
+    srcdir = "{fetch[src]}/autoconf-{version}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        self.unpack(artifact, tools)
+
+    def unpack(self, artifact, tools):
+        with tools.cwd(artifact.path, "bin"):
+            for file in tools.glob("*"):
+                tools.replace_in_file(
+                    file,
+                    artifact.strings.install_prefix,
+                    artifact.final_path)
+
+        with tools.cwd(artifact.path, "share/autoconf"):
+            tools.replace_in_file(
+                "autom4te.cfg",
+                artifact.strings.install_prefix,
+                artifact.final_path)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+TaskRegistry.get().add_task_class(Autoconf)

jolt/pkgs/automake.py

@@ -0,0 +1,41 @@
+from jolt import attributes, Parameter, Task
+from jolt.plugins import git, autotools
+from jolt.tasks import TaskRegistry
+
+
+@attributes.requires("requires_git")
+@attributes.requires("requires_texinfo")
+@autotools.requires(automake=False, libtool=False)
+class Automake(autotools.Autotools):
+    name = "automake"
+    version = Parameter("1.18.1", help="Automake version.")
+    requires_git = ["fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/automake/automake-{version}.tar.xz"]
+    requires_texinfo = ["texinfo"]
+    srcdir = "{fetch[src]}/automake-{version}"
+
+    def publish(self, artifact, tools):
+        super().publish(artifact, tools)
+        self.unpack(artifact, tools)
+
+    def unpack(self, artifact, tools):
+        with tools.cwd(artifact.path, "bin"):
+            for file in tools.glob("*"):
+                tools.replace_in_file(
+                    file,
+                    artifact.strings.install_prefix,
+                    artifact.final_path)
+
+        for file in tools.glob(artifact.path + "/share/automake-*/Automake/Config.pm"):
+            tools.replace_in_file(
+                file,
+                artifact.strings.install_prefix,
+                artifact.final_path)
+
+        with tools.cwd(artifact.path):
+            for file in tools.glob("share/aclocal-*"):
+                artifact.environ.ACLOCAL_PATH.append(file)
+
+        artifact.strings.install_prefix = artifact.final_path
+
+
+TaskRegistry.get().add_task_class(Automake)

jolt/pkgs/b2.py

@@ -0,0 +1,31 @@
+import os
+from jolt import attributes, Parameter
+from jolt.plugins import git
+from jolt.tasks import Task, TaskRegistry
+
+
+@attributes.common_metadata()
+@attributes.requires("requires_git")
+@attributes.system
+class B2(Task):
+    name = "b2"
+    version = Parameter("5.4.2", help="B2 version.")
+    requires_git = ["git:url=https://github.com/bfgroup/b2.git"]
+
+    def run(self, artifact, tools):
+        self.builddir = tools.builddir("build", incremental=True)
+        self.installdir = tools.builddir("install")
+        with tools.cwd("{git[b2]}"):
+            if self.system == "windows":
+                tools.run(".\\bootstrap.bat")
+                tools.run(".\\b2 install --prefix={installdir} --build-dir={builddir} -j{}", tools.cpu_count())
+            else:
+                tools.run("./bootstrap.sh")
+                tools.run("./b2 install --prefix={installdir} --build-dir={builddir} -j{}", tools.cpu_count())
+
+    def publish(self, artifact, tools):
+        with tools.cwd(self.installdir):
+            artifact.collect("*", symlinks=True)
+
+
+TaskRegistry.get().add_task_class(B2)