def validator(self):
from flexget import validator
root = validator.factory('list')
key_validator = validator.factory('regexp_match',
message='If statements cannot contain \'__\' or \'try\' statements')
key_validator.reject(r'.*?(__|try\s*:)')
key_validator.accept('.')
action = root.accept('dict').accept_valid_keys('root', key_validator=key_validator)
action.accept('choice').accept_choices(['accept', 'reject', 'fail'])
filter_action = action.accept('dict')
# Get a list of apiv2 input plugins, make sure to exclude self
valid_filters = [plugin for plugin in get_plugins_by_phase('filter')
if plugin.api_ver > 1 and plugin.name != 'if']
# Build a dict validator that accepts the available filter plugins and their settings
for plugin in valid_filters:
if hasattr(plugin.instance, 'validator'):
validator = plugin.instance.validator()
if validator.name == 'root':
# If a root validator is returned, grab the list of child validators
filter_action.valid[plugin.name] = validator.valid
else:
filter_action.valid[plugin.name] = [plugin.instance.validator()]
else:
filter_action.valid[plugin.name] = [validator.factory('any')]
return root
def test_path(self, tmpdir):
path = validator.factory('path')
path_allow_missing = validator.factory('path', allow_missing=True)
path.validate(tmpdir.strpath)
assert not path.errors.messages, '%s should be valid' % tmpdir.strpath
path_allow_missing.validate('missing_directory')
assert not path_allow_missing.errors.messages, 'missing_directory should be valid with allow_missing'
path.validate('missing_directory')
assert path.errors.messages, 'missing_directory should be invalid'
path_allow_missing.errors.messages = []
def test_path(self):
path = validator.factory('path')
path_allow_missing = validator.factory('path', allow_missing=True)
temp_path = maketemp()
path.validate(temp_path)
print path.errors.messages
assert not path.errors.messages, '%s should be valid' % (temp_path)
path_allow_missing.validate('missing_directory')
print path_allow_missing.errors.messages
assert not path_allow_missing.errors.messages, 'missing_directory should be valid with allow_missing'
path.validate('missing_directory')
print path.errors.messages
assert path.errors.messages, 'missing_directory should be invalid'
path_allow_missing.errors.messages = []
def validator(self):
from flexget import validator
root = validator.factory('list')
key_validator = validator.factory('regexp_match',
message='If statements cannot contain \'__\' or \'try\' statements')
key_validator.reject(r'.*?(__|try\s*:)')
key_validator.accept('.')
action = root.accept('dict').accept_valid_keys('root', key_validator=key_validator)
action.accept('choice').accept_choices(['accept', 'reject', 'fail'])
filter_action = action.accept('dict')
# Build a dict validator that accepts the available filter plugins and their settings
for plugin in get_plugins_by_phase('filter'):
if plugin.api_ver > 1 and hasattr(plugin.instance, 'validator'):
filter_action.accept(plugin.instance.validator, key=plugin.name)
return root
def test_dict(self):
dv = validator.factory('dict')
dv.accept('dict', key='foo')
result = dv.validate({'foo': {}})
assert not dv.errors.messages, 'should have passed foo'
assert result, 'invalid result for foo'
result = dv.validate({'bar': {}})
assert dv.errors.messages, 'should not have passed bar'
assert not result, 'should have an invalid result for bar'
# Test validation of dictionary keys
dv = validator.factory('dict')
dv.accept_valid_keys('dict', key_type='number')
result = dv.validate({3: {}})
assert not dv.errors.messages, 'should have passed 3'
assert result, 'invalid result for key 3'
def validator(self):
from flexget import validator
root = validator.factory('list')
key_validator = validator.factory('regexp_match',
message='If statements cannot contain `__`, `try` or `lambda` statements')
key_validator.reject(r'.*?(__|try\s*:|lambda)')
key_validator.accept('.')
action = root.accept('dict').accept_valid_keys('root', key_validator=key_validator)
action.accept('choice').accept_choices(['accept', 'reject', 'fail'])
filter_action = action.accept('dict')
# Build a dict validator that accepts all api > 2 plugins except input plugins.
for plugin in all_plugins.itervalues():
if plugin.api_ver > 1 and hasattr(plugin.instance, 'validator') and 'input' not in plugin.phase_handlers:
filter_action.accept(plugin.instance.validator, key=plugin.name)
return root
def validator(self):
from flexget import validator
root = validator.factory('root')
# Simple format, runs on_output for_accepted
root.accept('text')
# Advanced format
adv = root.accept('dict')
def add(name):
phase = adv.accept('dict', key=name)
phase.accept('text', key='phase')
phase.accept('text', key='for_entries')
phase.accept('text', key='for_accepted')
phase.accept('text', key='for_rejected')
phase.accept('text', key='for_failed')
for name in ['on_start', 'on_input', 'on_filter', 'on_output', 'on_exit']:
add(name)
adv.accept('boolean', key='fail_entries')
adv.accept('boolean', key='auto_escape')
adv.accept('boolean', key='allow_background')
return root
def validator(self):
from flexget import validator
config = validator.factory('dict')
config.accept('number', key='min')
config.accept('number', key='max')
config.accept('boolean', key='strict')
return config
def validator(self):
from flexget import validator
config = validator.factory("dict")
config.accept("text", key="phonenumber", required=True)
config.accept("text", key="password", required=True)
config.accept("text", key="message", required=False)
return config
def validator(self):
from flexget import validator
root = validator.factory('root')
# Simple format, runs on_output for_accepted
root.accept('text')
# Advanced format
adv = root.accept('dict')
def add(name):
phase = adv.accept('dict', key=name)
phase.accept('text', key='phase')
phase.accept('text', key='for_entries')
phase.accept('text', key='for_accepted')
phase.accept('text', key='for_rejected')
phase.accept('text', key='for_failed')
for phase in self.HANDLED_PHASES:
add('on_' + phase)
adv.accept('boolean', key='fail_entries')
adv.accept('boolean', key='auto_escape')
adv.accept('text', key='encoding')
adv.accept('boolean', key='allow_background')
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('choice', key='category').accept_choices(['all', 'movies', 'tv', 'music', 'books', 'xxx', 'other'])
root.accept('boolean', key='verified')
return root
def validator(self):
from flexget import validator
root = validator.factory("dict")
root.accept("text", key="template")
root.accept("text", key="file", required=True)
return root
def validator(self):
from flexget import validator
config = validator.factory()
# TODO: 320 and 480 need to be quoted. is it possible to validate
# without the need for quotes?
config.accept('choice').accept_choices(self.qualities, ignore_case=True)
return config
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('quality_requirements')
root.accept('list').accept('quality_requirements')
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('boolean')
root.accept('list').accept('text')
return root
def test_choice(self):
choice = validator.factory('choice')
choice.accept('foo')
choice.accept('Bar', ignore_case=True)
choice.accept(120)
choice.validate('foo')
print choice.errors.messages
assert not choice.errors.messages, 'foo should be valid'
choice.validate(120)
print choice.errors.messages
assert not choice.errors.messages, '120 should be valid'
choice.validate('bAR')
print choice.errors.messages
assert not choice.errors.messages, 'bAR should be valid'
choice.validate('xxx')
print choice.errors.messages
assert choice.errors.messages, 'xxx should be invalid'
choice.errors.messages = []
choice.validate(300)
print choice.errors.messages
assert choice.errors.messages, '300 should be invalid'
choice.errors.messages = []
choice.validate('fOO')
print choice.errors.messages
assert choice.errors.messages, 'fOO should be invalid'
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('list', key='dvds').accept('choice').accept_choices(self.dvd_lists)
root.accept('list', key='movies').accept('choice').accept_choices(self.movie_lists)
root.accept('text', key='api_key')
return root
def validator(self):
from flexget import validator
root = validator.factory("dict")
root.accept("text", key="account_id", required=True)
root.accept("boolean", key="strip_dates")
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('text') # TODO: file
bundle = root.accept('list')
bundle.accept('text')
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
config = root.accept_any_key('dict')
config.accept('regexp', key='regexp', required=True)
config.accept('text', key='format', required=True)
return root
def validator(self):
from flexget import validator
root = validator.factory("dict")
root.accept("text", key="username", required=True)
root.accept("text", key="password", required=True)
return root
def validator(self):
from flexget import validator
root = validator.factory("dict")
root.accept("boolean", key="use-ssl")
root.accept("path", key="ftp_tmp_path")
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('boolean')
deluge = root.accept('dict')
self.validate_connection_info(deluge)
deluge.accept(
'path', key='path', allow_replacement=True, allow_missing=True)
deluge.accept(
'path', key='movedone', allow_replacement=True, allow_missing=True)
deluge.accept('text', key='label')
deluge.accept('boolean', key='queuetotop')
deluge.accept('boolean', key='automanaged')
deluge.accept('number', key='maxupspeed')
deluge.accept('number', key='maxdownspeed')
deluge.accept('integer', key='maxconnections')
deluge.accept('integer', key='maxupslots')
deluge.accept('number', key='ratio')
deluge.accept('boolean', key='removeatratio')
deluge.accept('boolean', key='addpaused')
deluge.accept('boolean', key='compact')
deluge.accept('text', key='content_filename')
deluge.accept('boolean', key='main_file_only')
deluge.accept('boolean', key='enabled')
return root
def validator(self):
from flexget import validator
root = validator.factory('root')
root.accept('boolean')
regexp = root.accept('regexp_match')
regexp.accept('\d+ (minutes|hours|days|weeks)')
return root
def validator(self):
"""Return config validator."""
root = validator.factory('dict')
root.accept('text', key='username', required=True)
root.accept('text', key='password', required=True)
root.accept('number', key='gravity_multiplier')
# Scope as in pages like `browse`, `mp3/0day`, `foreign`, etc.
# Will only accept categories from `browse` which will it default to, unless user specifies other scopes
# via dict
root.accept('choice', key='category').accept_choices(CATEGORIES['browse'])
root.accept('number', key='category')
categories = root.accept('dict', key='category')
category_list = root.accept('list', key='category')
category_list.accept('choice').accept_choices(CATEGORIES['browse'])
for category in CATEGORIES:
categories.accept('choice', key=category).accept_choices(CATEGORIES[category])
categories.accept('boolean', key=category)
categories.accept('number', key=category)
category_list = categories.accept('list', key=category)
category_list.accept('choice', key=category).accept_choices(CATEGORIES[category])
category_list.accept('number', key=category)
return root
def validator(self):
root = validator.factory()
root.accept('text')
root.accept('boolean')
presets = root.accept('list')
presets.accept('text')
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('path')
bundle = root.accept('list')
bundle.accept('path')
return root
def validator(self):
from flexget import validator
root = validator.factory('choice')
root.accept_choices(['misc', 'movies', 'audio', 'tv', 'games', 'apps', 'pics', 'anime', 'comics',
'books', 'music video', 'unclassified', 'all'])
return root
def validator(self):
"""Validate given configuration"""
from flexget import validator
thetvdb = validator.factory('dict')
thetvdb.accept('number', key='min_series_rating')
thetvdb.accept('number', key='min_episode_rating')
thetvdb.accept('integer', key='min_episode_air_year')
thetvdb.accept('integer', key='max_episode_air_year')
thetvdb.accept('number', key='min_episode_runtime')
thetvdb.accept('number', key='max_episode_runtime')
thetvdb.accept('list', key='reject_content_rating').accept('text')
thetvdb.accept('list', key='accept_content_rating').accept('text')
thetvdb.accept('list', key='accept_network').accept('text')
thetvdb.accept('list', key='reject_network').accept('text')
thetvdb.accept('list', key='reject_genres').accept('text')
thetvdb.accept('list', key='reject_status').accept('text')
thetvdb.accept('list', key='reject_languages').accept('text')
thetvdb.accept('list', key='accept_languages').accept('text')
thetvdb.accept('list', key='accept_actors').accept('text')
thetvdb.accept('list', key='reject_actors').accept('text')
thetvdb.accept('list', key='accept_writers').accept('text')
thetvdb.accept('list', key='reject_writers').accept('text')
thetvdb.accept('list', key='accept_directors').accept('text')
thetvdb.accept('list', key='reject_directors').accept('text')
return thetvdb
def validator(self):
from flexget import validator
config = validator.factory('dict')
config.accept('url', key='url', required=True)
values = config.accept('dict', key='values', required=True)
values.accept_any_key('integer')
return config
def validator(self):
from flexget import validator
config = validator.factory("dict")
config.accept("text", key="apikey", required=True)
config.accept("text", key="device", required=True)
config.accept("text", key="title", required=False)
config.accept("text", key="body", required=False)
return config
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('choice', key='category').accept_choices(
['all', 'movies', 'tv', 'music', 'books', 'xxx', 'other'])
root.accept('boolean', key='verified')
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('list',
key='dvds').accept('choice').accept_choices(self.dvd_lists)
root.accept('list', key='movies').accept('choice').accept_choices(
self.movie_lists)
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('url')
complex = root.accept('dict')
complex.accept('url', key='url')
complex.accept('boolean', key='reverse')
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('boolean')
advanced = root.accept('dict')
advanced.accept('boolean', key='year')
advanced.accept('boolean', key='quality')
return root
def validator(self):
root = validator.factory()
advanced = root.accept("dict")
advanced.accept("text", key="username")
advanced.accept("text", key="password")
advanced.accept("integer", key="limit")
advanced.accept("any", key="fields")
return root
def validator(self):
"""Return config validator"""
root = validator.factory()
root.accept('boolean')
advanced = root.accept('dict')
self._validator(advanced)
advanced.accept('boolean', key='onlycomplete')
return root
def test_dict(self):
dv = validator.factory('dict')
dv.accept('dict', key='foo')
result = dv.validate({'foo': {}})
assert not dv.errors.messages, 'should have passed foo'
assert result, 'invalid result for foo'
result = dv.validate({'bar': {}})
assert dv.errors.messages, 'should not have passed bar'
assert not result, 'should have an invalid result for bar'
# Test validation of dictionary keys
dv = validator.factory('dict')
dv.accept_valid_keys('dict', key_type='number')
result = dv.validate({3: {}})
assert not dv.errors.messages, 'should have passed 3'
assert result, 'invalid result for key 3'
# Json schema cannot do key validation
"""result = dv.validate({'three': {}})
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('boolean')
root.accept('integer')
advanced = root.accept('dict')
advanced.accept('integer', key='min_seeds')
advanced.accept('interval', key='reject_for')
return root
def validator(self):
from flexget import validator
config = validator.factory('dict')
config.accept('text', key='require')
config.accept('list', key='require').accept('text')
config.accept('text', key='reject')
config.accept('list', key='reject').accept('text')
config.accept('boolean', key='strict')
return config
def validator(self):
from flexget import validator
subs = validator.factory('dict')
langs = subs.accept('list', key='languages')
langs.accept('text')
subs.accept('number', key='min_sub_rating')
subs.accept('number', key='match_limit')
subs.accept('path', key='output')
return subs
def validator(self):
""" Our configuration model.
"""
root = validator.factory()
root.accept("boolean")
root.accept("choice").accept_choices(self.SCRUB_MODES,
ignore_case=True)
root.accept("list").accept("text") # list of keys to scrub
return root
def root_config_validator():
"""Returns a validator for the 'presets' key of config."""
# TODO: better error messages
valid_plugins = [p for p in all_plugins if hasattr(all_plugins[p].instance, 'validator')]
root = validator.factory('dict')
root.reject_keys(valid_plugins, message='plugins should go under a specific preset. '
'(and presets are not allowed to be named the same as any plugins)')
root.accept_any_key('dict').accept_any_key('any')
return root
def validator(self):
from flexget import validator
config = validator.factory()
config.accept('boolean')
advanced = config.accept('dict')
advanced.accept('text', key='title_template')
advanced.accept('text', key='item_template')
advanced.accept('integer', key='timeout')
return config
def validator(self):
from flexget import validator
root = validator.factory()
valid_plugins = root.accept('list').accept('dict')
for plugin_name in get_plugin_keywords():
plugin = get_plugin_by_name(plugin_name)
if plugin.api_ver > 1 and hasattr(plugin.instance, 'validator'):
valid_plugins.accept(plugin.instance.validator, key=plugin_name)
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('file')
cookies = root.accept('dict')
cookies.accept('file', key='file', required=True)
cookies.accept('choice', key='type').accept_choices(
['firefox3', 'mozilla', 'lwp'])
return root
def validator(self):
from flexget import validator
root = validator.factory()
# Accept yes to just turn on
root.accept('boolean')
options = root.accept('dict')
self.build_options_validator(options)
options.accept('boolean', key='allow_seasonless')
return root
def validator(self):
root = validator.factory()
root.accept('boolean')
advanced = root.accept('dict')
advanced.accept('choice', key='category').accept_choices(CATEGORIES)
advanced.accept('integer', key='category')
advanced.accept('choice', key='sort_by').accept_choices(SORT)
advanced.accept('boolean', key='sort_reverse')
return root
def validator(self):
"""Return config validator"""
root = validator.factory()
root.accept('boolean')
advanced = root.accept('dict')
self._validator(advanced)
advanced.accept('number', key='min_ratio')
advanced.accept('interval', key='finished_for')
return root
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('text')
complex = root.accept('dict')
# TODO: accept a list of fields.
complex.accept('text', key='field')
complex.accept('boolean', key='reverse')
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('url', key='url', required=True)
root.accept('text', key='username', required=True)
root.accept('text', key='password', required=True)
root.accept('text', key='userfield')
root.accept('text', key='passfield')
return root
def validator(self):
from flexget import validator
root = validator.factory('choice')
root.accept_choices([
'misc', 'movies', 'audio', 'tv', 'games', 'apps', 'pics', 'anime',
'comics', 'books', 'music video', 'unclassified', 'all'
])
return root
def validator(self):
"""Return config validator."""
root = validator.factory('dict')
root.accept('url', key='url', required=False)
root.accept('url', key='website', required=False)
root.accept('text', key='apikey', required=False)
root.accept('choice', key='category', required=True).accept_choices(
['movie', 'tvsearch', 'tv', 'music', 'book'])
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('path', key='path', required=True)
root.accept('list', key='path').accept('path')
root.accept('text', key='mask')
root.accept('regexp', key='regexp')
root.accept('boolean', key='recursive')
return root
def validator(self):
from flexget import validator
root = validator.factory('dict')
root.accept('regexp_match', key='user_id').\
accept(USER_ID_RE, message='user_id must be in the form urXXXXXXX')
root.accept('text', key='username')
root.accept('text', key='password')
root.accept('text', key='list', required=True)
return root
def validator(self):
from flexget.validator import factory
root = factory('dict')
root.accept('list', key='fields', required=True).accept('text')
root.accept('choice', key='action', required=True).accept_choices(['accept', 'reject'])
inputs = root.accept('list', key='from', required=True)
add_plugin_validators(inputs, phase='input')
return root
def validator(self):
'''validator'''
from flexget import validator
d = validator.factory('dict')
d.accept('text', key='username')
d.accept('text', key='password')
d.accept('text', key='path')
d.accept('list', key='messages').accept('text')
return d
def validator(self):
from flexget import validator
config = validator.factory('dict')
config.accept('text', key='url', required=True)
config.accept('text', key='category')
config.accept('integer', key='priority')
config.accept('boolean', key='top')
return config
def validator(self):
from flexget import validator
root = validator.factory()
root.accept('choice').accept_choices(CATEGORIES)
advanced = root.accept('dict')
advanced.accept('choice', key='category').accept_choices(CATEGORIES)
advanced.accept('choice', key='filter').accept_choices(FILTERS)
return root
def validator(self):
from flexget import validator
config = validator.factory('dict')
config.accept('text', key='apikey', required=True)
config.accept('text', key='application')
config.accept('text', key='event')
config.accept('integer', key='priority')
config.accept('text', key='description')
return config
