searx.engines Namespace Reference

::1337x More...

Namespaces
namespace	1337x
namespace	9gag
namespace	ahmia
namespace	alpinelinux
namespace	annas_archive
namespace	apkmirror
namespace	apple_app_store
namespace	apple_maps
namespace	archlinux
namespace	artic
namespace	arxiv
namespace	ask
namespace	bandcamp
namespace	base
namespace	bilibili
namespace	bing
namespace	bing_images
namespace	bing_news
namespace	bing_videos
namespace	bpb
namespace	brave
namespace	bt4g
namespace	btdigg
namespace	ccc_media
namespace	chefkoch
namespace	cloudflareai
namespace	command
namespace	core
namespace	cppreference
namespace	crates
namespace	crossref
namespace	currency_convert
namespace	dailymotion
namespace	deepl
namespace	deezer
namespace	demo_offline
namespace	demo_online
namespace	destatis
namespace	deviantart
namespace	dictzone
namespace	digbt
namespace	discourse
namespace	docker_hub
namespace	doku
namespace	duckduckgo
namespace	duckduckgo_definitions
namespace	duckduckgo_extra
namespace	duckduckgo_weather
namespace	duden
namespace	dummy
	-offline
namespace	dummy-offline
namespace	ebay
namespace	elasticsearch
namespace	emojipedia
namespace	fdroid
namespace	findthatmeme
namespace	flickr
namespace	flickr_noapi
namespace	freesound
namespace	frinkiac
namespace	fyyd
namespace	geizhals
namespace	genius
namespace	gitea
namespace	github
namespace	gitlab
namespace	goodreads
namespace	google
namespace	google_images
namespace	google_news
namespace	google_play
namespace	google_scholar
namespace	google_videos
namespace	hackernews
namespace	hex
namespace	imdb
namespace	imgur
namespace	ina
namespace	internet_archive_scholar
namespace	invidious
namespace	jisho
namespace	json_engine
namespace	kickass
namespace	lemmy
namespace	lib_rs
namespace	libretranslate
namespace	lingva
namespace	livespace
namespace	loc
namespace	mariadb_server
namespace	mastodon
namespace	material_icons
namespace	mediathekviewweb
namespace	mediawiki
namespace	meilisearch
namespace	metacpan
namespace	mixcloud
namespace	mojeek
namespace	mongodb
namespace	moviepilot
namespace	mozhi
namespace	mrs
namespace	mullvad_leta
namespace	mwmbl
namespace	mysql_server
namespace	npm
namespace	nyaa
namespace	odysee
namespace	open_meteo
namespace	openlibrary
namespace	opensemantic
namespace	openstreetmap
namespace	openverse
namespace	pdbe
namespace	peertube
namespace	photon
namespace	pinterest
namespace	piped
namespace	piratebay
namespace	pixiv
namespace	pkg_go_dev
namespace	podcastindex
namespace	postgresql
namespace	presearch
namespace	pubmed
namespace	pypi
namespace	qwant
namespace	radio_browser
namespace	recoll
namespace	reddit
namespace	redis_server
namespace	rottentomatoes
namespace	rumble
namespace	scanr_structures
namespace	searchcode_code
namespace	searx_engine
namespace	seekr
namespace	semantic_scholar
namespace	sepiasearch
namespace	seznam
namespace	sjp
namespace	solidtorrents
namespace	solr
namespace	soundcloud
namespace	spotify
namespace	springer
namespace	sqlite
namespace	stackexchange
namespace	startpage
namespace	stract
namespace	svgrepo
namespace	tagesschau
namespace	tineye
namespace	tokyotoshokan
namespace	tootfinder
namespace	torznab
namespace	translated
namespace	unsplash
namespace	vimeo
namespace	voidlinux
namespace	wallhaven
namespace	wikicommons
namespace	wikidata
namespace	wikipedia
namespace	wolframalpha_api
namespace	wolframalpha_noapi
namespace	wordnik
namespace	wttr
namespace	www1x
namespace	xpath
namespace	yacy
namespace	yahoo
namespace	yahoo_news
namespace	yandex
namespace	yandex_music
namespace	yep
namespace	youtube_api
namespace	youtube_noapi
namespace	yummly
namespace	zlibrary

Functions
	check_engine_module (types.ModuleType module)
Engine|types.ModuleType|None	load_engine (dict engine_data)
	set_loggers (engine, engine_name)
	update_engine_attributes (Engine|types.ModuleType engine, engine_data)
	update_attributes_for_tor (Engine|types.ModuleType engine)
	is_missing_required_attributes (engine)
	using_tor_proxy (Engine|types.ModuleType engine)
	is_engine_active (Engine|types.ModuleType engine)
	register_engine (Engine|types.ModuleType engine)
	load_engines (engine_list)

Variables
	logger = logger.getChild('engines')
	ENGINE_DIR = dirname(realpath(__file__))
dict	ENGINE_DEFAULT_ARGS
str	DEFAULT_CATEGORY = 'other'
dict	categories = {'general': []}
dict	engines = {}
dict	engine_shortcuts = {}

Detailed Description

::1337x

::9gag

1337x

9GAG (social media)

Load and initialize the ``engines``, see :py:func:`load_engines` and register
:py:obj:`engine_shortcuts`.

usage::

    load_engines( settings['engines'] )

Function Documentation

check_engine_module()

searx.engines.check_engine_module

(

types.ModuleType

module

)

Definition at line 68 of file __init__.py.

def check_engine_module(module: types.ModuleType):
    # probe unintentional name collisions / for example name collisions caused
    # by import statements in the engine module ..
 
    # network: https://github.com/searxng/searxng/issues/762#issuecomment-1605323861
    obj = getattr(module, 'network', None)
    if obj and inspect.ismodule(obj):
        msg = f'type of {module.__name__}.network is a module ({obj.__name__}), expected a string'
        # logger.error(msg)
        raise TypeError(msg)
 
 

Referenced by searx.engines.load_engine().

Here is the caller graph for this function:

is_engine_active()

searx.engines.is_engine_active

(

Engine | types.ModuleType

engine

)

Definition at line 216 of file __init__.py.

def is_engine_active(engine: Engine | types.ModuleType):
    # check if engine is inactive
    if engine.inactive is True:
        return False
 
    # exclude onion engines if not using tor
    if 'onions' in engine.categories and not using_tor_proxy(engine):
        return False
 
    return True
 
 

References searx.engines.using_tor_proxy().

Referenced by searx.engines.load_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

is_missing_required_attributes()

searx.engines.is_missing_required_attributes

(

engine

)

An attribute is required when its name doesn't start with ``_`` (underline).
Required attributes must not be ``None``.

Definition at line 198 of file __init__.py.

def is_missing_required_attributes(engine):
    """An attribute is required when its name doesn't start with ``_`` (underline).
    Required attributes must not be ``None``.
 
    """
    missing = False
    for engine_attr in dir(engine):
        if not engine_attr.startswith('_') and getattr(engine, engine_attr) is None:
            logger.error('Missing engine config attribute: "{0}.{1}"'.format(engine.name, engine_attr))
            missing = True
    return missing
 
 

References searx.format.

Referenced by searx.engines.load_engine().

Here is the caller graph for this function:

load_engine()

Engine | types.ModuleType | None searx.engines.load_engine

(

dict

engine_data

)

Load engine from ``engine_data``.

:param dict engine_data:  Attributes from YAML ``settings:engines/<engine>``
:return: initialized namespace of the ``<engine>``.

1. create a namespace and load module of the ``<engine>``
2. update namespace with the defaults from :py:obj:`ENGINE_DEFAULT_ARGS`
3. update namespace with values from ``engine_data``

If engine *is active*, return namespace of the engine, otherwise return
``None``.

This function also returns ``None`` if initialization of the namespace fails
for one of the following reasons:

- engine name contains underscore
- engine name is not lowercase
- required attribute is not set :py:func:`is_missing_required_attributes`

Definition at line 80 of file __init__.py.

def load_engine(engine_data: dict) -> Engine | types.ModuleType | None:
    """Load engine from ``engine_data``.
 
    :param dict engine_data:  Attributes from YAML ``settings:engines/<engine>``
    :return: initialized namespace of the ``<engine>``.
 
    1. create a namespace and load module of the ``<engine>``
    2. update namespace with the defaults from :py:obj:`ENGINE_DEFAULT_ARGS`
    3. update namespace with values from ``engine_data``
 
    If engine *is active*, return namespace of the engine, otherwise return
    ``None``.
 
    This function also returns ``None`` if initialization of the namespace fails
    for one of the following reasons:
 
    - engine name contains underscore
    - engine name is not lowercase
    - required attribute is not set :py:func:`is_missing_required_attributes`
 
    """
    # pylint: disable=too-many-return-statements
 
    engine_name = engine_data.get('name')
    if engine_name is None:
        logger.error('An engine does not have a "name" field')
        return None
    if '_' in engine_name:
        logger.error('Engine name contains underscore: "{}"'.format(engine_name))
        return None
 
    if engine_name.lower() != engine_name:
        logger.warning('Engine name is not lowercase: "{}", converting to lowercase'.format(engine_name))
        engine_name = engine_name.lower()
        engine_data['name'] = engine_name
 
    # load_module
    module_name = engine_data.get('engine')
    if module_name is None:
        logger.error('The "engine" field is missing for the engine named "{}"'.format(engine_name))
        return None
    try:
        engine = load_module(module_name + '.py', ENGINE_DIR)
    except (SyntaxError, KeyboardInterrupt, SystemExit, SystemError, ImportError, RuntimeError):
        logger.exception('Fatal exception in engine "{}"'.format(module_name))
        sys.exit(1)
    except BaseException:
        logger.exception('Cannot load engine "{}"'.format(module_name))
        return None
 
    check_engine_module(engine)
    update_engine_attributes(engine, engine_data)
    update_attributes_for_tor(engine)
 
    # avoid cyclic imports
    # pylint: disable=import-outside-toplevel
    from searx.enginelib.traits import EngineTraitsMap
 
    trait_map = EngineTraitsMap.from_data()
    trait_map.set_traits(engine)
 
    if not is_engine_active(engine):
        return None
 
    if is_missing_required_attributes(engine):
        return None
 
    set_loggers(engine, engine_name)
 
    if not any(cat in settings['categories_as_tabs'] for cat in engine.categories):
        engine.categories.append(DEFAULT_CATEGORY)
 
    return engine
 
 

References searx.engines.check_engine_module(), searx.format, searx.engines.is_engine_active(), searx.engines.is_missing_required_attributes(), searx.engines.set_loggers(), searx.engines.update_attributes_for_tor(), and searx.engines.update_engine_attributes().

Referenced by searx.engines.load_engines().

Here is the call graph for this function:

Here is the caller graph for this function:

load_engines()

searx.engines.load_engines

(

engine_list

)

usage: ``engine_list = settings['engines']``

Definition at line 243 of file __init__.py.

def load_engines(engine_list):
    """usage: ``engine_list = settings['engines']``"""
    engines.clear()
    engine_shortcuts.clear()
    categories.clear()
    categories['general'] = []
    for engine_data in engine_list:
        engine = load_engine(engine_data)
        if engine:
            register_engine(engine)
    return engines

References searx.engines.load_engine(), and searx.engines.register_engine().

Here is the call graph for this function:

register_engine()

searx.engines.register_engine

(

Engine | types.ModuleType

engine

)

Definition at line 228 of file __init__.py.

def register_engine(engine: Engine | types.ModuleType):
    if engine.name in engines:
        logger.error('Engine config error: ambiguous name: {0}'.format(engine.name))
        sys.exit(1)
    engines[engine.name] = engine
 
    if engine.shortcut in engine_shortcuts:
        logger.error('Engine config error: ambiguous shortcut: {0}'.format(engine.shortcut))
        sys.exit(1)
    engine_shortcuts[engine.shortcut] = engine.name
 
    for category_name in engine.categories:
        categories.setdefault(category_name, []).append(engine)
 
 

References searx.format.

Referenced by searx.engines.load_engines().

Here is the caller graph for this function:

set_loggers()

searx.engines.set_loggers	(		engine,
			engine_name )

Definition at line 155 of file __init__.py.

def set_loggers(engine, engine_name):
    # set the logger for engine
    engine.logger = logger.getChild(engine_name)
    # the engine may have load some other engines
    # may sure the logger is initialized
    # use sys.modules.copy() to avoid "RuntimeError: dictionary changed size during iteration"
    # see https://github.com/python/cpython/issues/89516
    # and https://docs.python.org/3.10/library/sys.html#sys.modules
    modules = sys.modules.copy()
    for module_name, module in modules.items():
        if (
            module_name.startswith("searx.engines")
            and module_name != "searx.engines.__init__"
            and not hasattr(module, "logger")
        ):
            module_engine_name = module_name.split(".")[-1]
            module.logger = logger.getChild(module_engine_name)  # type: ignore
 
 

Referenced by searx.engines.load_engine().

Here is the caller graph for this function:

update_attributes_for_tor()

searx.engines.update_attributes_for_tor

(

Engine | types.ModuleType

engine

)

Definition at line 192 of file __init__.py.

def update_attributes_for_tor(engine: Engine | types.ModuleType):
    if using_tor_proxy(engine) and hasattr(engine, 'onion_url'):
        engine.search_url = engine.onion_url + getattr(engine, 'search_path', '')  # type: ignore
        engine.timeout += settings['outgoing'].get('extra_proxy_timeout', 0)  # type: ignore
 
 

References searx.engines.using_tor_proxy().

Referenced by searx.engines.load_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

update_engine_attributes()

searx.engines.update_engine_attributes	(	Engine | types.ModuleType	engine,
			engine_data )

Definition at line 174 of file __init__.py.

def update_engine_attributes(engine: Engine | types.ModuleType, engine_data):
    # set engine attributes from engine_data
    for param_name, param_value in engine_data.items():
        if param_name == 'categories':
            if isinstance(param_value, str):
                param_value = list(map(str.strip, param_value.split(',')))
            engine.categories = param_value  # type: ignore
        elif hasattr(engine, 'about') and param_name == 'about':
            engine.about = {**engine.about, **engine_data['about']}  # type: ignore
        else:
            setattr(engine, param_name, param_value)
 
    # set default attributes
    for arg_name, arg_value in ENGINE_DEFAULT_ARGS.items():
        if not hasattr(engine, arg_name):
            setattr(engine, arg_name, copy.deepcopy(arg_value))
 
 

Referenced by searx.engines.load_engine().

Here is the caller graph for this function:

using_tor_proxy()

searx.engines.using_tor_proxy

(

Engine | types.ModuleType

engine

)

Return True if the engine configuration declares to use Tor.

Definition at line 211 of file __init__.py.

def using_tor_proxy(engine: Engine | types.ModuleType):
    """Return True if the engine configuration declares to use Tor."""
    return settings['outgoing'].get('using_tor_proxy') or getattr(engine, 'using_tor_proxy', False)
 
 

Referenced by searx.engines.is_engine_active(), and searx.engines.update_attributes_for_tor().

Here is the caller graph for this function:

Variable Documentation

categories

dict searx.engines.categories = {'general': []}

Definition at line 55 of file __init__.py.

DEFAULT_CATEGORY

str searx.engines.DEFAULT_CATEGORY = 'other'

Definition at line 50 of file __init__.py.

ENGINE_DEFAULT_ARGS

dict searx.engines.ENGINE_DEFAULT_ARGS

Initial value:

=  {
    # Common options in the engine module
    "engine_type": "online",
    "paging": False,
    "time_range_support": False,
    "safesearch": False,
    # settings.yml
    "categories": ["general"],
    "enable_http": False,
    "shortcut": "-",
    "timeout": settings["outgoing"]["request_timeout"],
    "display_error_messages": True,
    "disabled": False,
    "inactive": False,
    "about": {},
    "using_tor_proxy": False,
    "send_accept_language_header": False,
    "tokens": [],
    "max_page": 0,
}

Definition at line 29 of file __init__.py.

ENGINE_DIR

searx.engines.ENGINE_DIR = dirname(realpath(__file__))

Definition at line 28 of file __init__.py.

engine_shortcuts

dict searx.engines.engine_shortcuts = {}

Definition at line 57 of file __init__.py.

engines

dict searx.engines.engines = {}

Definition at line 56 of file __init__.py.

logger

searx.engines.logger = logger.getChild('engines')

Definition at line 27 of file __init__.py.