searx.preferences.Preferences Class Reference

Public Member Functions
	__init__ (self, list[str] themes, list[str] categories, dict[str, Engine] engines, searx.plugins.PluginStorage plugins, ClientPref|None client=None)
	get_as_url_params (self)
	parse_encoded_data (self, str input_data)
	parse_dict (self, Dict[str, str] input_data)
	parse_form (self, Dict[str, str] input_data)
	get_value (self, str user_setting_name)
	save (self, flask.Response resp)
	validate_token (self, engine)

Public Attributes
dict	key_value_settings
	engines = EnginesSetting('engines', engines=engines.values())
	plugins = PluginsSetting('plugins', plugins=plugins)
	tokens = SetSetting('tokens')
	client = client or ClientPref()

Detailed Description

Validates and saves preferences to cookies

Definition at line 376 of file preferences.py.

Constructor & Destructor Documentation

__init__()

searx.preferences.Preferences.__init__	(		self,
		list[str]	themes,
		list[str]	categories,
		dict[str, Engine]	engines,
		searx.plugins.PluginStorage	plugins,
		ClientPref | None	client = None )

Definition at line 379 of file preferences.py.

    ):
 
        super().__init__()
 
        self.key_value_settings: Dict[str, Setting] = {
            # fmt: off
            'categories': MultipleChoiceSetting(
                ['general'],
                locked=is_locked('categories'),
                choices=categories + ['none']
            ),
            'language': SearchLanguageSetting(
                settings['search']['default_lang'],
                locked=is_locked('language'),
                choices=settings['search']['languages'] + ['']
            ),
            'locale': EnumStringSetting(
                settings['ui']['default_locale'],
                locked=is_locked('locale'),
                choices=list(LOCALE_NAMES.keys()) + ['']
            ),
            'autocomplete': EnumStringSetting(
                settings['search']['autocomplete'],
                locked=is_locked('autocomplete'),
                choices=list(autocomplete.backends.keys()) + ['']
            ),
            'favicon_resolver': EnumStringSetting(
                settings['search']['favicon_resolver'],
                locked=is_locked('favicon_resolver'),
                choices=list(favicons.proxy.CFG.resolver_map.keys()) + ['']
            ),
            'image_proxy': BooleanSetting(
                settings['server']['image_proxy'],
                locked=is_locked('image_proxy')
            ),
            'method': EnumStringSetting(
                settings['server']['method'],
                locked=is_locked('method'),
                choices=('GET', 'POST')
            ),
            'safesearch': MapSetting(
                settings['search']['safe_search'],
                locked=is_locked('safesearch'),
                map={
                    '0': 0,
                    '1': 1,
                    '2': 2
                }
            ),
            'theme': EnumStringSetting(
                settings['ui']['default_theme'],
                locked=is_locked('theme'),
                choices=themes
            ),
            'results_on_new_tab': BooleanSetting(
                settings['ui']['results_on_new_tab'],
                locked=is_locked('results_on_new_tab')
            ),
            'doi_resolver': MultipleChoiceSetting(
                [settings['default_doi_resolver'], ],
                locked=is_locked('doi_resolver'),
                choices=DOI_RESOLVERS
            ),
            'simple_style': EnumStringSetting(
                settings['ui']['theme_args']['simple_style'],
                locked=is_locked('simple_style'),
                choices=['', 'auto', 'light', 'dark', 'black']
            ),
            'center_alignment': BooleanSetting(
                settings['ui']['center_alignment'],
                locked=is_locked('center_alignment')
            ),
            'advanced_search': BooleanSetting(
                settings['ui']['advanced_search'],
                locked=is_locked('advanced_search')
            ),
            'query_in_title': BooleanSetting(
                settings['ui']['query_in_title'],
                locked=is_locked('query_in_title')
            ),
            'infinite_scroll': BooleanSetting(
                settings['ui']['infinite_scroll'],
                locked=is_locked('infinite_scroll')
            ),
            'search_on_category_select': BooleanSetting(
                settings['ui']['search_on_category_select'],
                locked=is_locked('search_on_category_select')
            ),
            'hotkeys': EnumStringSetting(
                settings['ui']['hotkeys'],
                choices=['default', 'vim']
            ),
            'url_formatting': EnumStringSetting(
                settings['ui']['url_formatting'],
                choices=['pretty', 'full', 'host']
            ),
            # fmt: on
        }
 
        self.engines = EnginesSetting('engines', engines=engines.values())
        self.plugins = PluginsSetting('plugins', plugins=plugins)
        self.tokens = SetSetting('tokens')
        self.client = client or ClientPref()
 

References __init__().

Referenced by __init__().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

get_as_url_params()

searx.preferences.Preferences.get_as_url_params

(

self

)

Return preferences as URL parameters

Definition at line 490 of file preferences.py.

    def get_as_url_params(self):
        """Return preferences as URL parameters"""
        settings_kv = {}
        for k, v in self.key_value_settings.items():
            if v.locked:
                continue
            if isinstance(v, MultipleChoiceSetting):
                settings_kv[k] = ','.join(v.get_value())
            else:
                settings_kv[k] = v.get_value()
 
        settings_kv['disabled_engines'] = ','.join(self.engines.disabled)
        settings_kv['enabled_engines'] = ','.join(self.engines.enabled)
 
        settings_kv['disabled_plugins'] = ','.join(self.plugins.disabled)
        settings_kv['enabled_plugins'] = ','.join(self.plugins.enabled)
 
        settings_kv['tokens'] = ','.join(self.tokens.values)
 
        return urlsafe_b64encode(compress(urlencode(settings_kv).encode())).decode()
 

References engines, key_value_settings, plugins, searx.enginelib.Engine.tokens, and tokens.

get_value()

searx.preferences.Preferences.get_value	(		self,
		str	user_setting_name )

Returns the value for ``user_setting_name``

Definition at line 562 of file preferences.py.

    def get_value(self, user_setting_name: str):
        """Returns the value for ``user_setting_name``"""
        ret_val = None
        if user_setting_name in self.key_value_settings:
            ret_val = self.key_value_settings[user_setting_name].get_value()
        return ret_val
 

References get_value(), and key_value_settings.

Referenced by get_value().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_dict()

searx.preferences.Preferences.parse_dict	(		self,
		Dict[str, str]	input_data )

parse preferences from request (``flask.request.form``)

Definition at line 519 of file preferences.py.

    def parse_dict(self, input_data: Dict[str, str]):
        """parse preferences from request (``flask.request.form``)"""
        for user_setting_name, user_setting in input_data.items():
            if user_setting_name in self.key_value_settings:
                if self.key_value_settings[user_setting_name].locked:
                    continue
                self.key_value_settings[user_setting_name].parse(user_setting)
            elif user_setting_name == 'disabled_engines':
                self.engines.parse_cookie(input_data.get('disabled_engines', ''), input_data.get('enabled_engines', ''))
            elif user_setting_name == 'disabled_plugins':
                self.plugins.parse_cookie(input_data.get('disabled_plugins', ''), input_data.get('enabled_plugins', ''))
            elif user_setting_name == 'tokens':
                self.tokens.parse(user_setting)
 

References engines, key_value_settings, plugins, searx.enginelib.Engine.tokens, and tokens.

Referenced by parse_encoded_data().

Here is the caller graph for this function:

parse_encoded_data()

searx.preferences.Preferences.parse_encoded_data	(		self,
		str	input_data )

parse (base64) preferences from request (``flask.request.form['preferences']``)

Definition at line 511 of file preferences.py.

    def parse_encoded_data(self, input_data: str):
        """parse (base64) preferences from request (``flask.request.form['preferences']``)"""
        bin_data = decompress(urlsafe_b64decode(input_data))
        dict_data = {}
        for x, y in parse_qs(bin_data.decode('ascii'), keep_blank_values=True).items():
            dict_data[x] = y[0]
        self.parse_dict(dict_data)
 

References parse_dict().

Here is the call graph for this function:

parse_form()

searx.preferences.Preferences.parse_form	(		self,
		Dict[str, str]	input_data )

Parse formular (``<input>``) data from a ``flask.request.form``

Definition at line 533 of file preferences.py.

    def parse_form(self, input_data: Dict[str, str]):
        """Parse formular (``<input>``) data from a ``flask.request.form``"""
        disabled_engines = []
        enabled_categories = []
        disabled_plugins = []
 
        # boolean preferences are not sent by the form if they're false,
        # so we have to add them as false manually if they're not sent (then they would be true)
        for key, setting in self.key_value_settings.items():
            if key not in input_data.keys() and isinstance(setting, BooleanSetting):
                input_data[key] = 'False'
 
        for user_setting_name, user_setting in input_data.items():
            if user_setting_name in self.key_value_settings:
                self.key_value_settings[user_setting_name].parse(user_setting)
            elif user_setting_name.startswith('engine_'):
                disabled_engines.append(user_setting_name)
            elif user_setting_name.startswith('category_'):
                enabled_categories.append(user_setting_name[len('category_') :])
            elif user_setting_name.startswith('plugin_'):
                disabled_plugins.append(user_setting_name)
            elif user_setting_name == 'tokens':
                self.tokens.parse_form(user_setting)
 
        self.key_value_settings['categories'].parse_form(enabled_categories)
        self.engines.parse_form(disabled_engines)
        self.plugins.parse_form(disabled_plugins)
 

References engines, key_value_settings, parse_form(), plugins, searx.enginelib.Engine.tokens, and tokens.

Referenced by parse_form().

Here is the call graph for this function:

Here is the caller graph for this function:

save()

searx.preferences.Preferences.save	(		self,
		flask.Response	resp )

Save cookie in the HTTP response object

Definition at line 569 of file preferences.py.

    def save(self, resp: flask.Response):
        """Save cookie in the HTTP response object"""
        for user_setting_name, user_setting in self.key_value_settings.items():
            # pylint: disable=unnecessary-dict-index-lookup
            if self.key_value_settings[user_setting_name].locked:
                continue
            user_setting.save(user_setting_name, resp)
        self.engines.save(resp)
        self.plugins.save(resp)
        self.tokens.save('tokens', resp)
        return resp
 

References engines, key_value_settings, plugins, save(), searx.enginelib.Engine.tokens, and tokens.

Referenced by save().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_token()

searx.preferences.Preferences.validate_token	(		self,
			engine )

Definition at line 581 of file preferences.py.

    def validate_token(self, engine):
        valid = True
        if hasattr(engine, 'tokens') and engine.tokens:
            valid = False
            for token in self.tokens.values:
                if token in engine.tokens:
                    valid = True
                    break
 
        return valid
 
 

References searx.enginelib.Engine.tokens, and tokens.

Member Data Documentation

client

searx.preferences.Preferences.client = client or ClientPref()

Definition at line 488 of file preferences.py.

engines

searx.preferences.Preferences.engines = EnginesSetting('engines', engines=engines.values())

Definition at line 485 of file preferences.py.

Referenced by get_as_url_params(), parse_dict(), parse_form(), and save().

key_value_settings

dict searx.preferences.Preferences.key_value_settings

Definition at line 390 of file preferences.py.

Referenced by get_as_url_params(), get_value(), parse_dict(), parse_form(), and save().

plugins

searx.preferences.Preferences.plugins = PluginsSetting('plugins', plugins=plugins)

Definition at line 486 of file preferences.py.

Referenced by get_as_url_params(), parse_dict(), parse_form(), and save().

tokens

searx.preferences.Preferences.tokens = SetSetting('tokens')

Definition at line 487 of file preferences.py.

Referenced by get_as_url_params(), parse_dict(), parse_form(), save(), and validate_token().

---

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

• /home/andrew/Documents/code/public/searxng/searx/preferences.py