pyinfra 2.9.1__py2.py3-none-any.whl → 3.0__py2.py3-none-any.whl

pyinfra_cli/prints.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 import platform
 import re
@@ -50,12 +52,6 @@ def jsonify(data, *args, **kwargs):
     return json.dumps(data, *args, **kwargs)
 
 
-def print_state_facts(state: "State"):
-    click.echo(err=True)
-    click.echo("--> Facts:", err=True)
-    click.echo(jsonify(state.facts, indent=4, default=json_encode), err=True)
-
-
 def print_state_operations(state: "State"):
     state_ops = {host: ops for host, ops in state.ops.items() if state.is_host_in_limit(host)}
 
@@ -76,7 +72,7 @@ def print_state_operations(state: "State"):
         click.echo(
             "    {0} (names={1}, hosts={2})".format(
                 op_hash,
-                meta["names"],
+                meta.names,
                 hosts,
             ),
             err=True,
@@ -161,22 +157,22 @@ def print_support_info():
 
 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:
@@ -202,139 +198,111 @@ def print_rows(rows):
         func(line)
 
 
-def print_meta(state: "State"):
-    group_combinations = _get_group_combinations(state.inventory.iter_activated_hosts())
-    rows: List[Tuple[Callable, Union[List[str], str]]] = []
+def truncate(text, max_length):
+    if len(text) <= max_length:
+        return text
 
-    for i, (groups, hosts) in enumerate(group_combinations.items(), 1):
-        if not hosts:
-            continue
+    text = text[: max_length - 3]
+    return f"{text}..."
 
-        if groups:
-            rows.append(
-                (
-                    logger.info,
-                    "Groups: {0}".format(
-                        click.style(" / ".join(groups), bold=True),
-                    ),
-                ),
-            )
-        else:
-            rows.append((logger.info, "Ungrouped:"))
 
-        for host in hosts:
-            meta = state.meta[host]
+def pretty_op_name(op_meta):
+    name = list(op_meta.names)[0]
+
+    if op_meta.args:
+        name = "{0} ({1})".format(name, ", ".join(str(arg) for arg in op_meta.args))
 
-            # Didn't connect to this host?
-            if host not in state.activated_hosts:
-                rows.append(
+    return name
+
+
+def print_meta(state: "State"):
+    rows: List[Tuple[Callable, Union[List[str], str]]] = [
+        (logger.info, ["Operation", "Change", "Conditional Change"]),
+    ]
+
+    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]),
                     (
-                        logger.info,
-                        [
-                            host.style_print_prefix("red", bold=True),
-                            click.style("No connection", "red"),
-                        ],
+                        "-"
+                        if len(hosts_in_op) == 0
+                        else "{0} ({1})".format(
+                            len(hosts_in_op),
+                            truncate(", ".join(sorted(hosts_in_op)), 48),
+                        )
                     ),
-                )
-                continue
-
-            rows.append(
-                (
-                    logger.info,
-                    [
-                        host.print_prefix,
-                        "Operations: {0}".format(meta["ops"]),
-                        "Change: {0}".format(meta["ops_change"]),
-                        "No change: {0}".format(meta["ops_no_change"]),
-                    ],
-                ),
+                    (
+                        "-"
+                        if len(hosts_maybe_in_op) == 0
+                        else "{0} ({1})".format(
+                            len(hosts_maybe_in_op),
+                            truncate(", ".join(sorted(hosts_maybe_in_op)), 48),
+                        )
+                    ),
+                ],
             )
-
-        if i != len(group_combinations):
-            rows.append((lambda m: click.echo(m, err=True), []))
+        )
 
     print_rows(rows)
 
 
 def print_results(state: "State"):
-    group_combinations = _get_group_combinations(state.inventory.iter_activated_hosts())
-    rows: List[Tuple[Callable, Union[List[str], str]]] = []
-
-    for i, (groups, hosts) in enumerate(group_combinations.items(), 1):
-        if not hosts:
-            continue
-
-        if groups:
-            rows.append(
-                (
-                    logger.info,
-                    "Groups: {0}".format(
-                        click.style(" / ".join(groups), bold=True),
-                    ),
-                ),
-            )
-        else:
-            rows.append((logger.info, "Ungrouped:"))
+    rows: List[Tuple[Callable, Union[List[str], str]]] = [
+        (logger.info, ["Operation", "Hosts", "Success", "Error", "No Change"]),
+    ]
 
-        for host in hosts:
-            # 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"),
-                        ],
-                    ),
-                )
+    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
 
-            results = state.results[host]
-
-            meta = state.meta[host]
-            success_ops = results["success_ops"]
-            partial_ops = results["partial_ops"]
-            # TODO: type meta object
-            changed_ops = success_ops - meta["ops_no_change"]  # type: ignore
-            error_ops = results["error_ops"]
-            ignored_error_ops = results["ignored_error_ops"]
+            hosts_in_op += 1
 
-            host_args = ("green",)
-            host_kwargs = {}
+            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)
 
-            # 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",)
+        row = [
+            pretty_op_name(state.op_meta[op_hash]),
+            str(hosts_in_op),
+        ]
 
-            # Ops did not complete!
-            else:
-                host_args = ("red",)
-                host_kwargs["bold"] = True
-
-            changed_str = "Changed: {0}".format(click.style(f"{changed_ops}", bold=True))
-            if partial_ops:
-                changed_str = f"{changed_str} ({partial_ops} partial)"
-
-            error_str = "Errors: {0}".format(click.style(f"{error_ops}", bold=True))
-            if ignored_error_ops:
-                error_str = f"{error_str} ({ignored_error_ops} ignored)"
-
-            rows.append(
-                (
-                    logger.info,
-                    [
-                        host.style_print_prefix(*host_args, **host_kwargs),
-                        changed_str,
-                        "No change: {0}".format(click.style(f"{meta['ops_no_change']}", bold=True)),
-                        error_str,
-                    ],
-                ),
-            )
+        if hosts_in_op_success:
+            row.append(f"{len(hosts_in_op_success)}")
+        else:
+            row.append("-")
+        if hosts_in_op_error:
+            row.append(f"{len(hosts_in_op_error)}")
+        else:
+            row.append("-")
+        if hosts_in_op_no_change:
+            row.append(f"{len(hosts_in_op_no_change)}")
+        else:
+            row.append("-")
 
-        if i != len(group_combinations):
-            rows.append((lambda m: click.echo(m, err=True), []))
+        rows.append((logger.info, row))
 
     print_rows(rows)

pyinfra_cli/util.py

@@ -1,12 +1,15 @@
+from __future__ import annotations
+
 import json
 import os
 from datetime import datetime
 from importlib import import_module
+from importlib.util import find_spec
 from io import IOBase
 from os import path
 from pathlib import Path
-from types import FunctionType, ModuleType
-from typing import TYPE_CHECKING, Callable
+from types import CodeType, FunctionType, ModuleType
+from typing import Callable
 
 import click
 import gevent
@@ -16,16 +19,20 @@ from pyinfra.api.command import PyinfraCommand
 from pyinfra.api.exceptions import PyinfraError
 from pyinfra.api.host import HostData
 from pyinfra.api.operation import OperationMeta
+from pyinfra.api.state import (
+    State,
+    StateHostMeta,
+    StateHostResults,
+    StateOperationHostData,
+    StateOperationMeta,
+)
 from pyinfra.context import ctx_config, ctx_host
 from pyinfra.progress import progress_spinner
 
 from .exceptions import CliError, UnexpectedExternalError
 
-if TYPE_CHECKING:
-    from pyinfra.api.state import State
-
 # Cache for compiled Python deploy code
-PYTHON_CODES = {}
+PYTHON_CODES: dict[str, CodeType] = {}
 
 
 def is_subdir(child, parent):
@@ -45,25 +52,26 @@ def exec_file(filename, return_locals: bool = False, is_deploy_code: bool = Fals
 
     if filename not in PYTHON_CODES:
         with open(filename, "r", encoding="utf-8") as f:
-            code = f.read()
+            code_str = f.read()
 
-        code = compile(code, filename, "exec")
+        code = compile(code_str, filename, "exec")
         PYTHON_CODES[filename] = code
 
     # Create some base attributes for our "module"
-    data = {
-        "__file__": filename,
-    }
+    data = {"__file__": filename}
 
     # Execute the code with locals/globals going into the dict above
     try:
         exec(PYTHON_CODES[filename], data)
+    except PyinfraError:
+        # Raise pyinfra errors as-is
+        raise
     except Exception as e:
-        if isinstance(e, (PyinfraError, UnexpectedExternalError)):
-            raise
+        # Wrap & re-raise errors in user code so we highlight filename/etc
         raise UnexpectedExternalError(e, filename)
+    finally:
+        state.current_exec_filename = old_current_exec_filename
 
-    state.current_exec_filename = old_current_exec_filename
     return data
 
 
@@ -75,7 +83,16 @@ def json_encode(obj):
     if isinstance(obj, PyinfraCommand):
         return repr(obj)
 
-    if isinstance(obj, OperationMeta):
+    if isinstance(
+        obj,
+        (
+            OperationMeta,
+            StateOperationMeta,
+            StateOperationHostData,
+            StateHostMeta,
+            StateHostResults,
+        ),
+    ):
         return repr(obj)
 
     # Python types
@@ -133,28 +150,44 @@ def parse_cli_arg(arg):
     return arg
 
 
-def try_import_module_attribute(path, prefix=None):
-    mod_path, attr_name = path.rsplit(".", 1)
-    module = None
+def try_import_module_attribute(path, prefix=None, raise_for_none=True):
+    if ":" in path:
+        # Allow a.module.name:function syntax
+        mod_path, attr_name = path.rsplit(":", 1)
+    elif "." in path:
+        # And also a.module.name.function
+        mod_path, attr_name = path.rsplit(".", 1)
+    else:
+        return None
 
+    possible_modules = [mod_path]
     if prefix:
-        full_path = f"{prefix}.{mod_path}"
+        possible_modules.append(f"{prefix}.{mod_path}")
+
+    module = None
+
+    for possible in possible_modules:
         try:
-            module = import_module(full_path)
-        except (ModuleNotFoundError, ImportError):
-            pass
-    else:
-        full_path = mod_path
+            # First use find_spec which checks if the possible module exists *without* importing
+            # it, thus any import errors it contains still get properly raised to the user.
+            spec = find_spec(possible)
+        except ModuleNotFoundError:
+            continue
+        else:
+            if spec is not None:
+                module = import_module(possible)
+                break
 
     if module is None:
-        try:
-            module = import_module(mod_path)
-        except (ModuleNotFoundError, ImportError):
-            raise CliError(f"No such module: {full_path}")
+        if raise_for_none:
+            raise CliError(f"No such module: {possible_modules[-1]}")
+        return
 
     attr = getattr(module, attr_name, None)
     if attr is None:
-        raise CliError(f"No such attribute in module {full_path}: {attr_name}")
+        if raise_for_none:
+            raise CliError(f"No such attribute in module {possible_modules[-1]}: {attr_name}")
+        return
 
     return attr
 

tests/test_api/test_api.py

@@ -1,4 +1,5 @@
 from unittest import TestCase
+from unittest.mock import patch
 
 from paramiko import SSHException
 
@@ -60,6 +61,7 @@ class TestInventoryApi(TestCase):
 
 
 class TestStateApi(PatchSSHTestCase):
+    @patch("pyinfra.connectors.base.raise_if_bad_type", lambda *args, **kwargs: None)
     def test_fail_percent(self):
         inventory = make_inventory(
             (

tests/test_api/test_api_arguments.py

@@ -12,44 +12,44 @@ class TestOperationKwargs(TestCase):
         state = State(config=config, inventory=inventory)
 
         kwargs, keys = pop_global_arguments({}, state=state, host=inventory.get_host("somehost"))
-        assert kwargs["sudo"] == "config-value"
+        assert kwargs["_sudo"] == "config-value"
 
     def test_get_from_host(self):
         config = Config(SUDO="config-value")
-        inventory = Inventory(([("somehost", {"sudo": "host-value"})], {}))
+        inventory = Inventory(([("somehost", {"_sudo": True})], {}))
 
         state = State(config=config, inventory=inventory)
 
         kwargs, keys = pop_global_arguments({}, state=state, host=inventory.get_host("somehost"))
-        assert kwargs["sudo"] == "host-value"
+        assert kwargs["_sudo"] is True
 
     def test_get_from_state_deploy_kwargs(self):
         config = Config(SUDO="config-value")
-        inventory = Inventory(([("somehost", {"sudo": "host-value"})], {}))
+        inventory = Inventory(([("somehost", {"_sudo": False})], {}))
         somehost = inventory.get_host("somehost")
 
         state = State(config=config, inventory=inventory)
-        somehost.current_deploy_kwargs = {"sudo": "deploy-kwarg-value"}
+        somehost.current_deploy_kwargs = {"_sudo": True}
 
         kwargs, keys = pop_global_arguments({}, state=state, host=somehost)
-        assert kwargs["sudo"] == "deploy-kwarg-value"
+        assert kwargs["_sudo"] is True
 
     def test_get_from_kwargs(self):
         config = Config(SUDO="config-value")
-        inventory = Inventory(([("somehost", {"sudo": "host-value"})], {}))
+        inventory = Inventory(([("somehost", {"_sudo": False})], {}))
         somehost = inventory.get_host("somehost")
 
         state = State(config=config, inventory=inventory)
         somehost.current_deploy_kwargs = {
-            "sudo": "deploy-kwarg-value",
-            "sudo_user": "deploy-kwarg-user",
+            "_sudo": False,
+            "_sudo_user": "deploy-kwarg-user",
         }
 
         kwargs, keys = pop_global_arguments(
-            {"sudo": "kwarg-value"},
+            {"_sudo": True},
             state=state,
             host=somehost,
         )
-        assert kwargs["sudo"] == "kwarg-value"
-        assert kwargs["sudo_user"] == "deploy-kwarg-user"
-        assert "sudo" in keys
+        assert kwargs["_sudo"] is True
+        assert kwargs["_sudo_user"] == "deploy-kwarg-user"
+        assert "_sudo" in keys

tests/test_api/test_api_deploys.py

@@ -24,7 +24,7 @@ class TestDeploysApi(PatchSSHTestCase):
 
         connect_all(state)
 
-        @deploy
+        @deploy()
         def test_deploy(state=None, host=None):
             server.shell(commands=["echo first command"])
             server.shell(commands=["echo second command"])
@@ -36,40 +36,36 @@ class TestDeploysApi(PatchSSHTestCase):
         # Ensure we have an op
         assert len(op_order) == 2
 
+        # Ensure run ops works
+        run_ops(state)
+
         first_op_hash = op_order[0]
-        assert state.op_meta[first_op_hash]["names"] == {"test_deploy | Server/Shell"}
-        assert state.ops[somehost][first_op_hash]["commands"] == [
+        assert state.op_meta[first_op_hash].names == {"test_deploy | server.shell"}
+        assert state.ops[somehost][first_op_hash].operation_meta._commands == [
             StringCommand("echo first command"),
         ]
-        assert state.ops[anotherhost][first_op_hash]["commands"] == [
+        assert state.ops[anotherhost][first_op_hash].operation_meta._commands == [
             StringCommand("echo first command"),
         ]
 
         second_op_hash = op_order[1]
-        assert state.op_meta[second_op_hash]["names"] == {"test_deploy | Server/Shell"}
-        assert state.ops[somehost][second_op_hash]["commands"] == [
+        assert state.op_meta[second_op_hash].names == {"test_deploy | server.shell"}
+        assert state.ops[somehost][second_op_hash].operation_meta._commands == [
             StringCommand("echo second command"),
         ]
-        assert state.ops[anotherhost][second_op_hash]["commands"] == [
+        assert state.ops[anotherhost][second_op_hash].operation_meta._commands == [
             StringCommand("echo second command"),
         ]
 
-        # Ensure run ops works
-        run_ops(state)
-
         # Ensure ops completed OK
-        assert state.results[somehost]["success_ops"] == 2
-        assert state.results[somehost]["ops"] == 2
-        assert state.results[anotherhost]["success_ops"] == 2
-        assert state.results[anotherhost]["ops"] == 2
+        assert state.results[somehost].success_ops == 2
+        assert state.results[somehost].ops == 2
+        assert state.results[anotherhost].success_ops == 2
+        assert state.results[anotherhost].ops == 2
 
         # And w/o errors
-        assert state.results[somehost]["error_ops"] == 0
-        assert state.results[anotherhost]["error_ops"] == 0
-
-        # And with the different modes
-        run_ops(state, serial=True)
-        run_ops(state, no_wait=True)
+        assert state.results[somehost].error_ops == 0
+        assert state.results[anotherhost].error_ops == 0
 
         disconnect_all(state)
 
@@ -87,11 +83,11 @@ class TestDeploysApi(PatchSSHTestCase):
 
         connect_all(state)
 
-        @deploy
+        @deploy()
         def test_nested_deploy():
             server.shell(commands=["echo nested command"])
 
-        @deploy
+        @deploy()
         def test_deploy():
             server.shell(commands=["echo first command"])
             test_nested_deploy()
@@ -104,22 +100,25 @@ class TestDeploysApi(PatchSSHTestCase):
         # Ensure we have an op
         assert len(op_order) == 3
 
+        # Ensure run ops works
+        run_ops(state)
+
         first_op_hash = op_order[0]
-        assert state.op_meta[first_op_hash]["names"] == {"test_deploy | Server/Shell"}
-        assert state.ops[somehost][first_op_hash]["commands"] == [
+        assert state.op_meta[first_op_hash].names == {"test_deploy | server.shell"}
+        assert state.ops[somehost][first_op_hash].operation_meta._commands == [
             StringCommand("echo first command"),
         ]
 
         second_op_hash = op_order[1]
-        assert state.op_meta[second_op_hash]["names"] == {
-            "test_deploy | test_nested_deploy | Server/Shell",
+        assert state.op_meta[second_op_hash].names == {
+            "test_deploy | test_nested_deploy | server.shell",
         }
-        assert state.ops[somehost][second_op_hash]["commands"] == [
+        assert state.ops[somehost][second_op_hash].operation_meta._commands == [
             StringCommand("echo nested command"),
         ]
 
         third_op_hash = op_order[2]
-        assert state.op_meta[third_op_hash]["names"] == {"test_deploy | Server/Shell"}
-        assert state.ops[somehost][third_op_hash]["commands"] == [
+        assert state.op_meta[third_op_hash].names == {"test_deploy | server.shell"}
+        assert state.ops[somehost][third_op_hash].operation_meta._commands == [
             StringCommand("echo second command"),
         ]