pyinfra 3.1.1__py2.py3-none-any.whl → 3.2__py2.py3-none-any.whl

pyinfra/facts/files.py

@@ -12,9 +12,11 @@ from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 
 from typing_extensions import Literal, NotRequired, TypedDict
 
+from pyinfra.api import StringCommand
 from pyinfra.api.command import QuoteString, make_formatted_string_command
 from pyinfra.api.facts import FactBase
 from pyinfra.api.util import try_int
+from pyinfra.facts.util.units import parse_size
 
 LINUX_STAT_COMMAND = "stat -c 'user=%U group=%G mode=%A atime=%X mtime=%Y ctime=%Z size=%s %N'"
 BSD_STAT_COMMAND = "stat -f 'user=%Su group=%Sg mode=%Sp atime=%a mtime=%m ctime=%c size=%z %N%SY'"
@@ -274,6 +276,12 @@ class Sha256File(HashFileFactBase, digits=64, cmds=["sha256sum", "shasum -a 256"
     """
 
 
+class Sha384File(HashFileFactBase, digits=96, cmds=["sha384sum", "shasum -a 384", "sha384"]):
+    """
+    Returns a SHA384 hash of a file, or ``None`` if the file does not exist.
+    """
+
+
 class Md5File(HashFileFactBase, digits=32, cmds=["md5sum", "md5"]):
     """
     Returns an MD5 hash of a file, or ``None`` if the file does not exist.
@@ -322,12 +330,91 @@ class FindFilesBase(FactBase):
     def process(self, output):
         return output
 
-    def command(self, path, quote_path=True):
-        return make_formatted_string_command(
-            "find {0} -type {type_flag} || true",
-            QuoteString(path) if quote_path else path,
-            type_flag=self.type_flag,
-        )
+    def command(
+        self,
+        path: str,
+        size: Optional[str | int] = None,
+        min_size: Optional[str | int] = None,
+        max_size: Optional[str | int] = None,
+        maxdepth: Optional[int] = None,
+        fname: Optional[str] = None,
+        iname: Optional[str] = None,
+        regex: Optional[str] = None,
+        args: Optional[List[str]] = None,
+        quote_path=True,
+    ):
+        """
+        @param path: the path to start the search from
+        @param size: exact size in bytes or human-readable format.
+                     GB means 1e9 bytes, GiB means 2^30 bytes
+        @param min_size: minimum size in bytes or human-readable format
+        @param max_size: maximum size in bytes or human-readable format
+        @param maxdepth: maximum depth to descend to
+        @param name: True if the last component of the pathname being examined matches pattern.
+                      Special shell pattern matching characters (“[”, “]”, “*”, and “?”)
+                      may be used as part of pattern.
+                      These characters may be matched explicitly
+                      by escaping them with a backslash (“\\”).
+
+        @param iname: Like -name, but the match is case insensitive.
+        @param regex: True if the whole path of the file matches pattern using regular expression.
+        @param args: additional arguments to pass to find
+        @param quote_path: if the path should be quoted
+        @return:
+        """
+        if args is None:
+            args = []
+
+        def maybe_quote(value):
+            return QuoteString(value) if quote_path else value
+
+        command = [
+            "find",
+            maybe_quote(path),
+            "-type",
+            self.type_flag,
+        ]
+
+        """
+        Why we need special handling for size:
+        https://unix.stackexchange.com/questions/275925/why-does-find-size-1g-not-find-any-files
+        In short, 'c' means bytes, without it, it means 512-byte blocks.
+        If we use any units other than 'c', it has a weird rounding behavior,
+        and is implementation-specific. So, we always use 'c'
+        """
+        if "-size" not in args:
+            if min_size is not None:
+                command.append("-size")
+                command.append("+{0}c".format(parse_size(min_size)))
+
+            if max_size is not None:
+                command.append("-size")
+                command.append("-{0}c".format(parse_size(max_size)))
+
+            if size is not None:
+                command.append("-size")
+                command.append("{0}c".format(size))
+
+        if maxdepth is not None and "-maxdepth" not in args:
+            command.append("-maxdepth")
+            command.append("{0}".format(maxdepth))
+
+        if fname is not None and "-fname" not in args:
+            command.append("-name")
+            command.append(maybe_quote(fname))
+
+        if iname is not None and "-iname" not in args:
+            command.append("-iname")
+            command.append(maybe_quote(iname))
+
+        if regex is not None and "-regex" not in args:
+            command.append("-regex")
+            command.append(maybe_quote(regex))
+
+        command.append("||")
+        command.append("true")
+
+        return StringCommand(*command)
 
 
 class FindFiles(FindFilesBase):

pyinfra/facts/git.py

@@ -21,9 +21,10 @@ class GitBranch(GitFactBase):
 class GitConfig(GitFactBase):
     default = dict
 
-    def command(self, repo=None) -> str:
+    def command(self, repo=None, system=False) -> str:
         if repo is None:
-            return "git config --global -l || true"
+            level = "--system" if system else "--global"
+            return f"git config {level} -l || true"
 
         return "! test -d {0} || (cd {0} && git config --local -l)".format(repo)
 

pyinfra/facts/mysql.py

@@ -214,8 +214,7 @@ class MysqlUserGrants(MysqlFactBase):
             mysql_port,
         )
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         database_table_privileges = defaultdict(set)
 
         for line in output:

pyinfra/facts/opkg.py

@@ -0,0 +1,233 @@
+"""
+Gather the information provided by ``opkg`` on OpenWrt systems:
+    + ``opkg`` configuration
+    + feeds configuration
+    + list of installed packages
+    + list of packages with available upgrades
+
+
+    see https://openwrt.org/docs/guide-user/additional-software/opkg
+"""
+
+import re
+from typing import Dict, NamedTuple, Union
+
+from pyinfra import logger
+from pyinfra.api import FactBase
+from pyinfra.facts.util.packaging import parse_packages
+
+# TODO - change NamedTuple to dataclass Opkgbut need to figure out how to get json serialization
+#        to work without changing core code
+
+
+class OpkgPkgUpgradeInfo(NamedTuple):
+    installed: str
+    available: str
+
+
+class OpkgConfInfo(NamedTuple):
+    paths: Dict[str, str]  # list of paths, e.g. {'root':'/', 'ram':'/tmp}
+    list_dir: str  # where package lists are stored, e.g. /var/opkg-lists
+    options: Dict[
+        str, Union[str, bool]
+    ]  # mapping from option to value, e.g. {'check_signature': True}
+    arch_cfg: Dict[str, int]  # priorities for architectures
+
+
+class OpkgFeedInfo(NamedTuple):
+    url: str  # url for the feed
+    fmt: str  # format of the feed, e.g. "src/gz"
+    kind: str  # whether it comes from the 'distribution' or is 'custom'
+
+
+class OpkgConf(FactBase):
+    """
+    Returns a NamedTuple with the current configuration:
+
+    .. code:: python
+
+        ConfInfo(
+            paths = {
+                "root": "/",
+                "ram": "/tmp",
+            },
+            list_dir = "/opt/opkg-lists",
+            options = {
+                "overlay_root": "/overlay"
+            },
+            arch_cfg = {
+                "all": 1,
+                "noarch": 1,
+                "i386_pentium": 10
+            }
+        )
+
+    """
+
+    regex = re.compile(
+        r"""
+                       ^(?:\s*)
+                       (?:
+                       (?:arch\s+(?P<arch>\w+)\s+(?P<priority>\d+))|
+                       (?:dest\s+(?P<dest>\w+)\s+(?P<dest_path>[\w/\-]+))|
+                       (?:lists_dir\s+(?P<lists_dir>ext)\s+(?P<list_path>[\w/\-]+))|
+                       (?:option\s+(?P<option>\w+)(?:\s+(?P<value>[^#]+))?)
+                       )?
+                       (?:\s*\#.*)?
+                       $
+                       """,
+        re.X,
+    )
+
+    @staticmethod
+    def default():
+        return OpkgConfInfo({}, "", {}, {})
+
+    def command(self) -> str:
+        return "cat /etc/opkg.conf"
+
+    def process(self, output):
+        dest, lists_dir, options, arch_cfg = {}, "", {}, {}
+        for line in output:
+            match = self.regex.match(line)
+
+            if match is None:
+                logger.warning(f"Opkg: could not parse opkg.conf line '{line}'")
+            elif match.group("arch") is not None:
+                arch_cfg[match.group("arch")] = int(match.group("priority"))
+            elif match.group("dest") is not None:
+                dest[match.group("dest")] = match.group("dest_path")
+            elif match.group("lists_dir") is not None:
+                lists_dir = match.group("list_path")
+            elif match.group("option") is not None:
+                options[match.group("option")] = match.group("value") or True
+
+        return OpkgConfInfo(dest, lists_dir, options, arch_cfg)
+
+
+class OpkgFeeds(FactBase):
+    """
+    Returns a dictionary containing the information for the distribution-provided and
+    custom opkg feeds:
+
+    .. code:: python
+
+        {
+         'openwrt_base': FeedInfo(url='http://downloads ... /i386_pentium/base', fmt='src/gz', kind='distribution'), # noqa: E501
+         'openwrt_core': FeedInfo(url='http://downloads ... /x86/geode/packages', fmt='src/gz', kind='distribution'), # noqa: E501
+         'openwrt_luci': FeedInfo(url='http://downloads ... /i386_pentium/luci', fmt='src/gz', kind='distribution'),# noqa: E501
+         'openwrt_packages': FeedInfo(url='http://downloads ... /i386_pentium/packages', fmt='src/gz', kind='distribution'),# noqa: E501
+         'openwrt_routing': FeedInfo(url='http://downloads ... /i386_pentium/routing', fmt='src/gz', kind='distribution'),# noqa: E501
+         'openwrt_telephony': FeedInfo(url='http://downloads ... /i386_pentium/telephony', fmt='src/gz', kind='distribution') # noqa: E501
+        }
+    """
+
+    regex = re.compile(
+        r"^(CUSTOM)|(?:\s*(?P<fmt>[\w/]+)\s+(?P<name>[\w]+)\s+(?P<url>[\w./:]+))?(?:\s*#.*)?$"
+    )
+    default = dict
+
+    def command(self) -> str:
+        return "cat /etc/opkg/distfeeds.conf; echo CUSTOM; cat /etc/opkg/customfeeds.conf"
+
+    def process(self, output):
+        feeds, kind = {}, "distribution"
+        for line in output:
+            match = self.regex.match(line)
+
+            if match is None:
+                logger.warning(f"Opkg: could not parse /etc/opkg/*feeds.conf line '{line}'")
+            elif match.group(0) == "CUSTOM":
+                kind = "custom"
+            elif match.group("name") is not None:
+                feeds[match.group("name")] = OpkgFeedInfo(
+                    match.group("url"), match.group("fmt"), kind
+                )
+
+        return feeds
+
+
+class OpkgInstallableArchitectures(FactBase):
+    """
+    Returns a dictionary containing the currently installable architectures for this system along
+    with their priority:
+
+    .. code:: python
+
+       {
+         'all': 1,
+         'i386_pentium': 10,
+         'noarch': 1
+        }
+    """
+
+    regex = re.compile(r"^(?:\s*arch\s+(?P<arch>[\w]+)\s+(?P<prio>\d+))?(\s*#.*)?$")
+    default = dict
+
+    def command(self) -> str:
+        return "/bin/opkg print-architecture"
+
+    def process(self, output):
+        arch_list = {}
+        for line in output:
+            match = self.regex.match(line)
+
+            if match is None:
+                logger.warning(f"could not parse arch line '{line}'")
+            elif match.group("arch") is not None:
+                arch_list[match.group("arch")] = int(match.group("prio"))
+
+        return arch_list
+
+
+class OpkgPackages(FactBase):
+    """
+    Returns a dict of installed opkg packages:
+
+    .. code:: python
+
+       {
+         'package_name': ['version'],
+         ...
+       }
+    """
+
+    regex = r"^([a-zA-Z0-9][\w\-\.]*)\s-\s([\w\-\.]+)"
+    default = dict
+
+    def command(self) -> str:
+        return "/bin/opkg list-installed"
+
+    def process(self, output):
+        return parse_packages(self.regex, sorted(output))
+
+
+class OpkgUpgradeablePackages(FactBase):
+    """
+    Returns a dict of installed and upgradable opkg packages:
+
+    .. code:: python
+
+        {
+          'package_name': (installed='1.2.3', available='1.2.8')
+          ...
+        }
+    """
+
+    regex = re.compile(r"^([a-zA-Z0-9][\w\-.]*)\s-\s([\w\-.]+)\s-\s([\w\-.]+)")
+    default = dict
+    use_default_on_error = True
+
+    def command(self) -> str:
+        return "/bin/opkg list-upgradable"  # yes, really spelled that way
+
+    def process(self, output):
+        result = {}
+        for line in output:
+            match = self.regex.match(line)
+            if match and len(match.groups()) == 3:
+                result[match.group(1)] = OpkgPkgUpgradeInfo(match.group(2), match.group(3))
+            else:
+                logger.warning(f"Opkg: could not list-upgradable line '{line}'")
+
+        return result

pyinfra/facts/pipx.py

@@ -0,0 +1,74 @@
+import re
+
+from pyinfra.api import FactBase
+
+from .util.packaging import parse_packages
+
+
+# TODO: move to an utils file
+def parse_environment(output):
+    environment_REGEX = r"^(?P<key>[A-Z_]+)=(?P<value>.*)$"
+    environment_variables = {}
+
+    for line in output:
+        matches = re.match(environment_REGEX, line)
+
+        if matches:
+            environment_variables[matches.group("key")] = matches.group("value")
+
+    return environment_variables
+
+
+PIPX_REGEX = r"^([a-zA-Z0-9_\-\+\.]+)\s+([0-9\.]+[a-z0-9\-]*)$"
+
+
+class PipxPackages(FactBase):
+    """
+    Returns a dict of installed pipx packages:
+
+    .. code:: python
+
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    default = dict
+
+    def requires_command(self) -> str:
+        return "pipx"
+
+    def command(self) -> str:
+        return "pipx list --short"
+
+    def process(self, output):
+        return parse_packages(PIPX_REGEX, output)
+
+
+class PipxEnvironment(FactBase):
+    """
+    Returns a dict of pipx environment variables:
+
+    .. code:: python
+
+        {
+            "PIPX_HOME": "/home/doodba/.local/pipx",
+            "PIPX_BIN_DIR": "/home/doodba/.local/bin",
+            "PIPX_SHARED_LIBS": "/home/doodba/.local/pipx/shared",
+            "PIPX_LOCAL_VENVS": "/home/doodba/.local/pipx/venvs",
+            "PIPX_LOG_DIR": "/home/doodba/.local/pipx/logs",
+            "PIPX_TRASH_DIR": "/home/doodba/.local/pipx/.trash",
+            "PIPX_VENV_CACHEDIR": "/home/doodba/.local/pipx/.cache",
+        }
+    """
+
+    default = dict
+
+    def requires_command(self) -> str:
+        return "pipx"
+
+    def command(self) -> str:
+        return "pipx environment"
+
+    def process(self, output):
+        return parse_environment(output)

pyinfra/facts/podman.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Iterable, List, TypeVar
+
+from pyinfra.api import FactBase
+
+T = TypeVar("T")
+
+
+class PodmanFactBase(FactBase[T]):
+    """
+    Base for facts using `podman` to retrieve
+    """
+
+    abstract = True
+
+    def requires_command(self, *args, **kwargs) -> str:
+        return "podman"
+
+
+class PodmanSystemInfo(PodmanFactBase[Dict[str, Any]]):
+    """
+    Output of 'podman system info'
+    """
+
+    def command(self) -> str:
+        return "podman system info --format=json"
+
+    def process(self, output: Iterable[str]) -> Dict[str, Any]:
+        output = json.loads(("").join(output))
+        assert isinstance(output, dict)
+        return output
+
+
+class PodmanPs(PodmanFactBase[List[Dict[str, Any]]]):
+    """
+    Output of 'podman ps'
+    """
+
+    def command(self) -> str:
+        return "podman ps --format=json --all"
+
+    def process(self, output: Iterable[str]) -> List[Dict[str, Any]]:
+        output = json.loads(("").join(output))
+        assert isinstance(output, list)
+        return output  # type: ignore

pyinfra/facts/postgres.py

@@ -58,6 +58,7 @@ class PostgresFactBase(FactBase):
         psql_password=None,
         psql_host=None,
         psql_port=None,
+        psql_database=None,
     ):
         return make_execute_psql_command(
             self.psql_command,
@@ -65,6 +66,7 @@ class PostgresFactBase(FactBase):
             password=psql_password,
             host=psql_host,
             port=psql_port,
+            database=psql_database,
         )
 
 

pyinfra/facts/server.py

@@ -5,14 +5,15 @@ import re
 import shutil
 from datetime import datetime
 from tempfile import mkdtemp
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from dateutil.parser import parse as parse_date
 from distro import distro
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import TypedDict
 
 from pyinfra.api import FactBase, ShortFactBase
 from pyinfra.api.util import try_int
+from pyinfra.facts import crontab
 
 ISO_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
 
@@ -31,8 +32,7 @@ class Home(FactBase[Optional[str]]):
     Returns the home directory of the given user, or the current user if no user is given.
     """
 
-    @staticmethod
-    def command(user=""):
+    def command(self, user=""):
         return f"echo ~{user}"
 
 
@@ -123,8 +123,7 @@ class Command(FactBase[str]):
     Returns the raw output lines of a given command.
     """
 
-    @staticmethod
-    def command(command):
+    def command(self, command):
         return command
 
 
@@ -133,8 +132,7 @@ class Which(FactBase[Optional[str]]):
     Returns the path of a given command according to `command -v`, if available.
     """
 
-    @staticmethod
-    def command(command):
+    def command(self, command):
         return "command -v {0} || true".format(command)
 
 
@@ -307,6 +305,36 @@ class LsbRelease(FactBase):
         return items
 
 
+class OsRelease(FactBase):
+    """
+    Returns a dictionary of release information stored in ``/etc/os-release``.
+
+    .. code:: python
+
+        {
+          "name": "EndeavourOS",
+          "pretty_name": "EndeavourOS",
+          "id": "endeavouros",
+          "id_like": "arch",
+          "build_id": "2024.06.25",
+          ...
+        }
+    """
+
+    def command(self):
+        return "cat /etc/os-release"
+
+    def process(self, output):
+        items = {}
+
+        for line in output:
+            if "=" in line:
+                key, value = line.split("=", 1)
+                items[key.strip().lower()] = value.strip().strip('"')
+
+        return items
+
+
 class Sysctl(FactBase):
     """
     Returns a dictionary of sysctl settings and values.
@@ -377,75 +405,9 @@ class Groups(FactBase[List[str]]):
         return groups
 
 
-class CrontabDict(TypedDict):
-    minute: NotRequired[Union[int, str]]
-    hour: NotRequired[Union[int, str]]
-    month: NotRequired[Union[int, str]]
-    day_of_month: NotRequired[Union[int, str]]
-    day_of_week: NotRequired[Union[int, str]]
-    comments: Optional[list[str]]
-    special_time: NotRequired[str]
-
-
-class Crontab(FactBase[Dict[str, CrontabDict]]):
-    """
-    Returns a dictionary of cron command -> execution time.
-
-    .. code:: python
-
-        {
-            "/path/to/command": {
-                "minute": "*",
-                "hour": "*",
-                "month": "*",
-                "day_of_month": "*",
-                "day_of_week": "*",
-            },
-            "echo another command": {
-                "special_time": "@daily",
-            },
-        }
-    """
-
-    default = dict
-
-    def requires_command(self, user=None) -> str:
-        return "crontab"
-
-    def command(self, user=None):
-        if user:
-            return "crontab -l -u {0} || true".format(user)
-        return "crontab -l || true"
-
-    def process(self, output):
-        crons: dict[str, CrontabDict] = {}
-        current_comments = []
-
-        for line in output:
-            line = line.strip()
-            if not line or line.startswith("#"):
-                current_comments.append(line)
-                continue
-
-            if line.startswith("@"):
-                special_time, command = line.split(None, 1)
-                crons[command] = {
-                    "special_time": special_time,
-                    "comments": current_comments,
-                }
-            else:
-                minute, hour, day_of_month, month, day_of_week, command = line.split(None, 5)
-                crons[command] = {
-                    "minute": try_int(minute),
-                    "hour": try_int(hour),
-                    "month": try_int(month),
-                    "day_of_month": try_int(day_of_month),
-                    "day_of_week": try_int(day_of_week),
-                    "comments": current_comments,
-                }
-
-            current_comments = []
-        return crons
+# for compatibility
+CrontabDict = crontab.CrontabDict
+Crontab = crontab.Crontab
 
 
 class Users(FactBase):