Inheritance diagram for searx.search.processors.ProcessorMap:

Collaboration diagram for searx.search.processors.ProcessorMap:

Public Member Functions
	init (self, list[dict[str, t.Any]] engine_list)
bool	register_processor (self, EngineProcessor eng_proc, bool eng_proc_ok)
Public Member Functions inherited from searx.search.processors.abstract.EngineProcessor
	__init__ (self, "Engine\|types.ModuleType" engine)
	initialize (self, t.Callable[["EngineProcessor", bool], bool] callback)
bool	init_engine (self)
	handle_exception (self, "ResultContainer" result_container, BaseException\|str exception_or_message, bool suspend=False)
	extend_container (self, "ResultContainer" result_container, float start_time, "list[Result \| LegacyResult]\|None" search_results)
bool	extend_container_if_suspended (self, "ResultContainer" result_container)
RequestParams\|None	get_params (self, "SearchQuery" search_query, str engine_category)
	search (self, str query, RequestParams params, "ResultContainer" result_container, float start_time, float timeout_limit)
	get_tests (self)
	get_default_tests (self)

Public Attributes
	register_processor
Public Attributes inherited from searx.search.processors.abstract.EngineProcessor
	engine = engine
logging.Logger	logger = engines[engine.name].logger
SuspendedStatus	suspended_status = SUSPENDED_STATUS.setdefault(key, SuspendedStatus())

Static Public Attributes
dict	processor_types

Additional Inherited Members
Protected Member Functions inherited from searx.search.processors.abstract.EngineProcessor
	_extend_container_basic (self, "ResultContainer" result_container, float start_time, "list[Result \| LegacyResult]" search_results)

Detailed Description

Class to manage :py:obj:`EngineProcessor` instances in a key/value map
(instances stored by *engine-name*).

Definition at line 35 of file __init__.py.

Member Function Documentation

◆ init()

searx.search.processors.ProcessorMap.init	(		self,
		list[dict[str, t.Any]]	engine_list )

Initialize all engines and registers a processor for each engine.

Definition at line 47 of file __init__.py.

    def init(self, engine_list: list[dict[str, t.Any]]):
        """Initialize all engines and registers a processor for each engine."""
 
        for eng_settings in engine_list:
            eng_name: str = eng_settings["name"]
 
            if eng_settings.get("inactive", False) is True:
                logger.info("Engine of name '%s' is inactive.", eng_name)
                continue
 
            eng_obj = engines.engines.get(eng_name)
            if eng_obj is None:
                logger.warning("Engine of name '%s' does not exists.", eng_name)
                continue
 
            eng_type = getattr(eng_obj, "engine_type", "online")
            proc_cls = self.processor_types.get(eng_type)
            if proc_cls is None:
                logger.error("Engine '%s' is of unknown engine_type: %s", eng_type)
                continue
 
            # initialize (and register) the engine
            eng_proc = proc_cls(eng_obj)
            eng_proc.initialize(self.register_processor)
 

References processor_types.

Referenced by searx.sqlitedb.SQLiteAppl.connect(), and searx.sqlitedb.SQLiteAppl.DB().

Here is the caller graph for this function:

◆ register_processor()

bool searx.search.processors.ProcessorMap.register_processor	(		self,
		EngineProcessor	eng_proc,
		bool	eng_proc_ok )

Register the :py:obj:`EngineProcessor`.

This method is usually passed as a callback to the initialization of the
:py:obj:`EngineProcessor`.

The value (true/false) passed in ``eng_proc_ok`` indicates whether the
initialization of the :py:obj:`EngineProcessor` was successful; if this
is not the case, the processor is not registered.

Definition at line 72 of file __init__.py.

    def register_processor(self, eng_proc: EngineProcessor, eng_proc_ok: bool) -> bool:
        """Register the :py:obj:`EngineProcessor`.
 
        This method is usually passed as a callback to the initialization of the
        :py:obj:`EngineProcessor`.
 
        The value (true/false) passed in ``eng_proc_ok`` indicates whether the
        initialization of the :py:obj:`EngineProcessor` was successful; if this
        is not the case, the processor is not registered.
        """
 
        if eng_proc_ok:
            self[eng_proc.engine.name] = eng_proc
            # logger.debug("registered engine processor: %s", eng_proc.engine.name)
        else:
            logger.error("init method of engine %s failed (%s).", eng_proc.engine.name)
 
        return eng_proc_ok
 
 

Member Data Documentation

◆ processor_types

dict searx.search.processors.ProcessorMap.processor_types

static

Initial value:

=  {
        OnlineProcessor.engine_type: OnlineProcessor,
        OfflineProcessor.engine_type: OfflineProcessor,
        OnlineDictionaryProcessor.engine_type: OnlineDictionaryProcessor,
        OnlineCurrencyProcessor.engine_type: OnlineCurrencyProcessor,
        OnlineUrlSearchProcessor.engine_type: OnlineUrlSearchProcessor,
    }

Definition at line 39 of file __init__.py.

Referenced by init().

◆ register_processor

searx.search.processors.ProcessorMap.register_processor

Definition at line 70 of file __init__.py.

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

/home/andrew/Documents/code/public/searxng/searx/search/processors/__init__.py

Public Member Functions

Public Attributes

Static Public Attributes