Skip to content
Back to top

# Source code for searx.result_types.answer

    # SPDX-License-Identifier: AGPL-3.0-or-later
    """
    Typification of the *answer* results.  Results of this type are rendered in
    the :origin:`answers.html <searx/templates/simple/elements/answers.html>`
    template.

    ----

    .. autoclass:: BaseAnswer
       :members:
       :show-inheritance:

    .. autoclass:: Answer
       :members:
       :show-inheritance:

    .. autoclass:: Translations
       :members:
       :show-inheritance:

    .. autoclass:: WeatherAnswer
       :members:
       :show-inheritance:

    .. autoclass:: AnswerSet
       :members:
       :show-inheritance:
    """
    # pylint: disable=too-few-public-methods

    __all__ = ["AnswerSet", "Answer", "Translations", "WeatherAnswer"]

    from flask_babel import gettext
    import msgspec

    from searx import weather
    from ._base import Result

    class BaseAnswer(Result, kw_only=True):
        """Base class of all answer types.  It is not intended to build instances of
        this class (aka *abstract*)."""

    class AnswerSet:
        """Aggregator for :py:obj:`BaseAnswer` items in a result container."""

        def __init__(self):
            self._answerlist = []

        def __len__(self):
            return len(self._answerlist)

        def __bool__(self):
            return bool(self._answerlist)

        def add(self, answer: BaseAnswer) -> None:
            a_hash = hash(answer)
            for i in self._answerlist:
                if hash(i) == a_hash:
                    return
            self._answerlist.append(answer)

        def __iter__(self):
            """Sort items in this set and iterate over the items."""
            self._answerlist.sort(key=lambda answer: answer.template)
            yield from self._answerlist

        def __contains__(self, answer: BaseAnswer) -> bool:
            a_hash = hash(answer)
            for i in self._answerlist:
                if hash(i) == a_hash:
                    return True
            return False

    class Answer(BaseAnswer, kw_only=True):
        """Simple answer type where the *answer* is a simple string with an optional
        :py:obj:`url field <Result.url>` field to link a resource (article, map, ..)
        related to the answer."""

        template: str = "answer/legacy.html"

        answer: str
        """Text of the answer."""

        def __hash__(self):
            """The hash value of field *answer* is the hash value of the
            :py:obj:`Answer` object.  :py:obj:`Answer <Result.__eq__>` objects are
            equal, when the hash values of both objects are equal."""
            return hash(self.answer)

    class Translations(BaseAnswer, kw_only=True):
        """Answer type with a list of translations.

        The items in the list of :py:obj:`Translations.translations` are of type
        :py:obj:`Translations.Item`:

        .. code:: python

           def response(resp):
               results = []
               ...
               foo_1 = Translations.Item(
                   text="foobar",
                   synonyms=["bar", "foo"],
                   examples=["foo and bar are placeholders"],
               )
               foo_url="https://www.deepl.com/de/translator#en/de/foo"
               ...
               Translations(results=results, translations=[foo], url=foo_url)

        """

        template: str = "answer/translations.html"
        """The template in :origin:`answer/translations.html
        <searx/templates/simple/answer/translations.html>`"""

        translations: "list[Translations.Item]"
        """List of translations."""

        def __post_init__(self):
            if not self.translations:
                raise ValueError("Translation does not have an item in the list translations")

        class Item(msgspec.Struct, kw_only=True):
            """A single element of the translations / a translation.  A translation
            consists of at least a mandatory ``text`` property (the translation) ,
            optional properties such as *definitions*, *synonyms* and *examples* are
            possible."""

            text: str
            """Translated text."""

            transliteration: str = ""
            """Transliteration_ of the requested translation.

            .. _Transliteration: https://en.wikipedia.org/wiki/Transliteration
            """

            examples: list[str] = []
            """List of examples for the requested translation."""

            definitions: list[str] = []
            """List of definitions for the requested translation."""

            synonyms: list[str] = []
            """List of synonyms for the requested translation."""

    class WeatherAnswer(BaseAnswer, kw_only=True):
        """Answer type for weather data."""

        template: str = "answer/weather.html"
        """The template is located at :origin:`answer/weather.html
        <searx/templates/simple/answer/weather.html>`"""

        current: "WeatherAnswer.Item"
        """Current weather at ``location``."""

        forecasts: "list[WeatherAnswer.Item]" = []
        """Weather forecasts for ``location``."""

        service: str = ""
        """Weather service from which this information was provided."""

        class Item(msgspec.Struct, kw_only=True):
            """Weather parameters valid for a specific point in time."""

            location: weather.GeoLocation
            """The geo-location the weather data is from (e.g. `Berlin, Germany`)."""

            temperature: weather.Temperature
            """Air temperature at 2m above the ground."""

            condition: weather.WeatherConditionType
            """Standardized designations that summarize the weather situation
            (e.g. ``light sleet showers and thunder``)."""

            # optional fields

            datetime: weather.DateTime | None = None
            """Time of the forecast - not needed for the current weather."""

            summary: str | None = None
            """One-liner about the weather forecast / current weather conditions.
            If unset, a summary is build up from temperature and current weather
            conditions.
            """

            feels_like: weather.Temperature | None = None
            """Apparent temperature, the temperature equivalent perceived by
            humans, caused by the combined effects of air temperature, relative
            humidity and wind speed.  The measure is most commonly applied to the
            perceived outdoor temperature.
            """

            pressure: weather.Pressure | None = None
            """Air pressure at sea level (e.g. 1030 hPa) """

            humidity: weather.RelativeHumidity | None = None
            """Amount of relative humidity in the air at 2m above the ground. The
            unit is ``%``, e.g. 60%)
            """

            wind_from: weather.Compass
            """The directon which moves towards / direction the wind is coming from."""

            wind_speed: weather.WindSpeed | None = None
            """Speed of wind / wind speed at 10m above the ground (10 min average)."""

            cloud_cover: int | None = None
            """Amount of sky covered by clouds / total cloud cover for all heights
            (cloudiness, unit: %)"""

            # attributes: dict[str, str | int] = {}
            # """Key-Value dict of additional typeless weather attributes."""

            def __post_init__(self):
                if not self.summary:
                    self.summary = gettext("{location}: {temperature}, {condition}").format(
                        location=self.location,
                        temperature=self.temperature,
                        condition=gettext(self.condition.capitalize()),
                    )

            @property
            def url(self) -> str | None:
                """Determines a `data URL`_ with a symbol for the weather
                conditions.  If no symbol can be assigned, ``None`` is returned.

                .. _data URL:
                   https://developer.mozilla.org/en-US/docs/Web/URI/Reference/Schemes/data
                """
                return weather.symbol_url(self.condition)