ansible-core 2.19.2__py3-none-any.whl → 2.20.0b1__py3-none-any.whl

ansible/module_utils/urls.py

@@ -1358,7 +1358,8 @@ def _split_multiext(name, min=3, max=4, count=2):
 
 def fetch_file(module, url, data=None, headers=None, method=None,
                use_proxy=True, force=False, last_mod_time=None, timeout=10,
-               unredirected_headers=None, decompress=True, ciphers=None):
+               unredirected_headers=None, decompress=True, ciphers=None,
+               ca_path=None, cookies=None):
     """Download and save a file via HTTP(S) or FTP (needs the module as parameter).
     This is basically a wrapper around fetch_url().
 
@@ -1375,6 +1376,8 @@ def fetch_file(module, url, data=None, headers=None, method=None,
     :kwarg unredirected_headers: (optional) A list of headers to not attach on a redirected request
     :kwarg decompress: (optional) Whether to attempt to decompress gzip content-encoded responses
     :kwarg ciphers: (optional) List of ciphers to use
+    :kwarg ca_path: (optional) Path to CA bundle
+    :kwarg cookies: (optional) CookieJar object to send with the request
 
     :returns: A string, the path to the downloaded file.
     """
@@ -1386,7 +1389,8 @@ def fetch_file(module, url, data=None, headers=None, method=None,
     module.add_cleanup_file(fetch_temp_file.name)
     try:
         rsp, info = fetch_url(module, url, data, headers, method, use_proxy, force, last_mod_time, timeout,
-                              unredirected_headers=unredirected_headers, decompress=decompress, ciphers=ciphers)
+                              unredirected_headers=unredirected_headers, decompress=decompress, ciphers=ciphers,
+                              ca_path=ca_path, cookies=cookies)
         if not rsp or (rsp.code and rsp.code >= 400):
             module.fail_json(msg="Failure downloading %s, %s" % (url, info['msg']))
         data = rsp.read(bufsize)

ansible/module_utils/yumdnf.py

@@ -32,10 +32,6 @@ yumdnf_argument_spec = dict(
         enablerepo=dict(type='list', elements='str', default=[]),
         exclude=dict(type='list', elements='str', default=[]),
         installroot=dict(type='str', default="/"),
-        install_repoquery=dict(
-            type='bool', default=True,
-            removed_in_version='2.20', removed_from_collection='ansible.builtin',
-        ),
         install_weak_deps=dict(type='bool', default=True),
         list=dict(type='str'),
         name=dict(type='list', elements='str', aliases=['pkg'], default=[]),
@@ -85,7 +81,6 @@ class YumDnf(metaclass=ABCMeta):
         self.enablerepo = self.module.params.get('enablerepo', [])
         self.exclude = self.module.params['exclude']
         self.installroot = self.module.params['installroot']
-        self.install_repoquery = self.module.params['install_repoquery']
         self.install_weak_deps = self.module.params['install_weak_deps']
         self.list = self.module.params['list']
         self.names = [p.strip() for p in self.module.params['name']]

ansible/modules/apt.py

@@ -372,6 +372,7 @@ import locale as locale_module
 import os
 import re
 import secrets
+import shlex
 import shutil
 import sys
 import tempfile
@@ -382,7 +383,6 @@ from ansible.module_utils.common.file import S_IRWXU_RXG_RXO
 from ansible.module_utils.common.locale import get_best_parsable_locale
 from ansible.module_utils.common.respawn import has_respawned, probe_interpreters_for_module, respawn_module
 from ansible.module_utils.common.text.converters import to_native, to_text
-from ansible.module_utils.six import string_types
 from ansible.module_utils.urls import fetch_file
 
 DPKG_OPTIONS = 'force-confdef,force-confold'
@@ -390,8 +390,6 @@ APT_GET_ZERO = "\n0 upgraded, 0 newly installed, 0 to remove"
 APTITUDE_ZERO = "\n0 packages upgraded, 0 newly installed, 0 to remove"
 APT_LISTS_PATH = "/var/lib/apt/lists"
 APT_UPDATE_SUCCESS_STAMP_PATH = "/var/lib/apt/periodic/update-success-stamp"
-APT_MARK_INVALID_OP = 'Invalid operation'
-APT_MARK_INVALID_OP_DEB6 = 'Usage: apt-mark [options] {markauto|unmarkauto} packages'
 
 CLEAN_OP_CHANGED_STR = dict(
     autoremove='The following packages will be REMOVED',
@@ -634,7 +632,7 @@ def expand_pkgspec_from_fnmatches(m, pkgspec, cache):
     if pkgspec:
         for pkgspec_pattern in pkgspec:
 
-            if not isinstance(pkgspec_pattern, string_types):
+            if not isinstance(pkgspec_pattern, str):
                 m.fail_json(msg="Invalid type for package name, expected string but got %s" % type(pkgspec_pattern))
 
             pkgname_pattern, version_cmp, version = package_split(pkgspec_pattern)
@@ -690,26 +688,30 @@ def parse_diff(output):
     return {'prepared': '\n'.join(diff[diff_start:diff_end])}
 
 
-def mark_installed_manually(m, packages):
+def mark_installed(m: AnsibleModule, packages: list[str], manual: bool) -> None:
+    """Mark packages as manually or automatically installed."""
     if not packages:
         return
 
+    if manual:
+        mark_msg = "manually"
+        mark_op = "manual"
+    else:
+        mark_msg = "auto"
+        mark_op = "auto"
+
     apt_mark_cmd_path = m.get_bin_path("apt-mark")
 
     # https://github.com/ansible/ansible/issues/40531
     if apt_mark_cmd_path is None:
-        m.warn("Could not find apt-mark binary, not marking package(s) as manually installed.")
+        m.warn(f"Could not find apt-mark binary, not marking package(s) as {mark_msg} installed.")
         return
 
-    cmd = "%s manual %s" % (apt_mark_cmd_path, ' '.join(packages))
+    cmd = [apt_mark_cmd_path, mark_op] + packages
     rc, out, err = m.run_command(cmd)
 
-    if APT_MARK_INVALID_OP in err or APT_MARK_INVALID_OP_DEB6 in err:
-        cmd = "%s unmarkauto %s" % (apt_mark_cmd_path, ' '.join(packages))
-        rc, out, err = m.run_command(cmd)
-
     if rc != 0:
-        m.fail_json(msg="'%s' failed: %s" % (cmd, err), stdout=out, stderr=err, rc=rc)
+        m.fail_json(msg=f"Command {shlex.join(cmd)!r} failed.", stdout=out, stderr=err, rc=rc)
 
 
 def install(m, pkgspec, cache, upgrade=False, default_release=None,
@@ -835,7 +837,7 @@ def install(m, pkgspec, cache, upgrade=False, default_release=None,
         data = dict(changed=False)
 
     if not build_dep and not m.check_mode:
-        mark_installed_manually(m, package_names)
+        mark_installed(m, package_names, manual=True)
 
     return (status, data)
 
@@ -914,6 +916,9 @@ def install_deb(
                                      dpkg_options=install_dpkg_options)
         if not success:
             m.fail_json(**retvals)
+        # Mark the dependencies as auto installed
+        # https://github.com/ansible/ansible/issues/78123
+        mark_installed(m, deps_to_install, manual=False)
         changed = retvals.get('changed', False)
 
     if pkgs_to_install:

ansible/modules/apt_repository.py

@@ -508,7 +508,7 @@ class UbuntuSourcesList(SourcesList):
                 try:
                     rc, out, err = self.module.run_command([self.gpg_bin, '--list-packets', key_file])
                 except OSError as ex:
-                    self.debug(f"Could check key against file {key_file!r}: {ex}")
+                    self.module.debug(f"Could check key against file {key_file!r}: {ex}")
                     continue
 
                 if key_fingerprint in out:

ansible/modules/assemble.py

@@ -131,7 +131,6 @@ import re
 import tempfile
 
 from ansible.module_utils.basic import AnsibleModule
-from ansible.module_utils.six import b, indexbytes
 from ansible.module_utils.common.text.converters import to_native
 
 
@@ -141,6 +140,7 @@ def assemble_from_fragments(src_path, delimiter=None, compiled_regexp=None, igno
     tmp = os.fdopen(tmpfd, 'wb')
     delimit_me = False
     add_newline = False
+    b_linesep = os.linesep.encode()
 
     for f in sorted(os.listdir(src_path)):
         if compiled_regexp and not compiled_regexp.search(f):
@@ -153,7 +153,7 @@ def assemble_from_fragments(src_path, delimiter=None, compiled_regexp=None, igno
 
         # always put a newline between fragments if the previous fragment didn't end with a newline.
         if add_newline:
-            tmp.write(b('\n'))
+            tmp.write(b_linesep)
 
         # delimiters should only appear between fragments
         if delimit_me:
@@ -163,16 +163,12 @@ def assemble_from_fragments(src_path, delimiter=None, compiled_regexp=None, igno
                 tmp.write(delimiter)
                 # always make sure there's a newline after the
                 # delimiter, so lines don't run together
-
-                # byte indexing differs on Python 2 and 3,
-                # use indexbytes for compat
-                # chr(10) == '\n'
-                if indexbytes(delimiter, -1) != 10:
-                    tmp.write(b('\n'))
+                if not delimiter.endswith(b_linesep):
+                    tmp.write(b_linesep)
 
         tmp.write(fragment_content)
         delimit_me = True
-        if fragment_content.endswith(b('\n')):
+        if fragment_content.endswith(b_linesep):
             add_newline = False
         else:
             add_newline = True

ansible/modules/blockinfile.py

@@ -102,6 +102,13 @@ options:
     type: bool
     default: no
     version_added: '2.16'
+  encoding:
+    description:
+      - The character set in which the target file is encoded.
+      - For a list of available built-in encodings, see U(https://docs.python.org/3/library/codecs.html#standard-encodings)
+    type: str
+    default: utf-8
+    version_added: '2.20'
 notes:
   - When using C(with_*) loops be aware that if you do not set a unique mark the block will be overwritten on each iteration.
   - As of Ansible 2.3, the O(dest) option has been changed to O(path) as default, but O(dest) still works as well.
@@ -192,15 +199,16 @@ EXAMPLES = r"""
 import re
 import os
 import tempfile
-from ansible.module_utils.six import b
+
 from ansible.module_utils.basic import AnsibleModule
-from ansible.module_utils.common.text.converters import to_bytes, to_native
+from ansible.module_utils.common.text.converters import to_native
 
 
-def write_changes(module, contents, path):
+def write_changes(module, contents, path, encoding=None):
 
     tmpfd, tmpfile = tempfile.mkstemp(dir=module.tmpdir)
-    with os.fdopen(tmpfd, 'wb') as tf:
+    # newline param set to translate newline sequences with system default line separator
+    with os.fdopen(tmpfd, 'w', encoding=encoding, newline=None) as tf:
         tf.write(contents)
 
     validate = module.params.get('validate', None)
@@ -246,6 +254,7 @@ def main():
             marker_end=dict(type='str', default='END'),
             append_newline=dict(type='bool', default=False),
             prepend_newline=dict(type='bool', default=False),
+            encoding=dict(type='str', default='utf-8'),
         ),
         mutually_exclusive=[['insertbefore', 'insertafter']],
         add_file_common_args=True,
@@ -254,6 +263,8 @@ def main():
     params = module.params
     path = params['path']
 
+    encoding = module.params.get('encoding', None)
+
     if os.path.isdir(path):
         module.fail_json(rc=256,
                          msg='Path %s is a directory !' % path)
@@ -274,7 +285,8 @@ def main():
         original = None
         lines = []
     else:
-        with open(path, 'rb') as f:
+        # newline param set to preserve newline sequences read from file
+        with open(path, 'r', encoding=encoding, newline='') as f:
             original = f.read()
         lines = original.splitlines(True)
 
@@ -288,10 +300,12 @@ def main():
 
     insertbefore = params['insertbefore']
     insertafter = params['insertafter']
-    block = to_bytes(params['block'])
-    marker = to_bytes(params['marker'])
+    block = params['block']
+    marker = params['marker']
     present = params['state'] == 'present'
-    blank_line = [b(os.linesep)]
+
+    line_separator = os.linesep
+    blank_line = [line_separator]
 
     if not present and not path_exists:
         module.exit_json(changed=False, msg="File %s not present" % path)
@@ -300,17 +314,19 @@ def main():
         insertafter = 'EOF'
 
     if insertafter not in (None, 'EOF'):
-        insertre = re.compile(to_bytes(insertafter, errors='surrogate_or_strict'))
+        insertre = re.compile(insertafter)
     elif insertbefore not in (None, 'BOF'):
-        insertre = re.compile(to_bytes(insertbefore, errors='surrogate_or_strict'))
+        insertre = re.compile(insertbefore)
     else:
         insertre = None
 
-    marker0 = re.sub(b(r'{mark}'), b(params['marker_begin']), marker) + b(os.linesep)
-    marker1 = re.sub(b(r'{mark}'), b(params['marker_end']), marker) + b(os.linesep)
+    marker0 = re.sub(r'{mark}', params['marker_begin'], marker) + line_separator
+    marker1 = re.sub(r'{mark}', params['marker_end'], marker) + line_separator
+
     if present and block:
-        if not block.endswith(b(os.linesep)):
-            block += b(os.linesep)
+        if not block.endswith(line_separator):
+            block += line_separator
+
         blocklines = [marker0] + block.splitlines(True) + [marker1]
     else:
         blocklines = []
@@ -329,9 +345,9 @@ def main():
                 match = insertre.search(original)
                 if match:
                     if insertafter:
-                        n0 = to_native(original).count('\n', 0, match.end())
+                        n0 = original.count('\n', 0, match.end())
                     elif insertbefore:
-                        n0 = to_native(original).count('\n', 0, match.start())
+                        n0 = original.count('\n', 0, match.start())
             else:
                 for i, line in enumerate(lines):
                     if insertre.search(line):
@@ -352,15 +368,15 @@ def main():
 
     # Ensure there is a line separator before the block of lines to be inserted
     if n0 > 0:
-        if not lines[n0 - 1].endswith(b(os.linesep)):
-            lines[n0 - 1] += b(os.linesep)
+        if not lines[n0 - 1].endswith(line_separator):
+            lines[n0 - 1] += line_separator
 
     # Before the block: check if we need to prepend a blank line
     # If yes, we need to add the blank line if we are not at the beginning of the file
     # and the previous line is not a blank line
     # In both cases, we need to shift by one on the right the inserting position of the block
     if params['prepend_newline'] and present:
-        if n0 != 0 and lines[n0 - 1] != b(os.linesep):
+        if n0 != 0 and lines[n0 - 1] != line_separator:
             lines[n0:n0] = blank_line
             n0 += 1
 
@@ -372,13 +388,13 @@ def main():
     # and the line right after is not a blank line
     if params['append_newline'] and present:
         line_after_block = n0 + len(blocklines)
-        if line_after_block < len(lines) and lines[line_after_block] != b(os.linesep):
+        if line_after_block < len(lines) and lines[line_after_block] != line_separator:
             lines[line_after_block:line_after_block] = blank_line
 
     if lines:
-        result = b''.join(lines)
+        result = ''.join(lines)
     else:
-        result = b''
+        result = ''
 
     if module._diff:
         diff['after'] = result
@@ -402,7 +418,7 @@ def main():
             backup_file = module.backup_local(path)
         # We should always follow symlinks so that we change the real file
         real_path = os.path.realpath(params['path'])
-        write_changes(module, result, real_path)
+        write_changes(module, result, real_path, encoding)
 
     if module.check_mode and not path_exists:
         module.exit_json(changed=changed, msg=msg, diff=diff)

ansible/modules/cron.py

@@ -219,20 +219,20 @@ import os
 import platform
 import pwd
 import re
+import shlex
 import sys
 import tempfile
 
 from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.common.file import S_IRWU_RWG_RWO
 from ansible.module_utils.common.text.converters import to_bytes, to_native
-from ansible.module_utils.six.moves import shlex_quote
 
 
 class CronTabError(Exception):
     pass
 
 
-class CronTab(object):
+class CronTab:
     """
         CronTab object to write time based crontab file
 
@@ -243,8 +243,8 @@ class CronTab(object):
     def __init__(self, module, user=None, cron_file=None):
         self.module = module
         self.user = user
-        self.root = (os.getuid() == 0)
-        self.lines = None
+        self.root = os.getuid() == 0
+        self.lines = []
         self.ansible = "#Ansible: "
         self.n_existing = ''
         self.cron_cmd = self.module.get_bin_path('crontab', required=True)
@@ -264,7 +264,6 @@ class CronTab(object):
 
     def read(self):
         # Read in the crontab from the system
-        self.lines = []
         if self.cron_file:
             # read the cronfile
             try:
@@ -280,7 +279,7 @@ class CronTab(object):
             # FIXME: using safely quoted shell for now, but this really should be two non-shell calls instead.
             (rc, out, err) = self.module.run_command(self._read_user_execute(), use_unsafe_shell=True)
 
-            if rc != 0 and rc != 1:  # 1 can mean that there are no jobs.
+            if rc not in (0, 1):  # 1 can mean that there are no jobs.
                 raise CronTabError("Unable to read crontab")
 
             self.n_existing = out
@@ -300,11 +299,10 @@ class CronTab(object):
     def is_empty(self):
         if len(self.lines) == 0:
             return True
-        else:
-            for line in self.lines:
-                if line.strip():
-                    return False
-            return True
+        for line in self.lines:
+            if line.strip():
+                return False
+        return True
 
     def write(self, backup_file=None):
         """
@@ -451,13 +449,10 @@ class CronTab(object):
         if special:
             if self.cron_file:
                 return "%s@%s %s %s" % (disable_prefix, special, self.user, job)
-            else:
-                return "%s@%s %s" % (disable_prefix, special, job)
-        else:
-            if self.cron_file:
-                return "%s%s %s %s %s %s %s %s" % (disable_prefix, minute, hour, day, month, weekday, self.user, job)
-            else:
-                return "%s%s %s %s %s %s %s" % (disable_prefix, minute, hour, day, month, weekday, job)
+            return "%s@%s %s" % (disable_prefix, special, job)
+        if self.cron_file:
+            return "%s%s %s %s %s %s %s %s" % (disable_prefix, minute, hour, day, month, weekday, self.user, job)
+        return "%s%s %s %s %s %s %s" % (disable_prefix, minute, hour, day, month, weekday, job)
 
     def get_jobnames(self):
         jobnames = []
@@ -495,8 +490,7 @@ class CronTab(object):
 
         if len(newlines) == 0:
             return True
-        else:
-            return False  # TODO add some more error testing
+        return False  # TODO add some more error testing
 
     def _update_env(self, name, decl, addenvfunction):
         newlines = []
@@ -529,13 +523,13 @@ class CronTab(object):
         user = ''
         if self.user:
             if platform.system() == 'SunOS':
-                return "su %s -c '%s -l'" % (shlex_quote(self.user), shlex_quote(self.cron_cmd))
-            elif platform.system() == 'AIX':
-                return "%s -l %s" % (shlex_quote(self.cron_cmd), shlex_quote(self.user))
-            elif platform.system() == 'HP-UX':
-                return "%s %s %s" % (self.cron_cmd, '-l', shlex_quote(self.user))
-            elif pwd.getpwuid(os.getuid())[0] != self.user:
-                user = '-u %s' % shlex_quote(self.user)
+                return "su %s -c '%s -l'" % (shlex.quote(self.user), shlex.quote(self.cron_cmd))
+            if platform.system() == 'AIX':
+                return "%s -l %s" % (shlex.quote(self.cron_cmd), shlex.quote(self.user))
+            if platform.system() == 'HP-UX':
+                return "%s %s %s" % (self.cron_cmd, '-l', shlex.quote(self.user))
+            if pwd.getpwuid(os.getuid())[0] != self.user:
+                user = '-u %s' % shlex.quote(self.user)
         return "%s %s %s" % (self.cron_cmd, user, '-l')
 
     def _write_execute(self, path):
@@ -546,10 +540,10 @@ class CronTab(object):
         if self.user:
             if platform.system() in ['SunOS', 'HP-UX', 'AIX']:
                 return "chown %s %s ; su '%s' -c '%s %s'" % (
-                    shlex_quote(self.user), shlex_quote(path), shlex_quote(self.user), self.cron_cmd, shlex_quote(path))
-            elif pwd.getpwuid(os.getuid())[0] != self.user:
-                user = '-u %s' % shlex_quote(self.user)
-        return "%s %s %s" % (self.cron_cmd, user, shlex_quote(path))
+                    shlex.quote(self.user), shlex.quote(path), shlex.quote(self.user), self.cron_cmd, shlex.quote(path))
+            if pwd.getpwuid(os.getuid())[0] != self.user:
+                user = '-u %s' % shlex.quote(self.user)
+        return "%s %s %s" % (self.cron_cmd, user, shlex.quote(path))
 
 
 def main():
@@ -668,7 +662,7 @@ def main():
 
     # if requested make a backup before making a change
     if backup and not module.check_mode:
-        (backuph, backup_file) = tempfile.mkstemp(prefix='crontab')
+        (dummy, backup_file) = tempfile.mkstemp(prefix='crontab')
         crontab.write(backup_file)
 
     if env:
@@ -763,9 +757,6 @@ def main():
 
     module.exit_json(**res_args)
 
-    # --- should never get here
-    module.exit_json(msg="Unable to execute cron task.")
-
 
 if __name__ == '__main__':
     main()

ansible/modules/deb822_repository.py

@@ -67,6 +67,17 @@ options:
         - Determines the path to the C(InRelease) file, relative to the normal
           position of an C(InRelease) file.
         type: str
+    install_python_debian:
+        description:
+        - Whether to automatically try to install the Python C(debian) library or not, if it is not already installed.
+          Without this library, the module does not work.
+            - Runs C(apt install python3-debian).
+            - Only works with the system Python. If you are using a Python on the remote that is not
+              the system Python, set O(install_python_debian=false) and ensure that the Python C(debian) library
+              for your Python version is installed some other way.
+        type: bool
+        default: false
+        version_added: '2.20'
     languages:
         description:
         - Defines which languages information such as translated
@@ -228,6 +239,7 @@ key_filename:
 
 import os
 import re
+import sys
 import tempfile
 import textwrap
 
@@ -235,9 +247,9 @@ from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.basic import missing_required_lib
 from ansible.module_utils.common.collections import is_sequence
 from ansible.module_utils.common.file import S_IRWXU_RXG_RXO, S_IRWU_RG_RO
+from ansible.module_utils.common.respawn import has_respawned, probe_interpreters_for_module, respawn_module
 from ansible.module_utils.common.text.converters import to_bytes
 from ansible.module_utils.common.text.converters import to_native
-from ansible.module_utils.six import raise_from  # type: ignore[attr-defined]
 from ansible.module_utils.urls import generic_urlparse
 from ansible.module_utils.urls import open_url
 from ansible.module_utils.urls import get_user_agent
@@ -326,7 +338,7 @@ def write_signed_by_key(module, v, slug):
         try:
             r = open_url(v, http_agent=get_user_agent())
         except Exception as exc:
-            raise_from(RuntimeError(to_native(exc)), exc)
+            raise RuntimeError('Could not fetch signed_by key.') from exc
         else:
             b_data = r.read()
     else:
@@ -357,6 +369,21 @@ def write_signed_by_key(module, v, slug):
     return changed, filename, None
 
 
+def install_python_debian(module, deb_pkg_name):
+
+    if not module.check_mode:
+        apt_path = module.get_bin_path('apt', required=True)
+        if apt_path:
+            rc, so, se = module.run_command([apt_path, 'update'])
+            if rc != 0:
+                module.fail_json(msg=f"Failed update while auto installing {deb_pkg_name} due to '{se.strip()}'")
+            rc, so, se = module.run_command([apt_path, 'install', deb_pkg_name, '-y', '-q'])
+            if rc != 0:
+                module.fail_json(msg=f"Failed to auto-install {deb_pkg_name} due to : '{se.strip()}'")
+    else:
+        module.fail_json(msg=f"{deb_pkg_name} must be installed to use check mode")
+
+
 def main():
     module = AnsibleModule(
         argument_spec={
@@ -395,6 +422,10 @@ def main():
             'inrelease_path': {
                 'type': 'str',
             },
+            'install_python_debian': {
+                'type': 'bool',
+                'default': False,
+            },
             'languages': {
                 'elements': 'str',
                 'type': 'list',
@@ -453,8 +484,53 @@ def main():
     )
 
     if not HAS_DEBIAN:
-        module.fail_json(msg=missing_required_lib("python3-debian"),
-                         exception=DEBIAN_IMP_ERR)
+        deb_pkg_name = 'python3-debian'
+        # This interpreter can't see the debian Python library- we'll do the following to try and fix that as per
+        # the apt_repository module:
+        # 1) look in common locations for system-owned interpreters that can see it; if we find one, respawn under it
+        # 2) finding none, try to install a matching python-debian package for the current interpreter version;
+        #    we limit to the current interpreter version to try and avoid installing a whole other Python just
+        #    for deb support
+        # 3) if we installed a support package, try to respawn under what we think is the right interpreter (could be
+        #    the current interpreter again, but we'll let it respawn anyway for simplicity)
+        # 4) if still not working, return an error and give up (some corner cases not covered, but this shouldn't be
+        #    made any more complex than it already is to try and cover more, eg, custom interpreters taking over
+        #    system locations)
+
+        if has_respawned():
+            # this shouldn't be possible; short-circuit early if it happens...
+            module.fail_json(msg=f"{deb_pkg_name} must be installed and visible from {sys.executable}.")
+
+        interpreters = ['/usr/bin/python3', '/usr/bin/python']
+
+        interpreter = probe_interpreters_for_module(interpreters, 'debian')
+
+        if interpreter:
+            # found the Python bindings; respawn this module under the interpreter where we found them
+            respawn_module(interpreter)
+            # this is the end of the line for this process, it will exit here once the respawned module has completed
+
+        # don't make changes if we're in check_mode
+        if module.check_mode:
+            module.fail_json(msg=f"{deb_pkg_name} must be installed to use check mode. If run with install_python_debian, this module can auto-install it.")
+
+        if module.params['install_python_debian']:
+            install_python_debian(module, deb_pkg_name)
+        else:
+            module.fail_json(msg=f'{deb_pkg_name} is not installed, and install_python_debian is False')
+
+        # try again to find the bindings in common places
+        interpreter = probe_interpreters_for_module(interpreters, 'debian')
+
+        if interpreter:
+            # found the Python bindings; respawn this module under the interpreter where we found them
+            # NB: respawn is somewhat wasteful if it's this interpreter, but simplifies the code
+            respawn_module(interpreter)
+            # this is the end of the line for this process, it will exit here once the respawned module has completed
+        else:
+            # we've done all we can do; just tell the user it's busted and get out
+            module.fail_json(msg=missing_required_lib(deb_pkg_name),
+                             exception=DEBIAN_IMP_ERR)
 
     check_mode = module.check_mode
 
@@ -510,14 +586,9 @@ def main():
         elif is_sequence(value):
             value = format_list(value)
         elif key == 'signed_by':
-            try:
-                key_changed, signed_by_filename, signed_by_data = write_signed_by_key(module, value, slug)
-                value = signed_by_filename or signed_by_data
-                changed |= key_changed
-            except RuntimeError as exc:
-                module.fail_json(
-                    msg='Could not fetch signed_by key: %s' % to_native(exc)
-                )
+            key_changed, signed_by_filename, signed_by_data = write_signed_by_key(module, value, slug)
+            value = signed_by_filename or signed_by_data
+            changed |= key_changed
 
         if value.count('\n') > 0:
             value = format_multiline(value)