maqet 0.0.1.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

qemu/qmp/util.py

@@ -1,219 +0,0 @@
-"""
-Miscellaneous Utilities
-
-This module provides asyncio utilities and compatibility wrappers for
-Python 3.6 to provide some features that otherwise become available in
-Python 3.7+.
-
-Various logging and debugging utilities are also provided, such as
-`exception_summary()` and `pretty_traceback()`, used primarily for
-adding information into the logging stream.
-"""
-
-import asyncio
-import sys
-import traceback
-from typing import (
-    Any,
-    Coroutine,
-    Optional,
-    TypeVar,
-    cast,
-)
-
-
-T = TypeVar('T')
-
-
-# --------------------------
-# Section: Utility Functions
-# --------------------------
-
-
-async def flush(writer: asyncio.StreamWriter) -> None:
-    """
-    Utility function to ensure a StreamWriter is *fully* drained.
-
-    `asyncio.StreamWriter.drain` only promises we will return to below
-    the "high-water mark". This function ensures we flush the entire
-    buffer -- by setting the high water mark to 0 and then calling
-    drain. The flow control limits are restored after the call is
-    completed.
-    """
-    transport = cast(  # type: ignore[redundant-cast]
-        asyncio.WriteTransport, writer.transport
-    )
-
-    # https://github.com/python/typeshed/issues/5779
-    low, high = transport.get_write_buffer_limits()  # type: ignore
-    transport.set_write_buffer_limits(0, 0)
-    try:
-        await writer.drain()
-    finally:
-        transport.set_write_buffer_limits(high, low)
-
-
-def upper_half(func: T) -> T:
-    """
-    Do-nothing decorator that annotates a method as an "upper-half" method.
-
-    These methods must not call bottom-half functions directly, but can
-    schedule them to run.
-    """
-    return func
-
-
-def bottom_half(func: T) -> T:
-    """
-    Do-nothing decorator that annotates a method as a "bottom-half" method.
-
-    These methods must take great care to handle their own exceptions whenever
-    possible. If they go unhandled, they will cause termination of the loop.
-
-    These methods do not, in general, have the ability to directly
-    report information to a caller’s context and will usually be
-    collected as a Task result instead.
-
-    They must not call upper-half functions directly.
-    """
-    return func
-
-
-# -------------------------------
-# Section: Compatibility Wrappers
-# -------------------------------
-
-
-def create_task(coro: Coroutine[Any, Any, T],
-                loop: Optional[asyncio.AbstractEventLoop] = None
-                ) -> 'asyncio.Future[T]':
-    """
-    Python 3.6-compatible `asyncio.create_task` wrapper.
-
-    :param coro: The coroutine to execute in a task.
-    :param loop: Optionally, the loop to create the task in.
-
-    :return: An `asyncio.Future` object.
-    """
-    if sys.version_info >= (3, 7):
-        if loop is not None:
-            return loop.create_task(coro)
-        return asyncio.create_task(coro)  # pylint: disable=no-member
-
-    # Python 3.6:
-    return asyncio.ensure_future(coro, loop=loop)
-
-
-def is_closing(writer: asyncio.StreamWriter) -> bool:
-    """
-    Python 3.6-compatible `asyncio.StreamWriter.is_closing` wrapper.
-
-    :param writer: The `asyncio.StreamWriter` object.
-    :return: `True` if the writer is closing, or closed.
-    """
-    if sys.version_info >= (3, 7):
-        return writer.is_closing()
-
-    # Python 3.6:
-    transport = writer.transport
-    assert isinstance(transport, asyncio.WriteTransport)
-    return transport.is_closing()
-
-
-async def wait_closed(writer: asyncio.StreamWriter) -> None:
-    """
-    Python 3.6-compatible `asyncio.StreamWriter.wait_closed` wrapper.
-
-    :param writer: The `asyncio.StreamWriter` to wait on.
-    """
-    if sys.version_info >= (3, 7):
-        await writer.wait_closed()
-        return
-
-    # Python 3.6
-    transport = writer.transport
-    assert isinstance(transport, asyncio.WriteTransport)
-
-    while not transport.is_closing():
-        await asyncio.sleep(0)
-
-    # This is an ugly workaround, but it's the best I can come up with.
-    sock = transport.get_extra_info('socket')
-
-    if sock is None:
-        # Our transport doesn't have a socket? ...
-        # Nothing we can reasonably do.
-        return
-
-    while sock.fileno() != -1:
-        await asyncio.sleep(0)
-
-
-def asyncio_run(coro: Coroutine[Any, Any, T], *, debug: bool = False) -> T:
-    """
-    Python 3.6-compatible `asyncio.run` wrapper.
-
-    :param coro: A coroutine to execute now.
-    :return: The return value from the coroutine.
-    """
-    if sys.version_info >= (3, 7):
-        return asyncio.run(coro, debug=debug)
-
-    # Python 3.6
-    loop = asyncio.get_event_loop()
-    loop.set_debug(debug)
-    ret = loop.run_until_complete(coro)
-    loop.close()
-
-    return ret
-
-
-# ----------------------------
-# Section: Logging & Debugging
-# ----------------------------
-
-
-def exception_summary(exc: BaseException) -> str:
-    """
-    Return a summary string of an arbitrary exception.
-
-    It will be of the form "ExceptionType: Error Message", if the error
-    string is non-empty, and just "ExceptionType" otherwise.
-    """
-    name = type(exc).__qualname__
-    smod = type(exc).__module__
-    if smod not in ("__main__", "builtins"):
-        name = smod + '.' + name
-
-    error = str(exc)
-    if error:
-        return f"{name}: {error}"
-    return name
-
-
-def pretty_traceback(prefix: str = "  | ") -> str:
-    """
-    Formats the current traceback, indented to provide visual distinction.
-
-    This is useful for printing a traceback within a traceback for
-    debugging purposes when encapsulating errors to deliver them up the
-    stack; when those errors are printed, this helps provide a nice
-    visual grouping to quickly identify the parts of the error that
-    belong to the inner exception.
-
-    :param prefix: The prefix to append to each line of the traceback.
-    :return: A string, formatted something like the following::
-
-      | Traceback (most recent call last):
-      |   File "foobar.py", line 42, in arbitrary_example
-      |     foo.baz()
-      | ArbitraryError: [Errno 42] Something bad happened!
-    """
-    output = "".join(traceback.format_exception(*sys.exc_info()))
-
-    exc_lines = []
-    for line in output.split('\n'):
-        exc_lines.append(prefix + line)
-
-    # The last line is always empty, omit it
-    return "\n".join(exc_lines[:-1])

qemu/utils/__init__.py

@@ -1,162 +0,0 @@
-"""
-QEMU development and testing utilities
-
-This package provides a small handful of utilities for performing
-various tasks not directly related to the launching of a VM.
-"""
-
-# Copyright (C) 2021 Red Hat Inc.
-#
-# Authors:
-#  John Snow <jsnow@redhat.com>
-#  Cleber Rosa <crosa@redhat.com>
-#
-# This work is licensed under the terms of the GNU GPL, version 2.  See
-# the COPYING file in the top-level directory.
-#
-
-import os
-import re
-import shutil
-from subprocess import CalledProcessError
-import textwrap
-from typing import Optional
-
-# pylint: disable=import-error
-from .accel import kvm_available, list_accel, tcg_available
-
-
-__all__ = (
-    'VerboseProcessError',
-    'add_visual_margin',
-    'get_info_usernet_hostfwd_port',
-    'kvm_available',
-    'list_accel',
-    'tcg_available',
-)
-
-
-def get_info_usernet_hostfwd_port(info_usernet_output: str) -> Optional[int]:
-    """
-    Returns the port given to the hostfwd parameter via info usernet
-
-    :param info_usernet_output: output generated by hmp command "info usernet"
-    :return: the port number allocated by the hostfwd option
-    """
-    for line in info_usernet_output.split('\r\n'):
-        regex = r'TCP.HOST_FORWARD.*127\.0\.0\.1\s+(\d+)\s+10\.'
-        match = re.search(regex, line)
-        if match is not None:
-            return int(match[1])
-    return None
-
-
-# pylint: disable=too-many-arguments
-def add_visual_margin(
-        content: str = '',
-        width: Optional[int] = None,
-        name: Optional[str] = None,
-        padding: int = 1,
-        upper_left: str = '┏',
-        lower_left: str = '┗',
-        horizontal: str = '━',
-        vertical: str = '┃',
-) -> str:
-    """
-    Decorate and wrap some text with a visual decoration around it.
-
-    This function assumes that the text decoration characters are single
-    characters that display using a single monospace column.
-
-    ┏━ Example ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    ┃ This is what this function looks like with text content that's
-    ┃ wrapped to 66 characters. The right-hand margin is left open to
-    ┃ accommodate the occasional unicode character that might make
-    ┃ predicting the total "visual" width of a line difficult. This
-    ┃ provides a visual distinction that's good-enough, though.
-    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    :param content: The text to wrap and decorate.
-    :param width:
-        The number of columns to use, including for the decoration
-        itself. The default (None) uses the available width of the
-        current terminal, or a fallback of 72 lines. A negative number
-        subtracts a fixed-width from the default size. The default obeys
-        the COLUMNS environment variable, if set.
-    :param name: A label to apply to the upper-left of the box.
-    :param padding: How many columns of padding to apply inside.
-    :param upper_left: Upper-left single-width text decoration character.
-    :param lower_left: Lower-left single-width text decoration character.
-    :param horizontal: Horizontal single-width text decoration character.
-    :param vertical: Vertical single-width text decoration character.
-    """
-    if width is None or width < 0:
-        avail = shutil.get_terminal_size(fallback=(72, 24))[0]
-        if width is None:
-            _width = avail
-        else:
-            _width = avail + width
-    else:
-        _width = width
-
-    prefix = vertical + (' ' * padding)
-
-    def _bar(name: Optional[str], top: bool = True) -> str:
-        ret = upper_left if top else lower_left
-        if name is not None:
-            ret += f"{horizontal} {name} "
-
-        filler_len = _width - len(ret)
-        ret += f"{horizontal * filler_len}"
-        return ret
-
-    def _wrap(line: str) -> str:
-        return os.linesep.join(
-            textwrap.wrap(
-                line, width=_width - padding, initial_indent=prefix,
-                subsequent_indent=prefix, replace_whitespace=False,
-                drop_whitespace=True, break_on_hyphens=False)
-        )
-
-    return os.linesep.join((
-        _bar(name, top=True),
-        os.linesep.join(_wrap(line) for line in content.splitlines()),
-        _bar(None, top=False),
-    ))
-
-
-class VerboseProcessError(CalledProcessError):
-    """
-    The same as CalledProcessError, but more verbose.
-
-    This is useful for debugging failed calls during test executions.
-    The return code, signal (if any), and terminal output will be displayed
-    on unhandled exceptions.
-    """
-    def summary(self) -> str:
-        """Return the normal CalledProcessError str() output."""
-        return super().__str__()
-
-    def __str__(self) -> str:
-        lmargin = '  '
-        width = -len(lmargin)
-        sections = []
-
-        # Does self.stdout contain both stdout and stderr?
-        has_combined_output = self.stderr is None
-
-        name = 'output' if has_combined_output else 'stdout'
-        if self.stdout:
-            sections.append(add_visual_margin(self.stdout, width, name))
-        else:
-            sections.append(f"{name}: N/A")
-
-        if self.stderr:
-            sections.append(add_visual_margin(self.stderr, width, 'stderr'))
-        elif not has_combined_output:
-            sections.append("stderr: N/A")
-
-        return os.linesep.join((
-            self.summary(),
-            textwrap.indent(os.linesep.join(sections), prefix=lmargin),
-        ))

qemu/utils/accel.py

@@ -1,84 +0,0 @@
-"""
-QEMU accel module:
-
-This module provides utilities for discover and check the availability of
-accelerators.
-"""
-# Copyright (C) 2015-2016 Red Hat Inc.
-# Copyright (C) 2012 IBM Corp.
-#
-# Authors:
-#  Fam Zheng <famz@redhat.com>
-#
-# This work is licensed under the terms of the GNU GPL, version 2.  See
-# the COPYING file in the top-level directory.
-#
-
-import logging
-import os
-import subprocess
-from typing import List, Optional
-
-
-LOG = logging.getLogger(__name__)
-
-# Mapping host architecture to any additional architectures it can
-# support which often includes its 32 bit cousin.
-ADDITIONAL_ARCHES = {
-    "x86_64": "i386",
-    "aarch64": "armhf",
-    "ppc64le": "ppc64",
-}
-
-
-def list_accel(qemu_bin: str) -> List[str]:
-    """
-    List accelerators enabled in the QEMU binary.
-
-    @param qemu_bin (str): path to the QEMU binary.
-    @raise Exception: if failed to run ``qemu -accel help``
-    @return a list of accelerator names.
-    """
-    if not qemu_bin:
-        return []
-    try:
-        out = subprocess.check_output([qemu_bin, '-accel', 'help'],
-                                      universal_newlines=True)
-    except:
-        LOG.debug("Failed to get the list of accelerators in %s", qemu_bin)
-        raise
-    # Skip the first line which is the header.
-    return [acc.strip() for acc in out.splitlines()[1:]]
-
-
-def kvm_available(target_arch: Optional[str] = None,
-                  qemu_bin: Optional[str] = None) -> bool:
-    """
-    Check if KVM is available using the following heuristic:
-      - Kernel module is present in the host;
-      - Target and host arches don't mismatch;
-      - KVM is enabled in the QEMU binary.
-
-    @param target_arch (str): target architecture
-    @param qemu_bin (str): path to the QEMU binary
-    @return True if kvm is available, otherwise False.
-    """
-    if not os.access("/dev/kvm", os.R_OK | os.W_OK):
-        return False
-    if target_arch:
-        host_arch = os.uname()[4]
-        if target_arch != host_arch:
-            if target_arch != ADDITIONAL_ARCHES.get(host_arch):
-                return False
-    if qemu_bin and "kvm" not in list_accel(qemu_bin):
-        return False
-    return True
-
-
-def tcg_available(qemu_bin: str) -> bool:
-    """
-    Check if TCG is available.
-
-    @param qemu_bin (str): path to the QEMU binary
-    """
-    return 'tcg' in list_accel(qemu_bin)