tiramisu-api-python/tiramisu_json_api/api.py

808 lines
29 KiB
Python
Raw Normal View History

2018-12-24 09:28:44 +01:00
from typing import Optional, Dict, List, Any
import warnings
import re
from .error import APIError, ValueWarning, ValueOptionError, ValueErrorWarning, PropertiesOptionError
from .setting import undefined
from .i18n import _
2019-01-10 09:54:22 +01:00
2018-12-24 09:28:44 +01:00
2019-01-16 16:38:32 +01:00
TYPE = {'boolean': bool,
'number': int,
2019-01-19 10:54:18 +01:00
'string': str,
'password': str,
'domain': str}
2019-01-16 16:38:32 +01:00
2018-12-24 09:28:44 +01:00
class Option:
2019-01-10 09:54:22 +01:00
# fake Option (IntOption, StrOption, ...)
2019-01-19 10:54:18 +01:00
# only usefull for warnings
2018-12-24 09:28:44 +01:00
def __init__(self,
path):
self.path = path
def __call__(self):
2019-02-05 07:01:22 +01:00
# suppose to be a weakref
2018-12-24 09:28:44 +01:00
return self
def impl_getpath(self):
return self.path
class TiramisuOptionOption:
2019-01-10 09:54:22 +01:00
# config.option(path).option
2018-12-24 09:28:44 +01:00
def __init__(self,
path: str,
2019-01-10 09:54:22 +01:00
schema: Dict,
2019-01-18 14:15:05 +01:00
model: Dict,
form: Dict) -> None:
2018-12-24 09:28:44 +01:00
self._path = path
self.schema = schema
2019-01-10 09:54:22 +01:00
self.model = model
2019-01-18 14:15:05 +01:00
self.form = form
2018-12-24 09:28:44 +01:00
def doc(self):
return self.schema['title']
def path(self):
return self._path
2019-01-18 14:15:05 +01:00
def name(self,
follow_symlink: bool=False) -> str:
if not follow_symlink or \
self.isoptiondescription() or \
not self.issymlinkoption():
path = self._path
else:
path = self.schema['opt_path']
return path.rsplit('.', 1)[-1]
2019-01-10 09:54:22 +01:00
2018-12-24 09:28:44 +01:00
def isoptiondescription(self):
return self.schema['type'] in ['object', 'array']
def ismasterslaves(self):
return self.schema['type'] == 'array'
def issymlinkoption(self) -> bool:
2019-01-18 14:15:05 +01:00
return self.schema['type'] == 'symlink'
2018-12-24 09:28:44 +01:00
def ismulti(self) -> bool:
return self.schema.get('isMulti', False)
def type(self) -> str:
if self.ismasterslaves():
return 'masterslaves'
if self.isoptiondescription():
return 'optiondescription'
types = {'number': 'int',
'choice': 'choice',
'boolean': 'bool',
'password': 'password',
'date': 'date',
'domain': 'domainname',
'url': 'url',
'username': 'username',
2019-01-18 14:15:05 +01:00
'string': 'str',
'symlink': 'symlink'}
2018-12-24 09:28:44 +01:00
if self.schema['type'] in types :
return types[self.schema['type']]
raise Exception('unsupported type {}'.format(self.schema['type']))
2019-01-10 09:54:22 +01:00
def properties(self) -> List[str]:
props = []
2019-01-16 17:45:44 +01:00
model = self.model.get(self._path, {})
2019-01-10 09:54:22 +01:00
if model.get('required'):
#FIXME 'empty', 'needs_len'
props.append('mandatory')
if model.get('readOnly'):
props.append('frozen')
2019-02-05 07:01:22 +01:00
if self.config.get_hidden(this._path):
2019-01-10 09:54:22 +01:00
props.append('hidden')
2019-01-17 09:40:52 +01:00
if self.form.get(self._path, {}).get('clearable'):
props.append('clearable')
2019-01-10 09:54:22 +01:00
return props
def requires(self) -> None:
# FIXME
return None
2018-12-24 09:28:44 +01:00
class TiramisuOptionProperty:
2019-01-10 09:54:22 +01:00
# config.option(path).property
2018-12-24 09:28:44 +01:00
def __init__(self,
2019-02-05 07:01:22 +01:00
path: str,
2018-12-24 09:28:44 +01:00
model: Dict) -> None:
2019-02-05 07:01:22 +01:00
self.path = path
2018-12-24 09:28:44 +01:00
self.model = model
2019-01-10 09:54:22 +01:00
def get(self, only_raises=False):
2018-12-24 09:28:44 +01:00
# FIXME if slave:
#if not isslave and childapi.option.ismulti():
# if 'empty' in props:
# obj['required'] = True
# props.remove('empty')
# if 'mandatory' in props:
# obj['needs_len'] = True
# props.remove('mandatory')
2019-01-10 09:54:22 +01:00
if not only_raises:
properties = self.model.get('properties', [])[:]
if self.model.get('required', False):
properties.append('mandatory')
if self.model.get('readOnly', False):
properties.append('frozen')
else:
properties = []
2019-02-05 07:01:22 +01:00
if self.config.get_hidden(self.path)
2018-12-24 09:28:44 +01:00
properties.append('hidden')
return properties
2019-01-10 09:54:22 +01:00
class _Value:
def _dict_walk(self,
ret: Dict,
schema: Dict,
root: str,
fullpath: bool,
withwarning: bool):
for key, option in schema['properties'].items():
hidden = self.temp.get(key, {}).get('hidden', None)
model_hidden = not self.model.get(key, {}).get('hidden', False) and \
self.model.get(key, {}).get('display', True)
if hidden is False or (hidden is None and model_hidden):
if option['type'] == 'object':
self._dict_walk(ret,
option,
root,
fullpath,
withwarning)
else:
2019-02-05 07:01:22 +01:00
value = self.config.get_value(key, schema)
2019-01-10 09:54:22 +01:00
self._display_warnings(key, value, option['type'], option['name'], withwarning)
ret[key] = value
def dict(self,
fullpath: bool=False,
withwarning: bool=False):
ret = {}
self._dict_walk(ret,
self.schema,
self.path,
fullpath,
withwarning)
return ret
2018-12-24 09:28:44 +01:00
2019-01-10 09:54:22 +01:00
def _display_warnings(self, path, value, type, name, withwarning=True):
2019-02-05 07:01:22 +01:00
for err in self.model.get(path, {}).get('error', []):
warnings.warn_explicit(ValueOptionError(value,
type,
Option(path),
'{0}'.format(err)),
ValueErrorWarning,
self.__class__.__name__, 0)
2018-12-24 09:28:44 +01:00
2019-01-10 09:54:22 +01:00
if withwarning and self.model.get(path, {}).get('warnings'):
2018-12-24 09:28:44 +01:00
for warn in self.model.get(path, {}).get('warnings'):
2019-02-05 07:01:22 +01:00
# FIXME ValueWarning needs value and type attribute!
2018-12-24 09:28:44 +01:00
warnings.warn_explicit(ValueWarning('{0}'.format(warn),
2019-02-05 07:01:22 +01:00
Option(path)),
2018-12-24 09:28:44 +01:00
ValueWarning,
self.__class__.__name__, 0)
2019-01-10 09:54:22 +01:00
2019-01-16 09:29:01 +01:00
class TiramisuOptionOwner:
# config.option(path).owner
def __init__(self,
config: 'Config',
schema: Dict,
model: List[Dict],
form: List[Dict],
temp: List[Dict],
path: str,
index: int) -> None:
self.config = config
self.schema = schema
self.model = model
self.form = form
self.temp = temp
self.path = path
self.index = index
def isdefault(self) -> Any:
2019-02-05 07:01:22 +01:00
return self.config.get_owner(self.path) == 'default'
2019-01-16 09:29:01 +01:00
2019-01-10 09:54:22 +01:00
class TiramisuOptionValue(_Value):
# config.option(path).value
def __init__(self,
config: 'Config',
schema: Dict,
model: List[Dict],
form: List[Dict],
temp: List[Dict],
path: str,
index: int) -> None:
self.config = config
self.schema = schema
self.model = model
self.form = form
self.temp = temp
self.path = path
self.index = index
2018-12-24 09:28:44 +01:00
def get(self) -> Any:
2019-02-05 07:01:22 +01:00
value = self.config.get_value(self.path, self.schema)
2018-12-24 09:28:44 +01:00
self._display_warnings(self.path, value, self.schema['type'], self.schema['name'])
return value
def list(self):
return self.schema['enum']
2019-01-19 10:54:18 +01:00
def _validate(self, type_, value):
if value in [None, undefined]:
return
if type_ == 'choice':
2019-01-16 16:38:32 +01:00
if value not in self.schema['enum']:
raise Exception('value {} is not in {}'.format(value, self.schema['enum']))
2019-01-19 10:54:18 +01:00
elif not isinstance(value, TYPE[type_]):
raise Exception('value {} is not a valid {} '.format(value, type_))
def set(self, value):
type_ = self.schema['type']
if self.schema.get('isMulti', False):
if not isinstance(value, list):
raise Exception('value must be a list')
for val in value:
self._validate(type_, val)
else:
self._validate(type_, value)
2019-02-05 07:01:22 +01:00
remote = self.form.get(self.path, {}).get('remote', False)
2018-12-24 09:28:44 +01:00
self.config.modify_value(self.path,
self.index,
value,
2019-02-05 07:01:22 +01:00
remote)
2019-01-19 10:54:18 +01:00
self._display_warnings(self.path, value, type_, self.schema['name'])
2018-12-24 09:28:44 +01:00
def reset(self):
2019-02-05 07:01:22 +01:00
remote = self.form.get(self.path, {}).get('remote', False)
2018-12-24 09:28:44 +01:00
self.config.delete_value(self.path,
self.index,
2019-02-05 07:01:22 +01:00
remote)
2018-12-24 09:28:44 +01:00
2019-01-10 09:54:22 +01:00
class _Option:
def list(self,
type='option'):
if type not in ['all', 'option']:
raise NotImplementedError()
for path, schema in self.schema['properties'].items():
if type == 'all' or schema['type'] not in ['object', 'array']:
hidden = self.temp.get(path, {}).get('hidden', None)
model_hidden = not self.model.get(path, {}).get('hidden', False) and \
self.model.get(path, {}).get('display', True)
if hidden is False or (hidden is None and model_hidden is True):
2019-01-10 09:54:22 +01:00
if schema['type'] in ['object', 'array']:
yield TiramisuOptionDescription(self.config,
schema,
self.model,
self.form,
self.temp,
path)
else:
yield TiramisuOption(self.config,
schema,
self.model,
self.form,
self.temp,
path,
self.index)
class TiramisuOptionDescription(_Option):
# config.option(path) (with path == OptionDescription)
def __init__(self,
config: 'Config',
schema: Dict,
model: List[Dict],
form: List[Dict],
temp: List[Dict],
path: str) -> None:
self.config = config
self.schema = schema
self.model = model
self.form = form
self.temp = temp
self.path = path
self.index = None
def __getattr__(self,
subfunc: str) -> Any:
if subfunc == 'option':
return TiramisuOptionOption(self.path,
self.schema,
2019-01-18 14:15:05 +01:00
self.model,
self.form)
2019-01-10 09:54:22 +01:00
if subfunc == 'property':
2019-02-05 07:01:22 +01:00
return TiramisuOptionProperty(self.path,
self.model.get(self.path, {}))
2019-01-19 10:54:18 +01:00
if subfunc == 'value':
return TiramisuOptionValue(self.config,
self.schema,
self.model,
self.form,
self.temp,
self.path,
self.index)
2019-01-10 09:54:22 +01:00
raise APIError(_('please specify a valid sub function ({})').format(subfunc))
def group_type(self):
2019-01-19 10:54:18 +01:00
hidden = self.temp.get(self.path, {}).get('hidden', None)
model_hidden = not self.model.get(self.path, {}).get('hidden', False) and \
self.model.get(self.path, {}).get('display', True)
if hidden is False or (hidden is None and model_hidden):
2019-01-10 09:54:22 +01:00
# FIXME
return 'default'
raise PropertiesOptionError(None, None, None, opt_type='optiondescription')
2018-12-24 09:28:44 +01:00
class TiramisuOption:
2019-01-10 09:54:22 +01:00
# config.option(path) (with path == Option)
2018-12-24 09:28:44 +01:00
def __init__(self,
config: 'Config',
schema: Dict,
model: List[Dict],
form: List[Dict],
temp: List[Dict],
path: str,
index: Optional[int]) -> None:
self.config = config
self.schema = schema
self.model = model
self.form = form
self.temp = temp
self.path = path
self.index = index
def __getattr__(self,
subfunc: str) -> Any:
if subfunc == 'option':
if self.index != None:
raise NotImplementedError()
return TiramisuOptionOption(self.path,
2019-01-10 09:54:22 +01:00
self.schema,
2019-01-18 14:15:05 +01:00
self.model,
self.form)
2018-12-24 09:28:44 +01:00
if subfunc == 'value':
return TiramisuOptionValue(self.config,
self.schema,
self.model,
self.form,
self.temp,
self.path,
self.index)
2019-01-16 09:29:01 +01:00
if subfunc == 'owner':
return TiramisuOptionOwner(self.config,
self.schema,
self.model,
self.form,
self.temp,
self.path,
self.index)
2018-12-24 09:28:44 +01:00
if subfunc == 'property':
if self.index != None:
raise NotImplementedError()
2019-02-05 07:01:22 +01:00
return TiramisuOptionProperty(self.path,
self.model.get(self.path, {}))
2018-12-24 09:28:44 +01:00
raise APIError(_('please specify a valid sub function ({})').format(subfunc))
class TiramisuContextProperty:
2019-01-10 09:54:22 +01:00
# config.property
2018-12-24 09:28:44 +01:00
# def __init__(self,
# json):
# self.json = json
def get(self):
# FIXME ?
return ['demoting_error_warning']
2019-01-10 09:54:22 +01:00
class ContextOption(_Option):
# config.option
def __init__(self,
config: 'Config',
model: Dict,
form: Dict,
schema: Dict,
temp: Dict) -> None:
self.config = config
self.model = model
self.form = form
2019-02-05 07:01:22 +01:00
self.schema = {'properties': schema}
2019-01-10 09:54:22 +01:00
self.temp = temp
def __call__(self,
path: str,
index: Optional[int]=None) -> TiramisuOption:
schema = self.config.get_schema(path)
if schema['type'] in ['object', 'array']:
return TiramisuOptionDescription(self.config,
schema,
self.model,
self.form,
self.temp,
path)
2019-01-10 09:54:22 +01:00
return TiramisuOption(self.config,
schema,
2019-01-10 09:54:22 +01:00
self.model,
self.form,
self.temp,
path,
index)
class ContextValue(_Value):
# config.value
def __init__(self,
config: 'Config',
model: Dict,
form: Dict,
schema: Dict,
temp: Dict) -> None:
self.config = config
self.model = model
self.form = form
first = next(iter(schema.keys()))
self.path = first.rsplit('.', 1)[0]
2019-01-16 17:45:44 +01:00
self.schema = {'properties': schema}
2019-01-10 09:54:22 +01:00
self.temp = temp
def __call__(self) -> TiramisuOptionValue:
return TiramisuOptionValue(self.config,
self.schema,
self.model,
self.form,
self.temp,
path,
index)
2019-01-16 17:45:44 +01:00
def mandatory(self):
for key, value in self.dict().items():
if self.model.get(key, {}).get('required') and \
value is None or \
(self.schema.get('isMulti') and (None in value or '' in value)):
yield key
2019-01-10 09:54:22 +01:00
2018-12-24 09:28:44 +01:00
class Config:
2019-01-10 09:54:22 +01:00
# config
2018-12-24 09:28:44 +01:00
def __init__(self,
json):
self.model_ori = json['model']
self.model = {option['key']: option for option in json['model']}
self.form = {}
for option in json['form']:
2019-02-05 07:01:22 +01:00
if 'key' in option:
2018-12-24 09:28:44 +01:00
if 'pattern' in option:
option['pattern'] = re.compile(option['pattern'])
self.form[option['key']] = option
self.temp = {}
self.schema = json['schema']
self.updates = []
2019-01-10 09:54:22 +01:00
first_path = next(iter(self.schema.keys()))
if '.' in first_path:
self.root = first_path.rsplit('.', 1)[0]
else:
self.root = ''
2018-12-24 09:28:44 +01:00
def __getattr__(self,
subfunc: str) -> Any:
if subfunc == 'property':
return TiramisuContextProperty()
2019-01-10 09:54:22 +01:00
if subfunc == 'option':
return ContextOption(self,
self.model,
self.form,
self.schema,
self.temp)
if subfunc == 'value':
return ContextValue(self,
self.model,
self.form,
self.schema,
self.temp)
2018-12-24 09:28:44 +01:00
raise APIError(_('please specify a valid sub function ({})').format(subfunc))
def add_value(self,
path: str,
index: Optional[int],
value: Any,
remote: bool) -> None:
self.updates_value('add',
path,
index,
value,
remote,
None)
def modify_value(self,
path: str,
index: Optional[int],
value: Any,
remote: bool) -> None:
schema = self.get_schema(path)
if value and isinstance(value, list) and value[-1] is undefined:
new_value = schema.get('defaultvalue')
if new_value is None:
len_value = len(value)
2019-02-05 07:01:22 +01:00
schema_value = schema.get('value', [])
if len(schema_value) >= len_value:
new_value = schema_value[len_value - 1]
2018-12-24 09:28:44 +01:00
value[-1] = new_value
self.updates_value('modify',
path,
index,
value,
remote,
None)
def delete_value(self,
path: str,
index: Optional[int],
remote: bool) -> None:
schema = self.get_schema(path)
2019-01-16 09:29:01 +01:00
value = schema.get('value');
2018-12-24 09:28:44 +01:00
if value is None and schema.get('isMulti', False):
value = []
self.updates_value('delete',
path,
index,
value,
remote,
None)
def get_schema(self,
path):
2019-01-10 09:54:22 +01:00
root_path = self.root
2019-01-19 10:54:18 +01:00
schema = {'properties': self.schema,
'type': 'object'}
2019-01-10 09:54:22 +01:00
if root_path:
root = self.root.split('.')
2019-02-05 07:01:22 +01:00
if not path.startswith(root):
raise Exception('cannot find {0}'.format(path))
2019-01-10 09:54:22 +01:00
subpaths = path.split('.')[len(root):]
2018-12-24 09:28:44 +01:00
else:
subpaths = path.split('.')
for subpath in subpaths:
if root_path:
root_path += '.' + subpath
else:
root_path = subpath
schema = schema['properties'][root_path]
2018-12-24 09:28:44 +01:00
return schema
2019-02-05 07:01:22 +01:00
def get_hidden(self,
path: str) -> bool:
property_ = 'hidden'
if property_ in self.temp.get(path, {}):
value = self.temp[path][property_]
else:
value = self.model.get(path, {}).get(property_)
return value
def get_value(self,
path: str,
schema: Dict) -> Any:
if 'value' in self.temp.get(path, {}):
value = self.temp[path]['value']
else:
value = self.model.get(path, {}).get('value')
if value is None and schema.get('isMulti', False):
value = []
return value
2018-12-24 09:28:44 +01:00
2019-02-05 07:01:22 +01:00
def get_owner(self,
path: str) -> str:
if 'owner' in self.temp.get(path, {}):
owner = self.temp[path]['owner']
else:
owner = self.model.get(path, {}).get('owner', 'default')
return owner
2018-12-24 09:28:44 +01:00
def updates_value(self,
action: str,
path: str,
index: Optional[int],
value: Optional[Any],
remote: bool,
masterslaves: Optional[str]) -> None:
update_last_action = False
if self.updates:
last_body = self.updates[-1]
if last_body['name'] == path:
2019-02-05 07:01:22 +01:00
if index is None and not 'index' in last_body:
2018-12-24 09:28:44 +01:00
last_action = last_body['action']
if last_action == action or \
last_action in ['delete', 'modify'] and action in ['delete', 'modify']:
update_last_action = True
elif index == None and action == 'delete':
for update in reversed(self.updates):
if masterslaves == None and update['name'] == path or \
masterslaves and path.startswith(masterslaves + '.'):
del self.updates[-1]
else:
break
elif last_body['index'] == index:
if last_body['action'] == 'add' and action == 'modify':
action = 'add'
update_last_action = True
elif last_body['action'] == action and action != 'delete' or \
last_body['action'] == 'modify' and action == 'delete':
update_last_action = True
elif last_body['action'] == 'add' and action == 'delete':
2019-01-10 09:54:22 +01:00
del self.updates[-1]
2018-12-24 09:28:44 +01:00
if update_last_action:
if value is None:
if 'value' in last_body:
del last_body['value']
else:
last_body['value'] = value
if index is None and 'index' in last_body:
del last_body['index']
last_body['action'] = action
else:
data = {'action': action,
'name': path}
if value is not None:
data['value'] = value
if index is not None:
data['index'] = index
self.updates.append(data)
if 'pattern' in self.form.get(path, {}) and (not isinstance(value, list) or undefined not in value):
match = self.test_value(path, value, remote)
else:
match = True
if match:
if remote:
ret = self.send_data({'updates': self.updates,
'model': self.model_ori})
self.updates = []
self.temp.clear()
# FIXME remove old key ?
for model in ret['model']:
self.model[model['key']] = model
self.model_ori = ret['model']
else:
self.temp.setdefault(path, {})['owner'] = 'tmp'
self.temp[path]['value'] = value
self.set_dependencies(path, value)
2018-12-24 09:28:44 +01:00
self.set_not_equal(path, value)
self.do_copy(path, value)
def test_value(self,
path: str,
value: Any,
remote: bool):
if isinstance(value, list):
for val in value:
if not self.test_value(path, val, remote):
return False
return True
else:
if value is None:
match = True
else:
match = self.form[path]['pattern'].search(value)
if not remote:
if not match:
self.temp.setdefault(path, {})['error'] = ['']
elif 'error' in self.model[path]:
del self.temp[path]['error']
return match
def set_dependencies(self,
path: str,
2019-02-05 07:01:22 +01:00
ori_value: Any,
force_hide: bool=False) -> None:
2018-12-24 09:28:44 +01:00
dependencies = self.form.get(path, {}).get('dependencies', {})
if dependencies:
2019-02-05 07:01:22 +01:00
if ori_value in dependencies['expected']:
expected = dependencies['expected'][ori_value]
2018-12-24 09:28:44 +01:00
else:
expected = dependencies['default']
for action in ['hide', 'show']:
expected_actions = expected.get(action)
if expected_actions:
if force_hide:
hidden = True
else:
hidden = action == 'hide'
2018-12-24 09:28:44 +01:00
for expected_path in expected_actions:
self.temp.setdefault(expected_path, {})['hidden'] = hidden
2019-02-05 07:01:22 +01:00
if 'value' in self.temp[expected_path]:
value = self.temp[expected_path]['value']
else:
value = self.model[expected_path].get('value')
self.set_dependencies(expected_path, value, hidden)
2018-12-24 09:28:44 +01:00
def set_not_equal(self,
path: str,
value: Any) -> None:
not_equal = self.form.get(path, {}).get('not_equal', {})
if not_equal:
vals = []
opts = []
if isinstance(value, list):
for val in value:
vals.append(val)
opts.append(path)
else:
vals.append(value)
opts.append(path)
for path_ in self.form[path]['not_equal']['options']:
schema = self.get_schema(path_)
2019-02-05 07:01:22 +01:00
p_value = self.get_value(path_, schema)
2018-12-24 09:28:44 +01:00
if isinstance(p_value, list):
for val in p_value:
vals.append(val)
opts.append(path_)
else:
vals.append(p_value)
opts.append(path_)
equal = []
warnings_only = self.form[path]['not_equal'].get('warnings', False)
if warnings_only:
msg = _('should be different from the value of "{}"')
msgcurr = _('value for {} should be different')
else:
msg = _('must be different from the value of "{}"')
msgcurr = _('value for {} must be different')
for idx_inf, val_inf in enumerate(vals):
for idx_sup, val_sup in enumerate(vals[idx_inf + 1:]):
if val_inf == val_sup is not None:
for opt_ in [opts[idx_inf], opts[idx_inf + idx_sup + 1]]:
if opt_ not in equal:
equal.append(opt_)
if equal:
equal_name = {}
for opt in equal:
schema = self.get_schema(opt)
equal_name[opt] = schema['title']
for opt_ in equal:
display_equal = []
for opt__ in equal:
if opt_ != opt__:
display_equal.append(equal_name[opt_])
display_equal = ', '.join(display_equal)
if opt_ == path:
msg_ = msgcurr.format(display_equal)
else:
msg_ = msg.format(display_equal)
if warnings_only:
self.model[opt_].setdefault('warnings', []).append(msg_)
else:
self.model[opt_].setdefault('error', []).append(msg_)
else:
for opt in opts:
if 'warnings' in self.model[opt]:
del self.model[opt]['warnings']
if 'error' in self.model[opt]:
del self.model[opt]['error']
def do_copy(self,
path: str,
value: Any) -> None:
copy = self.form.get(path, {}).get('copy')
if copy:
for opt in copy:
2019-02-05 07:01:22 +01:00
owner = self.get_owner(opt)
2018-12-24 09:28:44 +01:00
if owner == 'default':
2019-02-05 07:01:22 +01:00
# do not change in this.temp, it's default value
2018-12-24 09:28:44 +01:00
self.model[opt]['value'] = value
def send_data(self,
updates):
raise NotImplementedError('please implement send_data function')