pyinfra 3.0.dev0__py2.py3-none-any.whl → 3.0.1__py2.py3-none-any.whl

pyinfra/facts/git.py

@@ -5,32 +5,29 @@ import re
 from pyinfra.api.facts import FactBase
 
 
-class GitBranch(FactBase):
-    requires_command = "git"
+class GitFactBase(FactBase):
+    def requires_command(self, *args, **kwargs) -> str:
+        return "git"
 
-    @staticmethod
-    def command(repo):
+
+class GitBranch(GitFactBase):
+    def command(self, repo) -> str:
         return "! test -d {0} || (cd {0} && git describe --all)".format(repo)
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         return re.sub(r"(heads|tags)/", r"", "\n".join(output))
 
 
-class GitConfig(FactBase):
+class GitConfig(GitFactBase):
     default = dict
 
-    requires_command = "git"
-
-    @staticmethod
-    def command(repo=None):
+    def command(self, repo=None) -> str:
         if repo is None:
             return "git config --global -l || true"
 
         return "! test -d {0} || (cd {0} && git config --local -l)".format(repo)
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         items: dict[str, list[str]] = {}
 
         for line in output:
@@ -40,19 +37,15 @@ class GitConfig(FactBase):
         return items
 
 
-class GitTrackingBranch(FactBase):
-    requires_command = "git"
-
-    @staticmethod
-    def command(repo):
+class GitTrackingBranch(GitFactBase):
+    def command(self, repo) -> str:
         return r"! test -d {0} || (cd {0} && git status --branch --porcelain)".format(repo)
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         if not output:
             return None
 
-        m = re.search(r"\.{3}(\S+)\b", output[0])
+        m = re.search(r"\.{3}(\S+)\b", list(output)[0])
         if m:
             return m.group(1)
         return None

pyinfra/facts/gpg.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from urllib.parse import urlparse
 
 from pyinfra.api import FactBase
@@ -6,7 +8,8 @@ from pyinfra.api import FactBase
 class GpgFactBase(FactBase):
     abstract = True
 
-    requires_command = "gpg"
+    def requires_command(self, *args, **kwargs) -> str:
+        return "gpg"
 
     key_record_type = "pub"
     subkey_record_type = "sub"

pyinfra/facts/hardware.py

@@ -5,17 +5,17 @@ import re
 from pyinfra.api import FactBase, ShortFactBase
 
 
-class Cpus(FactBase):
+class Cpus(FactBase[int]):
     """
     Returns the number of CPUs on this server.
     """
 
-    command = "getconf NPROCESSORS_ONLN 2> /dev/null || getconf _NPROCESSORS_ONLN"
+    def command(self) -> str:
+        return "getconf NPROCESSORS_ONLN 2> /dev/null || getconf _NPROCESSORS_ONLN"
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         try:
-            return int(output[0])
+            return int(list(output)[0])
         except ValueError:
             pass
 
@@ -25,11 +25,13 @@ class Memory(FactBase):
     Returns the memory installed in this server, in MB.
     """
 
-    command = "vmstat -s"
-    requires_command = "vmstat"
+    def requires_command(self) -> str:
+        return "vmstat"
+
+    def command(self) -> str:
+        return "vmstat -s"
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         data = {}
 
         for line in output:
@@ -75,10 +77,12 @@ class BlockDevices(FactBase):
         }
     """
 
-    command = "df"
     regex = r"([a-zA-Z0-9\/\-_]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]{1,3})%\s+([a-zA-Z\/0-9\-_]+)"  # noqa: E501
     default = dict
 
+    def command(self) -> str:
+        return "df"
+
     def process(self, output):
         devices = {}
 
@@ -99,157 +103,201 @@ class BlockDevices(FactBase):
         return devices
 
 
-nettools_1_regexes = [
-    (
-        r"^inet addr:([0-9\.]+).+Bcast:([0-9\.]+).+Mask:([0-9\.]+)$",
-        ("ipv4", "address", "broadcast", "netmask"),
-    ),
-    (
-        r"^inet6 addr: ([0-9a-z:]+)\/([0-9]+) Scope:Global",
-        ("ipv6", "address", "mask_bits"),
-    ),
-]
-
-nettools_2_regexes = [
-    (
-        r"^inet ([0-9\.]+)\s+netmask ([0-9\.fx]+)(?:\s+broadcast ([0-9\.]+))?$",
-        ("ipv4", "address", "netmask", "broadcast"),
-    ),
-    (
-        r"^inet6 ([0-9a-z:]+)\s+prefixlen ([0-9]+)",
-        ("ipv6", "address", "mask_bits"),
-    ),
-]
-
-iproute2_regexes = [
-    (
-        r"^inet ([0-9\.]+)\/([0-9]{1,2})(?:\s+brd ([0-9\.]+))?",
-        ("ipv4", "address", "mask_bits", "broadcast"),
-    ),
-    (
-        r"^inet6 ([0-9a-z:]+)\/([0-9]{1,3})",
-        ("ipv6", "address", "mask_bits"),
-    ),
-]
-
-
-def _parse_regexes(regexes, lines):
-    data: dict[str, dict] = {
-        "ipv4": {},
-        "ipv6": {},
-    }
-
-    for line in lines:
-        for regex, groups in regexes:
-            matches = re.match(regex, line)
-            if matches:
-                ip_data = {}
-
-                for i, group in enumerate(groups[1:]):
-                    ip_data[group] = matches.group(i + 1)
-
-                if "mask_bits" in ip_data:
-                    ip_data["mask_bits"] = int(ip_data["mask_bits"])
-
-                target_group = data[groups[0]]
-                if target_group.get("address"):
-                    target_group.setdefault("additional_ips", []).append(ip_data)
-                else:
-                    target_group.update(ip_data)
-
-                break
-
-    return data
-
-
 class NetworkDevices(FactBase):
     """
     Gets & returns a dict of network devices. See the ``ipv4_addresses`` and
     ``ipv6_addresses`` facts for easier-to-use shortcuts to get device addresses.
 
     .. code:: python
-
-        {
-            "eth0": {
-                "ipv4": {
-                    "address": "127.0.0.1",
-                    "broadcast": "127.0.0.13",
-                    # Only one of these will exist:
-                    "netmask": "255.255.255.255",
-                    "mask_bits": 32,
-                },
-                "ipv6": {
-                    "address": "fe80::a00:27ff:fec3:36f0",
-                    "mask_bits": 64,
-                    "additional_ips": [{
-                        "address": "fe80::",
-                        "mask_bits": 128,
-                    }],
-                }
+        "enp1s0": {
+            "ether": "12:34:56:78:9A:BC",
+            "mtu": 1500,
+            "state": "UP",
+            "ipv4": {
+                "address": "192.168.1.100",
+                "mask_bits": 24,
+                "netmask": "255.255.255.0"
+            },
+            "ipv6": {
+                "address": "2001:db8:85a3::8a2e:370:7334",
+                "mask_bits": 64,
+                "additional_ips": [
+                    {
+                        "address": "fe80::1234:5678:9abc:def0",
+                        "mask_bits": 64
+                    }
+                ]
+            }
+        },
+        "incusbr0": {
+            "ether": "DE:AD:BE:EF:CA:FE",
+            "mtu": 1500,
+            "state": "UP",
+            "ipv4": {
+                "address": "10.0.0.1",
+                "mask_bits": 24,
+                "netmask": "255.255.255.0"
             },
+            "ipv6": {
+                "address": "fe80::dead:beef:cafe:babe",
+                "mask_bits": 64,
+                "additional_ips": [
+                    {
+                        "address": "2001:db8:1234:5678::1",
+                        "mask_bits": 64
+                    }
+                ]
+            }
+        },
+        "lo": {
+            "mtu": 65536,
+            "state": "UP",
+            "ipv6": {
+                "address": "::1",
+                "mask_bits": 128
+            }
+        },
+        "veth98806fd6": {
+            "ether": "AA:BB:CC:DD:EE:FF",
+            "mtu": 1500,
+            "state": "UP"
+        },
+        "vethda29df81": {
+            "ether": "11:22:33:44:55:66",
+            "mtu": 1500,
+            "state": "UP"
+        },
+        "wlo1": {
+            "ether": "77:88:99:AA:BB:CC",
+            "mtu": 1500,
+            "state": "UNKNOWN"
         }
     """
 
-    command = "ip addr show 2> /dev/null || ifconfig"
     default = dict
 
+    def command(self) -> str:
+        return "ip addr show 2> /dev/null || ifconfig -a"
+
     # Definition of valid interface names for Linux:
     # https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/net/core/dev.c?h=v5.1.3#n1020
-    _start_regexes = [
-        (
-            r"^([^/: \s]+)\s+Link encap:",
-            lambda lines: _parse_regexes(nettools_1_regexes, lines),
-        ),
-        (
-            r"^([^/: \s]+): flags=",
-            lambda lines: _parse_regexes(nettools_2_regexes, lines),
-        ),
-        (
-            r"^[0-9]+: ([^/: \s]+): ",
-            lambda lines: _parse_regexes(iproute2_regexes, lines),
-        ),
-    ]
-
     def process(self, output):
-        devices = {}
-
-        # Store current matches (start lines), the handler and any lines
-        matches = None
-        handler = None
-        line_buffer = []
+        def mask(value):
+            try:
+                if value.startswith("0x"):
+                    mask_bits = bin(int(value, 16)).count("1")
+                else:
+                    mask_bits = int(value)
+                netmask = ".".join(
+                    str((0xFFFFFFFF << (32 - b) >> mask_bits) & 0xFF) for b in (24, 16, 8, 0)
+                )
+            except ValueError:
+                mask_bits = sum(bin(int(x)).count("1") for x in value.split("."))
+                netmask = value
 
-        for line in output:
-            line = line.strip()
+            return mask_bits, netmask
 
-            matched = False
+        # Strip lines and merge them as a block of text
+        output = "\n".join(map(str.strip, output))
 
-            # Look for start lines
-            for regex, new_handler in self._start_regexes:
-                new_matches = re.match(regex, line)
+        # Splitting the output into sections per network device
+        device_sections = re.split(r"\n(?=\d+: [^\s/:]|[^\s/:]+:.*mtu )", output)
 
-                # If we find a start line
-                if new_matches:
-                    matched = True
+        # Dictionary to hold all device information
+        all_devices = {}
 
-                    # Assign any current matches with current handler, reset buffer
-                    if matches:
-                        devices[matches.group(1)] = handler(line_buffer)
-                        line_buffer = []
+        for section in device_sections:
+            # Extracting the device name
+            device_name_match = re.match(r"^(?:\d+: )?([^\s/:]+):", section)
+            if not device_name_match:
+                continue
+            device_name = device_name_match.group(1)
+
+            # Regular expressions to match different parts of the output
+            ether_re = re.compile(r"ether ([0-9A-Fa-f:]{17})")
+            mtu_re = re.compile(r"mtu (\d+)")
+            ipv4_re = (
+                # ip a
+                re.compile(
+                    r"inet (?P<address>\d+\.\d+\.\d+\.\d+)/(?P<mask>\d+)(?: metric \d+)?(?: brd (?P<broadcast>\d+\.\d+\.\d+\.\d+))?"  # noqa: E501
+                ),
+                # ifconfig -a
+                re.compile(
+                    r"inet (?P<address>\d+\.\d+\.\d+\.\d+)\s+netmask\s+(?P<mask>(?:\d+\.\d+\.\d+\.\d+)|(?:[0-9a-fA-FxX]+))(?:\s+broadcast\s+(?P<broadcast>\d+\.\d+\.\d+\.\d+))?"  # noqa: E501
+                ),
+            )
+            ipv6_re = (
+                # ip a
+                re.compile(r"inet6\s+(?P<address>[0-9a-fA-F:]+)/(?P<mask>\d+)"),
+                # ifconfig -a
+                re.compile(r"inet6\s+(?P<address>[0-9a-fA-F:]+)\s+prefixlen\s+(?P<mask>\d+)"),
+            )
+
+            # Parsing the output
+            ether = ether_re.search(section)
+            mtu = mtu_re.search(section)
+
+            # Building the result dictionary for the device
+            device_info = {}
+            if ether:
+                device_info["ether"] = ether.group(1)
+            if mtu:
+                device_info["mtu"] = int(mtu.group(1))
+
+            device_info["state"] = (
+                "UP" if "UP" in section else "DOWN" if "DOWN" in section else "UNKNOWN"
+            )
+
+            # IPv4 Addresses
+            ipv4_matches: list[re.Match[str]]
+            for ipv4_re_ in ipv4_re:
+                ipv4_matches = list(ipv4_re_.finditer(section))
+                if len(ipv4_matches):
+                    break
 
-                    # Set new matches/handler
-                    matches = new_matches
-                    handler = new_handler
+            if len(ipv4_matches):
+                ipv4_info = []
+                for ipv4 in ipv4_matches:
+                    address = ipv4.group("address")
+                    mask_value = ipv4.group("mask")
+                    mask_bits, netmask = mask(mask_value)
+                    try:
+                        broadcast = ipv4.group("broadcast")
+                    except IndexError:
+                        broadcast = None
+
+                    ipv4_info.append(
+                        {
+                            "address": address,
+                            "mask_bits": mask_bits,
+                            "netmask": netmask,
+                            "broadcast": broadcast,
+                        },
+                    )
+                device_info["ipv4"] = ipv4_info[0]
+                if len(ipv4_matches) > 1:
+                    device_info["ipv4"]["additional_ips"] = ipv4_info[1:]  # type: ignore[index]
+
+            # IPv6 Addresses
+            ipv6_matches: list[re.Match[str]]
+            for ipv6_re_ in ipv6_re:
+                ipv6_matches = list(ipv6_re_.finditer(section))
+                if ipv6_matches:
                     break
 
-            if not matched:
-                line_buffer.append(line)
+            if len(ipv6_matches):
+                ipv6_info = []
+                for ipv6 in ipv6_matches:
+                    address = ipv6.group("address")
+                    mask_bits = ipv6.group("mask")
+                    ipv6_info.append({"address": address, "mask_bits": int(mask_bits)})
+                device_info["ipv6"] = ipv6_info[0]
+                if len(ipv6_matches) > 1:
+                    device_info["ipv6"]["additional_ips"] = ipv6_info[1:]  # type: ignore[index]
 
-        # Handle any left over matches
-        if matches:
-            assert handler is not None
-            devices[matches.group(1)] = handler(line_buffer)
+            all_devices[device_name] = device_info
 
-        return devices
+        return all_devices
 
 
 class Ipv4Addrs(ShortFactBase):
@@ -276,7 +324,7 @@ class Ipv4Addrs(ShortFactBase):
             ips = []
 
             ip_details = details.get(self.ip_type)
-            if not ip_details:
+            if not ip_details or not ip_details.get("address"):
                 continue
 
             ips.append(ip_details["address"])
@@ -335,7 +383,7 @@ class Ipv4Addresses(ShortFactBase):
 
         for interface, details in data.items():
             ip_details = details.get(self.ip_type)
-            if not ip_details:
+            if not ip_details or not ip_details.get("address"):
                 continue  # pragma: no cover
 
             addresses[interface] = ip_details["address"]

pyinfra/facts/launchd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 
@@ -6,8 +8,11 @@ class LaunchdStatus(FactBase):
     Returns a dict of name -> status for launchd managed services.
     """
 
-    command = "launchctl list"
-    requires_command = "launchctl"
+    def command(self) -> str:
+        return "launchctl list"
+
+    def requires_command(self) -> str:
+        return "launchctl"
 
     default = dict
 

pyinfra/facts/lxd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from pyinfra.api import FactBase
@@ -8,11 +10,15 @@ class LxdContainers(FactBase):
     Returns a list of running LXD containers
     """
 
-    command = "lxc list --format json --fast"
-    requires_command = "lxc"
+    def command(self) -> str:
+        return "lxc list --format json --fast"
+
+    def requires_command(self) -> str:
+        return "lxc"
 
     default = list
 
     def process(self, output):
+        output = list(output)
         assert len(output) == 1
         return json.loads(output[0])

pyinfra/facts/mysql.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from collections import defaultdict
 
@@ -8,11 +10,11 @@ from .util.databases import parse_columns_and_rows
 
 
 def make_mysql_command(
-    database=None,
-    user=None,
-    password=None,
-    host=None,
-    port=None,
+    database: str | None = None,
+    user: str | None = None,
+    password: str | None = None,
+    host: str | None = None,
+    port: int | None = None,
     executable="mysql",
 ):
     target_bits = [executable]
@@ -37,7 +39,11 @@ def make_mysql_command(
     return StringCommand(*target_bits)
 
 
-def make_execute_mysql_command(command, ignore_errors=False, **mysql_kwargs):
+def make_execute_mysql_command(
+    command: str | StringCommand,
+    ignore_errors=False,
+    **mysql_kwargs,
+):
     commands_bits = [
         make_mysql_command(**mysql_kwargs),
         "-Be",
@@ -54,9 +60,11 @@ class MysqlFactBase(FactBase):
     abstract = True
 
     mysql_command: str
-    requires_command = "mysql"
     ignore_errors = False
 
+    def requires_command(self, *args, **kwargs) -> str:
+        return "mysql"
+
     def command(
         self,
         # Details for speaking to MySQL via `mysql` CLI via `mysql` CLI
@@ -64,7 +72,7 @@ class MysqlFactBase(FactBase):
         mysql_password=None,
         mysql_host=None,
         mysql_port=None,
-    ):
+    ) -> StringCommand:
         return make_execute_mysql_command(
             self.mysql_command,
             ignore_errors=self.ignore_errors,
@@ -128,8 +136,7 @@ class MysqlUsers(MysqlFactBase):
     default = dict
     mysql_command = "SELECT * FROM mysql.user"
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         rows = parse_columns_and_rows(output, "\t")
 
         users = {}
@@ -188,7 +195,7 @@ class MysqlUserGrants(MysqlFactBase):
     # Ignore errors as SHOW GRANTS will error if the user does not exist
     ignore_errors = True
 
-    def command(
+    def command(  # type: ignore[override]
         self,
         user,
         hostname="localhost",
@@ -197,7 +204,7 @@ class MysqlUserGrants(MysqlFactBase):
         mysql_password=None,
         mysql_host=None,
         mysql_port=None,
-    ):
+    ) -> StringCommand:
         self.mysql_command = 'SHOW GRANTS FOR "{0}"@"{1}"'.format(user, hostname)
 
         return super().command(

pyinfra/facts/npm.py

@@ -1,4 +1,5 @@
 # encoding: utf8
+from __future__ import annotations
 
 from pyinfra.api import FactBase
 
@@ -20,7 +21,8 @@ class NpmPackages(FactBase):
 
     default = dict
 
-    requires_command = "npm"
+    def requires_command(self, directory=None) -> str:
+        return "npm"
 
     def command(self, directory=None):
         if directory:

pyinfra/facts/openrc.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase
@@ -9,7 +11,6 @@ class OpenrcStatus(FactBase):
     """
 
     default = dict
-    requires_command = "rc-status"
     regex = (
         r"\s+([a-zA-Z0-9\-_]+)"
         r"\s+\[\s+"
@@ -19,6 +20,9 @@ class OpenrcStatus(FactBase):
         r"\s+\]"
     )
 
+    def requires_command(self, runlevel="default") -> str:
+        return "rc-status"
+
     def command(self, runlevel="default"):
         return "rc-status {0}".format(runlevel)
 
@@ -39,7 +43,9 @@ class OpenrcEnabled(FactBase):
     """
 
     default = dict
-    requires_command = "rc-update"
+
+    def requires_command(self, runlevel="default") -> str:
+        return "rc-update"
 
     def command(self, runlevel="default"):
         self.runlevel = runlevel