Ejemplo n.º 1
0
    def get_terminal_size(self):
        fallback = (80, 24)
        try:
            from shutil import get_terminal_size
        except ImportError:
            try:
                import termios
                import fcntl
                import struct
                fd = self.stdout.fileno()
                call = fcntl.ioctl(fd, termios.TIOCGWINSZ, "\x00" * 8)
                height, width = struct.unpack("hhhh", call)[:2]
            except (SystemExit, KeyboardInterrupt):
                raise
            except:
                width = int(os.environ.get('COLUMNS', fallback[0]))
                height = int(os.environ.get('COLUMNS', fallback[1]))
            # Work around above returning width, height = 0, 0 in Emacs
            width = width if width != 0 else fallback[0]
            height = height if height != 0 else fallback[1]
            return width, height
        else:
            # We are not going to care about the os environment variable
            # of LINES and COLUMNS because it refers to the wrong tty
            try:
                size = os.get_terminal_size(self.stdout.fileno())
            except (AttributeError, ValueError, OSError):
                # stdout is None, closed, detached, or not a terminal, or
                # os.get_terminal_size() is unsupported
                size = os.terminal_size(fallback)
            columns = size.columns
            lines = size.lines

            return os.terminal_size((columns, lines))
Ejemplo n.º 2
0
def get_size():
    """
    Returns the terminal size.

    Like `shutil.get_terminal_size()`, but works better.  Honors the COLUMNS and
    LINES environment variables, if set.  Otherwise, uses `_determine_size()`.
    """
    try:
        columns = int(os.environ['COLUMNS'])
    except (KeyError, ValueError):
        columns = 0

    try:
        lines = int(os.environ['LINES'])
    except (KeyError, ValueError):
        lines = 0

    if columns <= 0 or lines <= 0:
        try:
            size = _determine_size()
        except (NameError, OSError):
            size = os.terminal_size(fallback)
        if columns <= 0:
            columns = size.columns
        if lines <= 0:
            lines = size.lines

    return os.terminal_size((columns, lines))
Ejemplo n.º 3
0
def get_size():
    """
    Returns the terminal size.

    Like `shutil.get_terminal_size()`, but works better.  Honors the COLUMNS and
    LINES environment variables, if set.  Otherwise, uses `_determine_size()`.
    """
    try:
        columns = int(os.environ['COLUMNS'])
    except (KeyError, ValueError):
        columns = 0

    try:
        lines = int(os.environ['LINES'])
    except (KeyError, ValueError):
        lines = 0

    if columns <= 0 or lines <= 0:
        try:
            size = _determine_size()
        except (NameError, OSError):
            size = os.terminal_size(fallback)
        if columns <= 0:
            columns = size.columns
        if lines <= 0:
            lines = size.lines

    return os.terminal_size((columns, lines))
Ejemplo n.º 4
0
def container_exec(cmd, resource_group_name, name, exec_command, container_name=None):
    """Start exec for a container. """

    container_client = cf_container(cmd.cli_ctx)
    container_group_client = cf_container_groups(cmd.cli_ctx)
    container_group = container_group_client.get(resource_group_name, name)

    if container_name or container_name is None and len(container_group.containers) == 1:
        # If only one container in container group, use that container.
        if container_name is None:
            container_name = container_group.containers[0].name

        try:
            terminalsize = os.get_terminal_size()
        except OSError:
            terminalsize = os.terminal_size((80, 24))
        terminal_size = ContainerExecRequestTerminalSize(rows=terminalsize.lines, cols=terminalsize.columns)
        exec_request = ContainerExecRequest(command=exec_command, terminal_size=terminal_size)

        execContainerResponse = container_client.execute_command(resource_group_name, name, container_name, exec_request)

        if platform.system() is WINDOWS_NAME:
            _start_exec_pipe_windows(execContainerResponse.web_socket_uri, execContainerResponse.password)
        else:
            _start_exec_pipe_linux(execContainerResponse.web_socket_uri, execContainerResponse.password)

    else:
        raise CLIError('--container-name required when container group has more than one container.')
Ejemplo n.º 5
0
def get_terminal_size(fallback=(80, 24)):
    """Look up character width of terminal."""

    try:
        return shutil.get_terminal_size(fallback)
    except Exception:  # pragma: no cover
        return os.terminal_size(fallback)
Ejemplo n.º 6
0
def get_terminal_size():
    from shutil import get_terminal_size as t_size
    # get_terminal_size can report 0, 0 if run from pseudo-terminal prior Python 3.11 versions

    columns = t_size().columns or 80
    lines = t_size().lines or 24

    return os.terminal_size((columns, lines))
Ejemplo n.º 7
0
 def test_get_terminal_size_in_pty_defaults_to_80(self) -> None:
     # when run using a pty, `os.get_terminal_size()` returns `0, 0`
     ret = os.terminal_size((0, 0))
     mock_environ = os.environ.copy()
     mock_environ.pop('COLUMNS', None)
     with mock.patch.object(os, 'get_terminal_size', return_value=ret):
         with mock.patch.dict(os.environ, values=mock_environ, clear=True):
             assert get_terminal_width() == 80
Ejemplo n.º 8
0
 def test_get_terminal_size(self, mock_os):
     ts = os.terminal_size((10, 5))
     mock_os.get_terminal_size.return_value = ts
     width = utils.terminal_width(sys.stdout)
     self.assertEqual(10, width)
     mock_os.get_terminal_size.side_effect = OSError()
     width = utils.terminal_width(sys.stdout)
     self.assertIs(None, width)
Ejemplo n.º 9
0
def prepare_for_output(monkeypatch):
    # terminal size affects output display so force a consistent size
    monkeypatch.setattr(
        "shutil.get_terminal_size",
        lambda *args, **kwargs: os.terminal_size((1000, 1000)),
    )
    # raise an exception instead of exiting (or attempting to call func() with missing args)
    monkeypatch.setattr("argparse._sys.exit", raise_an_exception)
Ejemplo n.º 10
0
 def test_get_terminal_size(self, mock_os):
     ts = os.terminal_size((10, 5))
     mock_os.get_terminal_size.return_value = ts
     width = utils.terminal_width(sys.stdout)
     self.assertEqual(10, width)
     mock_os.get_terminal_size.side_effect = OSError()
     width = utils.terminal_width(sys.stdout)
     self.assertIs(None, width)
Ejemplo n.º 11
0
def get_terminal_size_stderr(fallback=(80, 24)):
    """
    Unlike shutil.get_terminal_size, which looks at stdout, this looks at stderr.
    """
    try:
        size = os.get_terminal_size(sys.__stderr__.fileno())
    except (AttributeError, ValueError, OSError):
        size = os.terminal_size(fallback)
    return size
Ejemplo n.º 12
0
def get_terminal_size(fallback=(80, 24)):
    """Get the size of the terminal window.

    For each of the two dimensions, the environment variable, COLUMNS
    and LINES respectively, is checked. If the variable is defined and
    the value is a positive integer, it is used.

    When COLUMNS or LINES is not defined, which is the common case,
    the terminal connected to sys.__stdout__ is queried
    by invoking os.get_terminal_size.

    If the terminal size cannot be successfully queried, either because
    the system doesn't support querying, or because we are not
    connected to a terminal, the value given in fallback parameter
    is used. Fallback defaults to (80, 24) which is the default
    size used by many terminal emulators.

    The value returned is a named tuple of type os.terminal_size.
    """
    # columns, lines are the working values
    try:
        columns = int(os.environ['COLUMNS'])
    except (KeyError, ValueError):
        columns = 0

    try:
        lines = int(os.environ['LINES'])
    except (KeyError, ValueError):
        lines = 0

    # only query if necessary
    if columns <= 0 or lines <= 0:
        try:
            size = os.get_terminal_size(sys.__stdout__.fileno())
        except (AttributeError, ValueError, OSError):
            # stdout is None, closed, detached, or not a terminal, or
            # os.get_terminal_size() is unsupported
            size = os.terminal_size(fallback)
        if columns <= 0:
            columns = size.columns
        if lines <= 0:
            lines = size.lines

    return os.terminal_size((columns, lines))
Ejemplo n.º 13
0
def get_terminal_size(fallback=(80, 24)):
    """Get the size of the terminal window.

    For each of the two dimensions, the environment variable, COLUMNS
    and LINES respectively, is checked. If the variable is defined and
    the value is a positive integer, it is used.

    When COLUMNS or LINES is not defined, which is the common case,
    the terminal connected to sys.__stdout__ is queried
    by invoking os.get_terminal_size.

    If the terminal size cannot be successfully queried, either because
    the system doesn't support querying, or because we are not
    connected to a terminal, the value given in fallback parameter
    is used. Fallback defaults to (80, 24) which is the default
    size used by many terminal emulators.

    The value returned is a named tuple of type os.terminal_size.
    """
    # columns, lines are the working values
    try:
        columns = int(os.environ['COLUMNS'])
    except (KeyError, ValueError):
        columns = 0

    try:
        lines = int(os.environ['LINES'])
    except (KeyError, ValueError):
        lines = 0

    # only query if necessary
    if columns <= 0 or lines <= 0:
        try:
            size = os.get_terminal_size(sys.__stdout__.fileno())
        except (AttributeError, ValueError, OSError):
            # stdout is None, closed, detached, or not a terminal, or
            # os.get_terminal_size() is unsupported
            size = os.terminal_size(fallback)
        if columns <= 0:
            columns = size.columns
        if lines <= 0:
            lines = size.lines

    return os.terminal_size((columns, lines))
Ejemplo n.º 14
0
def get_terminal_size(fallback=(80, 24)):
    try:
        columns = int(os.environ['COLUMNS'])
    except (KeyError, ValueError):
        columns = 0
    try:
        lines = int(os.environ['LINES'])
    except (KeyError, ValueError):
        lines = 0
    if columns <= 0 or lines <= 0:
        try:
            size = os.get_terminal_size(sys.__stdout__.fileno())
        except (NameError, OSError):
            size = os.terminal_size(fallback)
        if columns <= 0:
            columns = size.columns
        if lines <= 0:
            lines = size.lines
    return os.terminal_size((columns, lines))
Ejemplo n.º 15
0
def printer(monkeypatch, request):
    def fin():
        """Ensure that the cursor is shown when printer unit tests complete."""
        print(ansi.SHOW_CURSOR, end='', flush=True)

    request.addfinalizer(fin)

    monkeypatch.setattr('shutil.get_terminal_size', lambda: os.terminal_size(
        (80, 24)))
    return Printer()
Ejemplo n.º 16
0
def test_echo_with_pager_if_needed_u(mock_click, mock_shutil_get_terminal_size,
                                     columns, rows, output, uses_pager):
    mock_shutil_get_terminal_size.return_value = os.terminal_size(
        [columns, rows])

    echo.echo_with_pager_if_needed(output)

    if uses_pager:
        assert mock_click.mock_calls == [mock.call.echo_via_pager(output)]
    else:
        assert mock_click.mock_calls == [mock.call.echo(output)]
def test_utils_terminal_width_get_terminal_size(mock_os):
    if not hasattr(os, 'get_terminal_size'):
        raise nose.SkipTest('only needed for python 3.3 onwards')
    ts = os.terminal_size((10, 5))
    mock_os.get_terminal_size.return_value = ts
    width = utils.terminal_width(sys.stdout)
    assert width == 10

    mock_os.get_terminal_size.side_effect = OSError()
    width = utils.terminal_width(sys.stdout)
    assert width is None
Ejemplo n.º 18
0
def test_utils_terminal_width_get_terminal_size(mock_os):
    if not hasattr(os, 'get_terminal_size'):
        raise nose.SkipTest('only needed for python 3.3 onwards')
    ts = os.terminal_size((10, 5))
    mock_os.get_terminal_size.return_value = ts
    width = utils.terminal_width(sys.stdout)
    assert width == 10

    mock_os.get_terminal_size.side_effect = OSError()
    width = utils.terminal_width(sys.stdout)
    assert width is None
Ejemplo n.º 19
0
 def test_page(self, mockShutil: Mock, mockPager: Mock) -> None:
     cols: int = 80
     rows: int = 24
     mockShutil.get_terminal_size.return_value = os.terminal_size(
         (cols, rows))
     lines: List[str] = [
         "This is the first line.",
         "this is the second line.",
         "123456789 " * 10,
         "123\n567\n9 " * 10,
         "This is the third and final line.",
     ]
     lines = "\n".join(lines).splitlines()
     utils.page(lines)
     text: str = "\n".join(
         textwrap.fill(line.strip(), cols - 1) for line in lines)
     mockPager.assert_called_once_with(text)
Ejemplo n.º 20
0
def build_sizer(fd: Optional[Union[TextIO, int]] = None) -> Callable:
    """
    Build a function returning the terminal size depending on the available
    and requested I/O streams.
    Try to get the terminal size of the given io stream, otherwise defaults to stdin,
    and if stdin is no tty, defaults to a fixed size of (80, 24).
    """
    if fd is None:
        if os.isatty(0):
            return partial(os.get_terminal_size, 0)
    else:
        if isinstance(fd, TextIO):
            fd = fd.fileno()
        if type(fd) is int:
            if is_suitable_io_device(fd):
                return partial(os.get_terminal_size, fd)
            return partial(os.get_terminal_size, 0)
    return lambda: os.terminal_size((80, 24))
Ejemplo n.º 21
0
def test_show_list_tools_long_ifw(capsys, monkeypatch, columns, expect):
    update_xml = (Path(__file__).parent / "data" /
                  "mac-desktop-tools_ifw-update.xml").read_text("utf-8")
    monkeypatch.setattr(MetadataFactory, "fetch_http",
                        lambda self, _: update_xml)

    monkeypatch.setattr(shutil, "get_terminal_size",
                        lambda fallback: os.terminal_size((columns, 24)))

    meta = MetadataFactory(
        ArchiveId("tools", "mac", "desktop"),
        tool_name="tools_ifw",
        is_long_listing=True,
    )
    show_list(meta)
    out, err = capsys.readouterr()
    sys.stdout.write(out)
    sys.stderr.write(err)
    assert out == expect
Ejemplo n.º 22
0
def pager_process(pagercmd, stdout=None, stderr=None):
    if stdout is None:
        stdout = sys.stdout
    if stderr is None:
        stderr = sys.stderr
    # When running interactively `less` does not handle window resizes
    # unless we explicitly hardcode the new term size into the env.  There
    # is currently a bug in docker for mac that sometimes breaks this test.
    env = os.environ.copy()
    termsize = shutil.get_terminal_size()
    if 0 in termsize:
        warnings.warn("Could not determine terminal size")
        termsize = os.terminal_size((80, 24))
    env['COLUMNS'] = str(termsize.columns)
    env['LINES'] = str(termsize.lines)
    return subprocess.Popen(pagercmd,
                            shell=True,
                            universal_newlines=True,
                            bufsize=1,
                            stdin=subprocess.PIPE,
                            stdout=stdout,
                            stderr=stderr,
                            env=env)
Ejemplo n.º 23
0
import os

sz = os.get_terminal_size()
print(sz)
print(sz.columns)
print(sz.lines)
sz = os.terminal_size((50, 24))
Ejemplo n.º 24
0
		if record.levelno >= logging.CRITICAL:
			return self.critical_seq + msg + self.reset_all_seq
		elif record.levelno >= logging.ERROR:
			return self.error_seq + msg + self.reset_all_seq
		elif record.levelno >= logging.WARNING:
			return self.warning_seq + msg + self.reset_all_seq
		elif record.levelno >= STATUS:
			return self.status_seq + msg + self.reset_all_seq
		elif record.levelno >= MESSAGE:
			return self.message_seq + msg + self.reset_all_seq

		return msg


_last_term_sz = os.terminal_size((80, 24))


def get_term_sz() -> os.terminal_size:
	global _last_term_sz  # pylint: disable=C0103,W0603
	_last_term_sz = shutil.get_terminal_size(_last_term_sz)
	return _last_term_sz


class PrettyPrinter(_pprinter):

	def __init__(
		self,
		*args,  # noqa: ANN002
		indent: int = 2,
		width: Optional[int] = None,
Ejemplo n.º 25
0
# 13.5. Getting the Terminal Size

import os
sz = os.get_terminal_size()
# OSError: [WinError 6] 句柄无效。

print(sz)

os.terminal_size(columns=80, lines=24)

print(sz.columns)

print(sz.lines)
Ejemplo n.º 26
0
def get_terminal_size(fallback=(80, 24)):
    try:
        return shutil.get_terminal_size(fallback)
    except Exception:  # pragma: no cover
        return os.terminal_size(fallback)
Ejemplo n.º 27
0
 def test_get_terminal_size_in_pty_defaults_to_80(self) -> None:
     # when run using a pty, `os.get_terminal_size()` returns `0, 0`
     ret = os.terminal_size((0, 0))
     with mock.patch.object(os, 'get_terminal_size', return_value=ret):
         assert get_terminal_width() == 80
Ejemplo n.º 28
0
 def replacement(fallback=None):
     columns, lines = shutil.original_get_terminal_size(fallback)
     # One fewer column so that full-width progress bar doesn't flow
     # onto the next line.
     return os.terminal_size((columns - 1, lines))
Ejemplo n.º 29
0
def mock_shutil_get_terminal_size():
    fake_terminal = os.terminal_size([80, 24])
    with mock.patch("snapcraft_legacy.cli.echo.shutil.get_terminal_size",
                    return_value=fake_terminal) as mock_terminal_size:
        yield mock_terminal_size
Ejemplo n.º 30
0
 def get_terminal_size(fallback=(80, 24)):
     return os.terminal_size(fallback)
Ejemplo n.º 31
0
 def fake_terminal_size(*args, **kwargs):
     return os.terminal_size(PREDEFINED_TERMINAL_SIZE)
Ejemplo n.º 32
0
        parser.error('%s does not exist or no permissions or not executable' %
                     parsed.nvidia_settings_path)

    if not os.path.isfile(parsed.xterm_path) or not os.access(
            parsed.xterm_path, os.X_OK):
        parser.error('%s does not exist or no permissions or not executable' %
                     parsed.xterm_path)

    parsed.context_path = parsed.context_path.rstrip('/')

    return parsed


if __name__ == '__main__':

    name = 'nvidia-settings-rest-api'
    version = '0.0.1'

    config = cli_args(description='%s-%s' % (name, version))
    configure_root_logger(level=logging.DEBUG)
    set_process_name('name', 'version', config_obj=config)

    os.terminal_size((500, 20))

    api = Api(config=config, name=name, version=version)
    aiohttp.web.run_app(
        api.app,
        host=api.config.bind,
        port=api.config.port,
    )
Ejemplo n.º 33
0
def get_terminal_size(fallback=(80, 24)):
    try:
        return shutil.get_terminal_size(fallback)
    except Exception:  # pragma: no cover
        return os.terminal_size(fallback)
Ejemplo n.º 34
0
def _patched_get_terminal_size(fd=None):
    return os.terminal_size((80, 30))