atex 0.5__py3-none-any.whl → 0.7__py3-none-any.whl

atex-0.7.dist-info/RECORD

@@ -0,0 +1,32 @@
+atex/__init__.py,sha256=LdX67gprtHYeAkjLhFPKzpc7ECv2rHxUbHKDGbGXO1c,517
+atex/cli/__init__.py,sha256=erHv68SsybRbdgJ60013y9jVqY1ec-cb9T9ThPCJ_HY,2408
+atex/cli/minitmt.py,sha256=h1jHRGR0nqc7ANVTjmB5aeLron2A04vpzGGMQJLBliY,5793
+atex/cli/testingfarm.py,sha256=4oKWbkJwj0gs4_NnFP7w8fo2VvD5NpaPNG4HCeKm94I,6706
+atex/connection/__init__.py,sha256=O7rJDwf438lX2YgM8uHCC9gkmvaLYt3jRvtDq_FSzME,4107
+atex/connection/ssh.py,sha256=qVKeAY16pLGGS-d4TIF5A2DWWlNGR5qNlAmHo-jAIEc,13985
+atex/minitmt/__init__.py,sha256=wCda0QXwxlxkH4PpY0lGlNWT96_pUj7taNNP0Mo6TQk,522
+atex/minitmt/executor.py,sha256=zmFHo3M5hHDOzfZrXBPFSeqLmLK__q2KkT5A93ELEzY,13415
+atex/minitmt/fmf.py,sha256=HAjQkfrDLQLW2ZBvgQmleVpL_tfNSP9bUuqRt9BdjS4,7559
+atex/minitmt/scripts.py,sha256=WsLsQOmNxinpGUhOqqwN788zjcd5o79VC7I7UeGRwb8,5146
+atex/minitmt/testcontrol.py,sha256=l670ou1oPr5q3RA4QNQ0IgSh3uYvuvzcUW67NLNVgCA,12209
+atex/orchestrator/__init__.py,sha256=pMBBtev20KWAmQdth3RfuTwltXDm57CakDBpAsqyNYM,1592
+atex/orchestrator/aggregator.py,sha256=pTL6Ru70sin5WOc-dl3-bNSEvuOfWq7YLtduwiLX9q8,5463
+atex/provision/__init__.py,sha256=hJ7wbn6_LaCQVrIFilEcDA4z4LxglHYNEsxmizwr_OE,5573
+atex/provision/libvirt/VM_PROVISION,sha256=7pkZ-ozgTyK4qNGC-E-HUznr4IhbosWSASbB72Gknl8,2664
+atex/provision/libvirt/__init__.py,sha256=mAkGtciZsXdR9MVVrjm3OWNXZqTs_33-J1qAszFA0k4,768
+atex/provision/libvirt/setup-libvirt.sh,sha256=CXrEFdrj8CSHXQZCd2RWuRvTmw7QYFTVhZeLuhhXooI,1855
+atex/provision/nspawn/README,sha256=mIjOA6R5sM-1wGDm-7zBcEqax1NMSRzijwyeqVjGoqE,3127
+atex/provision/podman/README,sha256=kgP3vcTfWW9gcQzmXnyucjgWbqjNqm_ZM--pnqNTXRg,1345
+atex/provision/podman/host_container.sh,sha256=buCNz0BlsHY5I64sMSTGQHkvzEK0aeIhpGJXWCQVMXk,2283
+atex/provision/testingfarm/__init__.py,sha256=l4T4VOUQWKYEQXPe0OtfJmuW-aGSiSQ2mdOf6fSjpjU,605
+atex/provision/testingfarm/api.py,sha256=S-9m1D1CaG-1gEgh7oT1RkXPv2sfUw7Od7bW-Wv0uJQ,19262
+atex/provision/testingfarm/foo.py,sha256=WfGpn_saQb5x9Svx-gfViyXPVRF_u-gUjagUwLBClM0,8
+atex/util/__init__.py,sha256=PWU0STjLcQfe2pPaWKygRXQAudy8CNFdbnTGQ488mHs,1550
+atex/util/dedent.py,sha256=SEuJMtLzqz3dQ7g7qyZzEJ9VYynVlk52tQCJY-FveXo,603
+atex/util/log.py,sha256=oqJGXgHZkTgXVbD2-gzA2pqV3L8w0r_czYWIPfVz398,1776
+atex/util/subprocess.py,sha256=IQT9QHe2kMaaO_XPSry-DwObYstGsq6_QdwdbhYDjko,1826
+atex-0.7.dist-info/METADATA,sha256=VvPhdyVKdg_-kmR0y1WkClrYxw24yjoee3jGzkj6--g,5076
+atex-0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+atex-0.7.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
+atex-0.7.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
+atex-0.7.dist-info/RECORD,,

atex/minitmt/report.py

@@ -1,174 +0,0 @@
-import os
-import csv
-import gzip
-import ctypes
-import ctypes.util
-import contextlib
-from pathlib import Path
-
-from .. import util
-
-
-libc = ctypes.CDLL(ctypes.util.find_library('c'))
-
-# int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags)
-libc.linkat.argtypes = (
-    ctypes.c_int,
-    ctypes.c_char_p,
-    ctypes.c_int,
-    ctypes.c_char_p,
-    ctypes.c_int,
-)
-libc.linkat.restype = ctypes.c_int
-
-# fcntl.h:#define AT_EMPTY_PATH                0x1000  /* Allow empty relative pathname */
-AT_EMPTY_PATH = 0x1000
-
-# fcntl.h:#define AT_FDCWD             -100    /* Special value used to indicate
-AT_FDCWD = -100
-
-
-def linkat(*args):
-    if (ret := libc.linkat(*args)) == -1:
-        errno = ctypes.get_errno()
-        raise OSError(errno, os.strerror(errno))
-    return ret
-
-
-class CSVReporter(util.LockableClass):
-    """
-    Stores reported results as a GZIP-ed CSV and files (logs) under a related
-    directory.
-
-        with CSVReporter('file/storage/dir', 'results.csv.gz') as reporter:
-            sub = reporter.make_subreporter('rhel-9', 'x86_64')
-            sub({'name': '/some/test', 'status': 'pass'})
-            sub({'name': '/another/test', 'status': 'pass'})
-            ...
-            sub = reporter.make_subreporter('rhel-9', 'ppc64le')
-            ...
-            sock = accept_unix_connection()
-            reporter.store_file('/some/test', 'debug.log', sock, 1234)
-    """
-    class _ExcelWithUnixNewline(csv.excel):
-        lineterminator = '\n'
-
-    def __init__(self, storage_dir, results_file):
-        super().__init__()
-        self.storage_dir = Path(storage_dir)
-        if self.storage_dir.exists():
-            raise FileExistsError(f"{storage_dir} already exists")
-        self.results_file = Path(results_file)
-        if self.results_file.exists():
-            raise FileExistsError(f"{self.results_file} already exists")
-        self.storage_dir.mkdir()
-        self.csv_writer = None
-        self.results_gzip_handle = None
-
-    def __enter__(self):
-        f = gzip.open(self.results_file, 'wt', newline='')
-        try:
-            self.csv_writer = csv.writer(f, dialect=self._ExcelWithUnixNewline)
-        except:
-            f.close()
-            raise
-        self.results_gzip_handle = f
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.results_gzip_handle.close()
-        self.results_gzip_handle = None
-        self.csv_writer = None
-
-    def report(self, distro, arch, status, name, note, *files):
-        """
-        Persistently write out details of a test result.
-        """
-        with self.lock:
-            self.csv_writer.writerow((distro, arch, status, name, note, *files))
-
-    @staticmethod
-    def _normalize_path(path):
-        # the magic here is to treat any dangerous path as starting at /
-        # and resolve any weird constructs relative to /, and then simply
-        # strip off the leading / and use it as a relative path
-        path = path.lstrip('/')
-        path = os.path.normpath(f'/{path}')
-        return path[1:]
-
-    def make_subreporter(self, distro, arch):
-        """
-        Return a preconfigured reporter instance, suitable for use
-        by an Executor.
-        """
-        def reporter(result_line):
-            if 'files' in result_line:
-                files = (self._normalize_path(x['name']) for x in result_line['files'])
-            else:
-                files = ()
-            self.report(
-                distro, arch, result_line['status'], result_line['name'],
-                result_line.get('note', ''), *files,
-            )
-        return reporter
-
-    def _files_dir(self, result_name):
-        dir_path = self.storage_dir / result_name.lstrip('/')
-        dir_path.mkdir(parents=True, exist_ok=True)
-        return dir_path
-
-    def _files_file(self, result_name, file_name):
-        file_name = self._normalize_path(file_name)
-        return self._files_dir(result_name) / file_name
-
-    @contextlib.contextmanager
-    def open_tmpfile(self, open_mode=os.O_WRONLY):
-        flags = open_mode | os.O_TMPFILE
-        fd = os.open(self.storage_dir, flags, 0o644)
-        try:
-            yield fd
-        finally:
-            os.close(fd)
-#    def open_tmpfile(self, result_name, open_mode=os.O_WRONLY):
-#        """
-#        Open an anonymous (name-less) file for writing, in a directory relevant
-#        to 'result_name' and yield its file descriptor (int) as context, closing
-#        it when the context is exited.
-#        """
-#        flags = open_mode | os.O_TMPFILE
-#        fd = os.open(self._files_dir(result_name), flags, 0o644)
-#        try:
-#            yield fd
-#        finally:
-#            os.close(fd)
-
-    def link_tmpfile_to(self, result_name, file_name, fd):
-        """
-        Store a file named 'file_name' in a directory relevant to 'result_name'
-        whose 'fd' (a file descriptor) was created by open_tmpfile().
-
-        This function can be called multiple times with the same 'fd', and
-        does not close or otherwise alter the descriptor.
-        """
-        final_path = self._files_file(result_name, file_name)
-        linkat(fd, b'', AT_FDCWD, bytes(final_path), AT_EMPTY_PATH)
-
-    def store_file(self, result_name, file_name, in_fd, count):
-        """
-        Read 'count' bytes of binary data from an OS file descriptor 'in_fd'
-        and store them under 'result_name' as a file (or relative path)
-        named 'file_name', creating it.
-        """
-        final_path = self._files_file(result_name, file_name)
-        # be as efficient as possible, let the kernel handle big data
-        out_fd = None
-        try:
-            out_fd = os.open(final_path, os.O_WRONLY | os.O_CREAT)
-            while count > 0:
-                written = os.sendfile(out_fd, in_fd, None, count)
-                if written == 0:
-                    raise RuntimeError(f"got unexpected EOF when receiving {final_path}")
-                count -= written
-        finally:
-            if out_fd:
-                os.close(out_fd)

atex/minitmt/testme.py

@@ -1,3 +0,0 @@
-from ..util import debug
-
-debug("foo")

atex/ssh.py

@@ -1,320 +0,0 @@
-import os
-import time
-import tempfile
-import subprocess
-from pathlib import Path
-
-from . import util
-
-DEFAULT_OPTIONS = {
-    'LogLevel': 'ERROR',
-    'StrictHostKeyChecking': 'no',
-    'UserKnownHostsFile': '/dev/null',
-    'ConnectionAttempts': '3',
-    'ServerAliveCountMax': '4',
-    'ServerAliveInterval': '5',
-    'TCPKeepAlive': 'no',
-    'EscapeChar': 'none',
-    'ExitOnForwardFailure': 'yes',
-#     'RequestTTY': 'force',
-}
-
-
-def _shell_cmd(args, sudo=None):
-    """
-    Make a command line for running 'args' on the target system.
-    """
-    if sudo:
-        cmd = ('exec', 'sudo', '--no-update', '--non-interactive', '--user', sudo, '--', *args)
-    else:
-        cmd = ('exec', '--', *args)
-    return ' '.join(cmd)
-
-
-def _options_to_cli(options):
-    """
-    Assemble an ssh(1) or sshpass(1) command line with -o options.
-    """
-    list_opts = []
-    for key, value in options.items():
-        if isinstance(value, str):
-            list_opts.append(f'-o{key}={value}')
-        else:
-            if len(value) == 0:
-                raise ValueError(f"key {key} has an empty iterable value")
-            list_opts += (f'-o{key}={v}' for v in value)
-    return list_opts
-
-
-def _options_to_ssh(options, password=None, extra_cli_flags=()):
-    """
-    Assemble an ssh(1) or sshpass(1) command line with -o options.
-    """
-    cli_opts = _options_to_cli(options)
-    if password:
-        return (
-            'sshpass', '-p', password,
-            'ssh', *extra_cli_flags, '-oBatchMode=no', *cli_opts,
-            'ignored_arg',
-        )
-    else:
-        # let cli_opts override BatchMode if specified
-        return ('ssh', *extra_cli_flags, *cli_opts, '-oBatchMode=yes', 'ignored_arg')
-
-
-# return a string usable for rsync -e
-def _options_to_rsync_e(options, password=None):
-    """
-    Return a string usable for the rsync -e argument.
-    """
-    cli_opts = _options_to_cli(options)
-    batch_mode = '-oBatchMode=no' if password else '-oBatchMode=yes'
-    return ' '.join(('ssh', *cli_opts, batch_mode))  # no ignored_arg inside -e
-
-
-def _rsync_host_cmd(*args, options, password=None, sudo=None):
-    """
-    Assemble a rsync command line, noting that
-      - 'sshpass' must be before 'rsync', not inside the '-e' argument
-      - 'ignored_arg' must be passed by user as destination, not inside '-e'
-      - 'sudo' is part of '--rsync-path', yet another argument
-    """
-    return (
-        *(('sshpass', '-p', password) if password else ()),
-        'rsync',
-        '-e', _options_to_rsync_e(options, password=password),
-        '--rsync-path', _shell_cmd(('rsync',), sudo=sudo),
-        *args,
-    )
-
-
-class SSHConn:
-    r"""
-    Represents a persistent SSH connection to a host (ControlMaster).
-
-    When instantiated, it attempts to connect to the specified host, with any
-    subsequent instance method calls using that connection, or raising
-    ConnectionResetError when it is lost.
-
-    The ssh(1) command is parametrized purely and solely via ssh_config(5)
-    options, including 'Hostname', 'User', 'Port', etc.
-    Pass any overrides or missing options as 'options' (dict).
-
-        options = {
-            'Hostname': '1.2.3.4',
-            'User': 'testuser',
-            'IdentityFile': '/home/testuser/.ssh/id_rsa',
-        }
-
-        # with a persistent ControlMaster
-        conn = SSHConn(options)
-        conn.connect()
-        output = conn.run('ls /')
-        #proc = conn.Popen('ls /')  # non-blocking
-        conn.disconnect()
-
-        # or as try/except/finally
-        conn = SSHConn(options)
-        try:
-            conn.connect()
-            ...
-        finally:
-            conn.disconnect()
-
-        # or via Context Manager
-        with SSHConn(options) as conn:
-            ...
-    """
-
-    def __init__(self, options, *, password=None):
-        """
-        Connect to an SSH server specified in 'options'.
-
-		If 'password' is given, spawn the ssh(1) command via 'sshpass' and
-		pass the password to it.
-
-		If 'sudo' specifies a username, call sudo(8) on the remote shell
-		to run under a different user on the remote host.
-        """
-        self.options = DEFAULT_OPTIONS.copy()
-        self.options.update(options)
-        self.password = password
-        self.tmpdir = None
-        self.proc_master = None
-
-    def _assert_master(self):
-        proc = self.master_proc
-        if not proc:
-            raise RuntimeError("SSH ControlMaster is not running")
-        # we need to consume any potential proc output for the process to
-        # actually terminate (stop being a zombie) if it crashes
-        proc = self.master_proc
-        out = proc.stdout.read()
-        code = proc.poll()
-        if code is not None:
-            self.master_proc = None
-            raise RuntimeError(f"SSH ControlMaster on {self.tmpdir} exited with {code}:\n{out}")
-
-    def disconnect(self):
-        proc = self.master_proc
-        if not proc:
-            return
-        proc.terminate()
-        # don't zombie forever, return EPIPE on any attempts to write to us
-        proc.stdout.close()
-        proc.wait()
-        self.master_proc = None
-
-    def connect(self):
-        if self.proc_master:
-            raise FileExistsError(f"SSH ControlMaster process already running on {self.tmpdir}")
-
-        if not self.tmpdir:
-            self.tmpdir_handle = tempfile.TemporaryDirectory(prefix='atex-ssh-')
-            self.tmpdir = Path(self.tmpdir_handle.name)
-
-        options = self.options.copy()
-        options['SessionType'] = 'none'
-        options['ControlMaster'] = 'yes'
-        sock = self.tmpdir / 'control.sock'
-        options['ControlPath'] = sock
-
-        # TODO: shouldn't password be handled here and passed to _options_to_ssh
-        #       rather than for member .ssh() ?
-
-        proc = util.subprocess_Popen(
-            _options_to_ssh(options),
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            cwd=str(self.tmpdir),
-        )
-        os.set_blocking(proc.stdout.fileno(), False)
-
-        # wait for the master to either create the socket (indicating valid
-        # connection) or give up and exit
-        while proc.poll() is None:
-            if sock.exists():
-                break
-            time.sleep(0.1)
-        else:
-            code = proc.poll()
-            out = proc.stdout.read()
-            raise FileNotFoundError(
-                f"SSH ControlMaster failed to start on {self.tmpdir} with {code}:\n{out}",
-            )
-
-        self.master_proc = proc
-
-    def add_local_forward(self, *spec):
-        """
-        Add (one or more) ssh forwarding specifications as 'spec' to an
-        already-connected instance. Each specification has to follow the
-        format of ssh client's LocalForward option (see ssh_config(5)).
-        """
-        self._assert_master()
-        options = self.options.copy()
-        options['LocalForward'] = spec
-        options['ControlPath'] = self.tmpdir / 'control.sock'
-        util.subprocess_run(
-            _options_to_ssh(options, extra_cli_flags=('-O', 'forward')),
-            skip_frames=1,
-            check=True,
-        )
-
-    def add_remote_forward(self, *spec):
-        """
-        Add (one or more) ssh forwarding specifications as 'spec' to an
-        already-connected instance. Each specification has to follow the
-        format of ssh client's RemoteForward option (see ssh_config(5)).
-        """
-        self._assert_master()
-        options = self.options.copy()
-        options['RemoteForward'] = spec
-        options['ControlPath'] = self.tmpdir / 'control.sock'
-        util.subprocess_run(
-            _options_to_ssh(options, extra_cli_flags=('-O', 'forward')),
-            skip_frames=1,
-            check=True,
-        )
-
-    def __enter__(self):
-        self.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.disconnect()
-
-    def ssh(
-        self, cmd, *args, options=None, sudo=None, text=True,
-        func=util.subprocess_run, **run_kwargs,
-    ):
-        self._assert_master()
-        unified_options = self.options.copy()
-        if options:
-            unified_options.update(options)
-        unified_options['RemoteCommand'] = _shell_cmd((cmd, *args), sudo=sudo)
-        unified_options['ControlPath'] = self.tmpdir / 'control.sock'
-        return func(
-            _options_to_ssh(unified_options, password=self.password),
-            skip_frames=1,
-            text=text,
-            **run_kwargs,
-        )
-
-    def rsync(
-        self, *args, options=None, sudo=None,
-        func=util.subprocess_run, **run_kwargs,
-    ):
-        self._assert_master()
-        unified_options = self.options.copy()
-        if options:
-            unified_options.update(options)
-        unified_options['ControlPath'] = self.tmpdir / 'control.sock'
-        return func(
-            _rsync_host_cmd(*args, options=unified_options, password=self.password, sudo=sudo),
-            skip_frames=1,
-            text=True,
-            stdin=subprocess.DEVNULL,
-            **run_kwargs,
-        )
-
-
-# have options as kwarg to be compatible with other functions here
-def ssh(
-    cmd, *args, options, password=None, sudo=None, text=True,
-    func=util.subprocess_run, **run_kwargs,
-):
-    """
-	Execute ssh(1) with the given options.
-
-    On the remote system, run 'cmd' in a shell.
-
-    If 'password' is given, spawn the ssh(1) command via 'sshpass' and
-    pass the password to it.
-
-    If 'sudo' specifies a username, call sudo(8) on the remote shell
-    to run under a different user on the remote host.
-    """
-    unified_options = DEFAULT_OPTIONS.copy()
-    unified_options['RemoteCommand'] = _shell_cmd((cmd, *args), sudo=sudo)
-    unified_options.update(options)
-    return func(
-        _options_to_ssh(unified_options, password=password),
-        skip_frames=1,
-        text=text,
-        **run_kwargs,
-    )
-
-
-def rsync(
-    *args, options, password=None, sudo=None,
-    func=util.subprocess_run, **run_kwargs,
-):
-    return func(
-        _rsync_host_cmd(*args, options=options, password=password, sudo=sudo),
-        skip_frames=1,
-        text=True,
-        stdin=subprocess.DEVNULL,
-        **run_kwargs,
-    )

atex/util/lockable_class.py

@@ -1,38 +0,0 @@
-import threading
-
-
-class LockableClass:
-    """
-    A class with (nearly) all attribute accesses protected by threading.RLock,
-    making them thread-safe at the cost of some speed.
-
-        class MyClass(LockableClass):
-            def writer(self):
-                self.attr = 222     # thread-safe instance access
-            def reader(self):
-                print(self.attr)    # thread-safe instance access
-            def complex(self):
-                with self.lock:     # thread-safe context
-                    self.attr += 1
-
-    Here, 'lock' is a reserved attribute name and must not be overriden
-    by a derived class.
-
-    If overriding '__init__', make sure to call 'super().__init__()' *before*
-    any attribute accesses in your '__init__'.
-    """
-    def __init__(self):
-        object.__setattr__(self, 'lock', threading.RLock())
-
-    def __getattribute__(self, name):
-        # optimize built-ins
-        if name.startswith('__') or name == 'lock':
-            return object.__getattribute__(self, name)
-        lock = object.__getattribute__(self, 'lock')
-        with lock:
-            return object.__getattribute__(self, name)
-
-    def __setattr__(self, name, value):
-        lock = object.__getattribute__(self, 'lock')
-        with lock:
-            object.__setattr__(self, name, value)

atex-0.5.dist-info/RECORD

@@ -1,26 +0,0 @@
-atex/__init__.py,sha256=YyU5HzPiApngH_ZS7d5MhqpPvNgFXi7FpXWnkdhtQ1A,859
-atex/orchestrator.py,sha256=SqP07lsjBImdGN4E5jd816nvcHQxd0b0SMnJDy7KkLA,1083
-atex/ssh.py,sha256=CXLkqrZ1lByI7CRGAZAYS0ye0pUj8_5x2OOnYH4iyAU,10188
-atex/testingfarm.py,sha256=4ZXB9YPMFX_pO1yNVIbZX5elUTFSwFJnYHr4v35WBTU,18557
-atex/cli/__init__.py,sha256=hahfD6XqsS4GwvJ1Ou_WpEtR4xcC5IUq-rG11xGhLDU,2406
-atex/cli/minitmt.py,sha256=aLJhqwAA4BKgf2nTJUX-iK0ECQSNBSvYSTSlDqPu7qQ,2403
-atex/cli/testingfarm.py,sha256=xMV-J3IodqDFFiQehiTn_Skn6vcYkuy0krLHdByZ7C8,6683
-atex/minitmt/__init__.py,sha256=MasgXrgBBIyNT0tL-yI2jyKfPII_ektTDbT0Fh9lybI,4210
-atex/minitmt/fmf.py,sha256=HEpjCVyPeX7ImebL0u5d2wETYLCnLcz41FtGJXigCrU,6252
-atex/minitmt/report.py,sha256=AyZG5yDBhe8ajAjpwJhdms4f-CeFbXO6L9sibN65-wU,6036
-atex/minitmt/scripts.py,sha256=41DmyAwId5OAiP9g1VjslNaJ6iz2bCXaqBrHS3uZN7g,1620
-atex/minitmt/testme.py,sha256=aVh9Kjjenr8Q52x3nOhBFx6bGnxpM-amoVw-2JGvZVo,39
-atex/provision/__init__.py,sha256=2haBx9lPk0FHpYxykzfSwKkFLsaAcBjRCLoJE82hpT8,4029
-atex/provision/libvirt/VM_PROVISION,sha256=1OwGC8fEA74RaCC2yyWSnnML-QXlB_cPzhTxjsXofsQ,2469
-atex/provision/libvirt/__init__.py,sha256=IjcmbqD6SF_wP1LUISlwqw6mZ2opXEOfckXO_oCtsgc,787
-atex/provision/libvirt/setup-libvirt.sh,sha256=CXrEFdrj8CSHXQZCd2RWuRvTmw7QYFTVhZeLuhhXooI,1855
-atex/util/__init__.py,sha256=mejFs_IHvKqnuOA5xt60CWzX6fJ4VVx8T1kl1zuv5Vg,1550
-atex/util/dedent.py,sha256=uJYXKsEQECbJ58eqZFI5Bzlld0lD-C15NUcqRnvrLa4,603
-atex/util/lockable_class.py,sha256=hPuiPaUBUD-9bKLzaYYOrQ6JwLjk2zCzCkW8nm6SKpQ,1317
-atex/util/log.py,sha256=tQp4JZY1B4bca5CciscV4Q5ZsyKS2niOQb9_Vco_QOA,1776
-atex/util/subprocess.py,sha256=IWrwke4JylL6-jQoNMXnzKG4MVxbc9m6Q4wJVy4EBCM,1700
-atex-0.5.dist-info/METADATA,sha256=T1m2AdN1nkUMk3OKkdXEJ94V4xftTiJvMlUovPNzDi0,5076
-atex-0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-atex-0.5.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
-atex-0.5.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
-atex-0.5.dist-info/RECORD,,