def __post_init__(self):
if self.sentry_enable and not self.sentry_dsn:
raise Invalid('sentry_dsn is required when sentry_enable=True')
if self.smtp_enable:
if not self.smtp_host:
raise Invalid('smtp_host is required when smtp_enable=True')
if not self.smtp_port:
raise Invalid('smtp_port is required when smtp_enable=True')
scheduler_extra_networks = self._parse_scheduler_extra_networks()
self.registery_node_spec = {
'name': 'scheduler',
'modules': ['scheduler'],
'networks': [{
'name': self.scheduler_network,
'url': self.scheduler_url,
}] + scheduler_extra_networks
}
self.current_node_spec = {
'name': '{}@{}'.format(LOCAL_NODE_NAME, os.getpid()),
'modules': [],
'networks': [{
'name': self.scheduler_network,
'url': None,
}]
}
def validate(value):
if not isinstance(value, bytes):
raise Invalid('invalid bytes type')
if maxlen is not None:
if len(value) > maxlen:
raise Invalid('value must <= {}'.format(maxlen))
return value
def validate_loglevel(value):
try:
value = value.upper()
except Exception:
raise Invalid(f"Invalid log level {value!r}")
if value not in _LOG_LEVELS:
raise Invalid(f"Unknown log level {value!r}")
return value
def validator(value):
try:
i = int(value)
except:
raise Invalid("invalid int")
if i % 2 == 0:
return i
else:
raise Invalid("not even number")
def test_exception_position():
ex = Invalid('invalid').mark_index(0).mark_key('key')
assert ex.position == 'key[0]'
assert ex.position in str(ex)
assert ex.message in str(ex)
ex = Invalid('invalid').mark_key('key').mark_index(0)
assert ex.position == '[0].key'
assert ex.position in str(ex)
assert ex.message in str(ex)
def validate(value):
try:
value = parse_interval(value)
except (IndexError, KeyError, ValueError):
raise Invalid("invalid interval") from None
if value < min:
raise Invalid("interval must >= {}".format(min))
if value > max:
raise Invalid("interval must <= {}".format(max))
return value
def test_exception_str():
ex = Invalid('invalid').mark_index(0).mark_key('key')
assert str(ex) == 'invalid in key[0]'
ex = Invalid().mark_index(0).mark_key('key')
assert str(ex) == 'in key[0]'
ex = Invalid('invalid')
assert str(ex) == 'invalid'
ex = Invalid()
assert str(ex) == ''
def validate(value):
if default_schema:
value = coerce_url(value, default_schema=default_schema)
try:
_django_validate_url(value)
except ValidationError:
# TODO: access ValidationError.messages will cause error when
# django/i18n not setup, maybe use validators package instead
# raise Invalid(','.join(ex.messages).rstrip('.'))
raise Invalid('invalid or incorrect url format')
if len(value) > maxlen:
raise Invalid(f'url length must <= {maxlen}')
return value
def test_exception_position():
e = Invalid('invalid').mark_key('key')
assert e.position == 'key'
e = Invalid('invalid').mark_index(0)
assert e.position == '[0]'
e = Invalid('invalid').mark_index()
assert e.position == '[]'
e = Invalid('invalid').mark_key('key').mark_index(0).mark_index()
assert e.position == '[][0].key'
e = Invalid('invalid').mark_index().mark_index(0).mark_key('key')
assert e.position == 'key[0][]'
def _parse_story_volumes(cls, text: str):
"""
Format:
{volume}:{user}:{password}@{host}:{port}/{db}/{table}
>>> volumes = EnvConfig._parse_story_volumes('0:user:password@host:5432/db/table')
>>> expect = {0: dict(
... user='******', password='******',
... host='host', port=5432, db='db', table='table'
... )}
>>> volumes == expect
True
"""
re_volume = re.compile(
r'^(\d+)\:([^:@/]+)\:([^:@/]+)\@([^:@/]+)\:(\d+)\/([^:@/]+)\/([^:@/]+)$'
)
volumes = {}
for part in text.split(','):
match = re_volume.match(part)
if not match:
raise Invalid(f'invalid story volume {part!r}')
volume = int(match.group(1))
volumes[volume] = dict(
user=match.group(2),
password=match.group(3),
host=match.group(4),
port=int(match.group(5)),
db=match.group(6),
table=match.group(7),
)
return volumes
def choice_validator(value, *choices):
try:
if value in choices:
return value
except:
pass
raise Invalid('invalid choice')
def test_deprecated():
from validr.validators import builtin_validators # noqa
from validr.validators import build_re_validator # noqa
from validr.schema import MarkIndex, MarkKey # noqa
with pytest.warns(DeprecationWarning):
try:
with MarkIndex([1, 2, 3]):
raise Invalid('test')
except Invalid:
pass
with pytest.warns(DeprecationWarning):
try:
with MarkKey('key'):
raise Invalid('test')
except Invalid:
pass
def validate(value):
if value is True:
return Detail(True, exclude_fields=set(), all_fields=all_fields)
if value is False:
return Detail(False,
exclude_fields=extra_fields,
all_fields=all_fields)
try:
true_false, select_fields_list, include_fields_list, exclude_fields_list = \
_parse_detail_value(value)
except InvalidDetailValue as ex:
raise Invalid(str(ex)) from None
if true_false is True:
return Detail(True, exclude_fields=set(), all_fields=all_fields)
if true_false is False:
return Detail(False,
exclude_fields=extra_fields,
all_fields=all_fields)
if select_fields_list is not None:
exclude_fields = all_fields - set(select_fields_list)
else:
exclude_fields = set(extra_fields)
if include_fields_list is not None:
exclude_fields -= set(include_fields_list)
if exclude_fields_list is not None:
exclude_fields |= all_fields & set(exclude_fields_list)
detail = not extra_fields.issubset(exclude_fields)
return Detail(detail,
exclude_fields=exclude_fields,
all_fields=all_fields)
def __post_init__(self):
if self.sentry_enable and not self.sentry_dsn:
raise Invalid('sentry_dsn is required when sentry_enable=True')
if self.smtp_enable:
if not self.smtp_host:
raise Invalid('smtp_host is required when smtp_enable=True')
if not self.smtp_port:
raise Invalid('smtp_port is required when smtp_enable=True')
scheduler_extra_networks = self._parse_scheduler_extra_networks()
self.registery_node_spec = {
'name':
'scheduler',
'modules': ['scheduler'],
'networks': [{
'name': self.scheduler_network,
'url': self.scheduler_url,
}] + scheduler_extra_networks
}
self.current_node_spec = {
'name': '{}@{}'.format(LOCAL_NODE_NAME, os.getpid()),
'modules': [],
'networks': [{
'name': self.scheduler_network,
'url': None,
}]
}
if self.pg_story_volumes:
volumes = self._parse_story_volumes(self.pg_story_volumes)
else:
volumes = {
0:
dict(
user=self.pg_user,
password=self.pg_password,
host=self.pg_host,
port=self.pg_port,
db=self.pg_db,
table='story_volume_0',
)
}
self.pg_story_volumes_parsed = volumes
self.github_standby_configs_parsed = self._parse_github_standby_configs(
)
def validate(value):
try:
if isinstance(value, str):
value = unionid.decode(value)
if output_object:
return tuple_class(*value)
else:
return unionid.encode(*value)
except (unionid.UnionIdError, TypeError, ValueError) as ex:
raise Invalid('invalid unionid, {}'.format(str(ex))) from ex
def _parse_github_standby_configs(self):
configs = {}
items = (self.github_standby_configs or '').strip().split(';')
for item in filter(None, items):
parts = item.split(',')
if len(parts) != 3:
raise Invalid('invalid github standby configs')
domain, client_id, secret = parts
configs[domain] = GitHubConfigModel(domain=domain,
client_id=client_id,
secret=secret)
return configs
def validate(value):
try:
if not isinstance(value, datetime.datetime):
value = parse_datetime(value)
if value is None:
raise Invalid('not well formatted datetime')
if not timezone.is_aware(value):
value = timezone.make_aware(value, timezone=timezone.utc)
# https://bugs.python.org/issue13305
if value.year < 1000:
raise Invalid('not support datetime before year 1000')
if value.year > 2999:
raise Invalid('not support datetime after year 2999')
if output_object:
return value
else:
return value.strftime(format)
except Invalid:
raise
except Exception as ex:
raise Invalid('invalid datetime') from ex
def _parse_scheduler_extra_networks(self):
if not self.scheduler_extra_networks:
return []
networks = []
for part in self.scheduler_extra_networks.strip().split(','):
part = part.split('@', maxsplit=1)
if len(part) != 2:
raise Invalid('invalid scheduler_extra_networks')
name, url = part
networks.append(dict(name=name, url=url))
networks = validate_extra_networks(networks)
return list(networks)
def validate(value):
try:
if isinstance(value, list) and len(value) == 9:
value = tuple(value)
if isinstance(value, tuple):
value = datetime.datetime.fromtimestamp(time.mktime(value),
tz=timezone.utc)
elif not isinstance(value, datetime.datetime):
value = parse_datetime(value)
if value is None:
raise Invalid('not well formatted datetime')
if not timezone.is_aware(value):
value = timezone.make_aware(value, timezone=timezone.utc)
# https://bugs.python.org/issue13305
if value.year < 1000:
raise Invalid('not support datetime before 1000-01-01')
if output_object:
return value
else:
return value.strftime(format)
except Invalid:
raise
except Exception as ex:
raise Invalid('invalid datetime') from ex
def validate(value):
try:
if not isinstance(value, Cursor):
if base64:
value = urlsafe_b64decode(value.encode('ascii')).decode('utf-8')
value = Cursor.from_string(value, keys)
else:
value._check_missing_keys(keys)
except (UnicodeEncodeError, UnicodeDecodeError, ValueError) as ex:
raise Invalid(str(ex)) from None
if output_object:
return value
value = str(value)
if base64:
value = urlsafe_b64encode(value.encode('utf-8')).decode()
return value
def validate(value):
if value in choices:
return value
raise Invalid('invalid choice')
def test_mark_index():
with mark_index(0):
raise Invalid('invalid')
def test_mark_index_uncertainty():
with mark_index():
raise Invalid('invalid')
def test_mark_key():
with mark_key('key'):
raise Invalid('invalid')
def test_mark_key_index():
with mark_key('key'):
with mark_index(0):
with mark_index():
raise Invalid('invalid')
def validator(value):
if value in 'ABCD':
return value
raise Invalid('invalid choice')
def test_exception_message():
assert Invalid('invalid').message == 'invalid'
assert Invalid().message is None
def validate(value):
if value in items:
return value
raise Invalid('value must be one of {}'.format(items))