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

pyinfra/facts/deb.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import re
+import shlex
 
 from pyinfra.api import FactBase
 
@@ -54,8 +57,10 @@ class DebPackage(FactBase):
 
     requires_command = "dpkg"
 
-    def command(self, name):
-        return "! test -e {0} && (dpkg -s {0} 2>/dev/null || true) || dpkg -I {0}".format(name)
+    def command(self, package):
+        return "! test -e {0} && (dpkg -s {0} 2>/dev/null || true) || dpkg -I {0}".format(
+            shlex.quote(package)
+        )
 
     def process(self, output):
         data = {}

pyinfra/facts/dnf.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util import make_cat_files_command

pyinfra/facts/docker.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from pyinfra.api import FactBase
@@ -6,6 +8,7 @@ from pyinfra.api import FactBase
 class DockerFactBase(FactBase):
     abstract = True
 
+    docker_type: str
     requires_command = "docker"
 
     def process(self, output):
@@ -83,3 +86,19 @@ class DockerNetwork(DockerSingleMixin):
     """
 
     docker_type = "network"
+
+
+class DockerVolumes(DockerFactBase):
+    """
+    Returns ``docker inspect`` output for all Docker volumes.
+    """
+
+    command = "docker volume inspect `docker volume ls -q`"
+
+
+class DockerVolume(DockerSingleMixin):
+    """
+    Returns ``docker inspect`` output for a single Docker container.
+    """
+
+    docker_type = "volume"

pyinfra/facts/files.py

@@ -2,10 +2,14 @@
 The files facts provide information about the filesystem and it's contents on the target host.
 """
 
+from __future__ import annotations
+
 import re
 import stat
 from datetime import datetime
-from typing import List, Tuple
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+
+from typing_extensions import Literal, NotRequired, TypedDict
 
 from pyinfra.api.command import QuoteString, make_formatted_string_command
 from pyinfra.api.facts import FactBase
@@ -64,7 +68,25 @@ def _parse_mode(mode: str) -> int:
     return int(oct(out)[2:])
 
 
-class File(FactBase):
+def _parse_datetime(value: str) -> Optional[datetime]:
+    value = try_int(value)
+    if isinstance(value, int):
+        return datetime.utcfromtimestamp(value)
+    return None
+
+
+class FileDict(TypedDict):
+    mode: int
+    size: Union[int, str]
+    atime: Optional[datetime]
+    mtime: Optional[datetime]
+    ctime: Optional[datetime]
+    user: str
+    group: str
+    link_target: NotRequired[str]
+
+
+class File(FactBase[Union[FileDict, Literal[False], None]]):
     """
     Returns information about a file on the remote system:
 
@@ -98,36 +120,23 @@ class File(FactBase):
             bsd_stat_command=BSD_STAT_COMMAND,
         )
 
-    def process(self, output):
+    def process(self, output) -> Union[FileDict, Literal[False], None]:
         match = re.match(STAT_REGEX, output[0])
         if not match:
             return None
 
-        data = {}
-        path_type = None
-
-        for key, value in (
-            ("user", match.group(1)),
-            ("group", match.group(2)),
-            ("mode", match.group(3)),
-            ("atime", match.group(4)),
-            ("mtime", match.group(5)),
-            ("ctime", match.group(6)),
-            ("size", match.group(7)),
-        ):
-            if key == "mode":
-                path_type = FLAG_TO_TYPE[value[0]]
-                value = _parse_mode(value[1:])
-
-            elif key == "size":
-                value = try_int(value)
-
-            elif key in ("atime", "mtime", "ctime"):
-                value = try_int(value)
-                if isinstance(value, int):
-                    value = datetime.utcfromtimestamp(value)
-
-            data[key] = value
+        mode = match.group(3)
+        path_type = FLAG_TO_TYPE[mode[0]]
+
+        data: FileDict = {
+            "user": match.group(1),
+            "group": match.group(2),
+            "mode": _parse_mode(mode[1:]),
+            "atime": _parse_datetime(match.group(4)),
+            "mtime": _parse_datetime(match.group(5)),
+            "ctime": _parse_datetime(match.group(6)),
+            "size": try_int(match.group(7)),
+        }
 
         if path_type != self.type:
             return False
@@ -205,7 +214,13 @@ class Socket(File):
     type = "socket"
 
 
-class HashFileFactBase(FactBase):
+if TYPE_CHECKING:
+    FactBaseOptionalStr = FactBase[Optional[str]]
+else:
+    FactBaseOptionalStr = FactBase
+
+
+class HashFileFactBase(FactBaseOptionalStr):
     _raw_cmd: str
     _regexes: Tuple[str, str]
 
@@ -229,13 +244,14 @@ class HashFileFactBase(FactBase):
         self.path = path
         return make_formatted_string_command(self._raw_cmd, QuoteString(path))
 
-    def process(self, output):
+    def process(self, output) -> Optional[str]:
         output = output[0]
         escaped_path = re.escape(self.path)
         for regex in self._regexes:
             matches = re.match(regex % escaped_path, output)
             if matches:
                 return matches.group(1)
+        return None
 
 
 class Sha1File(HashFileFactBase, digits=40, cmds=["sha1sum", "shasum", "sha1"]):
@@ -294,6 +310,7 @@ class FindInFile(FactBase):
 class FindFilesBase(FactBase):
     abstract = True
     default = list
+    type_flag: str
 
     @staticmethod
     def process(output):
@@ -345,7 +362,6 @@ class Flags(FactBase):
         )
 
     def process(self, output):
-
         return [flag for flag in output[0].split(",") if len(flag) > 0] if len(output) == 1 else []
 
 
@@ -381,7 +397,6 @@ class Block(FactBase):
     default = list
 
     def command(self, path, marker=None, begin=None, end=None):
-
         self.path = path
         start = (marker or MARKER_DEFAULT).format(mark=begin or MARKER_BEGIN_DEFAULT)
         end = (marker or MARKER_DEFAULT).format(mark=end or MARKER_END_DEFAULT)

pyinfra/facts/gem.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/git.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api.facts import FactBase
@@ -29,7 +31,7 @@ class GitConfig(FactBase):
 
     @staticmethod
     def process(output):
-        items = {}
+        items: dict[str, list[str]] = {}
 
         for line in output:
             key, value = line.split("=", 1)

pyinfra/facts/gpg.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from urllib.parse import urlparse
 
 from pyinfra.api import FactBase
@@ -48,7 +50,7 @@ class GpgFactBase(FactBase):
 
             elif current_subkey or current_key:
                 target = current_subkey or current_key
-
+                assert target is not None
                 if bits[0] == "fpr":
                     target["fingerprint"] = bits[9]  # fingerprint = field 10
                 elif bits[0] == "uid":

pyinfra/facts/hardware.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase, ShortFactBase
@@ -193,28 +195,36 @@ class NetworkDevices(FactBase):
         output = "\n".join(map(str.strip, output))
 
         # Splitting the output into sections per network device
-        device_sections = re.split(r"\n(?=\d+: \w|\w+:.*mtu.*)", output)
+        device_sections = re.split(r"\n(?=\d+: [^\s/:]|[^\s/:]+:.*mtu )", output)
 
         # Dictionary to hold all device information
         all_devices = {}
 
         for section in device_sections:
             # Extracting the device name
-            device_name_match = re.match(r"^(?:\d+: )?([\w@]+):", section)
+            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"([0-9A-Fa-f:]{17})")
+            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 (\d+\.\d+\.\d+\.\d+)/(\d+)(?: brd (\d+\.\d+\.\d+\.\d+))"
-                ),  # ip a output,
+                    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 (\d+\.\d+\.\d+\.\d+)\s+netmask\s+((?:\d+\.\d+\.\d+\.\d+)|(?:[0-9a-fA-FxX]+))(?:\s+broadcast\s+(\d+\.\d+\.\d+\.\d+))"  # noqa: E501
-                ),  # ifconfig -a output
+                    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
@@ -233,18 +243,22 @@ class NetworkDevices(FactBase):
             )
 
             # IPv4 Addresses
+            ipv4_matches: list[re.Match[str]]
             for ipv4_re_ in ipv4_re:
-                ipv4_matches = ipv4_re_.findall(section)
-                if ipv4_matches:
+                ipv4_matches = list(ipv4_re_.finditer(section))
+                if len(ipv4_matches):
                     break
 
-            if ipv4_matches:
+            if len(ipv4_matches):
                 ipv4_info = []
                 for ipv4 in ipv4_matches:
-                    address = ipv4[0]
-                    mask_value = ipv4[1]
+                    address = ipv4.group("address")
+                    mask_value = ipv4.group("mask")
                     mask_bits, netmask = mask(mask_value)
-                    broadcast = ipv4[2] if len(ipv4) == 3 else None
+                    try:
+                        broadcast = ipv4.group("broadcast")
+                    except IndexError:
+                        broadcast = None
 
                     ipv4_info.append(
                         {
@@ -256,28 +270,24 @@ class NetworkDevices(FactBase):
                     )
                 device_info["ipv4"] = ipv4_info[0]
                 if len(ipv4_matches) > 1:
-                    device_info["ipv4"]["additional_ips"] = ipv4_info[1:]
+                    device_info["ipv4"]["additional_ips"] = ipv4_info[1:]  # type: ignore[index]
 
             # IPv6 Addresses
-            ipv6_re = (
-                re.compile(r"inet6\s+([0-9a-fA-F:]+)/(\d+)"),
-                re.compile(r"inet6\s+([0-9a-fA-F:]+)\s+prefixlen\s+(\d+)"),
-            )
-
+            ipv6_matches: list[re.Match[str]]
             for ipv6_re_ in ipv6_re:
-                ipv6_matches = ipv6_re_.findall(section)
+                ipv6_matches = list(ipv6_re_.finditer(section))
                 if ipv6_matches:
                     break
 
-            if ipv6_matches:
+            if len(ipv6_matches):
                 ipv6_info = []
                 for ipv6 in ipv6_matches:
-                    address = ipv6[0]
-                    mask_bits = ipv6[1] or ipv6[2]
+                    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:]
+                    device_info["ipv6"]["additional_ips"] = ipv6_info[1:]  # type: ignore[index]
 
             all_devices[device_name] = device_info
 

pyinfra/facts/iptables.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 # Mapping for iptables code arguments to variable names
@@ -27,16 +29,16 @@ def parse_iptables_rule(line):
 
     bits = line.split()
 
-    definition = {}
+    definition: dict = {}
 
     key = None
-    args = []
+    args: list[str] = []
     not_arg = False
 
     def add_args():
         arg_string = " ".join(args)
 
-        if key in IPTABLES_ARGS:
+        if key and key in IPTABLES_ARGS:
             definition_key = "not_{0}".format(IPTABLES_ARGS[key]) if not_arg else IPTABLES_ARGS[key]
             definition[definition_key] = arg_string
         else:

pyinfra/facts/launchd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 

pyinfra/facts/lxd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from pyinfra.api import FactBase

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",
@@ -53,6 +59,7 @@ def make_execute_mysql_command(command, ignore_errors=False, **mysql_kwargs):
 class MysqlFactBase(FactBase):
     abstract = True
 
+    mysql_command: str
     requires_command = "mysql"
     ignore_errors = False
 

pyinfra/facts/npm.py

@@ -1,4 +1,5 @@
 # encoding: utf8
+from __future__ import annotations
 
 from pyinfra.api import FactBase
 

pyinfra/facts/openrc.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase

pyinfra/facts/pacman.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+import shlex
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
@@ -21,9 +25,9 @@ class PacmanUnpackGroup(FactBase):
 
     default = list
 
-    def command(self, name):
+    def command(self, package):
         # Accept failure here (|| true) for invalid/unknown packages
-        return 'pacman -S --print-format "%n" {0} || true'.format(name)
+        return 'pacman -S --print-format "%n" {0} || true'.format(shlex.quote(package))
 
     def process(self, output):
         return output

pyinfra/facts/pip.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/pkg.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/pkgin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/postgres.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from pyinfra.api import FactBase, MaskString, QuoteString, StringCommand
+from pyinfra.api.util import try_int
+
+from .util.databases import parse_columns_and_rows
+
+
+def make_psql_command(
+    database: str | None = None,
+    user: str | None = None,
+    password: str | None = None,
+    host: str | None = None,
+    port: str | int | None = None,
+    executable="psql",
+) -> StringCommand:
+    target_bits: list[str] = []
+
+    if password:
+        target_bits.append(MaskString('PGPASSWORD="{0}"'.format(password)))
+
+    target_bits.append(executable)
+
+    if database:
+        target_bits.append("-d {0}".format(database))
+
+    if user:
+        target_bits.append("-U {0}".format(user))
+
+    if host:
+        target_bits.append("-h {0}".format(host))
+
+    if port:
+        target_bits.append("-p {0}".format(port))
+
+    return StringCommand(*target_bits)
+
+
+def make_execute_psql_command(command, **psql_kwargs):
+    return StringCommand(
+        make_psql_command(**psql_kwargs),
+        "-Ac",
+        QuoteString(command),  # quote this whole item as a single shell argument
+    )
+
+
+class PostgresFactBase(FactBase):
+    abstract = True
+
+    psql_command: str
+    requires_command = "psql"
+
+    def command(
+        self,
+        psql_user=None,
+        psql_password=None,
+        psql_host=None,
+        psql_port=None,
+    ):
+        return make_execute_psql_command(
+            self.psql_command,
+            user=psql_user,
+            password=psql_password,
+            host=psql_host,
+            port=psql_port,
+        )
+
+
+class PostgresRoles(PostgresFactBase):
+    """
+    Returns a dict of PostgreSQL roles and data:
+
+    .. code:: python
+
+        {
+            "pyinfra": {
+                "super": true,
+                "createrole": false,
+                "createdb": false,
+                ...
+            },
+        }
+    """
+
+    default = dict
+    psql_command = "SELECT * FROM pg_catalog.pg_roles"
+
+    def process(self, output):
+        # Remove the last line of the output (row count)
+        output = output[:-1]
+        rows = parse_columns_and_rows(
+            output,
+            "|",
+            # Remove the "rol" prefix on column names
+            remove_column_prefix="rol",
+        )
+
+        users = {}
+
+        for details in rows:
+            for key, value in list(details.items()):
+                if key in ("oid", "connlimit"):
+                    details[key] = try_int(value)
+
+                if key in (
+                    "super",
+                    "inherit",
+                    "createrole",
+                    "createdb",
+                    "canlogin",
+                    "replication",
+                    "bypassrls",
+                ):
+                    details[key] = value == "t"
+
+            users[details.pop("name")] = details
+
+        return users
+
+
+class PostgresDatabases(PostgresFactBase):
+    """
+    Returns a dict of PostgreSQL databases and metadata:
+
+    .. code:: python
+
+        {
+            "pyinfra_stuff": {
+                "encoding": "UTF8",
+                "collate": "en_US.UTF-8",
+                "ctype": "en_US.UTF-8",
+                ...
+            },
+        }
+    """
+
+    default = dict
+    psql_command = "SELECT pg_catalog.pg_encoding_to_char(encoding), * FROM pg_catalog.pg_database"
+
+    def process(self, output):
+        # Remove the last line of the output (row count)
+        output = output[:-1]
+        rows = parse_columns_and_rows(
+            output,
+            "|",
+            # Remove the "dat" prefix on column names
+            remove_column_prefix="dat",
+        )
+
+        databases = {}
+
+        for details in rows:
+            details["encoding"] = details.pop("pg_encoding_to_char")
+
+            for key, value in list(details.items()):
+                if key.endswith("id") or key in (
+                    "dba",
+                    "tablespace",
+                    "connlimit",
+                ):
+                    details[key] = try_int(value)
+
+                if key in ("istemplate", "allowconn"):
+                    details[key] = value == "t"
+
+            databases[details.pop("name")] = details
+
+        return databases