pantsbuild / pants / 19015773527

from __future__ import annotations

from collections.abc import Mapping

from dataclasses import dataclass

from typing import ClassVar, TypeVar, Union

from pants.engine.addresses import Address

from pants.util.frozendict import FrozenDict

from pants.util.strutil import softwrap

class InterpolationError(ValueError):

    @classmethod

    def attribute_error(cls, value: str | InterpolationValue, attribute: str) -> InterpolationError:

        msg = f"The placeholder {attribute!r} is unknown."

        if value and isinstance(value, InterpolationValue):

            msg += f" Try with one of: {', '.join(value.keys())}."

        return cls(msg)

ErrorT = TypeVar("ErrorT", bound=InterpolationError)

class InterpolationValue(FrozenDict[str, str]):

    _attribute_error_type: ClassVar[type[InterpolationError]] = InterpolationError

    def __getattr__(self, attribute: str) -> str:

        if attribute not in self:

            raise self._attribute_error_type.attribute_error(self, attribute)

        return self[attribute]

class InterpolationContext(FrozenDict[str, Union[str, InterpolationValue]]):

    @classmethod

    def from_dict(cls, data: Mapping[str, str | Mapping[str, str]]) -> InterpolationContext:

        return InterpolationContext({key: cls.create_value(value) for key, value in data.items()})

    @staticmethod

    def create_value(value: str | Mapping[str, str]) -> str | InterpolationValue:

        if isinstance(value, (str, InterpolationValue)):

            return value

        return InterpolationValue(value)

    def merge(self, other: Mapping[str, str | Mapping[str, str]]) -> InterpolationContext:

        return InterpolationContext.from_dict({**self, **other})

    def format(

        stack = [text]

        try:

            while "{" in stack[-1] and "}" in stack[-1]:

                if len(stack) >= 5:

                    raise InterpolationError(

                stack.append(stack[-1].format(**self))

                if stack[-1] == stack[-2]:

                    break

            return stack[-1]

        except (KeyError, InterpolationError) as e:

            default_error_cls = InterpolationError

            msg = f"Invalid value for the {source}: {text!r}.\n\n"

            if isinstance(e, InterpolationError):

                default_error_cls = type(e)

                msg += str(e)

                msg += f"The placeholder {e} is unknown."

                if self:

                    msg += f" Try with one of: {', '.join(sorted(self.keys()))}."

                    msg += " "

                    msg += softwrap(

            raise (error_cls or default_error_cls)(msg) from e

    @dataclass(frozen=True)

    class TextSource:

        address: Address | None = None

        target_alias: str | None = None

        field_alias: str | None = None

        options_scope: str | None = None

        def __post_init__(self):

            field_infos_is_none = (

            if self.options_scope is None:

                assert not any(field_infos_is_none), f"Missing target field details in {self!r}."

                assert all(field_infos_is_none), (

        def __str__(self) -> str:

            if self.options_scope:

                return f"`{self.options_scope}` configuration option"

            return (