searx.results.ResultContainer Class Reference

Collaboration diagram for searx.results.ResultContainer:

Public Member Functions
	__init__ (self)
	extend (self, str|None engine_name, results)
	close (self)
list[MainResult|LegacyResult]	get_ordered_results (self)
int	number_of_results (self)
	add_unresponsive_engine (self, str engine_name, str error_type, bool suspended=False)
	add_timing (self, str engine_name, float engine_time, float page_load_time)
	get_timings (self)

Public Attributes
	answers = AnswerSet()
dict[str, dict[str, str]]	engine_data = defaultdict(dict)
bool	paging = False
Set[UnresponsiveEngine]	unresponsive_engines = set()
list	timings = []
str|None	redirect_url = None
bool	on_result = lambda _: True

Static Public Attributes
dict	main_results_map [int, MainResult | LegacyResult]
list	infoboxes [LegacyResult]
set	suggestions [str]
set	corrections [str]

Protected Member Functions
	_merge_infobox (self, LegacyResult new_infobox)
	_merge_main_result (self, MainResult|LegacyResult result, position)

Protected Attributes
list	_number_of_results = []
bool	_closed = False
	_lock = RLock()
list[MainResult|LegacyResult]	_main_results_sorted = None

Detailed Description

In the result container, the results are collected, sorted and duplicates
will be merged.

Definition at line 50 of file results.py.

Constructor & Destructor Documentation

__init__()

searx.results.ResultContainer.__init__

(

self

)

Definition at line 62 of file results.py.

    def __init__(self):
        self.main_results_map = {}
        self.infoboxes = []
        self.suggestions = set()
        self.answers = AnswerSet()
        self.corrections = set()
 
        self._number_of_results: list[int] = []
        self.engine_data: dict[str, dict[str, str]] = defaultdict(dict)
        self._closed: bool = False
        self.paging: bool = False
        self.unresponsive_engines: Set[UnresponsiveEngine] = set()
        self.timings: List[Timing] = []
        self.redirect_url: str | None = None
        self.on_result = lambda _: True
        self._lock = RLock()
        self._main_results_sorted: list[MainResult | LegacyResult] = None  # type: ignore
 

References infoboxes, main_results_map, and suggestions.

Member Function Documentation

_merge_infobox()

searx.results.ResultContainer._merge_infobox ( self, LegacyResult new_infobox )

protected

Definition at line 153 of file results.py.

    def _merge_infobox(self, new_infobox: LegacyResult):
        add_infobox = True
 
        new_id = getattr(new_infobox, "id", None)
        if new_id is not None:
            with self._lock:
                for existing_infobox in self.infoboxes:
                    if new_id == getattr(existing_infobox, "id", None):
                        merge_two_infoboxes(existing_infobox, new_infobox)
                        add_infobox = False
        if add_infobox:
            self.infoboxes.append(new_infobox)
 

References searx.metrics.models.Histogram._lock, _lock, infoboxes, and searx.results.merge_two_infoboxes().

Referenced by extend().

Here is the call graph for this function:

Here is the caller graph for this function:

_merge_main_result()

searx.results.ResultContainer._merge_main_result ( self, MainResult | LegacyResult result, position )

protected

Definition at line 166 of file results.py.

    def _merge_main_result(self, result: MainResult | LegacyResult, position):
        result_hash = hash(result)
 
        with self._lock:
 
            merged = self.main_results_map.get(result_hash)
            if not merged:
                # if there is no duplicate in the merged results, append result
                result.positions = [position]
                self.main_results_map[result_hash] = result
                return
 
            merge_two_main_results(merged, result)
            # add the new position
            merged.positions.append(position)
 

References searx.metrics.models.Histogram._lock, _lock, main_results_map, and searx.results.merge_two_main_results().

Referenced by extend().

Here is the call graph for this function:

Here is the caller graph for this function:

add_timing()

searx.results.ResultContainer.add_timing	(		self,
		str	engine_name,
		float	engine_time,
		float	page_load_time )

Definition at line 275 of file results.py.

    def add_timing(self, engine_name: str, engine_time: float, page_load_time: float):
        with self._lock:
            if self._closed:
                log.error("call to ResultContainer.add_timing after ResultContainer.close")
                return
            self.timings.append(Timing(engine_name, total=engine_time, load=page_load_time))
 

References _closed, searx.metrics.models.Histogram._lock, _lock, searx.extended_types.SXNG_Request.timings, and timings.

add_unresponsive_engine()

searx.results.ResultContainer.add_unresponsive_engine	(		self,
		str	engine_name,
		str	error_type,
		bool	suspended = False )

Definition at line 267 of file results.py.

    def add_unresponsive_engine(self, engine_name: str, error_type: str, suspended: bool = False):
        with self._lock:
            if self._closed:
                log.error("call to ResultContainer.add_unresponsive_engine after ResultContainer.close")
                return
            if searx.engines.engines[engine_name].display_error_messages:
                self.unresponsive_engines.add(UnresponsiveEngine(engine_name, error_type, suspended))
 

References _closed, searx.metrics.models.Histogram._lock, _lock, and unresponsive_engines.

close()

searx.results.ResultContainer.close

(

self

)

Definition at line 182 of file results.py.

    def close(self):
        self._closed = True
 
        for result in self.main_results_map.values():
            result.score = calculate_score(result, result.priority)
            for eng_name in result.engines:
                counter_add(result.score, 'engine', eng_name, 'score')
 

References _closed, searx.results.calculate_score(), and main_results_map.

Referenced by get_ordered_results().

Here is the call graph for this function:

Here is the caller graph for this function:

extend()

searx.results.ResultContainer.extend	(		self,
		str | None	engine_name,
			results )

Definition at line 80 of file results.py.

    def extend(self, engine_name: str | None, results):  # pylint: disable=too-many-branches
        if self._closed:
            log.debug("container is closed, ignoring results: %s", results)
            return
        main_count = 0
 
        for result in list(results):
 
            if isinstance(result, Result):
                result.engine = result.engine or engine_name
                result.normalize_result_fields()
 
                if isinstance(result, BaseAnswer) and self.on_result(result):
                    self.answers.add(result)
                elif isinstance(result, MainResult) and self.on_result(result):
                    main_count += 1
                    self._merge_main_result(result, main_count)
                else:
                    # more types need to be implemented in the future ..
                    raise NotImplementedError(f"no handler implemented to process the result of type {result}")
 
            else:
                result["engine"] = result.get("engine") or engine_name or ""
                result = LegacyResult(result)  # for backward compatibility, will be romeved one day
                result.normalize_result_fields()
 
                if "suggestion" in result:
                    if self.on_result(result):
                        self.suggestions.add(result["suggestion"])
                    continue
 
                if "answer" in result:
                    if self.on_result(result):
                        warnings.warn(
                            f"answer results from engine {result.engine}"
                            " are without typification / migrate to Answer class.",
                            DeprecationWarning,
                        )
                        self.answers.add(result)  # type: ignore
                    continue
 
                if "correction" in result:
                    if self.on_result(result):
                        self.corrections.add(result["correction"])
                    continue
 
                if "infobox" in result:
                    if self.on_result(result):
                        self._merge_infobox(result)
                    continue
 
                if "number_of_results" in result:
                    if self.on_result(result):
                        self._number_of_results.append(result["number_of_results"])
                    continue
 
                if "engine_data" in result:
                    if self.on_result(result):
                        if result.engine:
                            self.engine_data[result.engine][result["key"]] = result["engine_data"]
                    continue
 
                if self.on_result(result):
                    main_count += 1
                    self._merge_main_result(result, main_count)
                    continue
 
        if engine_name in searx.engines.engines:
            eng = searx.engines.engines[engine_name]
            histogram_observe(main_count, "engine", eng.name, "result", "count")
            if not self.paging and eng.paging:
                self.paging = True
 

References _closed, _merge_infobox(), _merge_main_result(), _number_of_results, answers, corrections, engine_data, on_result, paging, and suggestions.

Here is the call graph for this function:

get_ordered_results()

list[MainResult | LegacyResult] searx.results.ResultContainer.get_ordered_results

(

self

)

Returns a sorted list of results to be displayed in the main result
area (:ref:`result types`).

Definition at line 190 of file results.py.

    def get_ordered_results(self) -> list[MainResult | LegacyResult]:
        """Returns a sorted list of results to be displayed in the main result
        area (:ref:`result types`)."""
 
        if not self._closed:
            self.close()
 
        if self._main_results_sorted:
            return self._main_results_sorted
 
        # first pass, sort results by "score" (descanding)
        results = sorted(self.main_results_map.values(), key=lambda x: x.score, reverse=True)
 
        # pass 2 : group results by category and template
        gresults = []
        categoryPositions = {}
        max_count = 8
        max_distance = 20
 
        for res in results:
            # do we need to handle more than one category per engine?
            engine = searx.engines.engines.get(res.engine or "")
            if engine:
                res.category = engine.categories[0] if len(engine.categories) > 0 else ""
 
            # do we need to handle more than one category per engine?
            category = f"{res.category}:{res.template}:{'img_src' if (res.thumbnail or res.img_src) else ''}"
            grp = categoryPositions.get(category)
 
            # group with previous results using the same category, if the group
            # can accept more result and is not too far from the current
            # position
 
            if (grp is not None) and (grp["count"] > 0) and (len(gresults) - grp["index"] < max_distance):
                # group with the previous results using the same category with
                # this one
                index = grp["index"]
                gresults.insert(index, res)
 
                # update every index after the current one (including the
                # current one)
                for item in categoryPositions.values():
                    v = item["index"]
                    if v >= index:
                        item["index"] = v + 1
 
                # update this category
                grp["count"] -= 1
 
            else:
                gresults.append(res)
                # update categoryIndex
                categoryPositions[category] = {"index": len(gresults), "count": max_count}
                continue
 
        self._main_results_sorted = gresults
        return self._main_results_sorted
 

References _closed, _main_results_sorted, close(), and main_results_map.

Referenced by number_of_results().

Here is the call graph for this function:

Here is the caller graph for this function:

get_timings()

searx.results.ResultContainer.get_timings

(

self

)

Definition at line 282 of file results.py.

    def get_timings(self):
        with self._lock:
            if not self._closed:
                log.error("call to ResultContainer.get_timings before ResultContainer.close")
                return []
            return self.timings
 
 

References _closed, searx.metrics.models.Histogram._lock, _lock, searx.extended_types.SXNG_Request.timings, and timings.

number_of_results()

int searx.results.ResultContainer.number_of_results

(

self

)

Returns the average of results number, returns zero if the average
result number is smaller than the actual result count.

Definition at line 249 of file results.py.

    def number_of_results(self) -> int:
        """Returns the average of results number, returns zero if the average
        result number is smaller than the actual result count."""
 
        if not self._closed:
            log.error("call to ResultContainer.number_of_results before ResultContainer.close")
            return 0
 
        with self._lock:
            resultnum_sum = sum(self._number_of_results)
            if not resultnum_sum or not self._number_of_results:
                return 0
 
            average = int(resultnum_sum / len(self._number_of_results))
            if average < len(self.get_ordered_results()):
                average = 0
            return average
 

References _closed, searx.metrics.models.Histogram._lock, _lock, _number_of_results, and get_ordered_results().

Here is the call graph for this function:

Member Data Documentation

_closed

bool searx.results.ResultContainer._closed = False

protected

Definition at line 71 of file results.py.

Referenced by add_timing(), add_unresponsive_engine(), close(), extend(), get_ordered_results(), get_timings(), and number_of_results().

_lock

searx.results.ResultContainer._lock = RLock()

protected

Definition at line 77 of file results.py.

Referenced by _merge_infobox(), _merge_main_result(), add_timing(), add_unresponsive_engine(), get_timings(), and number_of_results().

_main_results_sorted

list[MainResult | LegacyResult] searx.results.ResultContainer._main_results_sorted = None

protected

Definition at line 78 of file results.py.

Referenced by get_ordered_results().

_number_of_results

list searx.results.ResultContainer._number_of_results = []

protected

Definition at line 69 of file results.py.

Referenced by extend(), and number_of_results().

answers

searx.results.ResultContainer.answers = AnswerSet()

Definition at line 66 of file results.py.

Referenced by extend().

corrections

set searx.results.ResultContainer.corrections [str]

static

Definition at line 60 of file results.py.

Referenced by extend().

engine_data

dict[str, dict[str, str]] searx.results.ResultContainer.engine_data = defaultdict(dict)

Definition at line 70 of file results.py.

Referenced by searx.search.models.SearchQuery.__copy__(), and extend().

infoboxes

list searx.results.ResultContainer.infoboxes [LegacyResult]

static

Definition at line 57 of file results.py.

Referenced by __init__(), and _merge_infobox().

main_results_map

dict searx.results.ResultContainer.main_results_map [int, MainResult | LegacyResult]

static

Definition at line 56 of file results.py.

Referenced by __init__(), _merge_main_result(), close(), and get_ordered_results().

on_result

bool searx.results.ResultContainer.on_result = lambda _: True

Definition at line 76 of file results.py.

Referenced by extend().

paging

bool searx.results.ResultContainer.paging = False

Definition at line 72 of file results.py.

Referenced by extend().

redirect_url

str | None searx.results.ResultContainer.redirect_url = None

Definition at line 75 of file results.py.

suggestions

set searx.results.ResultContainer.suggestions [str]

static

Definition at line 58 of file results.py.

Referenced by __init__(), and extend().

timings

list searx.results.ResultContainer.timings = []

Definition at line 74 of file results.py.

Referenced by add_timing(), and get_timings().

unresponsive_engines

Set[UnresponsiveEngine] searx.results.ResultContainer.unresponsive_engines = set()

Definition at line 73 of file results.py.

Referenced by add_unresponsive_engine().

---

The documentation for this class was generated from the following file:

• /home/andrew/Documents/code/public/searxng/searx/results.py