FM / cli

/usr/lib/python3/dist-packages/uaclient/cli/

/usr/lib/python3/dist-packages/uaclient/cli

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
api.py	2460	0644	edit dl rm
attach.py	5611	0644	edit dl rm
auto_attach.py	958	0644	edit dl rm
cli_util.py	8273	0644	edit dl rm
collect_logs.py	1774	0644	edit dl rm
commands.py	3765	0644	edit dl rm
config.py	10982	0644	edit dl rm
cve.py	6891	0644	edit dl rm
cves.py	3869	0644	edit dl rm
detach.py	3464	0644	edit dl rm
disable.py	10906	0644	edit dl rm
enable.py	19265	0644	edit dl rm
fix.py	29315	0644	edit dl rm
formatter.py	8955	0644	edit dl rm
help.py	1707	0644	edit dl rm
parser.py	2782	0644	edit dl rm
refresh.py	2480	0644	edit dl rm
security_status.py	2860	0644	edit dl rm
status.py	2424	0644	edit dl rm
system.py	1074	0644	edit dl rm
__init__.py	9501	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/uaclient/cli/formatter.py (8955B)

import abc
import os
import re
import sys
import textwrap
from enum import Enum
from typing import Any, Dict, List, Optional  # noqa: F401

from uaclient.config import UAConfig
from uaclient.messages import TxtColor

COLOR_FORMATTING_PATTERN = r"\033\[.*?m"
LINK_START_PATTERN = r"\033]8;;.+?\033\\+"
LINK_END = "\033]8;;\033\\"
UTF8_ALTERNATIVES = {
    "—": "-",
    "✘": "x",
    "✔": "*",
}  # type: Dict[str, str]

class ContentAlignment(Enum):
    LEFT = "l"
    RIGHT = "r"

# Class attributes and methods so we don't need singletons or globals for this
class ProOutputFormatterConfig:
    use_utf8 = True
    use_color = True

# Initializing the class after the import is useful for unit testing
    @classmethod
    def init(cls, cfg: UAConfig):
        cls.use_utf8 = (
            sys.stdout.encoding is not None
            and "UTF-8" in sys.stdout.encoding.upper()
        )

cls.use_color = sys.stdout.isatty() and os.getenv("NO_COLOR") is None

@classmethod
    def disable_color(cls) -> None:
        cls.use_color = False

ProOutputFormatterConfig.init(cfg=UAConfig())

def create_link(text: str, url: str) -> str:
    return "\033]8;;{url}\033\\{text}\033]8;;\033\\".format(url=url, text=text)

def real_len(text: str) -> int:
    # ignore colors if existing
    result = re.sub(COLOR_FORMATTING_PATTERN, "", text)
    # Ignore link control characters and metadata
    result = re.sub(LINK_START_PATTERN, "", result)
    result = result.replace(LINK_END, "")

return len(result)

def _get_default_length():
    if sys.stdout.isatty():
        return os.get_terminal_size().columns
    # If you're not in a tty, we don't care about string length
    # If you have a thousand characters line, well, wow
    return 999

def process_formatter_config(text: str) -> str:
    output = text
    if not ProOutputFormatterConfig.use_color:
        output = re.sub(COLOR_FORMATTING_PATTERN, "", text)

if not ProOutputFormatterConfig.use_utf8:
        for char, alternative in UTF8_ALTERNATIVES.items():
            output = output.replace(char, alternative)
        output = output.encode("ascii", "ignore").decode()

if not sys.stdout.isatty():
        output = re.sub(LINK_START_PATTERN, "", output)
        output = output.replace(LINK_END, "")

return output

# We can't rely on textwrap because of the real_len function
# Textwrap is using a magic regex instead
def wrap_text(text: str, max_width: int) -> List[str]:
    if real_len(text) <= max_width:
        return [text]

words = text.split()
    wrapped_lines = []
    current_line = ""

for word in words:
        if real_len(current_line) + real_len(word) >= max_width:
            wrapped_lines.append(current_line.strip())
            current_line = word
        else:
            current_line += " " + word

if current_line:
        wrapped_lines.append(current_line.strip())

return wrapped_lines

class ProOutputFormatter(abc.ABC):
    @abc.abstractmethod
    def to_string(self, line_length: Optional[int] = None) -> str:
        pass

def __str__(self):
        return self.to_string()

class Table(ProOutputFormatter):
    SEPARATOR = " " * 2

def __init__(
        self,
        headers: Optional[List[str]] = None,
        rows: Optional[List[List[str]]] = None,
        alignment: Optional[List[ContentAlignment]] = None,
    ):
        self.headers = headers if headers is not None else []
        self.rows = rows if rows is not None else []
        self.column_sizes = self._get_column_sizes()
        self.alignment = (
            alignment
            if alignment is not None
            else [ContentAlignment.LEFT] * len(self.column_sizes)
        )
        if len(self.alignment) != len(self.column_sizes):
            raise ValueError(
                "'alignment' list should have length {}".format(
                    len(self.column_sizes)
                )
            )
        self.last_column_size = self.column_sizes[-1]

@staticmethod
    def ljust(string: str, total_length: int) -> str:
        str_length = real_len(string)
        if str_length >= total_length:
            return string
        return string + " " * (total_length - str_length)

@staticmethod
    def rjust(string: str, total_length: int) -> str:
        str_length = real_len(string)
        if str_length >= total_length:
            return string
        return " " * (total_length - str_length) + string

def _get_column_sizes(self) -> List[int]:
        if not self.headers and not self.rows:
            raise ValueError(
                "Empty table not supported. Please provide headers or rows."
            )

if self.rows and any(len(item) == 0 for item in self.rows):
            raise ValueError(
                "Empty row not supported. Please provide content for each row."
            )

all_content = []
        if self.headers:
            all_content.append(self.headers)
        if self.rows:
            all_content.extend(self.rows)

expected_length = len(all_content[0])
        if not all(len(item) == expected_length for item in all_content):
            raise ValueError(
                "Mixed lengths in table content. "
                "Please provide headers / rows of the same length."
            )

column_sizes = []
        for i in range(len(all_content[0])):
            column_sizes.append(
                max(real_len(str(item[i])) for item in all_content)
            )

return column_sizes

def to_string(self, line_length: Optional[int] = None) -> str:
        if line_length is None:
            line_length = _get_default_length()

rows = self.rows
        if self._get_line_length() > line_length:
            rows = self.wrap_last_column(line_length)
        output = ""
        if self.headers:
            output += (
                TxtColor.BOLD
                + self._fill_row(self.headers)
                + TxtColor.ENDC
                + "\n"
            )
        for row in rows:
            output += self._fill_row(row)
            output += "\n"

return process_formatter_config(output)

def _get_line_length(self) -> int:
        return sum(self.column_sizes) + (len(self.column_sizes) - 1) * len(
            self.SEPARATOR
        )

def wrap_last_column(self, max_length: int) -> List[List[str]]:
        self.last_column_size = max_length - (
            sum(self.column_sizes[:-1])
            + (len(self.column_sizes) - 1) * len(self.SEPARATOR)
        )
        new_rows = []
        for row in self.rows:
            if len(row[-1]) <= self.last_column_size:
                new_rows.append(row)
            else:
                wrapped_last_column = wrap_text(row[-1], self.last_column_size)
                new_rows.append(row[:-1] + [wrapped_last_column[0]])
                for extra_line in wrapped_last_column[1:]:
                    new_row = [" "] * (len(self.column_sizes) - 1) + [
                        extra_line
                    ]
                    new_rows.append(new_row)
        return new_rows

def _fill_row(self, row: List[str]) -> str:
        output = ""
        for i in range(len(row) - 1):
            if self.alignment[i] == ContentAlignment.LEFT:
                output += (
                    self.ljust(row[i], self.column_sizes[i]) + self.SEPARATOR
                )
            elif self.alignment[i] == ContentAlignment.RIGHT:
                output += (
                    self.rjust(row[i], self.column_sizes[i]) + self.SEPARATOR
                )
        if self.alignment[-1] == ContentAlignment.LEFT:
            output += row[-1]
        elif self.alignment[-1] == ContentAlignment.RIGHT:
            output += self.rjust(row[-1], self.last_column_size)
        return output

class Block(ProOutputFormatter):
    INDENT_SIZE = 4
    INDENT_CHAR = " "

def __init__(
        self,
        title: Optional[str] = None,
        content: Optional[List[Any]] = None,
    ):
        self.title = title
        self.content = content if content is not None else []

def to_string(self, line_length: Optional[int] = None) -> str:
        if line_length is None:
            line_length = _get_default_length()

line_length -= self.INDENT_SIZE

output = ""

if self.title:
            output += (
                TxtColor.BOLD
                + TxtColor.DISABLEGREY
                + self.title
                + TxtColor.ENDC
                + "\n"
            )

for item in self.content:
            if isinstance(item, ProOutputFormatter):
                item_str = item.to_string(line_length=line_length)
            else:
                item_str = "\n".join(wrap_text(str(item), line_length)) + "\n"

output += textwrap.indent(
                item_str, self.INDENT_CHAR * self.INDENT_SIZE
            )

return process_formatter_config(output)

cmd: