diff options
Diffstat (limited to 'searx/preferences.py')
| -rw-r--r-- | searx/preferences.py | 357 |
1 files changed, 279 insertions, 78 deletions
diff --git a/searx/preferences.py b/searx/preferences.py index 30a4252..5c9c293 100644 --- a/searx/preferences.py +++ b/searx/preferences.py @@ -1,13 +1,16 @@ +# SPDX-License-Identifier: AGPL-3.0-or-later +"""Searx preferences implementation. +""" + +# pylint: disable=useless-object-inheritance + from base64 import urlsafe_b64encode, urlsafe_b64decode from zlib import compress, decompress -from sys import version +from urllib.parse import parse_qs, urlencode from searx import settings, autocomplete from searx.languages import language_codes as languages -from searx.url_utils import parse_qs, urlencode - -if version[0] == '3': - unicode = str +from searx.webutils import VALID_LANGUAGE_CODE COOKIE_MAX_AGE = 60 * 60 * 24 * 365 * 5 # 5 years @@ -19,19 +22,23 @@ DOI_RESOLVERS = list(settings['doi_resolvers']) class MissingArgumentException(Exception): - pass + """Exption from ``cls._post_init`` when a argument is missed. + """ class ValidationException(Exception): - pass + """Exption from ``cls._post_init`` when configuration value is invalid. + """ -class Setting(object): + +class Setting: """Base class of user settings""" - def __init__(self, default_value, **kwargs): - super(Setting, self).__init__() + def __init__(self, default_value, locked=False, **kwargs): + super().__init__() self.value = default_value + self.locked = locked for key, value in kwargs.items(): setattr(self, key, value) @@ -41,33 +48,45 @@ class Setting(object): pass def parse(self, data): + """Parse ``data`` and store the result at ``self.value`` + + If needed, its overwritten in the inheritance. + """ self.value = data def get_value(self): + """Returns the value of the setting + + If needed, its overwritten in the inheritance. + """ return self.value def save(self, name, resp): + """Save cookie ``name`` in the HTTP reponse obect + + If needed, its overwritten in the inheritance.""" resp.set_cookie(name, self.value, max_age=COOKIE_MAX_AGE) class StringSetting(Setting): """Setting of plain string values""" - pass class EnumStringSetting(Setting): """Setting of a value which can only come from the given choices""" - def _validate_selection(self, selection): - if selection not in self.choices: - raise ValidationException('Invalid value: "{0}"'.format(selection)) - def _post_init(self): if not hasattr(self, 'choices'): raise MissingArgumentException('Missing argument: choices') self._validate_selection(self.value) + def _validate_selection(self, selection): + if selection not in self.choices: # pylint: disable=no-member + raise ValidationException('Invalid value: "{0}"'.format(selection)) + def parse(self, data): + """Parse and validate ``data`` and store the result at ``self.value`` + """ self._validate_selection(data) self.value = data @@ -77,7 +96,7 @@ class MultipleChoiceSetting(EnumStringSetting): def _validate_selections(self, selections): for item in selections: - if item not in self.choices: + if item not in self.choices: # pylint: disable=no-member raise ValidationException('Invalid value: "{0}"'.format(selections)) def _post_init(self): @@ -86,6 +105,8 @@ class MultipleChoiceSetting(EnumStringSetting): self._validate_selections(self.value) def parse(self, data): + """Parse and validate ``data`` and store the result at ``self.value`` + """ if data == '': self.value = [] return @@ -94,30 +115,78 @@ class MultipleChoiceSetting(EnumStringSetting): self._validate_selections(elements) self.value = elements - def parse_form(self, data): + def parse_form(self, data): # pylint: disable=missing-function-docstring + if self.locked: + return + self.value = [] for choice in data: - if choice in self.choices and choice not in self.value: + if choice in self.choices and choice not in self.value: # pylint: disable=no-member self.value.append(choice) def save(self, name, resp): + """Save cookie ``name`` in the HTTP reponse obect + """ resp.set_cookie(name, ','.join(self.value), max_age=COOKIE_MAX_AGE) +class SetSetting(Setting): + """Setting of values of type ``set`` (comma separated string) """ + def _post_init(self): + if not hasattr(self, 'values'): + self.values = set() + + def get_value(self): + """Returns a string with comma separated values. + """ + return ','.join(self.values) + + def parse(self, data): + """Parse and validate ``data`` and store the result at ``self.value`` + """ + if data == '': + self.values = set() # pylint: disable=attribute-defined-outside-init + return + + elements = data.split(',') + for element in elements: + self.values.add(element) + + def parse_form(self, data): # pylint: disable=missing-function-docstring + if self.locked: + return + + elements = data.split(',') + self.values = set(elements) # pylint: disable=attribute-defined-outside-init + + def save(self, name, resp): + """Save cookie ``name`` in the HTTP reponse obect + """ + resp.set_cookie(name, ','.join(self.values), max_age=COOKIE_MAX_AGE) + + class SearchLanguageSetting(EnumStringSetting): """Available choices may change, so user's value may not be in choices anymore""" + def _validate_selection(self, selection): + if selection != '' and not VALID_LANGUAGE_CODE.match(selection): + raise ValidationException('Invalid language code: "{0}"'.format(selection)) + def parse(self, data): - if data not in self.choices and data != self.value: + """Parse and validate ``data`` and store the result at ``self.value`` + """ + if data not in self.choices and data != self.value: # pylint: disable=no-member # hack to give some backwards compatibility with old language cookies data = str(data).replace('_', '-') - lang = data.split('-')[0] + lang = data.split('-', maxsplit=1)[0] + # pylint: disable=no-member if data in self.choices: pass elif lang in self.choices: data = lang else: data = self.value + self._validate_selection(data) self.value = data @@ -127,16 +196,21 @@ class MapSetting(Setting): def _post_init(self): if not hasattr(self, 'map'): raise MissingArgumentException('missing argument: map') - if self.value not in self.map.values(): + if self.value not in self.map.values(): # pylint: disable=no-member raise ValidationException('Invalid default value') def parse(self, data): + """Parse and validate ``data`` and store the result at ``self.value`` + """ + # pylint: disable=no-member if data not in self.map: raise ValidationException('Invalid choice: {0}'.format(data)) self.value = self.map[data] - self.key = data + self.key = data # pylint: disable=attribute-defined-outside-init def save(self, name, resp): + """Save cookie ``name`` in the HTTP reponse obect + """ if hasattr(self, 'key'): resp.set_cookie(name, self.key, max_age=COOKIE_MAX_AGE) @@ -150,24 +224,27 @@ class SwitchableSetting(Setting): if not hasattr(self, 'choices'): raise MissingArgumentException('missing argument: choices') - def transform_form_items(self, items): + def transform_form_items(self, items): # pylint: disable=missing-function-docstring return items - def transform_values(self, values): + def transform_values(self, values): # pylint: disable=missing-function-docstring return values - def parse_cookie(self, data): + def parse_cookie(self, data): # pylint: disable=missing-function-docstring + # pylint: disable=attribute-defined-outside-init if data[DISABLED] != '': self.disabled = set(data[DISABLED].split(',')) if data[ENABLED] != '': self.enabled = set(data[ENABLED].split(',')) - def parse_form(self, items): - items = self.transform_form_items(items) + def parse_form(self, items): # pylint: disable=missing-function-docstring + if self.locked: + return - self.disabled = set() - self.enabled = set() - for choice in self.choices: + items = self.transform_form_items(items) + self.disabled = set() # pylint: disable=attribute-defined-outside-init + self.enabled = set() # pylint: disable=attribute-defined-outside-init + for choice in self.choices: # pylint: disable=no-member if choice['default_on']: if choice['id'] in items: self.disabled.add(choice['id']) @@ -175,33 +252,36 @@ class SwitchableSetting(Setting): if choice['id'] not in items: self.enabled.add(choice['id']) - def save(self, resp): + def save(self, resp): # pylint: disable=arguments-differ + """Save cookie in the HTTP reponse obect + """ resp.set_cookie('disabled_{0}'.format(self.value), ','.join(self.disabled), max_age=COOKIE_MAX_AGE) resp.set_cookie('enabled_{0}'.format(self.value), ','.join(self.enabled), max_age=COOKIE_MAX_AGE) - def get_disabled(self): + def get_disabled(self): # pylint: disable=missing-function-docstring disabled = self.disabled - for choice in self.choices: + for choice in self.choices: # pylint: disable=no-member if not choice['default_on'] and choice['id'] not in self.enabled: disabled.add(choice['id']) return self.transform_values(disabled) - def get_enabled(self): + def get_enabled(self): # pylint: disable=missing-function-docstring enabled = self.enabled - for choice in self.choices: + for choice in self.choices: # pylint: disable=no-member if choice['default_on'] and choice['id'] not in self.disabled: enabled.add(choice['id']) return self.transform_values(enabled) class EnginesSetting(SwitchableSetting): + """Engine settings""" def _post_init(self): - super(EnginesSetting, self)._post_init() + super()._post_init() transformed_choices = [] - for engine_name, engine in self.choices.items(): + for engine_name, engine in self.choices.items(): # pylint: disable=no-member,access-member-before-definition for category in engine.categories: - transformed_choice = dict() + transformed_choice = {} transformed_choice['default_on'] = not engine.disabled transformed_choice['id'] = '{}__{}'.format(engine_name, category) transformed_choices.append(transformed_choice) @@ -212,7 +292,7 @@ class EnginesSetting(SwitchableSetting): def transform_values(self, values): if len(values) == 1 and next(iter(values)) == '': - return list() + return [] transformed_values = [] for value in values: engine, category = value.split('__') @@ -221,12 +301,13 @@ class EnginesSetting(SwitchableSetting): class PluginsSetting(SwitchableSetting): + """Plugin settings""" def _post_init(self): - super(PluginsSetting, self)._post_init() + super()._post_init() transformed_choices = [] - for plugin in self.choices: - transformed_choice = dict() + for plugin in self.choices: # pylint: disable=access-member-before-definition + transformed_choice = {} transformed_choice['default_on'] = plugin.default_on transformed_choice['id'] = plugin.id transformed_choices.append(transformed_choice) @@ -236,47 +317,126 @@ class PluginsSetting(SwitchableSetting): return [item[len('plugin_'):] for item in items] -class Preferences(object): +class Preferences: """Validates and saves preferences to cookies""" def __init__(self, themes, categories, engines, plugins): - super(Preferences, self).__init__() - - self.key_value_settings = {'categories': MultipleChoiceSetting(['general'], choices=categories + ['none']), - 'language': SearchLanguageSetting(settings['search']['language'], - choices=LANGUAGE_CODES), - 'locale': EnumStringSetting(settings['ui']['default_locale'], - choices=list(settings['locales'].keys()) + ['']), - 'autocomplete': EnumStringSetting(settings['search']['autocomplete'], - choices=list(autocomplete.backends.keys()) + ['']), - 'image_proxy': MapSetting(settings['server']['image_proxy'], - map={'': settings['server']['image_proxy'], - '0': False, - '1': True, - 'True': True, - 'False': False}), - 'method': EnumStringSetting('POST', choices=('GET', 'POST')), - 'safesearch': MapSetting(settings['search']['safe_search'], map={'0': 0, - '1': 1, - '2': 2}), - 'theme': EnumStringSetting(settings['ui']['default_theme'], choices=themes), - 'results_on_new_tab': MapSetting(False, map={'0': False, - '1': True, - 'False': False, - 'True': True}), - 'doi_resolver': MultipleChoiceSetting(['oadoi.org'], choices=DOI_RESOLVERS), - 'oscar-style': EnumStringSetting( - settings['ui'].get('theme_args', {}).get('oscar_style', 'logicodev'), - choices=['', 'logicodev', 'logicodev-dark', 'pointhi']), - } + super().__init__() + + self.key_value_settings = { + 'categories': MultipleChoiceSetting( + ['general'], + is_locked('categories'), + choices=categories + ['none'] + ), + 'language': SearchLanguageSetting( + settings['search'].get('default_lang', ''), + is_locked('language'), + choices=list(LANGUAGE_CODES) + [''] + ), + 'locale': EnumStringSetting( + settings['ui'].get('default_locale', ''), + is_locked('locale'), + choices=list(settings['locales'].keys()) + [''] + ), + 'autocomplete': EnumStringSetting( + settings['search'].get('autocomplete', ''), + is_locked('autocomplete'), + choices=list(autocomplete.backends.keys()) + [''] + ), + 'autofocus': MapSetting( + settings['ui'].get('autofocus', True), + is_locked('autofocus'), + map={ + '0': False, + '1': True, + 'False': False, + 'True': True + } + ), + 'archive_today': MapSetting( + settings['ui'].get('archive_today', True), + is_locked('archive_today'), + map={ + '0': False, + '1': True, + 'False': False, + 'True': True + } + ), + 'image_proxy': MapSetting( + settings['server'].get('image_proxy', False), + is_locked('image_proxy'), + map={ + '': settings['server'].get('image_proxy', 0), + '0': False, + '1': True, + 'True': True, + 'False': False + } + ), + 'method': EnumStringSetting( + settings['server'].get('method', 'POST'), + is_locked('method'), + choices=('GET', 'POST') + ), + 'safesearch': MapSetting( + settings['search'].get('safe_search', 0), + is_locked('safesearch'), + map={ + '0': 0, + '1': 1, + '2': 2 + } + ), + 'theme': EnumStringSetting( + settings['ui'].get('default_theme', 'oscar'), + is_locked('theme'), + choices=themes + ), + 'results_on_new_tab': MapSetting( + settings['ui'].get('results_on_new_tab', False), + is_locked('results_on_new_tab'), + map={ + '0': False, + '1': True, + 'False': False, + 'True': True + } + ), + 'doi_resolver': MultipleChoiceSetting( + [settings['default_doi_resolver'], ], + is_locked('doi_resolver'), + choices=DOI_RESOLVERS + ), + 'oscar-style': EnumStringSetting( + settings['ui'].get('theme_args', {}).get('oscar_style', 'logicodev'), + is_locked('oscar-style'), + choices=['', 'logicodev', 'logicodev-dark', 'pointhi']), + 'advanced_search': MapSetting( + settings['ui'].get('advanced_search', False), + is_locked('advanced_search'), + map={ + '0': False, + '1': True, + 'False': False, + 'True': True, + 'on': True, + } + ), + } self.engines = EnginesSetting('engines', choices=engines) self.plugins = PluginsSetting('plugins', choices=plugins) + self.tokens = SetSetting('tokens') self.unknown_params = {} 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: @@ -288,18 +448,24 @@ class Preferences(object): settings_kv['disabled_plugins'] = ','.join(self.plugins.disabled) settings_kv['enabled_plugins'] = ','.join(self.plugins.enabled) - return urlsafe_b64encode(compress(urlencode(settings_kv).encode('utf-8'))).decode('utf-8') + settings_kv['tokens'] = ','.join(self.tokens.values) + + return urlsafe_b64encode(compress(urlencode(settings_kv).encode())).decode() def parse_encoded_data(self, input_data): - decoded_data = decompress(urlsafe_b64decode(input_data.encode('utf-8'))) + """parse (base64) preferences from request (``flask.request.form['preferences']``)""" + decoded_data = decompress(urlsafe_b64decode(input_data.encode())) dict_data = {} - for x, y in parse_qs(decoded_data).items(): - dict_data[x.decode('utf8')] = y[0].decode('utf8') + for x, y in parse_qs(decoded_data.decode()).items(): + dict_data[x] = y[0] self.parse_dict(dict_data) def parse_dict(self, input_data): + """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', ''), @@ -307,6 +473,8 @@ class Preferences(object): 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) elif not any(user_setting_name.startswith(x) for x in [ 'enabled_', 'disabled_', @@ -316,6 +484,7 @@ class Preferences(object): self.unknown_params[user_setting_name] = user_setting def parse_form(self, input_data): + """Parse formular (``<input>``) data from a ``flask.request.form``""" disabled_engines = [] enabled_categories = [] disabled_plugins = [] @@ -328,6 +497,8 @@ class Preferences(object): 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) else: self.unknown_params[user_setting_name] = user_setting self.key_value_settings['categories'].parse_form(enabled_categories) @@ -336,16 +507,46 @@ class Preferences(object): # cannot be used in case of engines or plugins def get_value(self, user_setting_name): + """Returns the value for ``user_setting_name`` + """ + ret_val = None if user_setting_name in self.key_value_settings: - return self.key_value_settings[user_setting_name].get_value() + ret_val = self.key_value_settings[user_setting_name].get_value() if user_setting_name in self.unknown_params: - return self.unknown_params[user_setting_name] + ret_val = self.unknown_params[user_setting_name] + return ret_val def save(self, resp): + """Save cookie in the HTTP reponse obect + """ for user_setting_name, user_setting in self.key_value_settings.items(): + if user_setting.locked: + continue user_setting.save(user_setting_name, resp) self.engines.save(resp) self.plugins.save(resp) + self.tokens.save('tokens', resp) for k, v in self.unknown_params.items(): resp.set_cookie(k, v, max_age=COOKIE_MAX_AGE) return resp + + def validate_token(self, engine): # pylint: disable=missing-function-docstring + 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 + + +def is_locked(setting_name): + """Checks if a given setting name is locked by settings.yml + """ + if 'preferences' not in settings: + return False + if 'lock' not in settings['preferences']: + return False + return setting_name in settings['preferences']['lock'] |