ansible-core 2.15.4rc1__py3-none-any.whl → 2.16.0b2__py3-none-any.whl

ansible_test/_internal/commands/integration/cloud/galaxy.py

@@ -10,12 +10,21 @@ from ....config import (
 
 from ....docker_util import (
     docker_cp_to,
+    docker_exec,
 )
 
 from ....containers import (
     run_support_container,
 )
 
+from ....encoding import (
+    to_text,
+)
+
+from ....util import (
+    display,
+)
+
 from . import (
     CloudEnvironment,
     CloudEnvironmentConfig,
@@ -23,53 +32,59 @@ from . import (
 )
 
 
-# We add BasicAuthentication, to make the tasks that deal with
-# direct API access easier to deal with across galaxy_ng and pulp
-SETTINGS = b'''
-CONTENT_ORIGIN = 'http://ansible-ci-pulp:80'
-ANSIBLE_API_HOSTNAME = 'http://ansible-ci-pulp:80'
-ANSIBLE_CONTENT_HOSTNAME = 'http://ansible-ci-pulp:80/pulp/content'
-TOKEN_AUTH_DISABLED = True
-GALAXY_REQUIRE_CONTENT_APPROVAL = False
-GALAXY_AUTHENTICATION_CLASSES = [
-    "rest_framework.authentication.SessionAuthentication",
-    "rest_framework.authentication.TokenAuthentication",
-    "rest_framework.authentication.BasicAuthentication",
-]
-'''
-
-SET_ADMIN_PASSWORD = b'''#!/usr/bin/execlineb -S0
-foreground {
-  redirfd -w 1 /dev/null
-  redirfd -w 2 /dev/null
-  export DJANGO_SETTINGS_MODULE pulpcore.app.settings
-  export PULP_CONTENT_ORIGIN localhost
-  s6-setuidgid postgres
-  if { /usr/local/bin/django-admin reset-admin-password --password password }
-  if { /usr/local/bin/pulpcore-manager create-group system:partner-engineers --users admin }
-}
-'''
-
-# There are 2 overrides here:
-#   1. Change the gunicorn bind address from 127.0.0.1 to 0.0.0.0 now that Galaxy NG does not allow us to access the
-#      Pulp API through it.
-#   2. Grant access allowing us to DELETE a namespace in Galaxy NG. This is as CI deletes and recreates repos and
-#      distributions in Pulp which now breaks the namespace in Galaxy NG. Recreating it is the "simple" fix to get it
-#      working again.
-# These may not be needed in the future, especially if 1 becomes configurable by an env var but for now they must be
-# done.
-OVERRIDES = b'''#!/usr/bin/execlineb -S0
-foreground {
-    sed -i "0,/\\"127.0.0.1:24817\\"/s//\\"0.0.0.0:24817\\"/" /etc/services.d/pulpcore-api/run
+GALAXY_HOST_NAME = 'galaxy-pulp'
+SETTINGS = {
+    'PULP_CONTENT_ORIGIN': f'http://{GALAXY_HOST_NAME}',
+    'PULP_ANSIBLE_API_HOSTNAME': f'http://{GALAXY_HOST_NAME}',
+    'PULP_GALAXY_API_PATH_PREFIX': '/api/galaxy/',
+    # These paths are unique to the container image which has an nginx location for /pulp/content to route
+    # requests to the content backend
+    'PULP_ANSIBLE_CONTENT_HOSTNAME': f'http://{GALAXY_HOST_NAME}/pulp/content/api/galaxy/v3/artifacts/collections/',
+    'PULP_CONTENT_PATH_PREFIX': '/pulp/content/api/galaxy/v3/artifacts/collections/',
+    'PULP_GALAXY_AUTHENTICATION_CLASSES': [
+        'rest_framework.authentication.SessionAuthentication',
+        'rest_framework.authentication.TokenAuthentication',
+        'rest_framework.authentication.BasicAuthentication',
+        'django.contrib.auth.backends.ModelBackend',
+    ],
+    # This should probably be false see https://issues.redhat.com/browse/AAH-2328
+    'PULP_GALAXY_REQUIRE_CONTENT_APPROVAL': 'true',
+    'PULP_GALAXY_DEPLOYMENT_MODE': 'standalone',
+    'PULP_GALAXY_AUTO_SIGN_COLLECTIONS': 'false',
+    'PULP_GALAXY_COLLECTION_SIGNING_SERVICE': 'ansible-default',
+    'PULP_RH_ENTITLEMENT_REQUIRED': 'insights',
+    'PULP_TOKEN_AUTH_DISABLED': 'false',
+    'PULP_TOKEN_SERVER': f'http://{GALAXY_HOST_NAME}/token/',
+    'PULP_TOKEN_SIGNATURE_ALGORITHM': 'ES256',
+    'PULP_PUBLIC_KEY_PATH': '/src/galaxy_ng/dev/common/container_auth_public_key.pem',
+    'PULP_PRIVATE_KEY_PATH': '/src/galaxy_ng/dev/common/container_auth_private_key.pem',
+    'PULP_ANALYTICS': 'false',
+    'PULP_GALAXY_ENABLE_UNAUTHENTICATED_COLLECTION_ACCESS': 'true',
+    'PULP_GALAXY_ENABLE_UNAUTHENTICATED_COLLECTION_DOWNLOAD': 'true',
+    'PULP_GALAXY_ENABLE_LEGACY_ROLES': 'true',
+    'PULP_GALAXY_FEATURE_FLAGS__execution_environments': 'false',
+    'PULP_SOCIAL_AUTH_LOGIN_REDIRECT_URL': '/',
+    'PULP_GALAXY_FEATURE_FLAGS__ai_deny_index': 'true',
+    'PULP_DEFAULT_ADMIN_PASSWORD': 'password'
 }
 
-# This sed calls changes the first occurrence to "allow" which is conveniently the delete operation for a namespace.
-# https://github.com/ansible/galaxy_ng/blob/master/galaxy_ng/app/access_control/statements/standalone.py#L9-L11.
-backtick NG_PREFIX { python -c "import galaxy_ng; print(galaxy_ng.__path__[0], end='')" }
-importas ng_prefix NG_PREFIX
-foreground {
-    sed -i "0,/\\"effect\\": \\"deny\\"/s//\\"effect\\": \\"allow\\"/" ${ng_prefix}/app/access_control/statements/standalone.py
-}'''
+
+GALAXY_IMPORTER = b'''
+[galaxy-importer]
+ansible_local_tmp=~/.ansible/tmp
+ansible_test_local_image=false
+check_required_tags=false
+check_runtime_yaml=false
+check_changelog=false
+infra_osd=false
+local_image_docker=false
+log_level_main=INFO
+require_v1_or_greater=false
+run_ansible_doc=false
+run_ansible_lint=false
+run_ansible_test=false
+run_flake8=false
+'''.strip()
 
 
 class GalaxyProvider(CloudProvider):
@@ -81,13 +96,9 @@ class GalaxyProvider(CloudProvider):
     def __init__(self, args: IntegrationConfig) -> None:
         super().__init__(args)
 
-        # Cannot use the latest container image as either galaxy_ng 4.2.0rc2 or pulp 0.5.0 has sporatic issues with
-        # dropping published collections in CI. Try running the tests multiple times when updating. Will also need to
-        # comment out the cache tests in 'test/integration/targets/ansible-galaxy-collection/tasks/install.yml' when
-        # the newer update is available.
-        self.pulp = os.environ.get(
+        self.image = os.environ.get(
             'ANSIBLE_PULP_CONTAINER',
-            'quay.io/ansible/pulp-galaxy-ng:b79a7be64eff'
+            'quay.io/pulp/galaxy:4.7.1'
         )
 
         self.uses_docker = True
@@ -96,48 +107,46 @@ class GalaxyProvider(CloudProvider):
         """Setup cloud resource before delegation and reg cleanup callback."""
         super().setup()
 
-        galaxy_port = 80
-        pulp_host = 'ansible-ci-pulp'
-        pulp_port = 24817
-
-        ports = [
-            galaxy_port,
-            pulp_port,
-        ]
-
-        # Create the container, don't run it, we need to inject configs before it starts
-        descriptor = run_support_container(
-            self.args,
-            self.platform,
-            self.pulp,
-            pulp_host,
-            ports,
-            start=False,
-            allow_existing=True,
-        )
+        with tempfile.NamedTemporaryFile(mode='w+') as env_fd:
+            settings = '\n'.join(
+                f'{key}={value}' for key, value in SETTINGS.items()
+            )
+            env_fd.write(settings)
+            env_fd.flush()
+            display.info(f'>>> galaxy_ng Configuration\n{settings}', verbosity=3)
+            descriptor = run_support_container(
+                self.args,
+                self.platform,
+                self.image,
+                GALAXY_HOST_NAME,
+                [
+                    80,
+                ],
+                aliases=[
+                    GALAXY_HOST_NAME,
+                ],
+                start=True,
+                options=[
+                    '--env-file', env_fd.name,
+                ],
+            )
 
         if not descriptor:
             return
 
-        if not descriptor.running:
-            pulp_id = descriptor.container_id
-
-            injected_files = {
-                '/etc/pulp/settings.py': SETTINGS,
-                '/etc/cont-init.d/111-postgres': SET_ADMIN_PASSWORD,
-                '/etc/cont-init.d/000-ansible-test-overrides': OVERRIDES,
-            }
-            for path, content in injected_files.items():
-                with tempfile.NamedTemporaryFile() as temp_fd:
-                    temp_fd.write(content)
-                    temp_fd.flush()
-                    docker_cp_to(self.args, pulp_id, temp_fd.name, path)
-
-            descriptor.start(self.args)
-
-        self._set_cloud_config('PULP_HOST', pulp_host)
-        self._set_cloud_config('PULP_PORT', str(pulp_port))
-        self._set_cloud_config('GALAXY_PORT', str(galaxy_port))
+        injected_files = [
+            ('/etc/galaxy-importer/galaxy-importer.cfg', GALAXY_IMPORTER, 'galaxy-importer'),
+        ]
+        for path, content, friendly_name in injected_files:
+            with tempfile.NamedTemporaryFile() as temp_fd:
+                temp_fd.write(content)
+                temp_fd.flush()
+                display.info(f'>>> {friendly_name} Configuration\n{to_text(content)}', verbosity=3)
+                docker_exec(self.args, descriptor.container_id, ['mkdir', '-p', os.path.dirname(path)], True)
+                docker_cp_to(self.args, descriptor.container_id, temp_fd.name, path)
+                docker_exec(self.args, descriptor.container_id, ['chown', 'pulp:pulp', path], True)
+
+        self._set_cloud_config('PULP_HOST', GALAXY_HOST_NAME)
         self._set_cloud_config('PULP_USER', 'admin')
         self._set_cloud_config('PULP_PASSWORD', 'password')
 
@@ -150,21 +159,19 @@ class GalaxyEnvironment(CloudEnvironment):
         pulp_user = str(self._get_cloud_config('PULP_USER'))
         pulp_password = str(self._get_cloud_config('PULP_PASSWORD'))
         pulp_host = self._get_cloud_config('PULP_HOST')
-        galaxy_port = self._get_cloud_config('GALAXY_PORT')
-        pulp_port = self._get_cloud_config('PULP_PORT')
 
         return CloudEnvironmentConfig(
             ansible_vars=dict(
                 pulp_user=pulp_user,
                 pulp_password=pulp_password,
-                pulp_api='http://%s:%s' % (pulp_host, pulp_port),
-                pulp_server='http://%s:%s/pulp_ansible/galaxy/' % (pulp_host, pulp_port),
-                galaxy_ng_server='http://%s:%s/api/galaxy/' % (pulp_host, galaxy_port),
+                pulp_api=f'http://{pulp_host}',
+                pulp_server=f'http://{pulp_host}/pulp_ansible/galaxy/',
+                galaxy_ng_server=f'http://{pulp_host}/api/galaxy/',
             ),
             env_vars=dict(
                 PULP_USER=pulp_user,
                 PULP_PASSWORD=pulp_password,
-                PULP_SERVER='http://%s:%s/pulp_ansible/galaxy/api/' % (pulp_host, pulp_port),
-                GALAXY_NG_SERVER='http://%s:%s/api/galaxy/' % (pulp_host, galaxy_port),
+                PULP_SERVER=f'http://{pulp_host}/pulp_ansible/galaxy/api/',
+                GALAXY_NG_SERVER=f'http://{pulp_host}/api/galaxy/',
             ),
         )

ansible_test/_internal/commands/integration/cloud/httptester.py

@@ -13,7 +13,6 @@ from ....config import (
 )
 
 from ....containers import (
-    CleanupMode,
     run_support_container,
 )
 
@@ -62,8 +61,6 @@ class HttptesterProvider(CloudProvider):
             'http-test-container',
             ports,
             aliases=aliases,
-            allow_existing=True,
-            cleanup=CleanupMode.YES,
             env={
                 KRB5_PASSWORD_ENV: generate_password(),
             },

ansible_test/_internal/commands/integration/cloud/nios.py

@@ -8,7 +8,6 @@ from ....config import (
 )
 
 from ....containers import (
-    CleanupMode,
     run_support_container,
 )
 
@@ -22,8 +21,6 @@ from . import (
 class NiosProvider(CloudProvider):
     """Nios plugin. Sets up NIOS mock server for tests."""
 
-    DOCKER_SIMULATOR_NAME = 'nios-simulator'
-
     # Default image to run the nios simulator.
     #
     # The simulator must be pinned to a specific version
@@ -31,7 +28,7 @@ class NiosProvider(CloudProvider):
     #
     # It's source source itself resides at:
     # https://github.com/ansible/nios-test-container
-    DOCKER_IMAGE = 'quay.io/ansible/nios-test-container:1.5.0'
+    DOCKER_IMAGE = 'quay.io/ansible/nios-test-container:2.0.0'
 
     def __init__(self, args: IntegrationConfig) -> None:
         super().__init__(args)
@@ -65,17 +62,18 @@ class NiosProvider(CloudProvider):
             nios_port,
         ]
 
-        run_support_container(
+        descriptor = run_support_container(
             self.args,
             self.platform,
             self.image,
-            self.DOCKER_SIMULATOR_NAME,
+            'nios-simulator',
             ports,
-            allow_existing=True,
-            cleanup=CleanupMode.YES,
         )
 
-        self._set_cloud_config('NIOS_HOST', self.DOCKER_SIMULATOR_NAME)
+        if not descriptor:
+            return
+
+        self._set_cloud_config('NIOS_HOST', descriptor.name)
 
     def _setup_static(self) -> None:
         raise NotImplementedError()

ansible_test/_internal/commands/integration/cloud/openshift.py

@@ -16,7 +16,6 @@ from ....config import (
 )
 
 from ....containers import (
-    CleanupMode,
     run_support_container,
     wait_for_file,
 )
@@ -31,8 +30,6 @@ from . import (
 class OpenShiftCloudProvider(CloudProvider):
     """OpenShift cloud provider plugin. Sets up cloud resources before delegation."""
 
-    DOCKER_CONTAINER_NAME = 'openshift-origin'
-
     def __init__(self, args: IntegrationConfig) -> None:
         super().__init__(args, config_extension='.kubeconfig')
 
@@ -74,10 +71,8 @@ class OpenShiftCloudProvider(CloudProvider):
             self.args,
             self.platform,
             self.image,
-            self.DOCKER_CONTAINER_NAME,
+            'openshift-origin',
             ports,
-            allow_existing=True,
-            cleanup=CleanupMode.YES,
             cmd=cmd,
         )
 
@@ -87,7 +82,7 @@ class OpenShiftCloudProvider(CloudProvider):
         if self.args.explain:
             config = '# Unknown'
         else:
-            config = self._get_config(self.DOCKER_CONTAINER_NAME, 'https://%s:%s/' % (self.DOCKER_CONTAINER_NAME, port))
+            config = self._get_config(descriptor.name, 'https://%s:%s/' % (descriptor.name, port))
 
         self._write_config(config)
 

ansible_test/_internal/commands/integration/cloud/vcenter.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import configparser
-import os
 
 from ....util import (
     ApplicationError,
@@ -13,15 +12,6 @@ from ....config import (
     IntegrationConfig,
 )
 
-from ....containers import (
-    CleanupMode,
-    run_support_container,
-)
-
-from .... data import (
-    data_context,
-)
-
 from . import (
     CloudEnvironment,
     CloudEnvironmentConfig,
@@ -32,74 +22,16 @@ from . import (
 class VcenterProvider(CloudProvider):
     """VMware vcenter/esx plugin. Sets up cloud resources for tests."""
 
-    DOCKER_SIMULATOR_NAME = 'vcenter-simulator'
-
     def __init__(self, args: IntegrationConfig) -> None:
         super().__init__(args)
 
-        # The simulator must be pinned to a specific version to guarantee CI passes with the version used.
-        if os.environ.get('ANSIBLE_VCSIM_CONTAINER'):
-            self.image = os.environ.get('ANSIBLE_VCSIM_CONTAINER')
-        else:
-            self.image = 'quay.io/ansible/vcenter-test-container:1.7.0'
-
-        # VMware tests can be run on govcsim or BYO with a static config file.
-        # When testing ansible-core, the simulator is the default if no config is provided. This facilitates easier testing of the plugin's container support.
-        # When testing a collection, static config is the default if no config is provided.
-        default_mode = 'govcsim' if data_context().content.is_ansible else 'static'
-
-        self.vmware_test_platform = os.environ.get('VMWARE_TEST_PLATFORM', default_mode)
-
-        if self.vmware_test_platform == 'govcsim':
-            display.warning(
-                'The govcsim simulator is deprecated and will be removed in a future version of ansible-test. Use a static configuration instead.',
-                unique=True,
-            )
-
-            self.uses_docker = True
-            self.uses_config = False
-        elif self.vmware_test_platform == 'static':
-            self.uses_docker = False
-            self.uses_config = True
+        self.uses_config = True
 
     def setup(self) -> None:
         """Setup the cloud resource before delegation and register a cleanup callback."""
         super().setup()
 
-        self._set_cloud_config('vmware_test_platform', self.vmware_test_platform)
-
-        if self.vmware_test_platform == 'govcsim':
-            self._setup_dynamic_simulator()
-            self.managed = True
-        elif self.vmware_test_platform == 'static':
-            self._use_static_config()
-            self._setup_static()
-        else:
-            raise ApplicationError('Unknown vmware_test_platform: %s' % self.vmware_test_platform)
-
-    def _setup_dynamic_simulator(self) -> None:
-        """Create a vcenter simulator using docker."""
-        ports = [
-            443,
-            8080,
-            8989,
-            5000,  # control port for flask app in simulator
-        ]
-
-        run_support_container(
-            self.args,
-            self.platform,
-            self.image,
-            self.DOCKER_SIMULATOR_NAME,
-            ports,
-            allow_existing=True,
-            cleanup=CleanupMode.YES,
-        )
-
-        self._set_cloud_config('vcenter_hostname', self.DOCKER_SIMULATOR_NAME)
-
-    def _setup_static(self) -> None:
-        if not os.path.exists(self.config_static_path):
+        if not self._use_static_config():
             raise ApplicationError('Configuration file does not exist: %s' % self.config_static_path)
 
 
@@ -108,37 +40,21 @@ class VcenterEnvironment(CloudEnvironment):
 
     def get_environment_config(self) -> CloudEnvironmentConfig:
         """Return environment configuration for use in the test environment after delegation."""
-        try:
-            # We may be in a container, so we cannot just reach VMWARE_TEST_PLATFORM,
-            # We do a try/except instead
-            parser = configparser.ConfigParser()
-            parser.read(self.config_path)  # static
-
-            env_vars = {}
-            ansible_vars = dict(
-                resource_prefix=self.resource_prefix,
-            )
-            ansible_vars.update(dict(parser.items('DEFAULT', raw=True)))
-        except KeyError:  # govcsim
-            env_vars = dict(
-                VCENTER_HOSTNAME=str(self._get_cloud_config('vcenter_hostname')),
-                VCENTER_USERNAME='user',
-                VCENTER_PASSWORD='pass',
-            )
-
-            ansible_vars = dict(
-                vcsim=str(self._get_cloud_config('vcenter_hostname')),
-                vcenter_hostname=str(self._get_cloud_config('vcenter_hostname')),
-                vcenter_username='user',
-                vcenter_password='pass',
-            )
+        # We may be in a container, so we cannot just reach VMWARE_TEST_PLATFORM,
+        # We do a try/except instead
+        parser = configparser.ConfigParser()
+        parser.read(self.config_path)  # static
+
+        ansible_vars = dict(
+            resource_prefix=self.resource_prefix,
+        )
+        ansible_vars.update(dict(parser.items('DEFAULT', raw=True)))
 
         for key, value in ansible_vars.items():
             if key.endswith('_password'):
                 display.sensitive.add(value)
 
         return CloudEnvironmentConfig(
-            env_vars=env_vars,
             ansible_vars=ansible_vars,
             module_defaults={
                 'group/vmware': {

ansible_test/_internal/commands/sanity/__init__.py

@@ -879,6 +879,7 @@ class SanityCodeSmellTest(SanitySingleVersion):
             self.__include_directories: bool = self.config.get('include_directories')
             self.__include_symlinks: bool = self.config.get('include_symlinks')
             self.__py2_compat: bool = self.config.get('py2_compat', False)
+            self.__error_code: str | None = self.config.get('error_code', None)
         else:
             self.output = None
             self.extensions = []
@@ -894,6 +895,7 @@ class SanityCodeSmellTest(SanitySingleVersion):
             self.__include_directories = False
             self.__include_symlinks = False
             self.__py2_compat = False
+            self.__error_code = None
 
         if self.no_targets:
             mutually_exclusive = (
@@ -912,6 +914,11 @@ class SanityCodeSmellTest(SanitySingleVersion):
             if problems:
                 raise ApplicationError('Sanity test "%s" option "no_targets" is mutually exclusive with options: %s' % (self.name, ', '.join(problems)))
 
+    @property
+    def error_code(self) -> t.Optional[str]:
+        """Error code for ansible-test matching the format used by the underlying test program, or None if the program does not use error codes."""
+        return self.__error_code
+
     @property
     def all_targets(self) -> bool:
         """True if test targets will not be filtered using includes, excludes, requires or changes. Mutually exclusive with no_targets."""
@@ -996,6 +1003,8 @@ class SanityCodeSmellTest(SanitySingleVersion):
                 pattern = '^(?P<path>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+): (?P<message>.*)$'
             elif self.output == 'path-message':
                 pattern = '^(?P<path>[^:]*): (?P<message>.*)$'
+            elif self.output == 'path-line-column-code-message':
+                pattern = '^(?P<path>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+): (?P<code>[^:]*): (?P<message>.*)$'
             else:
                 raise ApplicationError('Unsupported output type: %s' % self.output)
 
@@ -1025,6 +1034,7 @@ class SanityCodeSmellTest(SanitySingleVersion):
                     path=m['path'],
                     line=int(m.get('line', 0)),
                     column=int(m.get('column', 0)),
+                    code=m.get('code'),
                 ) for m in matches]
 
                 messages = settings.process_errors(messages, paths)

ansible_test/_internal/commands/sanity/import.py

@@ -127,14 +127,20 @@ class ImportTest(SanityMultipleVersion):
             ('plugin', _get_module_test(False)),
         ):
             if import_type == 'plugin' and python.version in REMOTE_ONLY_PYTHON_VERSIONS:
-                continue
+                # Plugins are not supported on remote-only Python versions.
+                # However, the collection loader is used by the import sanity test and unit tests on remote-only Python versions.
+                # To support this, it is tested as a plugin, but using a venv which installs no requirements.
+                # Filtering of paths relevant to the Python version tested has already been performed by filter_remote_targets.
+                venv_type = 'empty'
+            else:
+                venv_type = import_type
 
             data = '\n'.join([path for path in paths if test(path)])
 
             if not data and not args.prime_venvs:
                 continue
 
-            virtualenv_python = create_sanity_virtualenv(args, python, f'{self.name}.{import_type}', coverage=args.coverage, minimize=True)
+            virtualenv_python = create_sanity_virtualenv(args, python, f'{self.name}.{venv_type}', coverage=args.coverage, minimize=True)
 
             if not virtualenv_python:
                 display.warning(f'Skipping sanity test "{self.name}" on Python {python.version} due to missing virtual environment support.')

ansible_test/_internal/commands/sanity/pylint.py

@@ -18,6 +18,11 @@ from . import (
     SANITY_ROOT,
 )
 
+from ...constants import (
+    CONTROLLER_PYTHON_VERSIONS,
+    REMOTE_ONLY_PYTHON_VERSIONS,
+)
+
 from ...io import (
     make_dirs,
 )
@@ -38,6 +43,7 @@ from ...util import (
 
 from ...util_common import (
     run_command,
+    process_scoped_temporary_file,
 )
 
 from ...ansible_util import (
@@ -81,6 +87,8 @@ class PylintTest(SanitySingleVersion):
         return [target for target in targets if os.path.splitext(target.path)[1] == '.py' or is_subdir(target.path, 'bin')]
 
     def test(self, args: SanityConfig, targets: SanityTargets, python: PythonConfig) -> TestResult:
+        min_python_version_db_path = self.create_min_python_db(args, targets.targets)
+
         plugin_dir = os.path.join(SANITY_ROOT, 'pylint', 'plugins')
         plugin_names = sorted(p[0] for p in [
             os.path.splitext(p) for p in os.listdir(plugin_dir)] if p[1] == '.py' and p[0] != '__init__')
@@ -163,7 +171,7 @@ class PylintTest(SanitySingleVersion):
                 continue
 
             context_start = datetime.datetime.now(tz=datetime.timezone.utc)
-            messages += self.pylint(args, context, context_paths, plugin_dir, plugin_names, python, collection_detail)
+            messages += self.pylint(args, context, context_paths, plugin_dir, plugin_names, python, collection_detail, min_python_version_db_path)
             context_end = datetime.datetime.now(tz=datetime.timezone.utc)
 
             context_times.append('%s: %d (%s)' % (context, len(context_paths), context_end - context_start))
@@ -194,6 +202,22 @@ class PylintTest(SanitySingleVersion):
 
         return SanitySuccess(self.name)
 
+    def create_min_python_db(self, args: SanityConfig, targets: t.Iterable[TestTarget]) -> str:
+        """Create a database of target file paths and their minimum required Python version, returning the path to the database."""
+        target_paths = set(target.path for target in self.filter_remote_targets(list(targets)))
+        controller_min_version = CONTROLLER_PYTHON_VERSIONS[0]
+        target_min_version = REMOTE_ONLY_PYTHON_VERSIONS[0]
+        min_python_versions = {
+            os.path.abspath(target.path): target_min_version if target.path in target_paths else controller_min_version for target in targets
+        }
+
+        min_python_version_db_path = process_scoped_temporary_file(args)
+
+        with open(min_python_version_db_path, 'w') as database_file:
+            json.dump(min_python_versions, database_file)
+
+        return min_python_version_db_path
+
     @staticmethod
     def pylint(
         args: SanityConfig,
@@ -203,6 +227,7 @@ class PylintTest(SanitySingleVersion):
         plugin_names: list[str],
         python: PythonConfig,
         collection_detail: CollectionDetail,
+        min_python_version_db_path: str,
     ) -> list[dict[str, str]]:
         """Run pylint using the config specified by the context on the specified paths."""
         rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', context.split('/')[0] + '.cfg')
@@ -234,6 +259,7 @@ class PylintTest(SanitySingleVersion):
             '--rcfile', rcfile,
             '--output-format', 'json',
             '--load-plugins', ','.join(sorted(load_plugins)),
+            '--min-python-version-db', min_python_version_db_path,
         ] + paths  # fmt: skip
 
         if data_context().content.collection: