def test_types(self):
with pytest.raises(fields.MarshallingError):
class WrongType:
pass
x = WrongType()
field1 = fields.Wildcard(WrongType) # noqa
field2 = fields.Wildcard(x) # noqa
def test_marshal_wildcard_with_skip_none(self):
wild = fields.Wildcard(fields.String)
model = OrderedDict([('foo', fields.Raw), ('*', wild)])
marshal_dict = OrderedDict([('foo', None), ('bat', None),
('baz', 'biz'), ('bar', None)])
output = marshal(marshal_dict, model, skip_none=True)
assert output == {'baz': 'biz'}
def test_marshal_wildcard_nested(self):
nest = fields.Nested(
OrderedDict([('thumbnail', fields.String),
('video', fields.String)]))
wild = fields.Wildcard(nest)
wildcard_fields = OrderedDict([('*', wild)])
model = OrderedDict([('preview', fields.Nested(wildcard_fields))])
sub_dict = OrderedDict([('9:16', {
'thumbnail': 24,
'video': 12
}), ('16:9', {
'thumbnail': 25,
'video': 11
}), ('1:1', {
'thumbnail': 26,
'video': 10
})])
marshal_dict = OrderedDict([('preview', sub_dict)])
output = marshal(marshal_dict, model)
assert output == {
'preview': {
'1:1': {
'thumbnail': '26',
'video': '10'
},
'16:9': {
'thumbnail': '25',
'video': '11'
},
'9:16': {
'thumbnail': '24',
'video': '12'
}
}
}
class GetSubmissionTextsDto:
api = Namespace('get submission texts',
description='submission-specific get operations')
status = api.model(
'Status', {
'status': fields.String(description="Request status"),
'message':
fields.String(description="Message describing the status")
})
tags = {'*': fields.Wildcard(fields.String)}
token = {
"word": fields.String(description='original word'),
"lemma": fields.String(description='lemma of original word'),
"tags": fields.Nested(tags)
}
tokens = {
"tokens":
fields.List(cls_or_instance=fields.Nested(token),
description='list of tokens')
}
sentences = {
"sentences":
fields.List(cls_or_instance=fields.Nested(tokens),
description='list of sentences')
}
text_fields = {
'text_id':
fields.Integer(description='text identifier'),
'processing_complete':
fields.Boolean(
description='Boolean indicating if text has been processed'),
'raw_text':
fields.String(description='Original text input'),
'processed_text':
fields.Nested(sentences)
}
submission_fields = {
'submission_id':
fields.Integer(description='submission identifier'),
'text_count':
fields.Integer(
description='number indicating the amount of texts in submission'),
'submitted_date':
fields.DateTime(description='date of submission'),
'tags':
fields.List(cls_or_instance=fields.String(),
description='submission tags')
}
get_submission_texts = api.inherit(
'get submission texts', status, {
'submission': fields.Nested(submission_fields, default=dict()),
'texts': fields.List(cls_or_instance=fields.Nested(text_fields))
})
def test_defaults(self):
field = fields.Wildcard(fields.String)
assert not field.required
assert field.__schema__ == {
'type': 'object',
'additionalProperties': {
'type': 'string'
}
}
def test_list_of_raw(self):
field = fields.Wildcard(fields.Raw)
data = [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]
expected = [OrderedDict([('a', 1), ('b', 1)]),
OrderedDict([('a', 2), ('b', 1)]),
OrderedDict([('a', 3), ('b', 1)])]
self.assert_field(field, data, expected)
data = [1, 2, 'a']
self.assert_field(field, data, data)
def test_marshal_wildcard_list(self):
wild = fields.Wildcard(fields.List(fields.String))
wildcard_fields = OrderedDict([('*', wild)])
model = OrderedDict([('preview', fields.Nested(wildcard_fields))])
sub_dict = OrderedDict([('1:1', [1, 2, 3]), ('16:9', [4, 5, 6]),
('9:16', [7, 8, 9])])
marshal_dict = OrderedDict([('preview', sub_dict)])
output = marshal(marshal_dict, model)
assert output == {
'preview': {
'9:16': ['7', '8', '9'],
'16:9': ['4', '5', '6'],
'1:1': ['1', '2', '3']
}
}
def test_clone(self, api):
wild1 = fields.Wildcard(fields.String)
wild2 = wild1.clone()
wild_fields1 = api.model('cloneWildcard1', {'*': wild1})
wild_fields2 = api.model('cloneWildcard2', {'*': wild2})
data = {'John': 12, 'bob': 42, 'Jane': '68'}
expected1 = {'John': '12', 'bob': '42', 'Jane': '68'}
result1 = api.marshal(data, wild_fields1)
result2 = api.marshal(data, wild_fields2)
assert expected1 == result1
assert result2 == result1
def test_with_scoped_attribute_on_dict_or_obj(self):
class Test(object):
def __init__(self, data):
self.data = data
class Nested(object):
def __init__(self, value):
self.value = value
nesteds = [Nested(i) for i in ['a', 'b', 'c']]
test_obj = Test(nesteds)
test_dict = {'data': [{'value': 'a'}, {'value': 'b'}, {'value': 'c'}]}
field = fields.Wildcard(fields.String(attribute='value'), attribute='data')
assert ['a' == 'b', 'c'], field.output('whatever', test_obj)
assert ['a' == 'b', 'c'], field.output('whatever', test_dict)
def test_marshal_wildcard_with_envelope(self):
wild = fields.Wildcard(fields.String)
model = OrderedDict([('foo', fields.Raw), ('*', wild)])
marshal_dict = OrderedDict([('foo', {
'bat': 'baz'
}), ('a', 'toto'), ('b', 'tata')])
output = marshal(marshal_dict, model, envelope='hey')
assert output == {
'hey': {
'a': 'toto',
'b': 'tata',
'foo': {
'bat': 'baz'
}
}
}
class StatePredict:
api = Namespace('state_predict', description='Model for detecting the current state of the mission.')
prediction_dto = api.model('Prediction', {
'cur_state': fields.String(required=True, description='The current state'),
'message': fields.String(required=True, description='The message generating the prediction'),
'message_index': fields.Integer(default=-1, description='The message index within the chat stream'),
'predictions': fields.Wildcard(fields.Float)
})
payload_model = api.model('Payload', {
'domain_name': fields.String(required=True, description=''),
'message': fields.String(required=True, description='')
})
state_payload = reqparse.RequestParser(bundle_errors=True)
state_payload.add_argument('domain_name', help='The name of the domain to predict against')
state_payload.add_argument('message', help='The message to predict on', location="json")
class TextDto:
api = Namespace('text', description='Text-related operations')
status = api.model(
'status', {
'status': fields.String(description="request status"),
'message': fields.String(description="status message")
})
tags = {'*': fields.Wildcard(fields.String)}
token = {
"word": fields.String(description='original word'),
"lemma": fields.String(description='lemma of original word'),
"tags": fields.Nested(tags)
}
tokens = {
"tokens":
fields.List(cls_or_instance=fields.Nested(token),
description='list of tokens')
}
sentences = {
"sentences":
fields.List(cls_or_instance=fields.Nested(tokens),
description='list of sentences')
}
text = api.inherit(
'text_details', status, {
'id':
fields.Integer(description='public id of text'),
'submitted_date':
fields.DateTime(description='Time text was submitted'),
'processing_complete':
fields.Boolean(
description='indicates if text is processed or not'),
'raw_text':
fields.String(description="raw submitted text"),
'processed_text':
fields.Nested(sentences, default=dict())
})
def test_wildcard(self, api):
wild1 = fields.Wildcard(fields.String)
wild2 = fields.Wildcard(fields.Integer)
wild3 = fields.Wildcard(fields.String)
wild4 = fields.Wildcard(fields.String, default='x')
wild5 = fields.Wildcard(fields.String)
wild6 = fields.Wildcard(fields.Integer)
wild7 = fields.Wildcard(fields.String)
wild8 = fields.Wildcard(fields.String)
mod5 = OrderedDict()
mod5['toto'] = fields.Integer
mod5['bob'] = fields.Integer
mod5['*'] = wild5
wild_fields1 = api.model('WildcardModel1', {'*': wild1})
wild_fields2 = api.model('WildcardModel2', {'j*': wild2})
wild_fields3 = api.model('WildcardModel3', {'*': wild3})
wild_fields4 = api.model('WildcardModel4', {'*': wild4})
wild_fields5 = api.model('WildcardModel5', mod5)
wild_fields6 = api.model(
'WildcardModel6', {
'nested': {
'f1': fields.String(default='12'),
'f2': fields.Integer(default=13)
},
'a*': wild6
})
wild_fields7 = api.model('WildcardModel7', {'*': wild7})
wild_fields8 = api.model('WildcardModel8', {'*': wild8})
class Dummy(object):
john = 12
bob = '42'
alice = None
class Dummy2(object):
pass
class Dummy3(object):
a = None
b = None
data = {'John': 12, 'bob': 42, 'Jane': '68'}
data3 = Dummy()
data4 = Dummy2()
data5 = {'John': 12, 'bob': 42, 'Jane': '68', 'toto': '72'}
data6 = {'nested': {'f1': 12, 'f2': 13}, 'alice': '14'}
data7 = Dummy3()
data8 = None
expected1 = {'John': '12', 'bob': '42', 'Jane': '68'}
expected2 = {'John': 12, 'Jane': 68}
expected3 = {'john': '12', 'bob': '42'}
expected4 = {'*': 'x'}
expected5 = {'John': '12', 'bob': 42, 'Jane': '68', 'toto': 72}
expected6 = {'nested': {'f1': '12', 'f2': 13}, 'alice': 14}
expected7 = {}
expected8 = {}
result1 = api.marshal(data, wild_fields1)
result2 = api.marshal(data, wild_fields2)
result3 = api.marshal(data3, wild_fields3, skip_none=True)
result4 = api.marshal(data4, wild_fields4)
result5 = api.marshal(data5, wild_fields5)
result6 = api.marshal(data6, wild_fields6)
result7 = api.marshal(data7, wild_fields7, skip_none=True)
result8 = api.marshal(data8, wild_fields8, skip_none=True)
assert expected1 == result1
assert expected2 == result2
assert expected3 == result3
assert expected4 == result4
assert expected5 == result5
assert expected6 == result6
assert expected7 == result7
assert expected8 == result8
"Identifica se a requisição foi processada com sucesso ou se houveram erros",
example="success",
default="success"),
"error":
fields.String(
required=False,
description=
"Se o status for diferente de \"success\" esse campo irá conter uma mensagem amigavel "
+ "sobre o erro ocorrido",
example=
"Ops, Houve um erro desconhecido no servidor, se o erro persistir, contate o suporte"
),
"messages":
fields.Wildcard(
fields.String,
required=False,
description=
"Se o status for \"validation_error\" esse campo irá conter as mensagens de erro de validação"
)
}
def make_response_model(model: dict) -> dict:
updated_model = model.copy()
updated_model.update(default_response_model)
return updated_model
##### TASKS MODELS #####
get_tasks_response_model = {
"total":
fields.Integer(
from flask_restplus import fields
from weakref import WeakSet
class AnyNotNullField(fields.Raw):
__schema_type__ = 'any'
def format(self, value):
if not isinstance(value, WeakSet):
return value
class ForbiddenField(fields.Raw):
__schema_type__ = 'any'
def format(self, value):
return
# ==================== Wildcard fields =======================
wild_any_fields = fields.Wildcard(AnyNotNullField,
description="other fields",
skip_none=False,
allow_null=False)
wild_forbid_fields = fields.Wildcard(ForbiddenField,
description="forbidden fields for output")
'Lname': 'Zimmerman'
}, {
'Fname': 'Jeremy',
'Lname': 'Leininger'
}]
MAP_KEY_EXAMPLE = [{"Fname": "FirstName"}, {"Lname": "LastName"}]
api = Namespace(
'basic-map',
description=
'Maps one JSON Object to another JSON Object based off of a map key')
basic_input = api.model(
'Basic Input', {
'input_data':
fields.List(fields.Wildcard(fields.String),
example=INPUT_DATA_EXAMPLE),
'map_key':
fields.List(fields.Wildcard(fields.String), example=MAP_KEY_EXAMPLE)
})
@api.route('/')
class BasicMap(Resource):
@api.expect(basic_input)
@api.doc('basic_map')
def post(self):
#print(request.json)
input_list = request.json['input_data']
map_key = request.json['map_key']
- DETACHED_PROCESS
- CREATE_DEFAULT_ERROR_MODE
- CREATE_BREAKAWAY_FROM_JOB"""),
'cwd':
fields.String(
required=False,
default=None,
example=".",
description=
"""If cwd is not None, the function changes the working directory to cwd before executing the child. cwd can be a string, bytes or path-like object. In particular, the function looks for executable (or for the first item in args) relative to cwd if the executable path is a relative path."""
),
'env':
fields.Wildcard(
fields.String,
required=False,
default={},
example={},
description=
"""If env is not None, it must be a mapping that defines the environment variables for the new process; these are used instead of the default behavior of inheriting the current process' environment."""
),
'restore_signals':
fields.Boolean(
required=False,
default=True,
example=True,
description=
"""If restore_signals is true (the default) all signals that Python has set to SIG_IGN are restored to SIG_DFL in the child process before the exec. Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals. (POSIX only)"""
),
'start_new_session':
fields.Boolean(
required=False,
default=False,
ast.literal_eval(args[self.PAGE_KEY]) if args[self.PAGE_KEY] is not None else None
, args[self.PAGE_SIZE])
except Exception as e:
print(f'Exception occured during getPagedArchive {e}')
return 'Internal Server Error', 500
return marshal(result, multiArchiveMetadata), 200
singleArchiveMetadata = archive.model('singleArchiveMetadata', {
'id': fields.String,
'thumbnailUrl': fields.String,
'title': fields.String
})
multiArchiveMetadata = archive.model('multiArchiveMetadata', {
'nextPageKey': fields.Wildcard(fields.String),
'archives': fields.List(fields.Nested(singleArchiveMetadata))
})
@archive.route('/<string:id>',
doc={
"deprecated": True
})
class getArchive(Resource):
def get(self, id):
print(f'archive item - id {id}')
try:
# TODO : Need DI for Archive, not creating dynamically
description="Name of the model",
help="Name cannot be blank."),
'version':
fields.String(required=True,
description="Version of the model",
help="Name cannot be blank."),
'format':
fields.String(required=True,
description="Format of the model",
help="Name cannot be blank."),
'author':
fields.String(required=True,
description="Author of the model",
help="Name cannot be blank."),
'metrics':
fields.Wildcard(fields.String),
'customProperties':
fields.Wildcard(fields.String)
})
model_signature_parameter = api.model(
'ModelSignatureParameter', {
'name':
fields.String(required=True,
description="Name of the model",
help="Name cannot be blank."),
'order':
fields.String(required=True,
description="Version of the model",
help="Name cannot be blank."),
'type':
+
'while a lower scores could mean missing data or generalization. When a match score is '
+
'below the match_threshold of the chatbot, a no_answer is given by the chatbot.'
),
})
chatbot_statistics_dict = api.model(
'Chatbot Statistics per day', {
'*':
fields.Wildcard(
fields.Nested(chatbot_statistics),
example={
'user_count': 5,
'session_count': 7,
'total_msg_count': 63,
'bot_msg_count': 30,
'user_msg_count': 21,
'accuracy': 84.75,
'match_score': 0.77239636
},
description='The chatbot statistics for a specific day')
})
suggestion = api.model(
'Suggestion', {
'text':
fields.String(readOnly=True,
example='How much does TV Plus cost?',
description='The text'),
'score':
fields.Float(readOnly=True,
# urlmap
m_secprofilemap = api.model(
"Security Profile Map", {
"name": fields.String(required=True),
"match": fields.String(required=True),
"acl_profile": fields.String(required=True),
"acl_active": fields.Boolean(required=True),
"waf_profile": fields.String(required=True),
"waf_active": fields.Boolean(required=True),
"limit_ids": fields.List(fields.Raw()),
})
m_map = api.model("Security Profile Map",
{"*": fields.Wildcard(fields.Nested(m_secprofilemap))})
m_urlmap = api.model(
"URL Map", {
"id": fields.String(required=True),
"name": fields.String(required=True),
"match": fields.String(required=True),
"map": fields.List(fields.Nested(m_secprofilemap)),
})
# wafrule
m_wafrule = api.model(
"WAF Rule", {
"id": fields.String(required=True),
"name": fields.String(required=True),
# urlmap
m_secprofilemap = api.model("Security Profile Map", {
"name": fields.String(required=True),
"match": fields.String(required=True),
"acl_profile": fields.String(required=True),
"acl_active": fields.Boolean(required=True),
"waf_profile": fields.String(required=True),
"waf_active": fields.Boolean(required=True),
"limit_ids": fields.List(fields.Raw()),
})
m_map = api.model("Security Profile Map", {
"*": fields.Wildcard(fields.Nested(m_secprofilemap))
})
m_urlmap = api.model("URL Map", {
"id": fields.String(required=True),
"name": fields.String(required=True),
"match": fields.String(required=True),
"map": fields.List(fields.Nested(m_secprofilemap)),
})
# wafsig
m_wafsig = api.model("WAF Signature", {
"id": fields.String(required=True),
"name": fields.String(required=True),
"msg": fields.String(required=True),
from apps.api.profile.controllers import member_api
entity = member_api.model('Entity', {'id': fields.Integer})
basic_profile = member_api.model(
'BasicProfile',
{
'real_name': fields.String,
'gender': fields.String,
# 'birthday': fields.String
})
extra_profile = member_api.model('ExtraProfile', {
'profile_category': fields.String,
'*': fields.Wildcard(fields.String)
})
user_profile = member_api.clone(
'UserProfile', entity, {
'user_type': fields.String,
'user_name': fields.String,
'user_status': fields.String,
})
member_profile = member_api.clone(
'MemberProfile', user_profile, {
'basic_profile': fields.Nested(basic_profile),
'extra_profile': fields.List(fields.Nested(extra_profile))
})
