ansible-core 2.18.7rc1__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible/executor/task_result.py

@@ -4,78 +4,148 @@
 
 from __future__ import annotations
 
-from ansible import constants as C
-from ansible.parsing.dataloader import DataLoader
+import collections.abc as _c
+import dataclasses
+import functools
+import typing as t
+
+from ansible import constants
+from ansible.utils import vars as _vars
 from ansible.vars.clean import module_response_deepcopy, strip_internal_keys
+from ansible.module_utils._internal import _messages
+from ansible._internal import _collection_proxy
+
+if t.TYPE_CHECKING:
+    from ansible.inventory.host import Host
+    from ansible.playbook.task import Task
 
 _IGNORE = ('failed', 'skipped')
-_PRESERVE = ('attempts', 'changed', 'retries')
-_SUB_PRESERVE = {'_ansible_delegated_vars': ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection')}
+_PRESERVE = {'attempts', 'changed', 'retries', '_ansible_no_log', 'exception', 'warnings', 'deprecations'}
+_SUB_PRESERVE = {'_ansible_delegated_vars': {'ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection'}}
 
 # stuff callbacks need
 CLEAN_EXCEPTIONS = (
     '_ansible_verbose_always',  # for debug and other actions, to always expand data (pretty jsonification)
     '_ansible_item_label',  # to know actual 'item' variable
-    '_ansible_no_log',  # jic we didnt clean up well enough, DON'T LOG
+    '_ansible_no_log',  # jic we didn't clean up well enough, DON'T LOG
     '_ansible_verbose_override',  # controls display of ansible_facts, gathering would be very noise with -v otherwise
 )
 
 
-class TaskResult:
-    '''
+@t.final
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class _WireTaskResult:
+    """A thin version of `_RawTaskResult` which can be sent over the worker queue."""
+
+    host_name: str
+    task_uuid: str
+    return_data: _c.MutableMapping[str, object]
+    task_fields: _c.Mapping[str, object]
+
+
+class _BaseTaskResult:
+    """
     This class is responsible for interpreting the resulting data
     from an executed task, and provides helper methods for determining
     the result of a given task.
-    '''
+    """
 
-    def __init__(self, host, task, return_data, task_fields=None):
-        self._host = host
-        self._task = task
+    def __init__(self, host: Host, task: Task, return_data: _c.MutableMapping[str, t.Any], task_fields: _c.Mapping[str, t.Any]) -> None:
+        self.__host = host
+        self.__task = task
+        self._return_data = return_data  # FIXME: this should be immutable, but strategy result processing mutates it in some corner cases
+        self.__task_fields = task_fields
 
-        if isinstance(return_data, dict):
-            self._result = return_data.copy()
-        else:
-            self._result = DataLoader().load(return_data)
+    @property
+    def host(self) -> Host:
+        """The host associated with this result."""
+        return self.__host
 
-        if task_fields is None:
-            self._task_fields = dict()
-        else:
-            self._task_fields = task_fields
+    @property
+    def _host(self) -> Host:
+        """Use the `host` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_host` in favor of `host`' core_version='2.23'
+        return self.__host
+
+    @property
+    def task(self) -> Task:
+        """The task associated with this result."""
+        return self.__task
+
+    @property
+    def _task(self) -> Task:
+        """Use the `task` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_task` in favor of `task`' core_version='2.23'
+        return self.__task
+
+    @property
+    def task_fields(self) -> _c.Mapping[str, t.Any]:
+        """The task fields associated with this result."""
+        return self.__task_fields
+
+    @property
+    def _task_fields(self) -> _c.Mapping[str, t.Any]:
+        """Use the `task_fields` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_task_fields` in favor of `task`' core_version='2.23'
+        return self.__task_fields
+
+    @property
+    def exception(self) -> _messages.ErrorSummary | None:
+        """The error from this task result, if any."""
+        return self._return_data.get('exception')
+
+    @property
+    def warnings(self) -> _c.Sequence[_messages.WarningSummary]:
+        """The warnings for this task, if any."""
+        return _collection_proxy.SequenceProxy(self._return_data.get('warnings') or [])
 
     @property
-    def task_name(self):
-        return self._task_fields.get('name', None) or self._task.get_name()
+    def deprecations(self) -> _c.Sequence[_messages.DeprecationSummary]:
+        """The deprecation warnings for this task, if any."""
+        return _collection_proxy.SequenceProxy(self._return_data.get('deprecations') or [])
+
+    @property
+    def _loop_results(self) -> list[_c.MutableMapping[str, t.Any]]:
+        """Return a list of loop results. If no loop results are present, an empty list is returned."""
+        results = self._return_data.get('results')
+
+        if not isinstance(results, list):
+            return []
 
-    def is_changed(self):
+        return results
+
+    @property
+    def task_name(self) -> str:
+        return str(self.task_fields.get('name', '')) or self.task.get_name()
+
+    def is_changed(self) -> bool:
         return self._check_key('changed')
 
-    def is_skipped(self):
-        # loop results
-        if 'results' in self._result:
-            results = self._result['results']
+    def is_skipped(self) -> bool:
+        if self._loop_results:
             # Loop tasks are only considered skipped if all items were skipped.
             # some squashed results (eg, dnf) are not dicts and can't be skipped individually
-            if results and all(isinstance(res, dict) and res.get('skipped', False) for res in results):
+            if all(isinstance(loop_res, dict) and loop_res.get('skipped', False) for loop_res in self._loop_results):
                 return True
 
         # regular tasks and squashed non-dict results
-        return self._result.get('skipped', False)
+        return bool(self._return_data.get('skipped', False))
 
-    def is_failed(self):
-        if 'failed_when_result' in self._result or \
-           'results' in self._result and True in [True for x in self._result['results'] if 'failed_when_result' in x]:
+    def is_failed(self) -> bool:
+        if 'failed_when_result' in self._return_data or any(isinstance(loop_res, dict) and 'failed_when_result' in loop_res for loop_res in self._loop_results):
             return self._check_key('failed_when_result')
-        else:
-            return self._check_key('failed')
 
-    def is_unreachable(self):
+        return self._check_key('failed')
+
+    def is_unreachable(self) -> bool:
         return self._check_key('unreachable')
 
-    def needs_debugger(self, globally_enabled=False):
-        _debugger = self._task_fields.get('debugger')
-        _ignore_errors = C.TASK_DEBUGGER_IGNORE_ERRORS and self._task_fields.get('ignore_errors')
+    def needs_debugger(self, globally_enabled: bool = False) -> bool:
+        _debugger = self.task_fields.get('debugger')
+        _ignore_errors = constants.TASK_DEBUGGER_IGNORE_ERRORS and self.task_fields.get('ignore_errors')
 
         ret = False
+
         if globally_enabled and ((self.is_failed() and not _ignore_errors) or self.is_unreachable()):
             ret = True
 
@@ -92,62 +162,95 @@ class TaskResult:
 
         return ret
 
-    def _check_key(self, key):
-        '''get a specific key from the result or its items'''
+    def _check_key(self, key: str) -> bool:
+        """Fetch a specific named boolean value from the result; if missing, a logical OR of the value from nested loop results; False for non-loop results."""
+        if (value := self._return_data.get(key, ...)) is not ...:
+            return bool(value)
 
-        if isinstance(self._result, dict) and key in self._result:
-            return self._result.get(key, False)
-        else:
-            flag = False
-            for res in self._result.get('results', []):
-                if isinstance(res, dict):
-                    flag |= res.get(key, False)
-            return flag
+        return any(isinstance(result, dict) and result.get(key) for result in self._loop_results)
 
-    def clean_copy(self):
 
-        ''' returns 'clean' taskresult object '''
+@t.final
+class _RawTaskResult(_BaseTaskResult):
+    def as_wire_task_result(self) -> _WireTaskResult:
+        """Return a `_WireTaskResult` from this instance."""
+        return _WireTaskResult(
+            host_name=self.host.name,
+            task_uuid=self.task._uuid,
+            return_data=self._return_data,
+            task_fields=self.task_fields,
+        )
 
-        # FIXME: clean task_fields, _task and _host copies
-        result = TaskResult(self._host, self._task, {}, self._task_fields)
+    def as_callback_task_result(self) -> CallbackTaskResult:
+        """Return a `CallbackTaskResult` from this instance."""
+        ignore: tuple[str, ...]
 
         # statuses are already reflected on the event type
-        if result._task and result._task.action in C._ACTION_DEBUG:
+        if self.task and self.task.action in constants._ACTION_DEBUG:
             # debug is verbose by default to display vars, no need to add invocation
             ignore = _IGNORE + ('invocation',)
         else:
             ignore = _IGNORE
 
-        subset = {}
+        subset: dict[str, dict[str, object]] = {}
+
         # preserve subset for later
-        for sub in _SUB_PRESERVE:
-            if sub in self._result:
-                subset[sub] = {}
-                for key in _SUB_PRESERVE[sub]:
-                    if key in self._result[sub]:
-                        subset[sub][key] = self._result[sub][key]
-
-        if isinstance(self._task.no_log, bool) and self._task.no_log or self._result.get('_ansible_no_log', False):
-            x = {"censored": "the output has been hidden due to the fact that 'no_log: true' was specified for this result"}
-
-            # preserve full
-            for preserve in _PRESERVE:
-                if preserve in self._result:
-                    x[preserve] = self._result[preserve]
-
-            result._result = x
-        elif self._result:
-            result._result = module_response_deepcopy(self._result)
-
-            # actually remove
-            for remove_key in ignore:
-                if remove_key in result._result:
-                    del result._result[remove_key]
+        for sub, sub_keys in _SUB_PRESERVE.items():
+            sub_data = self._return_data.get(sub)
+
+            if isinstance(sub_data, dict):
+                subset[sub] = {key: value for key, value in sub_data.items() if key in sub_keys}
+
+        # DTFIX-FUTURE: is checking no_log here redundant now that we use _ansible_no_log everywhere?
+        if isinstance(self.task.no_log, bool) and self.task.no_log or self._return_data.get('_ansible_no_log'):
+            censored_result = censor_result(self._return_data)
+
+            if self._loop_results:
+                # maintain shape for loop results so callback behavior recognizes a loop was performed
+                censored_result.update(results=[
+                    censor_result(loop_res) if isinstance(loop_res, dict) and loop_res.get('_ansible_no_log') else loop_res for loop_res in self._loop_results
+                ])
+
+            return_data = censored_result
+        elif self._return_data:
+            return_data = {k: v for k, v in module_response_deepcopy(self._return_data).items() if k not in ignore}
 
             # remove almost ALL internal keys, keep ones relevant to callback
-            strip_internal_keys(result._result, exceptions=CLEAN_EXCEPTIONS)
+            strip_internal_keys(return_data, exceptions=CLEAN_EXCEPTIONS)
+        else:
+            return_data = {}
 
         # keep subset
-        result._result.update(subset)
+        return_data.update(subset)
+
+        return CallbackTaskResult(self.host, self.task, return_data, self.task_fields)
+
+
+@t.final
+class CallbackTaskResult(_BaseTaskResult):
+    """Public contract of TaskResult """
+
+    @property
+    def _result(self) -> _c.MutableMapping[str, t.Any]:
+        """Use the `result` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_result` in favor of `result`' core_version='2.23'
+        return self.result
+
+    @functools.cached_property
+    def result(self) -> _c.MutableMapping[str, t.Any]:
+        """
+        Returns a cached copy of the task result dictionary for consumption by callbacks.
+        Internal custom types are transformed to native Python types to facilitate access and serialization.
+        """
+        return t.cast(_c.MutableMapping[str, t.Any], _vars.transform_to_native_types(self._return_data))
+
+
+TaskResult = CallbackTaskResult
+"""Compatibility name for the pre-2.19 callback-shaped TaskResult passed to callbacks."""
+
+
+def censor_result(result: _c.Mapping[str, t.Any]) -> dict[str, t.Any]:
+    censored_result = {key: value for key in _PRESERVE if (value := result.get(key, ...)) is not ...}
+    censored_result.update(censored="the output has been hidden due to the fact that 'no_log: true' was specified for this result")
 
-        return result
+    return censored_result

ansible/galaxy/__init__.py

@@ -18,7 +18,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 #
 ########################################################################
-''' This manages remote shared Ansible objects, mainly roles'''
+""" This manages remote shared Ansible objects, mainly roles"""
 
 from __future__ import annotations
 
@@ -40,7 +40,7 @@ def get_collections_galaxy_meta_info():
 
 
 class Galaxy(object):
-    ''' Keeps global galaxy info '''
+    """ Keeps global galaxy info """
 
     def __init__(self):
         # TODO: eventually remove this as it contains a mismash of properties that aren't really global

ansible/galaxy/api.py

@@ -57,13 +57,13 @@ def should_retry_error(exception):
     if isinstance(exception, GalaxyError) and exception.http_code in RETRY_HTTP_ERROR_CODES:
         return True
 
-    if isinstance(exception, AnsibleError) and (orig_exc := getattr(exception, 'orig_exc', None)):
+    if isinstance(exception, AnsibleError) and (cause := exception.__cause__):
         # URLError is often a proxy for an underlying error, handle wrapped exceptions
-        if isinstance(orig_exc, URLError):
-            orig_exc = orig_exc.reason
+        if isinstance(cause, URLError):
+            cause = cause.reason
 
         # Handle common URL related errors
-        if isinstance(orig_exc, (TimeoutError, BadStatusLine, IncompleteRead)):
+        if isinstance(cause, (TimeoutError, BadStatusLine, IncompleteRead)):
             return True
 
     return False
@@ -92,7 +92,7 @@ def g_connect(versions):
                 try:
                     data = self._call_galaxy(n_url, method='GET', error_context_msg=error_context_msg, cache=True)
                 except (AnsibleError, GalaxyError, ValueError, KeyError) as err:
-                    # Either the URL doesnt exist, or other error. Or the URL exists, but isn't a galaxy API
+                    # Either the URL doesn't exist, or other error. Or the URL exists, but isn't a galaxy API
                     # root (not JSON, no 'available_versions') so try appending '/api/'
                     if n_url.endswith('/api') or n_url.endswith('/api/'):
                         raise
@@ -138,7 +138,7 @@ def g_connect(versions):
                     'The v2 Ansible Galaxy API is deprecated and no longer supported. '
                     'Ensure that you have configured the ansible-galaxy CLI to utilize an '
                     'updated and supported version of Ansible Galaxy.',
-                    version='2.20'
+                    version='2.20',
                 )
 
             return method(self, *args, **kwargs)
@@ -337,10 +337,7 @@ class GalaxyAPI:
         if not isinstance(other_galaxy_api, self.__class__):
             return NotImplemented
 
-        return (
-            self._priority > other_galaxy_api._priority or
-            self.name < self.name
-        )
+        return self._priority > other_galaxy_api._priority
 
     @property  # type: ignore[misc]  # https://github.com/python/mypy/issues/1362
     @g_connect(['v1', 'v2', 'v3'])
@@ -408,11 +405,8 @@ class GalaxyAPI:
                             method=method, timeout=self._server_timeout, http_agent=user_agent(), follow_redirects='safe')
         except HTTPError as e:
             raise GalaxyError(e, error_context_msg)
-        except Exception as e:
-            raise AnsibleError(
-                "Unknown error when attempting to call Galaxy at '%s': %s" % (url, to_native(e)),
-                orig_exc=e
-            )
+        except Exception as ex:
+            raise AnsibleError(f"Unknown error when attempting to call Galaxy at {url!r}.") from ex
 
         resp_data = to_text(resp.read(), errors='surrogate_or_strict')
         try:
@@ -471,8 +465,8 @@ class GalaxyAPI:
             resp = open_url(url, data=args, validate_certs=self.validate_certs, method="POST", http_agent=user_agent(), timeout=self._server_timeout)
         except HTTPError as e:
             raise GalaxyError(e, 'Attempting to authenticate to galaxy')
-        except Exception as e:
-            raise AnsibleError('Unable to authenticate to galaxy: %s' % to_native(e), orig_exc=e)
+        except Exception as ex:
+            raise AnsibleError('Unable to authenticate to galaxy.') from ex
 
         data = json.loads(to_text(resp.read(), errors='surrogate_or_strict'))
         return data
@@ -817,8 +811,17 @@ class GalaxyAPI:
 
         signatures = data.get('signatures') or []
 
+        download_url_info = urlparse(data['download_url'])
+        if not download_url_info.scheme and not download_url_info.path.startswith('/'):
+            # galaxy does a lot of redirects, with much more complex pathing than we use
+            # within this codebase, without updating _call_galaxy to be able to return
+            # the final URL, we can't reliably build a relative URL.
+            raise AnsibleError(f'Invalid non absolute download_url: {data["download_url"]}')
+
+        download_url = urljoin(self.api_server, data['download_url'])
+
         return CollectionVersionMetadata(data['namespace']['name'], data['collection']['name'], data['version'],
-                                         data['download_url'], data['artifact']['sha256'],
+                                         download_url, data['artifact']['sha256'],
                                          data['metadata']['dependencies'], data['href'], signatures)
 
     @g_connect(['v2', 'v3'])
@@ -874,7 +877,7 @@ class GalaxyAPI:
         except GalaxyError as err:
             if err.http_code != 404:
                 raise
-            # v3 doesn't raise a 404 so we need to mimick the empty response from APIs that do.
+            # v3 doesn't raise a 404 so we need to mimic the empty response from APIs that do.
             return []
 
         if 'data' in data:
@@ -896,12 +899,10 @@ class GalaxyAPI:
             if not next_link:
                 break
             elif relative_link:
-                # TODO: This assumes the pagination result is relative to the root server. Will need to be verified
-                # with someone who knows the AH API.
-
-                # Remove the query string from the versions_url to use the next_link's query
-                versions_url = urljoin(versions_url, urlparse(versions_url).path)
-                next_link = versions_url.replace(versions_url_info.path, next_link)
+                next_link_info = urlparse(next_link)
+                if not next_link_info.scheme and not next_link_info.path.startswith('/'):
+                    raise AnsibleError(f'Invalid non absolute pagination link: {next_link}')
+                next_link = urljoin(self.api_server, next_link)
 
             data = self._call_galaxy(to_native(next_link, errors='surrogate_or_strict'),
                                      error_context_msg=error_context_msg, cache=True, cache_key=cache_key)

ansible/galaxy/collection/__init__.py

@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import errno
 import fnmatch
 import functools
 import glob
@@ -31,6 +30,7 @@ from dataclasses import dataclass
 from hashlib import sha256
 from io import BytesIO
 from importlib.metadata import distribution
+from importlib.resources import files
 from itertools import chain
 
 try:
@@ -85,7 +85,6 @@ if t.TYPE_CHECKING:
     FilesManifestType = t.Dict[t.Literal['files', 'format'], t.Union[t.List[FileManifestEntryType], int]]
 
 import ansible.constants as C
-from ansible.compat.importlib_resources import files
 from ansible.errors import AnsibleError
 from ansible.galaxy.api import GalaxyAPI
 from ansible.galaxy.collection.concrete_artifact_manager import (
@@ -126,13 +125,13 @@ from ansible.galaxy.dependency_resolution.dataclasses import (
 from ansible.galaxy.dependency_resolution.versioning import meets_requirements
 from ansible.plugins.loader import get_all_plugin_loaders
 from ansible.module_utils.common.file import S_IRWU_RG_RO, S_IRWXU_RXG_RXO, S_IXANY
+from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.module_utils.common.collections import is_sequence
 from ansible.module_utils.common.yaml import yaml_dump
 from ansible.utils.collection_loader import AnsibleCollectionRef
 from ansible.utils.display import Display
 from ansible.utils.hashing import secure_hash, secure_hash_s
-from ansible.utils.sentinel import Sentinel
 
 
 display = Display()
@@ -201,9 +200,9 @@ class CollectionSignatureError(Exception):
 
 # FUTURE: expose actual verify result details for a collection on this object, maybe reimplement as dataclass on py3.8+
 class CollectionVerifyResult:
-    def __init__(self, collection_name):  # type: (str) -> None
-        self.collection_name = collection_name  # type: str
-        self.success = True  # type: bool
+    def __init__(self, collection_name: str) -> None:
+        self.collection_name = collection_name
+        self.success = True
 
 
 def verify_local_collection(local_collection, remote_collection, artifacts_manager):
@@ -1433,9 +1432,6 @@ def find_existing_collections(path_filter, artifacts_manager, namespace_filter=N
     :param path: Collection dirs layout search path.
     :param artifacts_manager: Artifacts manager.
     """
-    if files is None:
-        raise AnsibleError('importlib_resources is not installed and is required')
-
     if path_filter and not is_sequence(path_filter):
         path_filter = [path_filter]
     if namespace_filter and not is_sequence(namespace_filter):
@@ -1692,11 +1688,7 @@ def _extract_tar_dir(tar, dirname, b_dest):
     b_dir_path = os.path.join(b_dest, to_bytes(dirname, errors='surrogate_or_strict'))
 
     b_parent_path = os.path.dirname(b_dir_path)
-    try:
-        os.makedirs(b_parent_path, mode=S_IRWXU_RXG_RXO)
-    except OSError as e:
-        if e.errno != errno.EEXIST:
-            raise
+    os.makedirs(b_parent_path, mode=S_IRWXU_RXG_RXO, exist_ok=True)
 
     if tar_member.type == tarfile.SYMTYPE:
         b_link_path = to_bytes(tar_member.linkname, errors='surrogate_or_strict')

ansible/galaxy/collection/concrete_artifact_manager.py

@@ -35,10 +35,10 @@ from ansible.module_utils.common.text.converters import to_bytes, to_native, to_
 from ansible.module_utils.api import retry_with_delays_and_condition
 from ansible.module_utils.api import generate_jittered_backoff
 from ansible.module_utils.common.process import get_bin_path
+from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.yaml import yaml_load
 from ansible.module_utils.urls import open_url
 from ansible.utils.display import Display
-from ansible.utils.sentinel import Sentinel
 
 import ansible.constants as C
 
@@ -449,9 +449,9 @@ def _extract_collection_from_git(repo_url, coll_ver, b_path):
     except subprocess.CalledProcessError as proc_err:
         raise AnsibleError(  # should probably be LookupError
             'Failed to switch a cloned Git repo `{repo_url!s}` '
-            'to the requested revision `{commitish!s}`.'.
+            'to the requested revision `{revision!s}`.'.
             format(
-                commitish=to_native(version),
+                revision=to_native(version),
                 repo_url=to_native(git_url),
             ),
         ) from proc_err
@@ -485,16 +485,13 @@ def _download_file(url, b_path, expected_hash, validate_certs, token=None, timeo
     display.display("Downloading %s to %s" % (url, to_text(b_tarball_dir)))
     # NOTE: Galaxy redirects downloads to S3 which rejects the request
     # NOTE: if an Authorization header is attached so don't redirect it
-    try:
-        resp = open_url(
-            to_native(url, errors='surrogate_or_strict'),
-            validate_certs=validate_certs,
-            headers=None if token is None else token.headers(),
-            unredirected_headers=['Authorization'], http_agent=user_agent(),
-            timeout=timeout
-        )
-    except Exception as err:
-        raise AnsibleError(to_native(err), orig_exc=err)
+    resp = open_url(
+        to_native(url, errors='surrogate_or_strict'),
+        validate_certs=validate_certs,
+        headers=None if token is None else token.headers(),
+        unredirected_headers=['Authorization'], http_agent=user_agent(),
+        timeout=timeout
+    )
 
     with open(b_file_path, 'wb') as download_file:  # type: t.BinaryIO
         actual_hash = _consume_file(resp, write_to=download_file)
@@ -659,14 +656,8 @@ def _get_json_from_installed_dir(
     try:
         with open(b_json_filepath, 'rb') as manifest_fd:
             b_json_text = manifest_fd.read()
-    except (IOError, OSError):
-        raise LookupError(
-            "The collection {manifest!s} path '{path!s}' does not exist.".
-            format(
-                manifest=filename,
-                path=to_native(b_json_filepath),
-            )
-        )
+    except OSError as ex:
+        raise LookupError(f"The collection {filename!r} path {to_text(b_json_filepath)!r} does not exist.") from ex
 
     manifest_txt = to_text(b_json_text, errors='surrogate_or_strict')
 

ansible/galaxy/dependency_resolution/dataclasses.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import os
+import pathlib
 import typing as t
 
 from collections import namedtuple
@@ -25,6 +26,8 @@ if t.TYPE_CHECKING:
         '_ComputedReqKindsMixin',
     )
 
+import ansible
+import ansible.release
 
 from ansible.errors import AnsibleError, AnsibleAssertionError
 from ansible.galaxy.api import GalaxyAPI
@@ -39,6 +42,7 @@ _ALLOW_CONCRETE_POINTER_IN_SOURCE = False  # NOTE: This is a feature flag
 _GALAXY_YAML = b'galaxy.yml'
 _MANIFEST_JSON = b'MANIFEST.json'
 _SOURCE_METADATA_FILE = b'GALAXY.yml'
+_ANSIBLE_PACKAGE_PATH = pathlib.Path(ansible.__file__).parent
 
 display = Display()
 
@@ -224,6 +228,13 @@ class _ComputedReqKindsMixin:
         if dir_path.endswith(to_bytes(os.path.sep)):
             dir_path = dir_path.rstrip(to_bytes(os.path.sep))
         if not _is_collection_dir(dir_path):
+            dir_pathlib = pathlib.Path(to_text(dir_path))
+
+            # special handling for bundled collections without manifests, e.g., ansible._protomatter
+            if dir_pathlib.is_relative_to(_ANSIBLE_PACKAGE_PATH):
+                req_name = f'{dir_pathlib.parent.name}.{dir_pathlib.name}'
+                return cls(req_name, ansible.release.__version__, dir_path, 'dir', None)
+
             display.warning(
                 u"Collection at '{path!s}' does not have a {manifest_json!s} "
                 u'file, nor has it {galaxy_yml!s}: cannot detect version.'.
@@ -578,10 +589,9 @@ class _ComputedReqKindsMixin:
 
         See https://github.com/ansible/ansible/pull/81606 for extra context.
         """
-        version_string = self.ver[0]
-        return version_string.isdigit() or not (
-            version_string == '*' or
-            version_string.startswith(('<', '>', '!='))
+        version_spec_start_char = self.ver[0]
+        return version_spec_start_char.isdigit() or not (
+            version_spec_start_char.startswith(('<', '>', '!', '*'))
         )
 
     @property