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

jolt/plugins/ninjacli.py

@@ -1,271 +0,0 @@
-import glob
-import sys
-import os
-import subprocess
-import hashlib
-import json
-import errno
-import uuid
-join = os.path.join
-
-
-_hash_cache = {}
-
-
-class Depfile(object):
-    def __init__(self, objfile, dependencies=None, cmdline=None):
-        self.valid = False
-        self.product = ""
-        self.cmdline = cmdline
-        self.path = objfile + ".d"
-        self.dependencies = []
-
-        if not dependencies:
-            if not os.path.exists(self.path):
-                return
-
-            with open(self.path) as f:
-                data = f.read()
-
-            data = data.split(":", 1)
-            if len(data) <= 1:
-                return
-
-            dependencies = data[1]
-            dependencies = dependencies.split()
-            dependencies = [f.rstrip("\\").strip() for f in dependencies]
-            dependencies = [os.path.normpath(f)
-                            for f in filter(lambda n: n, dependencies)]
-
-        self.product = objfile
-        self.dependencies = dependencies or []
-        self.valid = True
-
-    def _hash_file(self, filepath):
-        digest = _hash_cache.get(filepath)
-        if digest:
-            return digest
-
-        sha = hashlib.sha1()
-        try:
-            with open(filepath, "rb") as f:
-                sha.update(f.read())
-        except Exception:
-            sha.update(str(uuid.uuid4()).encode())
-
-        _hash_cache[filepath] = digest = sha.hexdigest()
-        return digest
-
-    @property
-    def hash_cmdline(self):
-        sha_cmd = hashlib.sha1(str(self.cmdline).replace(os.getenv("JOLT_CACHEDIR"), "").encode())
-        return sha_cmd.hexdigest()
-
-    @property
-    def hash_deps(self):
-        if type(self.dependencies) == str:
-            return self.dependencies
-        sha = hashlib.sha1()
-        for dep in sorted(self.dependencies):
-            fh = self._hash_file(dep)
-            sha.update(fh.encode())
-        return sha.hexdigest()
-
-    @property
-    def hash(self):
-        sha = hashlib.sha1()
-        sha.update(self.hash_cmdline.encode())
-        sha.update(self.hash_deps.encode())
-        return sha.hexdigest()
-
-
-class LibraryManifest(object):
-    def __init__(self, path):
-        self._path = path
-        self._data = {}
-        self._objects = set()
-
-    def read(self):
-        try:
-            with open(self._path, "r") as f:
-                self._data = json.loads(f.read())
-        except Exception:
-            pass
-
-    def write(self):
-        with open(self._path, "w") as f:
-            f.write(json.dumps(self._data, indent=2))
-
-    def add_library(self, library_file):
-        self._data["filename"] = library_file
-
-    def add_object_file(self, objpath, cmdline):
-        depfile = Depfile(objpath, cmdline=cmdline)
-        objects = self.objects
-        objects[objpath] = {"digest": depfile.hash, "deps": depfile.dependencies}
-        self._data["objects"] = objects
-
-        if objpath in self._objects:
-            print("error: object file name collision: {}".format(objpath))
-            sys.exit(1)
-        self._objects.add(objpath)
-
-    def get_object(self, objpath, builddir):
-        objdir = join(builddir, os.path.dirname(objpath))
-        data = self.objects.get(objpath)
-        if not data:
-            return False
-
-        try:
-            os.makedirs(objdir)
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                return False
-
-        rv = subprocess.call([os.getenv("AR", "ar"), "x", self.library, objpath], cwd=objdir)
-        if rv != 0:
-            return False
-
-        with open(objpath + ".d", "w") as f:
-            f.write("{}: {}\n".format(objpath, " ".join(data["deps"])))
-            return True
-
-        return False
-
-    @property
-    def objects(self):
-        return self._data.get("objects", {})
-
-    @property
-    def library(self):
-        return os.path.join(os.path.dirname(self._path), self._data["filename"])
-
-    @property
-    def path(self):
-        return self._path
-
-
-class Cache(object):
-    def __init__(self, builddir):
-        self._builddir = builddir
-        self._objects = {}
-        self._objnames = {}
-        self._sources = {}
-
-    def add_manifest(self, manifest):
-        for objpath, objdata in manifest.objects.items():
-            objname = os.path.basename(objpath)
-            objpath_known = self._objnames.get(objname, objpath)
-            if objpath_known != objpath:
-                # Multiple objects with the same basename.
-                # No way to know which object will be extracted
-                # from the archive. Remove entries and fall back
-                # to compilation.
-                try:
-                    self._objnames[objname] = None
-                    del self._objects[objpath_known]
-                except KeyError:
-                    pass
-                continue
-            self._objnames[objname] = objpath
-            obj = self._objects.get(str(objpath), [])
-            deps = [join(self._builddir, dep) for dep in objdata["deps"]]
-            obj.append({
-                "digest": objdata["digest"],
-                "manifest": manifest.path,
-                "deps": Depfile(objpath, dependencies=deps).hash_deps})
-            self._objects[str(objpath)] = obj
-
-    def load_manifests(self, cachedir, task):
-        pattern = "{cachedir}/{task}/*/.ninja.json".format(cachedir=cachedir, task=task)
-        manifests = glob.glob(pattern)
-
-        maxartifacts = int(os.getenv("NINJACACHE_MAXARTIFACTS", 0))
-        if maxartifacts > 0:
-            manifests = manifests[:maxartifacts]
-
-        for manifest in manifests:
-            manifest = LibraryManifest(manifest)
-            manifest.read()
-            self.add_manifest(manifest)
-
-    def load(self):
-        with open(join(self._builddir, ".cache.json")) as f:
-            self._objects = json.load(f)
-
-    def save(self):
-        with open(join(self._builddir, ".cache.json"), "w") as f:
-            json.dump(self._objects, f, indent=2)
-
-    def lookup(self, objpath, cmdline):
-        for objdata in self._objects.get(objpath, []):
-            dep = Depfile(objpath, objdata["deps"], cmdline)
-            if dep.hash == objdata["digest"]:
-                manifest = LibraryManifest(objdata["manifest"])
-                manifest.read()
-                return manifest
-
-
-class LockFile(object):
-    def __init__(self, path=".", *args, **kwargs):
-        from fasteners import process_lock
-        self._file = process_lock.InterProcessLock(os.path.join(path, ".ninja.lock"))
-
-    def __enter__(self, *args, **kwargs):
-        self._file.acquire()
-        return self
-
-    def __exit__(self, *args, **kwargs):
-        self._file.release()
-
-
-###############################################################################
-
-def argscan(args, arg):
-    try:
-        index = args.index(arg)
-    except ValueError:
-        return None
-    if len(args) <= index + 1:
-        return None
-    return args[index + 1]
-
-
-def verbose(fmt, *args, **kwargs):
-    if os.getenv("NINJACACHE_VERBOSE", "0") == "1":
-        print(fmt.format(*args, **kwargs))
-
-
-def cli(compiler_args):
-    objfile = argscan(sys.argv, "-o")
-
-    if os.getenv("NINJACACHE_DISABLE", "0") != "1":
-        cache = Cache(os.getcwd())
-        cache.load()
-        manifest = cache.lookup(objfile, compiler_args)
-        if manifest:
-            if manifest.get_object(objfile, os.getcwd()):
-                verbose("Reusing {} from {}", objfile, manifest.library)
-                with LockFile():
-                    manifest = LibraryManifest(".ninja.json")
-                    manifest.read()
-                    manifest.add_object_file(objfile, compiler_args)
-                    manifest.write()
-                    sys.exit(0)
-            else:
-                verbose("Extraction from library failed, rule will be executed normally")
-
-    rv = subprocess.call(compiler_args)
-    if rv != 0:
-        sys.exit(rv)
-
-    with LockFile():
-        manifest = LibraryManifest(".ninja.json")
-        manifest.read()
-        manifest.add_object_file(objfile, compiler_args)
-        manifest.write()
-
-
-if __name__ == "__main__":
-    compiler_args = sys.argv[sys.argv.index("--") + 1:]
-    cli(compiler_args)

jolt/plugins/repo.py

@@ -1,253 +0,0 @@
-from copy import copy
-from threading import RLock
-from xml.dom import minidom
-
-from jolt.influence import HashInfluenceProvider, HashInfluenceRegistry
-from jolt.tools import Tools
-from jolt import filesystem as fs
-from jolt import log
-from jolt.plugins import git
-from jolt.scheduler import NetworkExecutorExtension, NetworkExecutorExtensionFactory
-from jolt.xmldom import Attribute, Composition, SubElement, Element, ElementTree, ET
-
-
-@Attribute('name')
-@Attribute('fetch')
-class RepoRemote(SubElement):
-    def __init__(self, elem=None):
-        super(RepoRemote, self).__init__('remote', elem=elem)
-
-
-@Attribute('revision')
-@Attribute('remote')
-@Attribute('sync-j')
-class RepoDefault(SubElement):
-    def __init__(self, elem=None):
-        super(RepoDefault, self).__init__('default', elem=elem)
-
-
-@Attribute('path')
-@Attribute('name')
-@Attribute('revision')
-@Attribute('upstream')
-@Attribute('remote')
-class RepoProject(SubElement):
-    def __init__(self, elem=None):
-        super(RepoProject, self).__init__('project', elem=elem)
-
-    def get_diff(self):
-        with self.tools.cwd(self.path_or_name):
-            return self.tools.run("git diff --no-ext-diff HEAD", output_on_error=True)
-        assert False, "git command failed"
-
-    def get_head(self):
-        with self.tools.cwd(self.path_or_name):
-            return self.tools.run("git rev-parse HEAD", output_on_error=True).strip()
-        assert False, "git command failed"
-
-    def get_remote_branches(self, commit):
-        with self.tools.cwd(self.path_or_name):
-            result = self.tools.run("git branch -r --contains {0}", commit, output_on_error=True)
-            if not result:
-                return []
-            result = result.strip().splitlines()
-            result = [line.strip() for line in result]
-            return result
-        assert False, "git command failed"
-
-    def get_local_commits(self):
-        with self.tools.cwd(self.path_or_name):
-            result = self.tools.run("git rev-list HEAD ^@{{upstream}}", output_on_error=True)
-            if not result:
-                return []
-            result = result.strip("\r\n ")
-            return result.splitlines()
-        assert False, "git command failed"
-
-    def has_local_ref(self, ref):
-        with self.tools.cwd(self.path_or_name):
-            try:
-                return True if self.tools.run("git show-ref {0}", ref, output=False) else False
-            except Exception:
-                return False
-
-    def get_remote_ref(self, commit, remote, pattern=None):
-        with self.tools.cwd(self.path_or_name):
-            result = self.tools.run(
-                "git ls-remote {0}{1}",
-                remote,
-                " {0}".format(pattern) if pattern else "",
-                output_on_error=True)
-            if not result:
-                return None
-            result = result.strip().splitlines()
-            result = [line.split("\t") for line in result]
-            result = {line[0]: line[1] for line in result}
-            return result.get(commit)
-        assert False, "git command failed"
-
-    @property
-    def path_or_name(self):
-        return self.path or self.name
-
-
-@Composition(RepoRemote, "remote")
-@Composition(RepoDefault, "default")
-@Composition(RepoProject, "project")
-class RepoManifest(ElementTree):
-    def __init__(self, task, path):
-        super(RepoManifest, self).__init__(element=Element('manifest'))
-        self.path = path
-        self.tools = task.tools
-
-    def append(self, element):
-        self.getroot().append(element)
-
-    def get(self, key):
-        self.getroot().get(key)
-
-    def set(self, key, value):
-        self.getroot().set(key, value)
-
-    def parse(self, filename=".repo/manifest.xml"):
-        with open(fs.path.join(self.tools.getcwd(), filename)) as f:
-            root = ET.fromstring(f.read())
-            self._setroot(root)
-            for project in self.projects:
-                project.tools = self.tools
-            return self
-        raise Exception("failed to parse xml file")
-
-    def format(self):
-        return minidom.parseString(ET.tostring(self.getroot())).toprettyxml(indent="  ")
-
-    def write(self, filename):
-        with open(filename, 'w') as f:
-            f.write(self.format())
-
-    def get_remote(self, project):
-        if len(self.defaults) > 0:
-            return project.remote or self.defaults[0].remote
-        return project.remote
-
-    def get_upstream(self, project):
-        if len(self.defaults) > 0:
-            return project.upstream or self.defaults[0].revision or "master"
-        return project.upstream or "master"
-
-    def assert_clean(self):
-        for project in self.projects:
-            assert not project.get_diff(), \
-                "repo project '{0}' has local changes"\
-                .format(project.path_or_name)
-
-    def lock_revisions(self):
-        for project in self.projects:
-            head = project.get_head()
-            if not project.get_remote_branches(head):
-                remote_ref = project.get_remote_ref(
-                    head, self.get_remote(project))
-                assert remote_ref, \
-                    "repo project '{0}' has unpublished commits"\
-                    .format(project.path_or_name)
-                head = remote_ref
-
-            if not project.upstream:
-                if project.revision and project.has_local_ref(project.revision):
-                    project.upstream = project.revision
-                else:
-                    project.upstream = self.get_upstream(project)
-
-            if not project.revision.startswith("refs/changes"):
-                project.revision = head
-
-
-_git_repos = {}
-_git_repo_lock = RLock()
-
-_repo_manifests = {}
-_repo_manifest_lock = RLock()
-
-
-class RepoInfluenceProvider(HashInfluenceProvider):
-    name = "Repo"
-    path = "."
-
-    def __init__(self, path=None, include=None, exclude=None, network=True):
-        self.path = path or self.__class__.path
-        self.include = include
-        self.exclude = exclude
-        self.network = network
-
-    def get_influence(self, task):
-        self.tools = Tools(task, task.joltdir)
-        try:
-            manifest_path = fs.path.join(task.joltdir, task.expand(self.path))
-            manifest = RepoManifest(task, manifest_path)
-            manifest.parse(fs.path.join(manifest_path, ".repo", "manifest.xml"))
-
-            result = []
-            for project in sorted(manifest.projects, key=lambda p: p.name):
-                if self.include is not None and project.path_or_name not in self.include:
-                    continue
-                if self.exclude is not None and project.path_or_name in self.exclude:
-                    continue
-
-                with _git_repo_lock:
-                    gip = _git_repos.get(project.path_or_name)
-                    if gip is None:
-                        gip = git.GitInfluenceProvider(project.path_or_name)
-                        _git_repos[project.path_or_name] = gip
-                    result.append(gip.get_influence(task))
-
-            return "\n".join(result)
-
-        except KeyError:
-            log.exception()
-        assert False, "failed to calculate hash influence for repo manifest at {0}".format(self.path)
-
-    def get_manifest(self, task):
-        manifest_path = fs.path.join(task.joltdir, task.expand(self.path))
-        with _repo_manifest_lock:
-            manifest = _repo_manifests.get(manifest_path)
-            if manifest is None:
-                manifest = RepoManifest(task, manifest_path)
-                manifest.parse()
-                manifest.assert_clean()
-                manifest.lock_revisions()
-                _repo_manifests[manifest_path] = manifest
-            return manifest
-
-
-class RepoNetworkExecutorExtension(NetworkExecutorExtension):
-    def get_parameters(self, task):
-        rip = list(filter(
-            lambda n: isinstance(n, RepoInfluenceProvider),
-            task.task.influence))
-        if rip:
-            assert len(rip) == 1, "task influenced by multiple repo manifests"
-            rip = rip[0]
-            if rip.network:
-                manifest = rip.get_manifest(task.task)
-                return {"repo_manifest": manifest.format()}
-        return {}
-
-
-@NetworkExecutorExtensionFactory.Register
-class RepoNetworkExecutorExtensionFactory(NetworkExecutorExtensionFactory):
-    def create(self):
-        return RepoNetworkExecutorExtension()
-
-
-def global_influence(path, include=None, exclude=None, network=True, cls=RepoInfluenceProvider):
-    HashInfluenceRegistry.get().register(cls(path, include, exclude, network))
-
-
-def influence(path='.', include=None, exclude=None, network=True, cls=RepoInfluenceProvider):
-    def _decorate(taskcls):
-        if "influence" not in taskcls.__dict__:
-            taskcls.influence = copy(taskcls.influence)
-        provider = cls(path, include, exclude, network)
-        taskcls.influence.append(provider)
-        return taskcls
-    return _decorate

jolt-0.9.76.dist-info/RECORD

@@ -1,79 +0,0 @@
-jolt/__init__.py,sha256=qutdbYzm0pxIkt77a_DESDzaHVy7Ew-m4vfBOStW9YM,1391
-jolt/__main__.py,sha256=w_97LnlsoL6TI-Fnh-XC8BwMu4pWbv4Hqx-XqBuARO4,1393
-jolt/cache.py,sha256=nc647OkK9tqIpXmbkA8MaViFRV2bFMt4P0n7UdwLu6A,59840
-jolt/cli.py,sha256=Nil4cw_wIKZQyUZU3DRGqOAyXJqA8NzzEwTvLD0rmAw,35197
-jolt/colors.py,sha256=P6vhaILGoOn8odEwQ6-z871YQoTe3HRLgS6clavwVHs,737
-jolt/config.py,sha256=3N5efjG7GcrVcne_BTEv7ogWWlpuoVYJdK3SDvzWlbg,8543
-jolt/error.py,sha256=s19gQwTXDovl3Vh5XTmsU-3bdTBx1apg3FRCczvAJQs,2110
-jolt/expires.py,sha256=SNJpZ7mKYIyde81I5K1h08GDlpgk0uFcG9Yk-lfXUEM,2330
-jolt/filesystem.py,sha256=9l0bevHb48W46pHOAaDEDR0fD4fm06ybzXpZ2ndNmYw,5815
-jolt/graph.py,sha256=xhILzRYvCygApRqSCiWa2faQ2JTNOlWeAQz-wYzPME8,22861
-jolt/hooks.py,sha256=foeQR5MAMj2JBIoMxEBWneFSNutE79p4v1GsTrwHCvY,9475
-jolt/influence.py,sha256=FITkvqjyIWQmsusGoL4GCx3lUbaC6g6Xy3wWc67saQ8,15426
-jolt/inspection.py,sha256=QkOCXAbjJBdw1SMsb6xH_3GHXV5BcdzaGD7HrGmOJss,3931
-jolt/loader.py,sha256=D_VpzrEh4XmSFVvoAdkdAVBv5GUoi-FHi4uG7Ut_Evg,10179
-jolt/log.py,sha256=tKtPgOLrMYB_KzN6MR7YI51UYmRG8wczuY1HXjFfH3k,11117
-jolt/manifest.py,sha256=j_ajjoBh2xou7Gpsp8G-v1tRNDrwlmIseAdZ8xT61fc,7639
-jolt/options.py,sha256=vfdgIDSlXwjhVLZW00Ez6bcyv5QJkhkUGuz1RY2jz2A,371
-jolt/scheduler.py,sha256=RAFbxL5ur32xaRYML5Il_kFXAcrWOjVpMafa3NWg5-M,18404
-jolt/tasks.py,sha256=b0hbLUWB_aDkAKwbOCMqeY9nOhD3GTtzPzvyAC1Pe6U,66235
-jolt/tools.py,sha256=6YBIFb73_1VSaY1jOdEedSfUaA7xM7UHno3SjbB75Sw,66050
-jolt/utils.py,sha256=EdgEFwgxwN4mKNI3-Ltjh1Xwdq3ja4CqaVgJ6hLy6B0,12806
-jolt/version.py,sha256=kKIBQ2qBgSohxcmuzxuKRIG9_A1ZZCxZhuUoulze8TU,23
-jolt/version_utils.py,sha256=32nJyuhv__rE4Phqq5TCo6_tB4RlZTmhqbFeaCR_OBM,3900
-jolt/xmldom.py,sha256=bD-d5OG9_I_nFRdMN397D62xM3L_bXPvK8FYTX-4uos,5543
-jolt/pkgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jolt/pkgs/golang.py,sha256=r5QLhyAswvMMEbTZiKdZxSwPxn3if-NT2T-MkXIND_8,1153
-jolt/pkgs/nodejs.py,sha256=lqO7snxMhHb0ZiG0YfU_JtDGXkXU2zxJ5_Ac4uoM0Xk,1197
-jolt/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jolt/plugins/alias.py,sha256=yRstDB8H-JPiN3-hwI6hnt8Seh7KBr3U-Vam8UivUWA,313
-jolt/plugins/allure.py,sha256=uc8ZWRSLhOterCM4GLFjPgd7OEbk5Gbd3FXdUQzHjFY,10151
-jolt/plugins/amqp.py,sha256=afFaMC4pIGeVPDmlx4q9r37fWZBtg4p1Z-_LDlpCykU,32129
-jolt/plugins/autoweight.py,sha256=LTpma3HM1jsAx1PatDIWcddAkRw1SPhHA4Dl9H9p2lo,1245
-jolt/plugins/cmake.py,sha256=IAF8PhaaByJVwBYSEdVlu1MdIyhXp8Luv4ygIvtPkqo,2687
-jolt/plugins/conan.py,sha256=fTidFjF5lKYsrTRb_yokmnRUvMIt6FNhAPMT-5wz5_w,7654
-jolt/plugins/cxxinfo.py,sha256=yuHkgT2Lqg2v1GmrjINXBF--KeSOfMya7_HN8AA2hbw,2398
-jolt/plugins/dashboard.py,sha256=hCbmv8mCYHu-9EtE-Hr-r5Zu5WiAmdnvomHSeJv0sHM,641
-jolt/plugins/debian.py,sha256=5uzICZzFscV-HwLqvlqtLr7EpcUFm0N5qa2jDoHd3A8,11569
-jolt/plugins/docker.py,sha256=ZdPuSoqNZGUF-NaHvOd63JWujJbDWAeUX9_3D4aBubY,19171
-jolt/plugins/email.py,sha256=-iudgYKijSnpZdrZRcuBtYyqK7UVEvaUQOAyudJJL0I,3356
-jolt/plugins/email.xslt,sha256=qEbCHlfcm_epv36xirCRQO2ncxqseiGHmS1oRnQ4PY8,7200
-jolt/plugins/environ.py,sha256=TKyajli6790VRMAVFKxKxUgdTR8Gg-4ftsgTd05cO74,3371
-jolt/plugins/ftp.py,sha256=Ei1OJI5waCGaqvQt6RSAAnCy8Q5zORLeU7p5Op2WxmU,6545
-jolt/plugins/gdb.py,sha256=rhhzGsDwVTtVRWvK74db8RaK04__qjOJYhwxIkXFAg4,5470
-jolt/plugins/gerrit.py,sha256=hpJhDDKpHyzBxh2e1RsOaoLFoDllD-Zw9OUC5R6Zi_M,1420
-jolt/plugins/git.py,sha256=eu52zRmc-JOwVoTuFnc6u4pscV4h4I1FzDW_OjXxwAs,13855
-jolt/plugins/golang.py,sha256=vV4iRoJpWkyfrBa96s6jgU8Sz8GnGl-lzG_FSj5epzQ,2049
-jolt/plugins/googletest.py,sha256=8BQUlaeXmfJE7PtBdSUkirllk8nvZeYUDWMILuIYsak,191
-jolt/plugins/http.py,sha256=2tm_givpyGCB7jbfGgNcXMDDIWW2iHZnpMwj-H3S9Jc,4002
-jolt/plugins/junit.py,sha256=_1vXMEQBNuLbwc8l4UFm1iONYdehxJxWDRgFtPy3do8,1342
-jolt/plugins/logstash.py,sha256=0Se6ZDBuwUZkSdquqBJk3MzRd0BltClmzPl_lYrR_rw,1788
-jolt/plugins/ninja-cache.py,sha256=S7ARx1O5zki02mPw3YJjqqp933H-pcyVCtJ1wwc5xhk,2629
-jolt/plugins/ninja-compdb.py,sha256=NldGQt83bbpQed37wtrL2OOLvuAY1tzxIQExC9zRi6s,7852
-jolt/plugins/ninja.py,sha256=-20fo0L6_8nG99Y8lTZiUx-j42hmMahnzvAs6BJwUFY,73515
-jolt/plugins/ninjacli.py,sha256=cYGuOzBmTuT1IGfG6Etl1zDIV1lZMy85RZWCHVkmVb8,8165
-jolt/plugins/nodejs.py,sha256=HHDbvmdlqnao3qOtpCD9UY7iyTIX4gb2WxKUBtn-3cM,1879
-jolt/plugins/paths.py,sha256=lcHQdTrc7jQ-lHFWJhOUzm9TKLf1CyCn_d9op_KVcV4,1686
-jolt/plugins/podman.py,sha256=S55rjyC28Fk5PHohVVeNUc5EAFpOli1FxXJVqFG3bnE,20101
-jolt/plugins/python.py,sha256=kLx1Y3ezMH9AOW36DH_cNyDlvbIdTkyvPjwLYolnCEU,3073
-jolt/plugins/repo.py,sha256=tBlNVrn5F1kU8D-kHOfUTMUcPdMnG_BbP44hirALHNA,8947
-jolt/plugins/report.py,sha256=e7aJ-XeqjvWib7fTewvOubi9xVSY6NwfdU6bdVJtNfo,2179
-jolt/plugins/selfdeploy.py,sha256=vQW90DLdO0WL-R609LO-TloeaGlHuZl5f9nVcEmokfE,5994
-jolt/plugins/strings.py,sha256=ngrSxPT2eFOlmJkc8ZKEabYL5ltisFnwxldRQUgen8k,1538
-jolt/plugins/symlinks.py,sha256=E-M4tmF-rfBvIXetflz906MxG7-vIAfKULT3y9HtQSc,1921
-jolt/plugins/telemetry.py,sha256=L3QDUORkl57310quO_DA-NUCayqw_yQz_0JRKjejOVM,3461
-jolt/plugins/timeline.py,sha256=pqQpnhYjE3eRnOZUSHI4Qz6X4Ehvo-kAaRXdRihdXaM,1620
-jolt/plugins/volume.py,sha256=5mAsLNs47DKvfdkDb4E413VAEQOM0RIJOsrWBFinutQ,3583
-jolt/plugins/yaml-ninja.py,sha256=6V5YlGaZ3G1EyCTW6flMcslIh6DHttRSoUXdi0rX2Mc,3060
-jolt/plugins/yamltask.py,sha256=yECalMWOI48rn7yqWwxXxlSq1HDKnJ2llLD_SI_Ogys,3528
-jolt/plugins/selfdeploy/README.rst,sha256=dAer5CQHPOOCUAMcVljKzn5ICzjsNKWhw2tAvBAL8So,3130
-jolt/plugins/selfdeploy/setup.py,sha256=NxI9mg5iccZ29zdAq6g2QwTANtbWsSZLX-YVlqnaNps,3015
-jolt/templates/cxxexecutable.cmake.template,sha256=f0dg1VOFlamlF8fuHFTki5dsJ2ssSupiqk62QmRby4Y,1720
-jolt/templates/cxxlibrary.cmake.template,sha256=GMEG2G3QoY3E5fsNer52zOqgM221-abeCkV__mVbZ94,1750
-jolt/templates/export.sh.template,sha256=8RBkv8ebN4D-VlwH6ZAWo_i7EzBGzmRwqbDwZvlbh-g,1778
-jolt/templates/timeline.html.template,sha256=w6K11kwyMrA7w3GWlVlubbK0a3vcP6TGXU5n-0s6PP4,1410
-jolt-0.9.76.dist-info/METADATA,sha256=IwM2hfq-s3r8OcINp_BrD2ofvLhMmMyyRCLJ5o-RHVk,5493
-jolt-0.9.76.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-jolt-0.9.76.dist-info/entry_points.txt,sha256=VZ-QH38Z9HJc1O57wfzr-soHn6exwc3N0TSrRum4tYg,44
-jolt-0.9.76.dist-info/top_level.txt,sha256=HwzVmAwUrvCUUHRi3zUfcpdKTsdNrZmPCvsrsWSFyqE,5
-jolt-0.9.76.dist-info/RECORD,,