def data(self, values):
"""
Set plain dictionary object which are suitable for OpenTMI backend
:param values:
:return:
"""
data = remove_empty_from_dict(values)
def has_attribute(ref, key):
"""
Validates that attribute key has in ref
:param ref: Object
:param key: String
:return: None
:raise KeyError: if does not exists
"""
if not hasattr(ref, key):
raise KeyError("Key '{}' does not exists".format(key))
def fnc(value, path):
"""
mapper function
:param value: Value to be set
:param path: array of nested path
:return:
"""
ref = self
for key in path[0:-1]:
has_attribute(ref, key)
ref = getattr(ref, key)
key = path[-1]
has_attribute(ref, key)
setattr(ref, key, value)
map_values_deep(data, fnc)
def available_metrics_tuples(self):
result = set()
for entry in self.result.values():
py_.map_values_deep(entry,
lambda __, path: result.add(tuple(path)))
return sorted(result)
def data(self):
"""
Get plain Dictionary object which are suitable for OpenTMI backend
:return: Dictionary containsi whole data
"""
data = map_values_deep(
self._data, lambda x: x.data if isinstance(x, BaseApi) else x)
return remove_empty_from_dict(data)
def put(self):
data = request.get_json(force=True)
objToPut = []
for item in data['body']:
filters = self.makeFilter(item)
item = omit(item, ['_id', 'updated_at'])
item = map_values_deep(item, updaterIds)
objToPut.append({'filter': filters, 'data': item})
return self.entity().batch_process(objToPut)
def post(self):
valid = syncValidate().validate()
if valid:
try:
query = json.loads(valid['query'])
body = json.loads(valid['body'])
entity = valid['entity']
except Exception as error:
return FactoryInvalid.responseInvalid({'msg': str(error)}, 422)
query = map_values_deep(query, updaterIds)
return {
'results': Model(name=entity).updateMany(query, body)
}
def post(self):
valid = aggregateValidate().validate()
if valid:
try:
pipeline = json.loads(valid['pipeline'])
entity = valid['entity']
except Exception as error:
return FactoryInvalid.responseInvalid({'msg': str(error)}, 422)
if not has(pipeline, '[0].$match.roles\._id'):
return FactoryInvalid.responseInvalid(
{
'msg':
'Must delimite $match which roles._id ($match {role.id})'
}, 422)
args = map_values_deep(pipeline, updaterIds)
return {'items': Aggregate(entity).pipeline(args)}
def test_map_values_deep(case, expected):
assert _.map_values_deep(*case) == expected
def opts_update_from_env(opts):
return map_values_deep(opts, lambda x: resolve_env(x, prefix='env/'))