def dict_check(
self,
path, # type: PathType
left_dict, # type: typing.Union[NoValue, typing.Mapping[typing.Text, typing.Any]]
right_dict, # type: typing.Union[NoValue, typing.Mapping[typing.Text, typing.Any]]
):
# type: (...) -> typing.Iterable[PathType]
if determine_object_type(
left_dict) == ObjectType.PARAMETER or determine_object_type(
right_dict) == ObjectType.PARAMETER:
return (path, )
else:
return ()
def get_properties(swagger_spec, schema):
# type: (Spec, typing.Optional[typing.Mapping[typing.Text, typing.Any]]) -> typing.Optional[typing.Set[typing.Text]]
if schema is None or determine_object_type(schema) != ObjectType.SCHEMA:
return None
required, not_required = get_collapsed_properties_type_mappings(
definition=schema, deref=swagger_spec.deref)
return set(chain(iterkeys(required), iterkeys(not_required)))
def _bless_models(container, json_reference, visited_models, swagger_spec):
"""
Callback used during the swagger spec ingestion process to add
``x-model`` attribute to models which does not define it.
The callbacks is in charge of adding MODEL_MARKER in case a model
(identifies as an object of type SCHEMA) has enough information for
determining a model name (ie. has ``title`` attribute defined)
INFO: Implementation detail.
Respect ``collect_models`` this callback gets executed on the model_spec's parent container.
This is needed because this callback could modify (adding MODEL_MARKER) the model_spec;
performing this operation when the container represents model_spec will generate errors
because we're iterating over an object that gets mutated by the callback.
:param container: container being visited
:param json_reference: URI of the current container
:type json_reference: str
:type visited_models: dict (k,v) == (model_name, path)
:type swagger_spec: :class:`bravado_core.spec.Spec`
"""
if not is_dict_like(container):
return
key = json_reference.split('/')[-1]
deref = swagger_spec.deref
model_spec = deref(container.get(key))
if (
not is_dict_like(model_spec) or
not is_object(swagger_spec, model_spec, no_default_type=True) or
# NOTE: determine_object_type uses a simple heuristic to determine if a model_spec has a SCHEMA type
# for this reason is important that model_spec is recognized as model in the most accurate way
# so we should not rely on default typing of a schema
determine_object_type(model_spec) != ObjectType.SCHEMA or
deref(model_spec.get(MODEL_MARKER)) is not None
):
return
model_name = _get_model_name(model_spec)
if not model_name:
return
_register_visited_model(
json_reference=json_reference,
model_spec=model_spec,
model_name=model_name,
visited_models=visited_models,
is_blessed=True,
swagger_spec=swagger_spec,
)
def descend(self, value):
if is_ref(value):
# Update spec_resolver scope to be able to dereference relative specs from a not root file
with in_scope(self.spec_resolver, value):
uri, deref_value = self.resolve(value['$ref'])
object_type = determine_object_type(
object_dict=deref_value,
default_type_to_object=self.default_type_to_object,
)
known_mapping_key = object_type.get_root_holder()
if known_mapping_key is None:
return self.descend(value=deref_value)
else:
uri = urlparse(uri)
if uri not in self.known_mappings.get(
known_mapping_key, {}):
# The placeholder is present to interrupt the recursion
# during the recursive traverse of the data model (``descend``)
self.known_mappings[known_mapping_key][uri] = None
self.known_mappings[known_mapping_key][
uri] = self.descend(value=deref_value)
return {
'$ref':
'#/{}/{}'.format(known_mapping_key,
self.marshal_uri(uri))
}
elif is_dict_like(value):
return {
key: self.descend(value=subval)
for key, subval in iteritems(value)
}
elif is_list_like(value):
return [
self.descend(value=subval)
for index, subval in enumerate(value)
]
else:
return value
def descend(value):
if is_ref(value):
uri, deref_value = resolve(value['$ref'])
# Update spec_resolver scope to be able to dereference relative specs from a not root file
with in_scope(spec_resolver, {'x-scope': [uri]}):
object_type = determine_object_type(object_dict=deref_value)
if object_type.get_root_holder() is None:
return descend(value=deref_value)
else:
mapping_key = object_type.get_root_holder(
) or 'definitions'
uri = urlparse(uri)
if uri not in known_mappings.get(mapping_key, {}):
# The placeholder is present to interrupt the recursion
# during the recursive traverse of the data model (``descend``)
known_mappings[mapping_key][uri] = None
known_mappings[mapping_key][uri] = descend(
value=deref_value)
return {
'$ref': '#/{}/{}'.format(mapping_key, marshal_uri(uri))
}
elif is_dict_like(value):
return {
key: descend(value=subval)
for key, subval in iteritems(value)
}
elif is_list_like(value):
return [
descend(value=subval) for index, subval in enumerate(value)
]
else:
return value
def test_determine_object_type(default_type_to_object, object_dict, expected_object_type):
assert determine_object_type(object_dict, default_type_to_object) == expected_object_type
def test_determine_object_type(object_dict, expected_object_type):
assert determine_object_type(object_dict) == expected_object_type
