pyinfra 2.9.2__py2.py3-none-any.whl → 3.0b1__py2.py3-none-any.whl

tests/test_connectors/test_util.py

@@ -3,90 +3,68 @@
 from unittest import TestCase
 
 from pyinfra.api import Config, State
-from pyinfra.connectors.util import (
-    make_unix_command,
-    make_unix_command_for_host,
-    split_combined_output,
-)
+from pyinfra.connectors.util import make_unix_command, make_unix_command_for_host
 
 from ..util import make_inventory
 
 
-class TestConnectorUtil(TestCase):
-    def test_split_combined_output_works(self):
-        results = split_combined_output(
-            [
-                ("stdout", "stdout1"),
-                ("stdout", "stdout2"),
-                ("stderr", "stderr1"),
-                ("stdout", "stdout3"),
-            ],
-        )
-
-        assert results == (["stdout1", "stdout2", "stdout3"], ["stderr1"])
-
-    def test_split_combined_output_raises(self):
-        with self.assertRaises(ValueError):
-            split_combined_output(["nope", ""])
-
-
 class TestMakeUnixCommandConnectorUtil(TestCase):
     def test_command(self):
         command = make_unix_command("echo Šablony")
         assert command.get_raw_value() == "sh -c 'echo Šablony'"
 
     def test_doas_command(self):
-        command = make_unix_command("uptime", doas=True)
+        command = make_unix_command("uptime", _doas=True)
         assert command.get_raw_value() == "doas -n sh -c uptime"
 
     def test_doas_user_command(self):
-        command = make_unix_command("uptime", doas=True, doas_user="pyinfra")
+        command = make_unix_command("uptime", _doas=True, _doas_user="pyinfra")
         assert command.get_raw_value() == "doas -n -u pyinfra sh -c uptime"
 
     def test_sudo_command(self):
-        command = make_unix_command("uptime", sudo=True)
+        command = make_unix_command("uptime", _sudo=True)
         assert command.get_raw_value() == "sudo -H -n sh -c uptime"
 
     def test_sudo_multi_arg_command(self):
-        command = make_unix_command("echo hi", sudo=True, preserve_sudo_env=True)
+        command = make_unix_command("echo hi", _sudo=True, _preserve_sudo_env=True)
         assert command.get_raw_value() == "sudo -H -n -E sh -c 'echo hi'"
 
     def test_sudo_preserve_env_command(self):
-        command = make_unix_command("uptime", sudo=True, preserve_sudo_env=True)
+        command = make_unix_command("uptime", _sudo=True, _preserve_sudo_env=True)
         assert command.get_raw_value() == "sudo -H -n -E sh -c uptime"
 
     def test_use_sudo_login_command(self):
-        command = make_unix_command("uptime", sudo=True, use_sudo_login=True)
+        command = make_unix_command("uptime", _sudo=True, _use_sudo_login=True)
         assert command.get_raw_value() == "sudo -H -n -i sh -c uptime"
 
     def test_sudo_user_command(self):
-        command = make_unix_command("uptime", sudo=True, sudo_user="pyinfra")
+        command = make_unix_command("uptime", _sudo=True, _sudo_user="pyinfra")
         assert command.get_raw_value() == "sudo -H -n -u pyinfra sh -c uptime"
 
     def test_su_command(self):
-        command = make_unix_command("uptime", su_user="pyinfra")
+        command = make_unix_command("uptime", _su_user="pyinfra")
         assert command.get_raw_value() == "su pyinfra -c 'sh -c uptime'"
 
     def test_su_multi_arg_command(self):
-        command = make_unix_command("echo hi", su_user="pyinfra")
+        command = make_unix_command("echo hi", _su_user="pyinfra")
         assert command.get_raw_value() == "su pyinfra -c 'sh -c '\"'\"'echo hi'\"'\"''"
 
     def test_use_su_login_command(self):
-        command = make_unix_command("uptime", su_user="pyinfra", use_su_login=True)
+        command = make_unix_command("uptime", _su_user="pyinfra", _use_su_login=True)
         assert command.get_raw_value() == "su -l pyinfra -c 'sh -c uptime'"
 
     def test_preserve_su_env_command(self):
-        command = make_unix_command("uptime", su_user="pyinfra", preserve_su_env=True)
+        command = make_unix_command("uptime", _su_user="pyinfra", _preserve_su_env=True)
         assert command.get_raw_value() == "su -m pyinfra -c 'sh -c uptime'"
 
     def test_su_shell_command(self):
-        command = make_unix_command("uptime", su_user="pyinfra", su_shell="bash")
+        command = make_unix_command("uptime", _su_user="pyinfra", _su_shell="bash")
         assert command.get_raw_value() == "su -s `which bash` pyinfra -c 'sh -c uptime'"
 
     def test_command_env(self):
         command = make_unix_command(
             "uptime",
-            env={
+            _env={
                 "key": "value",
                 "anotherkey": "anothervalue",
             },
@@ -97,23 +75,23 @@ class TestMakeUnixCommandConnectorUtil(TestCase):
         ]
 
     def test_command_chdir(self):
-        command = make_unix_command("uptime", chdir="/opt/somedir")
+        command = make_unix_command("uptime", _chdir="/opt/somedir")
         assert command.get_raw_value() == "sh -c 'cd /opt/somedir && uptime'"
 
     def test_custom_shell_command(self):
-        command = make_unix_command("uptime", shell_executable="bash")
+        command = make_unix_command("uptime", _shell_executable="bash")
         assert command.get_raw_value() == "bash -c uptime"
 
     def test_mixed_command(self):
         command = make_unix_command(
             "echo hi",
-            chdir="/opt/somedir",
-            env={"key": "value"},
-            sudo=True,
-            sudo_user="root",
-            preserve_sudo_env=True,
-            su_user="pyinfra",
-            shell_executable="bash",
+            _chdir="/opt/somedir",
+            _env={"key": "value"},
+            _sudo=True,
+            _sudo_user="root",
+            _preserve_sudo_env=True,
+            _su_user="pyinfra",
+            _shell_executable="bash",
         )
         assert command.get_raw_value() == (
             "sudo -H -n -E -u root "  # sudo bit
@@ -125,7 +103,7 @@ class TestMakeUnixCommandConnectorUtil(TestCase):
     def test_command_exists_su_config_only(self):
         """
         This tests covers a bug that appeared when `make_unix_command` is called
-        with `su_user=False` (default) but `SU_USER` set on the config object,
+        with `_su_user=False` (default) but `SU_USER` set on the config object,
         resulting in an empty command output.
         """
         state = State(make_inventory(), Config(SU_USER=True))

tests/test_connectors/test_vagrant.py

@@ -3,7 +3,7 @@ from unittest import TestCase
 from unittest.mock import mock_open, patch
 
 from pyinfra.api.exceptions import InventoryError
-from pyinfra.connectors.vagrant import get_vagrant_options, make_names_data
+from pyinfra.connectors.vagrant import VagrantInventoryConnector, get_vagrant_options
 
 FAKE_VAGRANT_OPTIONS = {
     "groups": {
@@ -69,7 +69,7 @@ class TestVagrantConnector(TestCase):
     )
     @patch("pyinfra.connectors.vagrant.path.exists", lambda path: True)
     def test_make_names_data_with_options(self):
-        data = make_names_data()
+        data = list(VagrantInventoryConnector.make_names_data())
 
         assert data == [
             (
@@ -103,7 +103,7 @@ class TestVagrantConnector(TestCase):
         ]
 
     def test_make_names_data_with_limit(self):
-        data = make_names_data(limit=("ubuntu16",))
+        data = list(VagrantInventoryConnector.make_names_data(name=("ubuntu16",)))
 
         assert data == [
             (
@@ -120,4 +120,4 @@ class TestVagrantConnector(TestCase):
 
     def test_make_names_data_no_matches(self):
         with self.assertRaises(InventoryError):
-            make_names_data(limit="nope")
+            list(VagrantInventoryConnector.make_names_data(name="nope"))

pyinfra/api/operation.pyi

@@ -1,117 +0,0 @@
-from typing import (
-    Callable,
-    Dict,
-    Generator,
-    Generic,
-    Iterable,
-    List,
-    Mapping,
-    Protocol,
-    Tuple,
-    overload,
-)
-
-from typing_extensions import ParamSpec
-
-from pyinfra.api.command import (
-    FileDownloadCommand,
-    FileUploadCommand,
-    FunctionCommand,
-    StringCommand,
-)
-from pyinfra.api.host import Host
-from pyinfra.api.state import State
-
-P = ParamSpec("P")
-
-Command = str | StringCommand | FileDownloadCommand | FileUploadCommand | FunctionCommand
-
-class OperationMeta:
-    changed: bool
-    commands: List[str] | None
-    hash: str | None
-
-    stdout_lines: List[str]
-    stdout: str
-    stderr_lines: List[str]
-    stderr: str
-
-class Operation(Generic[P], Protocol):
-    def __call__(
-        self,
-        _sudo: bool | None = None,
-        _sudo_user: str | None = None,
-        _use_sudo_login: bool | None = None,
-        _use_sudo_password: bool | None = None,
-        _preserve_sudo_env: bool | None = None,
-        _su_user: str | None = None,
-        _use_su_login: bool | None = None,
-        _preserve_su_env: bool | None = None,
-        _su_shell: str | None = None,
-        _doas: bool | None = None,
-        _doas_user: str | None = None,
-        _shell_executable: str | None = None,
-        _chdir: str | None = None,
-        _env: Mapping[str, str] | None = None,
-        _success_exit_codes: Iterable[int] | None = None,
-        _timeout: int | None = None,
-        _get_pty: bool | None = None,
-        _stdin: str | List[str] | Tuple[str, ...] | None = None,
-        name: str | None = None,
-        _ignore_errors: bool | None = None,
-        _continue_on_error: bool | None = None,
-        _precondition: str | None = None,
-        _postcondition: str | None = None,
-        _on_success: Callable[[State, Host, str], None] | None = None,
-        _on_error: Callable[[State, Host, str], None] | None = None,
-        _parallel: int | None = None,
-        _run_once: bool | None = None,
-        _serial: bool | None = None,
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> OperationMeta: ...
-
-def add_op(
-    state: State,
-    op_func: Operation[P],
-    _sudo: bool | None = None,
-    _sudo_user: str | None = None,
-    _use_sudo_login: bool | None = None,
-    _use_sudo_password: bool | None = None,
-    _preserve_sudo_env: bool | None = None,
-    _su_user: str | None = None,
-    _use_su_login: bool | None = None,
-    _preserve_su_env: bool | None = None,
-    _su_shell: str | None = None,
-    _doas: bool | None = None,
-    _doas_user: str | None = None,
-    _shell_executable: str | None = None,
-    _chdir: str | None = None,
-    _env: Mapping[str, str] | None = None,
-    _success_exit_codes: Iterable[int] | None = None,
-    _timeout: int | None = None,
-    _get_pty: bool | None = None,
-    _stdin: str | List[str] | Tuple[str, ...] | None = None,
-    name: str | None = None,
-    _ignore_errors: bool | None = None,
-    _continue_on_error: bool | None = None,
-    _precondition: str | None = None,
-    _postcondition: str | None = None,
-    _on_success: Callable[[State, Host, str], None] | None = None,
-    _on_error: Callable[[State, Host, str], None] | None = None,
-    _parallel: int | None = None,
-    _run_once: bool | None = None,
-    _serial: bool | None = None,
-    host: Iterable[Host] | Host | None = None,
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> Dict[Host, OperationMeta]: ...
-@overload
-def operation(func: Callable[P, Generator[Command, None, None]]) -> Operation[P]: ...
-@overload
-def operation(
-    pipeline_facts=None,
-    is_idempotent: bool = True,
-    idempotent_notice=None,
-    frame_offset=1,
-) -> Callable[[Callable[P, Generator[Command, None, None]]], Operation[P]]: ...

pyinfra/connectors/ansible.py

@@ -1,171 +0,0 @@
-"""
-**Note**: this connector is a work in progress! While it parses the list of
-hosts OK, it doesn't handle nested groups properly yet.
-
-The `@ansible` connector can be used to parse Ansible inventory files.
-
-.. code:: python
-
-    # Load an Ansible inventory relative to the current directory
-    pyinfra @ansible/path/to/inventory
-
-    # Load using an absolute path
-    pyinfra @ansible//absolute/path/to/inventory
-"""
-import json
-import re
-from collections import defaultdict
-from configparser import ConfigParser
-from os import path
-from typing import TYPE_CHECKING, Optional
-
-from pyinfra import logger
-from pyinfra.api.exceptions import InventoryError
-from pyinfra.api.util import memoize
-
-if TYPE_CHECKING:
-    from pyinfra.api.host import Host
-
-try:
-    import yaml
-except ImportError:
-    yaml = None  # type: ignore
-
-
-@memoize
-def show_warning():
-    logger.warning("The @ansible connector is in alpha!")
-
-
-def make_names_data(inventory_filename: Optional[str] = None):
-    show_warning()
-
-    if not inventory_filename:
-        raise InventoryError("No Ansible inventory filename provided!")
-
-    if not path.exists(inventory_filename):
-        raise InventoryError(
-            ("Could not find Ansible inventory file: {0}").format(inventory_filename),
-        )
-
-    return parse_inventory(inventory_filename)
-
-
-def parse_inventory(inventory_filename: str):
-    # fallback to INI if no extension
-    extension = inventory_filename.split(".")[-1] if "." in inventory_filename else "ini"
-
-    # host:set(groups) mapping
-    host_to_groups = {}
-
-    if extension in ["ini"]:
-        host_to_groups = parse_inventory_ini(inventory_filename)
-    elif extension in ["json"]:
-        with open(inventory_filename, encoding="utf-8") as inventory_file:
-            inventory_tree = json.load(inventory_file)
-            # close file early
-        host_to_groups = parse_inventory_tree(inventory_tree)
-    elif extension in ["yaml", "yml"]:
-        if yaml is None:
-            raise Exception(
-                (
-                    "To parse YAML Ansible inventories requires `pyyaml`. "
-                    "Install it with `pip install pyyaml`."
-                ),
-            )
-        with open(inventory_filename, encoding="utf-8") as inventory_file:
-            inventory_tree = yaml.safe_load(inventory_file)
-            # close file early
-        host_to_groups = parse_inventory_tree(inventory_tree)
-    else:
-        raise InventoryError(("Ansible inventory file format not supported: {0}").format(extension))
-
-    return [(host, {}, sorted(list(host_to_groups.get(host, [])))) for host in host_to_groups]
-
-
-def parse_inventory_ini(inventory_filename: str):
-    config = ConfigParser(
-        delimiters=(" "),  # we only handle the hostnames for now
-        allow_no_value=True,  # we don't by default have = values
-        interpolation=None,  # remove any Python interpolation
-    )
-    config.read(inventory_filename)
-
-    host_to_groups = defaultdict(set)
-    group_to_hosts = defaultdict(set)
-    hosts = []
-
-    # First pass - load hosts/groups of hosts
-    for section in config.sections():
-        if ":" in section:  # ignore :children and :vars sections this time
-            continue
-
-        options = config.options(section)
-        for host in _parse_ansible_hosts(options):
-            hosts.append(host)
-            host_to_groups[host].add(section)
-            group_to_hosts[section].add(host)
-
-    # Second pass - load any children groups
-    for section in config.sections():
-        if not section.endswith(":children"):  # we only support :children for now
-            continue
-
-        group_name = section.replace(":children", "")
-
-        options = config.options(section)
-        for sub_group_name in options:
-            sub_group_hosts = group_to_hosts[sub_group_name]
-            for host in sub_group_hosts:
-                host_to_groups[host].add(group_name)
-
-    return host_to_groups
-
-
-def _parse_ansible_hosts(hosts):
-    for host in hosts:
-        expand_match = re.search(r"\[[0-9:]+\]", host)
-        if expand_match:
-            expand_string = host[expand_match.start() : expand_match.end()]
-            bits = expand_string[1:-1].split(":")  # remove the [] either side
-
-            zfill = 0
-            if bits[0].startswith("0"):
-                zfill = len(bits[0])
-
-            start, end = int(bits[0]), int(bits[1])
-            step = int(bits[2]) if len(bits) > 2 else 1
-
-            for n in range(start, end + 1, step):
-                number_as_string = "{0}".format(n)
-                if zfill:
-                    number_as_string = number_as_string.zfill(zfill)
-
-                hostname = host.replace(expand_string, number_as_string)
-                yield hostname
-        else:
-            yield host
-
-
-def parse_inventory_tree(inventory_tree, host_to_groups=dict(), group_stack=set()):
-    for group in inventory_tree:
-        # set logic adds tolerance for duplicate group names
-        groups = group_stack.union({group})
-
-        if "hosts" in inventory_tree[group]:
-            for host in inventory_tree[group]["hosts"]:
-                append_groups_to_host(host, groups, host_to_groups)
-
-        if "children" in inventory_tree[group]:
-            # recursively parse inventory tree
-            parse_inventory_tree(inventory_tree[group]["children"], host_to_groups, groups)
-
-    return host_to_groups
-
-
-def append_groups_to_host(host: "Host", groups, host_to_groups):
-    if host in host_to_groups:
-        # set logic handles de-duplication
-        host_to_groups[host] = host_to_groups[host].union(groups)
-    else:
-        host_to_groups[host] = groups

pyinfra/connectors/mech.py

@@ -1,186 +0,0 @@
-"""
-The ``@mech`` connector reads the current mech status and generates an inventory
-for any running VMs.
-
-.. code:: python
-
-    # Run on all hosts
-    pyinfra @mech ...
-
-    # Run on a specific VM
-    pyinfra @mech/my-vm-name ...
-
-    # Run on multiple named VMs
-    pyinfra @mech/my-vm-name,@mech/another-vm-name ...
-"""
-
-import json
-from os import path
-from queue import Queue
-from threading import Thread
-
-from pyinfra import local, logger
-from pyinfra.api.exceptions import InventoryError
-from pyinfra.api.util import memoize
-from pyinfra.progress import progress_spinner
-
-
-def _get_mech_ssh_config(queue, progress, target):
-    logger.debug("Loading SSH config for %s", target)
-
-    # Note: We have to work-around the fact that "mech ssh-config somehost"
-    # does not return the correct "Host" value. When "mech" fixes this
-    # issue we can simply this code.
-    lines = local.shell(
-        "mech ssh-config {0}".format(target),
-        splitlines=True,
-    )
-
-    newlines = []
-    for line in lines:
-        if line.startswith("Host "):
-            newlines.append("Host " + target)
-        else:
-            newlines.append(line)
-
-    queue.put(newlines)
-
-    progress(target)
-
-
-@memoize
-def get_mech_config(limit=None):
-    logger.info("Getting Mech config...")
-
-    if limit and not isinstance(limit, (list, tuple)):
-        limit = [limit]
-
-    # Note: There is no "--machine-readable" option to 'mech status'
-    with progress_spinner({"mech ls"}) as progress:
-        output = local.shell(
-            "mech ls",
-            splitlines=True,
-        )
-        progress("mech ls")
-
-    targets = []
-
-    for line in output:
-
-        address = ""
-
-        data = line.split()
-        target = data[0]
-
-        if len(data) == 5:
-            address = data[1]
-
-        # Skip anything not in the limit
-        if limit is not None and target not in limit:
-            continue
-
-        # For each vm that has an address, fetch it's SSH config in a thread
-        if address != "" and address[0].isdigit():
-            targets.append(target)
-
-    threads = []
-    config_queue = Queue()
-
-    with progress_spinner(targets) as progress:
-        for target in targets:
-            thread = Thread(
-                target=_get_mech_ssh_config,
-                args=(config_queue, progress, target),
-            )
-            threads.append(thread)
-            thread.start()
-
-    for thread in threads:
-        thread.join()
-
-    queue_items = list(config_queue.queue)
-
-    lines = []
-    for output in queue_items:
-        lines.extend(output)
-
-    return lines
-
-
-@memoize
-def get_mech_options():
-    if path.exists("@mech.json"):
-        with open("@mech.json", "r", encoding="utf-8") as f:
-            return json.loads(f.read())
-    return {}
-
-
-def _make_name_data(host):
-    mech_options = get_mech_options()
-    mech_host = host["Host"]
-
-    data = {
-        "ssh_hostname": host["HostName"],
-    }
-
-    for config_key, data_key in (
-        ("Port", "ssh_port"),
-        ("User", "ssh_user"),
-        ("IdentityFile", "ssh_key"),
-    ):
-        if config_key in host:
-            data[data_key] = host[config_key]
-
-    # Update any configured JSON data
-    if mech_host in mech_options.get("data", {}):
-        data.update(mech_options["data"][mech_host])
-
-    # Work out groups
-    groups = mech_options.get("groups", {}).get(mech_host, [])
-
-    if "@mech" not in groups:
-        groups.append("@mech")
-
-    return "@mech/{0}".format(host["Host"]), data, groups
-
-
-def make_names_data(limit=None):
-    mech_ssh_info = get_mech_config(limit)
-
-    logger.debug("Got Mech SSH info: \n%s", mech_ssh_info)
-
-    hosts = []
-    current_host = None
-
-    for line in mech_ssh_info:
-        if not line:
-            if current_host:
-                hosts.append(_make_name_data(current_host))
-
-            current_host = None
-            continue
-
-        key, value = line.strip().split(" ", 1)
-
-        if key == "Host":
-            if current_host:
-                hosts.append(_make_name_data(current_host))
-
-            # Set the new host
-            current_host = {
-                key: value,
-            }
-
-        elif current_host:
-            current_host[key] = value
-
-        else:
-            logger.debug("Extra Mech SSH key/value (%s=%s)", key, value)
-
-    if current_host:
-        hosts.append(_make_name_data(current_host))
-
-    if not hosts:
-        raise InventoryError("No running Mech instances found!")
-
-    return hosts

pyinfra/connectors/pyinfrawinrmsession/__init__.py

@@ -1,28 +0,0 @@
-import base64
-
-import winrm
-
-
-class PyinfraWinrmSession(winrm.Session):
-    """This is our subclassed Session that allows for env setting"""
-
-    def run_cmd(self, command, args=(), env=None):
-        shell_id = self.protocol.open_shell(env_vars=env)
-        command_id = self.protocol.run_command(shell_id, command, args)
-        rs = winrm.Response(self.protocol.get_command_output(shell_id, command_id))
-        self.protocol.cleanup_command(shell_id, command_id)
-        self.protocol.close_shell(shell_id)
-        return rs
-
-    def run_ps(self, script, env=None):
-        """base64 encodes a Powershell script and executes the powershell
-        encoded script command
-        """
-        # must use utf16 little endian on windows
-        encoded_ps = base64.b64encode(script.encode("utf_16_le")).decode("ascii")
-        rs = self.run_cmd("powershell -encodedcommand {0}".format(encoded_ps), env=env)
-        if len(rs.std_err):
-            # if there was an error message, clean it it up and make it human
-            # readable
-            rs.std_err = self._clean_error_msg(rs.std_err)
-        return rs