::1337x More...

Namespaces
namespace	1337x
namespace	360search
namespace	360search_videos
namespace	9gag
namespace	acfun
namespace	adobe_stock
namespace	ahmia
namespace	alpinelinux
namespace	annas_archive
namespace	ansa
namespace	apkmirror
namespace	apple_app_store
namespace	apple_maps
namespace	archlinux
namespace	artic
namespace	arxiv
namespace	ask
namespace	astrophysics_data_system
namespace	baidu
namespace	bandcamp
namespace	base
namespace	bilibili
namespace	bing
namespace	bing_images
namespace	bing_news
namespace	bing_videos
namespace	bitchute
namespace	bpb
namespace	brave
namespace	bt4g
namespace	btdigg
namespace	ccc_media
namespace	chefkoch
namespace	chinaso
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	github_code
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	huggingface
namespace	il_post
namespace	imdb
namespace	imgur
namespace	ina
namespace	invidious
namespace	ipernity
namespace	iqiyi
namespace	jisho
namespace	json_engine
namespace	kickass
namespace	lemmy
namespace	lib_rs
namespace	libretranslate
namespace	lingva
namespace	livespace
namespace	loc
namespace	marginalia
namespace	mariadb_server
namespace	mastodon
namespace	material_icons
namespace	mediathekviewweb
namespace	mediawiki
namespace	meilisearch
namespace	metacpan
namespace	microsoft_learn
namespace	mixcloud
namespace	mojeek
namespace	mongodb
namespace	moviepilot
namespace	mozhi
namespace	mrs
namespace	mullvad_leta
namespace	mwmbl
namespace	mysql_server
namespace	naver
namespace	niconico
namespace	npm
namespace	nyaa
namespace	odysee
namespace	ollama
namespace	open_meteo
namespace	openalex
namespace	openclipart
namespace	openlibrary
namespace	opensemantic
namespace	openstreetmap
namespace	openverse
namespace	pdbe
namespace	peertube
namespace	photon
namespace	pinterest
namespace	piped
namespace	piratebay
namespace	pixabay
namespace	pixiv
namespace	pkg_go_dev
namespace	podcastindex
namespace	postgresql
namespace	presearch
namespace	public_domain_image_archive
namespace	pubmed
namespace	pypi
namespace	quark
namespace	qwant
namespace	radio_browser
namespace	recoll
namespace	reddit
namespace	repology
namespace	reuters
namespace	rottentomatoes
namespace	rumble
namespace	scanr_structures
namespace	searchcode_code
namespace	searx_engine
namespace	seekr
namespace	selfhst
namespace	semantic_scholar
namespace	senscritique
namespace	sepiasearch
namespace	seznam
namespace	sogou
namespace	sogou_images
namespace	sogou_videos
namespace	sogou_wechat
namespace	solidtorrents
namespace	solr
namespace	soundcloud
namespace	spotify
namespace	springer
namespace	sqlite
namespace	stackexchange
namespace	startpage
namespace	steam
namespace	stract
namespace	svgrepo
namespace	tagesschau
namespace	tineye
namespace	tokyotoshokan
namespace	tootfinder
namespace	torznab
namespace	translated
namespace	tubearchivist
namespace	unsplash
namespace	uxwing
namespace	valkey_server
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	zlibrary

Functions
	check_engine_module (types.ModuleType module)
"Engine \| types.ModuleType \| None"	load_engine (dict[str, t.Any] engine_data)
	set_loggers ("Engine\|types.ModuleType" engine, str engine_name)
	update_engine_attributes ("Engine \| types.ModuleType" engine, dict[str, t.Any] engine_data)
	update_attributes_for_tor ("Engine \| types.ModuleType" engine)
	is_missing_required_attributes ("Engine \| types.ModuleType" engine)
	using_tor_proxy ("Engine \| types.ModuleType" engine)
	is_engine_active ("Engine \| types.ModuleType" engine)
bool	call_engine_setup ("Engine \| types.ModuleType" engine, dict[str, t.Any] engine_data)
	register_engine ("Engine \| types.ModuleType" engine)
	load_engines (list[dict[str, t.Any]] 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

::360search_videos

::360search

1337x

360Search search engine for searxng

360Search-Videos: A search engine for retrieving videos from 360Search.

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

◆ call_engine_setup()

bool searx.engines.call_engine_setup	(	"Engine \| types.ModuleType"	engine,
		dict[str, t.Any]	engine_data )

Definition at line 232 of file __init__.py.

def call_engine_setup(engine: "Engine | types.ModuleType", engine_data: dict[str, t.Any]) -> bool:
    setup_ok = False
    setup_func = getattr(engine, "setup", None)
 
    if setup_func is None:
        setup_ok = True
    elif not callable(setup_func):
        logger.error("engine's setup method isn't a callable (is of type: %s)", type(setup_func))
    else:
        try:
            setup_ok = engine.setup(engine_data)
        except Exception as e:  # pylint: disable=broad-except
            logger.exception('exception : {0}'.format(e))
 
    if not setup_ok:
        logger.error("%s: Engine setup was not successful, engine is set to inactive.", engine.name)
    return setup_ok
 
 

Referenced by load_engine().

Here is the caller graph for this function:

◆ check_engine_module()

searx.engines.check_engine_module ( types.ModuleType module )

Definition at line 69 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 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 220 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 using_tor_proxy().

Referenced by 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 | types.ModuleType" engine )

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

Definition at line 202 of file __init__.py.

def is_missing_required_attributes(engine: "Engine | types.ModuleType"):
    """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
 
 

Referenced by load_engine().

Here is the caller graph for this function:

◆ load_engine()

"Engine | types.ModuleType | None" searx.engines.load_engine ( dict[str, t.Any] 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 81 of file __init__.py.

def load_engine(engine_data: dict[str, t.Any]) -> "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 call_engine_setup(engine, engine_data):
        return None
 
    if not any(cat in settings['categories_as_tabs'] for cat in engine.categories):
        engine.categories.append(DEFAULT_CATEGORY)
 
    return engine
 
 

References call_engine_setup(), check_engine_module(), is_engine_active(), is_missing_required_attributes(), set_loggers(), update_attributes_for_tor(), and update_engine_attributes().

Referenced by load_engines().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_engines()

searx.engines.load_engines ( list[dict[str, t.Any]] engine_list )

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

Definition at line 266 of file __init__.py.

def load_engines(engine_list: list[dict[str, t.Any]]):
    """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 load_engine(), and register_engine().

Here is the call graph for this function:

◆ register_engine()

searx.engines.register_engine ( "Engine | types.ModuleType" engine )

Definition at line 251 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)
 
 

Referenced by load_engines().

Here is the caller graph for this function:

◆ set_loggers()

searx.engines.set_loggers	(	"Engine\|types.ModuleType"	engine,
		str	engine_name )

Definition at line 159 of file __init__.py.

def set_loggers(engine: "Engine|types.ModuleType", engine_name: str):
    # 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 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 196 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 using_tor_proxy().

Referenced by 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,
		dict[str, t.Any]	engine_data )

Definition at line 178 of file __init__.py.

def update_engine_attributes(engine: "Engine | types.ModuleType", engine_data: dict[str, t.Any]):
    # 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 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 215 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 is_engine_active(), and update_attributes_for_tor().

Here is the caller graph for this function:

Variable Documentation

◆ categories

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

Definition at line 53 of file __init__.py.

◆ DEFAULT_CATEGORY

str searx.engines.DEFAULT_CATEGORY = 'other'

Definition at line 51 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 30 of file __init__.py.

◆ ENGINE_DIR

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

Definition at line 27 of file __init__.py.

◆ engine_shortcuts

dict searx.engines.engine_shortcuts = {}

Definition at line 58 of file __init__.py.

◆ engines

dict searx.engines.engines = {}

Definition at line 55 of file __init__.py.

◆ logger

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

Definition at line 26 of file __init__.py.

Functions
	check_engine_module (types.ModuleType module)
"Engine \| types.ModuleType \| None"	load_engine (dict[str, t.Any] engine_data)
	set_loggers ("Engine\|types.ModuleType" engine, str engine_name)
	update_engine_attributes ("Engine \| types.ModuleType" engine, dict[str, t.Any] engine_data)
	update_attributes_for_tor ("Engine \| types.ModuleType" engine)
	is_missing_required_attributes ("Engine \| types.ModuleType" engine)
	using_tor_proxy ("Engine \| types.ModuleType" engine)
	is_engine_active ("Engine \| types.ModuleType" engine)
bool	call_engine_setup ("Engine \| types.ModuleType" engine, dict[str, t.Any] engine_data)
	register_engine ("Engine \| types.ModuleType" engine)
	load_engines (list[dict[str, t.Any]] engine_list)

Namespaces

Functions

Variables

Detailed Description

Function Documentation

◆ call_engine_setup()

◆ check_engine_module()

◆ is_engine_active()

◆ is_missing_required_attributes()

◆ load_engine()

◆ load_engines()

◆ register_engine()

◆ set_loggers()

◆ update_attributes_for_tor()

◆ update_engine_attributes()

◆ using_tor_proxy()

Variable Documentation

◆ categories

◆ DEFAULT_CATEGORY

◆ ENGINE_DEFAULT_ARGS

◆ ENGINE_DIR

◆ engine_shortcuts

◆ engines

◆ logger