mirror of https://github.com/searxng/searxng.git
316 lines
11 KiB
Python
316 lines
11 KiB
Python
# SPDX-License-Identifier: AGPL-3.0-or-later
|
|
# pylint: disable=missing-module-docstring
|
|
|
|
from collections import defaultdict
|
|
from typing import Dict, List, Optional, Tuple
|
|
from searx.exceptions import SearxParameterException
|
|
from searx.webutils import VALID_LANGUAGE_CODE
|
|
from searx.query import RawTextQuery
|
|
from searx.engines import categories, engines
|
|
from searx.search import SearchQuery, EngineRef
|
|
from searx.preferences import Preferences, is_locked
|
|
from searx.utils import detect_language
|
|
|
|
|
|
# remove duplicate queries.
|
|
# HINT: does not fix "!music !soundcloud", because the categories are 'none' and 'music'
|
|
def deduplicate_engineref_list(engineref_list: List[EngineRef]) -> List[EngineRef]:
|
|
engineref_dict = {q.category + '|' + q.name: q for q in engineref_list}
|
|
return list(engineref_dict.values())
|
|
|
|
|
|
def validate_engineref_list(
|
|
engineref_list: List[EngineRef], preferences: Preferences
|
|
) -> Tuple[List[EngineRef], List[EngineRef], List[EngineRef]]:
|
|
"""Validate query_engines according to the preferences
|
|
|
|
Returns:
|
|
List[EngineRef]: list of existing engines with a validated token
|
|
List[EngineRef]: list of unknown engine
|
|
List[EngineRef]: list of engine with invalid token according to the preferences
|
|
"""
|
|
valid = []
|
|
unknown = []
|
|
no_token = []
|
|
for engineref in engineref_list:
|
|
if engineref.name not in engines:
|
|
unknown.append(engineref)
|
|
continue
|
|
|
|
engine = engines[engineref.name]
|
|
if not preferences.validate_token(engine):
|
|
no_token.append(engineref)
|
|
continue
|
|
|
|
valid.append(engineref)
|
|
return valid, unknown, no_token
|
|
|
|
|
|
def parse_pageno(form: Dict[str, str]) -> int:
|
|
pageno_param = form.get('pageno', '1')
|
|
if not pageno_param.isdigit() or int(pageno_param) < 1:
|
|
raise SearxParameterException('pageno', pageno_param)
|
|
return int(pageno_param)
|
|
|
|
|
|
def parse_lang(preferences: Preferences, form: Dict[str, str], raw_text_query: RawTextQuery) -> str:
|
|
if is_locked('language'):
|
|
return preferences.get_value('language')
|
|
# get language
|
|
# set specific language if set on request, query or preferences
|
|
# search with multiple languages is not supported (by most engines)
|
|
if len(raw_text_query.languages):
|
|
query_lang = raw_text_query.languages[-1]
|
|
elif 'language' in form:
|
|
query_lang = form.get('language')
|
|
else:
|
|
query_lang = preferences.get_value('language')
|
|
|
|
# check language
|
|
if not VALID_LANGUAGE_CODE.match(query_lang) and query_lang != 'auto':
|
|
raise SearxParameterException('language', query_lang)
|
|
|
|
return query_lang
|
|
|
|
|
|
def parse_safesearch(preferences: Preferences, form: Dict[str, str]) -> int:
|
|
if is_locked('safesearch'):
|
|
return preferences.get_value('safesearch')
|
|
|
|
if 'safesearch' in form:
|
|
query_safesearch = form.get('safesearch')
|
|
# first check safesearch
|
|
if not query_safesearch.isdigit():
|
|
raise SearxParameterException('safesearch', query_safesearch)
|
|
query_safesearch = int(query_safesearch)
|
|
else:
|
|
query_safesearch = preferences.get_value('safesearch')
|
|
|
|
# safesearch : second check
|
|
if query_safesearch < 0 or query_safesearch > 2:
|
|
raise SearxParameterException('safesearch', query_safesearch)
|
|
|
|
return query_safesearch
|
|
|
|
|
|
def parse_time_range(form: Dict[str, str]) -> Optional[str]:
|
|
query_time_range = form.get('time_range')
|
|
# check time_range
|
|
query_time_range = None if query_time_range in ('', 'None') else query_time_range
|
|
if query_time_range not in (None, 'day', 'week', 'month', 'year'):
|
|
raise SearxParameterException('time_range', query_time_range)
|
|
return query_time_range
|
|
|
|
|
|
def parse_license_filter(form: Dict[str, str]) -> Optional[str]:
|
|
license_filter = form.get('license_filter')
|
|
|
|
if license_filter in ('public', 'freetouse', 'commercial'):
|
|
return license_filter
|
|
|
|
return None
|
|
|
|
|
|
def parse_timeout(form: Dict[str, str], raw_text_query: RawTextQuery) -> Optional[float]:
|
|
timeout_limit = raw_text_query.timeout_limit
|
|
if timeout_limit is None:
|
|
timeout_limit = form.get('timeout_limit')
|
|
|
|
if timeout_limit is None or timeout_limit in ['None', '']:
|
|
return None
|
|
try:
|
|
return float(timeout_limit)
|
|
except ValueError as e:
|
|
raise SearxParameterException('timeout_limit', timeout_limit) from e
|
|
|
|
|
|
def parse_category_form(query_categories: List[str], name: str, value: str) -> None:
|
|
if name == 'categories':
|
|
query_categories.extend(categ for categ in map(str.strip, value.split(',')) if categ in categories)
|
|
elif name.startswith('category_'):
|
|
category = name[9:]
|
|
|
|
# if category is not found in list, skip
|
|
if category not in categories:
|
|
return
|
|
|
|
if value != 'off':
|
|
# add category to list
|
|
query_categories.append(category)
|
|
elif category in query_categories:
|
|
# remove category from list if property is set to 'off'
|
|
query_categories.remove(category)
|
|
|
|
|
|
def get_selected_categories(preferences: Preferences, form: Optional[Dict[str, str]]) -> List[str]:
|
|
selected_categories = []
|
|
|
|
if not is_locked('categories') and form is not None:
|
|
for name, value in form.items():
|
|
parse_category_form(selected_categories, name, value)
|
|
|
|
# if no category is specified for this search,
|
|
# using user-defined default-configuration which
|
|
# (is stored in cookie)
|
|
if not selected_categories:
|
|
cookie_categories = preferences.get_value('categories')
|
|
for ccateg in cookie_categories:
|
|
selected_categories.append(ccateg)
|
|
|
|
# if still no category is specified, using general
|
|
# as default-category
|
|
if not selected_categories:
|
|
selected_categories = ['general']
|
|
|
|
return selected_categories
|
|
|
|
|
|
def get_engineref_from_category_list( # pylint: disable=invalid-name
|
|
category_list: List[str],
|
|
disabled_engines: List[str],
|
|
) -> List[EngineRef]:
|
|
result = []
|
|
for categ in category_list:
|
|
result.extend(
|
|
EngineRef(engine.name, categ)
|
|
for engine in categories[categ]
|
|
if (engine.name, categ) not in disabled_engines
|
|
)
|
|
return result
|
|
|
|
|
|
def parse_generic(preferences: Preferences, form: Dict[str, str], disabled_engines: List[str]) -> List[EngineRef]:
|
|
query_engineref_list = []
|
|
query_categories = []
|
|
|
|
# set categories/engines
|
|
explicit_engine_list = False
|
|
if not is_locked('categories'):
|
|
# parse the form only if the categories are not locked
|
|
for pd_name, pd in form.items(): # pylint: disable=invalid-name
|
|
if pd_name == 'engines':
|
|
pd_engines = [
|
|
EngineRef(engine_name, engines[engine_name].categories[0])
|
|
for engine_name in map(str.strip, pd.split(','))
|
|
if engine_name in engines
|
|
]
|
|
if pd_engines:
|
|
query_engineref_list.extend(pd_engines)
|
|
explicit_engine_list = True
|
|
else:
|
|
parse_category_form(query_categories, pd_name, pd)
|
|
|
|
if explicit_engine_list:
|
|
# explicit list of engines with the "engines" parameter in the form
|
|
if query_categories:
|
|
# add engines from referenced by the "categories" parameter and the "category_*"" parameters
|
|
query_engineref_list.extend(get_engineref_from_category_list(query_categories, disabled_engines))
|
|
else:
|
|
# no "engines" parameters in the form
|
|
if not query_categories:
|
|
# and neither "categories" parameter nor "category_*"" parameters in the form
|
|
# -> get the categories from the preferences (the cookies or the settings)
|
|
query_categories = get_selected_categories(preferences, None)
|
|
|
|
# using all engines for that search, which are
|
|
# declared under the specific categories
|
|
query_engineref_list.extend(get_engineref_from_category_list(query_categories, disabled_engines))
|
|
|
|
return query_engineref_list
|
|
|
|
|
|
def parse_engine_data(form):
|
|
engine_data = defaultdict(dict)
|
|
for k, v in form.items():
|
|
if k.startswith("engine_data"):
|
|
_, engine, key = k.split('-')
|
|
engine_data[engine][key] = v
|
|
return engine_data
|
|
|
|
|
|
def get_search_query_from_webapp(
|
|
preferences: Preferences, form: Dict[str, str]
|
|
) -> Tuple[SearchQuery, RawTextQuery, List[EngineRef], List[EngineRef], str]:
|
|
"""Assemble data from preferences and request.form (from the HTML form) needed
|
|
in a search query.
|
|
|
|
The returned tuple consits of:
|
|
|
|
1. instance of :py:obj:`searx.search.SearchQuery`
|
|
2. instance of :py:obj:`searx.query.RawTextQuery`
|
|
3. list of :py:obj:`searx.search.EngineRef` instances
|
|
4. string with the *selected locale* of the query
|
|
|
|
About language/locale: if the client selects the alias ``auto`` the
|
|
``SearchQuery`` object is build up by the :py:obj:`detected language
|
|
<searx.utils.detect_language>`. If language recognition does not have a
|
|
match the language preferred by the :py:obj:`Preferences.client` is used.
|
|
If client does not have a preference, the default ``all`` is used.
|
|
|
|
The *selected locale* in the tuple always represents the selected
|
|
language/locale and might differ from the language recognition.
|
|
|
|
"""
|
|
# no text for the query ?
|
|
if not form.get('q'):
|
|
raise SearxParameterException('q', '')
|
|
|
|
# set blocked engines
|
|
disabled_engines = preferences.engines.get_disabled()
|
|
|
|
# parse query, if tags are set, which change
|
|
# the search engine or search-language
|
|
raw_text_query = RawTextQuery(form['q'], disabled_engines)
|
|
|
|
# set query
|
|
query = raw_text_query.getQuery()
|
|
query_pageno = parse_pageno(form)
|
|
query_safesearch = parse_safesearch(preferences, form)
|
|
query_time_range = parse_time_range(form)
|
|
query_license = parse_license_filter(form)
|
|
query_timeout = parse_timeout(form, raw_text_query)
|
|
external_bang = raw_text_query.external_bang
|
|
redirect_to_first_result = raw_text_query.redirect_to_first_result
|
|
engine_data = parse_engine_data(form)
|
|
|
|
query_lang = parse_lang(preferences, form, raw_text_query)
|
|
selected_locale = query_lang
|
|
|
|
if query_lang == 'auto':
|
|
query_lang = detect_language(query, threshold=0.8, only_search_languages=True)
|
|
query_lang = query_lang or preferences.client.locale_tag or 'all'
|
|
|
|
if not is_locked('categories') and raw_text_query.specific:
|
|
# if engines are calculated from query,
|
|
# set categories by using that information
|
|
query_engineref_list = raw_text_query.enginerefs
|
|
else:
|
|
# otherwise, using defined categories to
|
|
# calculate which engines should be used
|
|
query_engineref_list = parse_generic(preferences, form, disabled_engines)
|
|
|
|
query_engineref_list = deduplicate_engineref_list(query_engineref_list)
|
|
query_engineref_list, query_engineref_list_unknown, query_engineref_list_notoken = validate_engineref_list(
|
|
query_engineref_list, preferences
|
|
)
|
|
|
|
return (
|
|
SearchQuery(
|
|
query,
|
|
query_engineref_list,
|
|
query_lang,
|
|
query_safesearch,
|
|
query_pageno,
|
|
query_time_range,
|
|
query_license,
|
|
query_timeout,
|
|
external_bang=external_bang,
|
|
engine_data=engine_data,
|
|
redirect_to_first_result=redirect_to_first_result,
|
|
),
|
|
raw_text_query,
|
|
query_engineref_list_unknown,
|
|
query_engineref_list_notoken,
|
|
selected_locale,
|
|
)
|