searx.webadapter Namespace Reference

Functions
List[EngineRef]	deduplicate_engineref_list (List[EngineRef] engineref_list)
Tuple[List[EngineRef], List[EngineRef], List[EngineRef]]	validate_engineref_list (List[EngineRef] engineref_list, Preferences preferences)
int	parse_pageno (Dict[str, str] form)
str	parse_lang (Preferences preferences, Dict[str, str] form, RawTextQuery raw_text_query)
int	parse_safesearch (Preferences preferences, Dict[str, str] form)
Optional[str]	parse_time_range (Dict[str, str] form)
Optional[float]	parse_timeout (Dict[str, str] form, RawTextQuery raw_text_query)
None	parse_category_form (List[str] query_categories, str name, str value)
List[str]	get_selected_categories (Preferences preferences, Optional[Dict[str, str]] form)
List[EngineRef]	get_engineref_from_category_list (List[str] category_list, List[str] disabled_engines)
List[EngineRef]	parse_generic (Preferences preferences, Dict[str, str] form, List[str] disabled_engines)
	parse_engine_data (form)
Tuple[SearchQuery, RawTextQuery, List[EngineRef], List[EngineRef], str]	get_search_query_from_webapp (Preferences preferences, Dict[str, str] form)

Function Documentation

deduplicate_engineref_list()

List[EngineRef] searx.webadapter.deduplicate_engineref_list

(

List[EngineRef]

engineref_list

)

Definition at line 17 of file webadapter.py.

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())
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

get_engineref_from_category_list()

List[EngineRef] searx.webadapter.get_engineref_from_category_list	(	List[str]	category_list,
		List[str]	disabled_engines )

Definition at line 159 of file webadapter.py.

) -> 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
 
 

Referenced by searx.webadapter.parse_generic().

Here is the caller graph for this function:

get_search_query_from_webapp()

Tuple[SearchQuery, RawTextQuery, List[EngineRef], List[EngineRef], str] searx.webadapter.get_search_query_from_webapp	(	Preferences	preferences,
		Dict[str, str]	form )

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.

Definition at line 222 of file webadapter.py.

) -> 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_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_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,
    )

References searx.webadapter.deduplicate_engineref_list(), searx.webadapter.parse_engine_data(), searx.webadapter.parse_generic(), searx.webadapter.parse_pageno(), searx.webadapter.parse_safesearch(), searx.webadapter.parse_time_range(), searx.webadapter.parse_timeout(), and searx.webadapter.validate_engineref_list().

Here is the call graph for this function:

get_selected_categories()

List[str] searx.webadapter.get_selected_categories	(	Preferences	preferences,
		Optional[Dict[str, str]]	form )

Definition at line 136 of file webadapter.py.

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
 
 

References searx.webadapter.parse_category_form().

Here is the call graph for this function:

parse_category_form()

None searx.webadapter.parse_category_form	(	List[str]	query_categories,
		str	name,
		str	value )

Definition at line 118 of file webadapter.py.

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)
 
 

Referenced by searx.webadapter.get_selected_categories(), and searx.webadapter.parse_generic().

Here is the caller graph for this function:

parse_engine_data()

searx.webadapter.parse_engine_data

(

form

)

Definition at line 213 of file webadapter.py.

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
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

parse_generic()

List[EngineRef] searx.webadapter.parse_generic	(	Preferences	preferences,
		Dict[str, str]	form,
		List[str]	disabled_engines )

Definition at line 173 of file webadapter.py.

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
 
 

References searx.webadapter.get_engineref_from_category_list(), and searx.webadapter.parse_category_form().

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_lang()

str searx.webadapter.parse_lang	(	Preferences	preferences,
		Dict[str, str]	form,
		RawTextQuery	raw_text_query )

Definition at line 56 of file webadapter.py.

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
 
 

parse_pageno()

int searx.webadapter.parse_pageno

(

Dict[str, str]

form

)

Definition at line 49 of file webadapter.py.

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)
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

parse_safesearch()

int searx.webadapter.parse_safesearch	(	Preferences	preferences,
		Dict[str, str]	form )

Definition at line 76 of file webadapter.py.

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
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

parse_time_range()

Optional[str] searx.webadapter.parse_time_range

(

Dict[str, str]

form

)

Definition at line 96 of file webadapter.py.

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
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

parse_timeout()

Optional[float] searx.webadapter.parse_timeout	(	Dict[str, str]	form,
		RawTextQuery	raw_text_query )

Definition at line 105 of file webadapter.py.

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
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function:

validate_engineref_list()

Tuple[List[EngineRef], List[EngineRef], List[EngineRef]] searx.webadapter.validate_engineref_list	(	List[EngineRef]	engineref_list,
		Preferences	preferences )

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

Definition at line 22 of file webadapter.py.

) -> 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
 
 

Referenced by searx.webadapter.get_search_query_from_webapp().

Here is the caller graph for this function: