pyinfra 0.11.dev3__py3-none-any.whl → 3.6__py3-none-any.whl

pyinfra_cli/prints.py

@@ -1,26 +1,33 @@
+from __future__ import annotations
+
 import json
+import platform
 import re
+import sys
+from typing import TYPE_CHECKING, Callable, Dict, Iterator, List, Tuple, Union
 
 import click
 
-from pyinfra import logger
-from pyinfra.api.facts import get_fact_names
+from pyinfra import __version__, logger
 from pyinfra.api.host import Host
-from pyinfra.api.operation import get_operation_names
 
 from .util import json_encode
 
-ANSI_RE = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')  # noqa: W605
+if TYPE_CHECKING:
+    from pyinfra.api.state import State
+
+
+ANSI_RE = re.compile(r"\033\[((?:\d|;)*)([a-zA-Z])")
 
 
 def _strip_ansi(value):
-    return ANSI_RE.sub('', value)
+    return ANSI_RE.sub("", value)
 
 
-def _get_group_combinations(inventory):
-    group_combinations = {}
+def _get_group_combinations(inventory: Iterator[Host]):
+    group_combinations: Dict[Tuple, List[Host]] = {}
 
-    for host in inventory.iter_all_hosts():
+    for host in inventory:
         # Tuple for hashability, set to normalise order
         host_groups = tuple(set(host.groups))
 
@@ -45,34 +52,32 @@ def jsonify(data, *args, **kwargs):
     return json.dumps(data, *args, **kwargs)
 
 
-def print_state_facts(state):
-    print()
-    print('--> Facts:')
-    print(jsonify(state.facts, indent=4, default=json_encode))
+def print_state_operations(state: "State"):
+    state_ops = {host: ops for host, ops in state.ops.items() if state.is_host_in_limit(host)}
 
+    click.echo(err=True)
+    click.echo("--> Operations:", err=True)
+    click.echo(jsonify(state_ops, indent=4, default=json_encode), err=True)
+    click.echo(err=True)
+    click.echo("--> Operation meta:", err=True)
+    click.echo(jsonify(state.op_meta, indent=4, default=json_encode), err=True)
 
-def print_state_operations(state):
-    print()
-    print('--> Operations:')
-    print(jsonify(state.ops, indent=4, default=json_encode))
-    print()
-    print('--> Operation meta:')
-    print(jsonify(state.op_meta, indent=4, default=json_encode))
-
-    print()
-    print('--> Operation order:')
-    print()
+    click.echo(err=True)
+    click.echo("--> Operation order:", err=True)
+    click.echo(err=True)
     for op_hash in state.get_op_order():
         meta = state.op_meta[op_hash]
-        hosts = set(
-            host for host, operations in state.ops.items()
-            if op_hash in operations
+        hosts = set(host for host, operations in state.ops.items() if op_hash in operations)
+
+        click.echo(
+            "    {0} (names={1}, hosts={2})".format(
+                op_hash,
+                meta.names,
+                hosts,
+            ),
+            err=True,
         )
 
-        print('    {0} (names={1}, hosts={2})'.format(
-            op_hash, meta['names'], hosts,
-        ))
-
 
 def print_groups_by_comparison(print_items, comparator=lambda item: item[0]):
     items = []
@@ -84,79 +89,110 @@ def print_groups_by_comparison(print_items, comparator=lambda item: item[0]):
             items.append(name)
 
         else:
-            print('    {0}'.format(', '.join((
-                click.style(name, bold=True)
-                for name in items
-            ))))
+            click.echo(
+                "    {0}".format(", ".join((click.style(name, bold=True) for name in items))),
+                err=True,
+            )
 
             items = [name]
 
         last_name = name
 
     if items:
-        print('    {0}'.format(', '.join((
-            click.style(name, bold=True)
-            for name in items
-        ))))
-
-
-def print_facts_list():
-    fact_names = sorted(get_fact_names())
-    print_groups_by_comparison(fact_names)
-
-
-def print_operations_list():
-    operation_names = sorted(get_operation_names())
-    print_groups_by_comparison(
-        operation_names,
-        comparator=lambda item: item.split('.')[0],
-    )
+        click.echo(
+            "    {0}".format(", ".join((click.style(name, bold=True) for name in items))),
+            err=True,
+        )
 
 
 def print_fact(fact_data):
-    print(jsonify(fact_data, indent=4, default=json_encode))
+    click.echo(jsonify(fact_data, indent=4, default=json_encode), err=True)
 
 
-def print_inventory(state):
+def print_inventory(state: "State"):
     for host in state.inventory:
-        if not state.is_host_in_limit(host):
-            continue
-
-        print()
-        print('--> Data for: {0}'.format(click.style(host.name, bold=True)))
-        print(jsonify(host.data, indent=4, default=json_encode))
+        click.echo(err=True)
+        click.echo(host.print_prefix, err=True)
+        click.echo("--> Groups: {0}".format(", ".join(host.groups)), err=True)
+        click.echo("--> Data:", err=True)
+        click.echo(jsonify(host.data, indent=4, default=json_encode), err=True)
 
 
 def print_facts(facts):
     for name, data in facts.items():
-        print()
-        print('--> Fact data for: {0}'.format(
-            click.style(name, bold=True),
-        ))
+        click.echo(err=True)
+        click.echo(
+            "--> Fact data for: {0}".format(
+                click.style(name, bold=True),
+            ),
+            err=True,
+        )
         print_fact(data)
 
 
+def print_support_info() -> None:
+    from importlib.metadata import PackageNotFoundError, requires, version
+
+    from packaging.requirements import Requirement
+
+    click.echo(
+        """
+    If you are having issues with pyinfra or wish to make feature requests, please
+    check out the GitHub issues at https://github.com/Fizzadar/pyinfra/issues .
+    When adding an issue, be sure to include the following:
+""",
+    )
+
+    click.echo("    System: {0}".format(platform.system()), err=True)
+    click.echo("      Platform: {0}".format(platform.platform()), err=True)
+    click.echo("      Release: {0}".format(platform.uname()[2]), err=True)
+    click.echo("      Machine: {0}".format(platform.uname()[4]), err=True)
+    click.echo("    pyinfra: v{0}".format(__version__), err=True)
+
+    seen_reqs: set[str] = set()
+    for requirement_string in sorted(requires("pyinfra") or []):
+        requirement = Requirement(requirement_string)
+        if requirement.name in seen_reqs:
+            continue
+        seen_reqs.add(requirement.name)
+        try:
+            click.echo(
+                "      {0}: v{1}".format(requirement.name, version(requirement.name)),
+                err=True,
+            )
+        except PackageNotFoundError:
+            # package not installed in this environment
+            continue
+
+    click.echo("    Executable: {0}".format(sys.argv[0]), err=True)
+    click.echo(
+        "    Python: {0} ({1}, {2})".format(
+            platform.python_version(),
+            platform.python_implementation(),
+            platform.python_compiler(),
+        ),
+        err=True,
+    )
+
+
 def print_rows(rows):
     # Go through the rows and work out all the widths in each column
-    column_widths = []
+    row_column_widths: list[list[int]] = []
 
     for _, columns in rows:
         if isinstance(columns, str):
             continue
 
         for i, column in enumerate(columns):
-            if i >= len(column_widths):
-                column_widths.append([])
+            if i >= len(row_column_widths):
+                row_column_widths.append([])
 
             # Length of the column (with ansi codes removed)
             width = len(_strip_ansi(column.strip()))
-            column_widths[i].append(width)
+            row_column_widths[i].append(width)
 
     # Get the max width of each column and add 4 padding spaces
-    column_widths = [
-        max(widths) + 4
-        for widths in column_widths
-    ]
+    column_widths = [max(widths) + 4 for widths in row_column_widths]
 
     # Now print each column, keeping text justified to the widths above
     for func, columns in rows:
@@ -170,115 +206,138 @@ def print_rows(rows):
                 desired_width = column_widths[i]
                 padding = desired_width - len(stripped)
 
-                justified.append('{0}{1}'.format(
-                    column, ' '.join('' for _ in range(padding)),
-                ))
+                justified.append(
+                    "{0}{1}".format(
+                        column,
+                        " ".join("" for _ in range(padding)),
+                    ),
+                )
 
-            line = ''.join(justified)
+            line = "".join(justified)
 
         func(line)
 
 
-def print_meta(state):
-    group_combinations = _get_group_combinations(state.inventory)
-    rows = []
+def truncate(text, max_length):
+    if len(text) <= max_length:
+        return text
 
-    for i, (groups, hosts) in enumerate(group_combinations.items(), 1):
-        hosts = [
-            host for host in hosts
-            if state.is_host_in_limit(host)
-        ]
+    text = text[: max_length - 3]
+    return f"{text}..."
 
-        if not hosts:
-            continue  # pragma: no cover
 
-        if groups:
-            rows.append((logger.info, 'Groups: {0}'.format(
-                click.style(' / '.join(groups), bold=True),
-            )))
-        else:
-            rows.append((logger.info, 'Ungrouped:'))
+def pretty_op_name(op_meta):
+    name = list(op_meta.names)[0]
 
-        for host in hosts:
-            meta = state.meta[host]
+    if op_meta.args:
+        name = "{0} ({1})".format(name, ", ".join(str(arg) for arg in op_meta.args))
+
+    return name
 
-            # Didn't connect to this host?
-            if host not in state.activated_hosts:
-                rows.append((logger.info, [
-                    host.style_print_prefix('red', bold=True),
-                    click.style('No connection', 'red'),
-                ]))
-                continue
 
-            rows.append((logger.info, [
-                host.print_prefix,
-                'Operations: {0}'.format(meta['ops']),
-                'Commands: {0}'.format(meta['commands']),
-            ]))
+def print_meta(state: "State"):
+    rows: List[Tuple[Callable, Union[List[str], str]]] = [
+        (logger.info, ["Operation", "Change", "Conditional Change"]),
+    ]
 
-        if i != len(group_combinations):
-            rows.append((print, []))
+    for op_hash in state.get_op_order():
+        hosts_in_op = []
+        hosts_maybe_in_op = []
+        for host in state.inventory.iter_activated_hosts():
+            if op_hash in state.ops[host]:
+                op_data = state.get_op_data_for_host(host, op_hash)
+                if op_data.operation_meta._maybe_is_change:
+                    if op_data.global_arguments["_if"]:
+                        hosts_maybe_in_op.append(host.name)
+                    else:
+                        hosts_in_op.append(host.name)
+
+        rows.append(
+            (
+                logger.info,
+                [
+                    pretty_op_name(state.op_meta[op_hash]),
+                    (
+                        "-"
+                        if len(hosts_in_op) == 0
+                        else "{0} ({1})".format(
+                            len(hosts_in_op),
+                            truncate(", ".join(sorted(hosts_in_op)), 48),
+                        )
+                    ),
+                    (
+                        "-"
+                        if len(hosts_maybe_in_op) == 0
+                        else "{0} ({1})".format(
+                            len(hosts_maybe_in_op),
+                            truncate(", ".join(sorted(hosts_maybe_in_op)), 48),
+                        )
+                    ),
+                ],
+            )
+        )
 
     print_rows(rows)
 
 
-def print_results(state):
-    group_combinations = _get_group_combinations(state.inventory)
-    rows = []
+def print_results(state: "State"):
+    rows: List[Tuple[Callable, Union[List[str], str]]] = [
+        (logger.info, ["Operation", "Hosts", "Success", "Error", "No Change"]),
+    ]
+
+    totals = {"hosts": 0, "success": 0, "error": 0, "no_change": 0}
 
-    for i, (groups, hosts) in enumerate(group_combinations.items(), 1):
-        hosts = [
-            host for host in hosts
-            if state.is_host_in_limit(host)
+    for op_hash in state.get_op_order():
+        hosts_in_op = 0
+        hosts_in_op_success: list[str] = []
+        hosts_in_op_error: list[str] = []
+        hosts_in_op_no_change: list[str] = []
+        for host in state.inventory.iter_activated_hosts():
+            if op_hash not in state.ops[host]:
+                continue
+
+            hosts_in_op += 1
+
+            op_meta = state.ops[host][op_hash].operation_meta
+            if op_meta.did_succeed(_raise_if_not_complete=False):
+                if op_meta.did_change():
+                    hosts_in_op_success.append(host.name)
+                else:
+                    hosts_in_op_no_change.append(host.name)
+            else:
+                hosts_in_op_error.append(host.name)
+
+        row = [
+            pretty_op_name(state.op_meta[op_hash]),
+            str(hosts_in_op),
         ]
 
-        if not hosts:
-            continue
+        totals["hosts"] += hosts_in_op
 
-        if groups:
-            rows.append((logger.info, 'Groups: {0}'.format(
-                click.style(' / '.join(groups), bold=True),
-            )))
+        if hosts_in_op_success:
+            num_hosts_in_op_success = len(hosts_in_op_success)
+            row.append(str(num_hosts_in_op_success))
+            totals["success"] += num_hosts_in_op_success
         else:
-            rows.append((logger.info, 'Ungrouped:'))
-
-        for host in hosts:
-            # Didn't conenct to this host?
-            if host not in state.activated_hosts:
-                rows.append((logger.info, [
-                    host.style_print_prefix('red', bold=True),
-                    click.style('No connection', 'red'),
-                ]))
-                continue
-
-            results = state.results[host]
+            row.append("-")
 
-            meta = state.meta[host]
-            success_ops = results['success_ops']
-            error_ops = results['error_ops']
+        if hosts_in_op_error:
+            num_hosts_in_op_error = len(hosts_in_op_error)
+            row.append(str(num_hosts_in_op_error))
+            totals["error"] += num_hosts_in_op_error
+        else:
+            row.append("-")
 
-            host_args = ('green',)
-            host_kwargs = {}
+        if hosts_in_op_no_change:
+            num_hosts_in_op_no_change = len(hosts_in_op_no_change)
+            row.append(str(num_hosts_in_op_no_change))
+            totals["no_change"] += num_hosts_in_op_no_change
+        else:
+            row.append("-")
 
-            # If all ops got complete
-            if results['ops'] == meta['ops']:
-                # We had some errors - but we ignored them - so "warning" color
-                if error_ops != 0:
-                    host_args = ('yellow',)
+        rows.append((logger.info, row))
 
-            # Ops did not complete!
-            else:
-                host_args = ('red',)
-                host_kwargs['bold'] = True
-
-            rows.append((logger.info, [
-                host.style_print_prefix(*host_args, **host_kwargs),
-                'Successful: {0}'.format(click.style(str(success_ops), bold=True)),
-                'Errors: {0}'.format(click.style(str(error_ops), bold=True)),
-                'Commands: {0}/{1}'.format(results['commands'], meta['commands']),
-            ]))
-
-        if i != len(group_combinations):
-            rows.append((print, []))
+    totals_row = ["Grand total"] + [str(i) if i else "-" for i in totals.values()]
+    rows.append((logger.info, totals_row))
 
     print_rows(rows)