def checker(ontology):
modelname_checker = FormatChecker()
# Pass the ontology object as a closure
modelname_checker.checks("modelname",
raises=ValidationError)(is_modelname(ontology))
# Returns the checker after configuring it
return modelname_checker
def test_it_can_register_checkers(self):
checker = FormatChecker()
checker.checks("new")(self.fn)
self.assertEqual(
checker.checkers,
dict(FormatChecker.checkers, new=(self.fn, ()))
)
def test_validate_with_format(app, db):
"""Test that validation can accept custom format rules."""
with app.app_context():
checker = FormatChecker()
checker.checks("foo")(lambda el: el.startswith("foo"))
data = {"bar": "foo", "$schema": {"properties": {"bar": {"format": "foo"}}}}
# test record creation with valid data
assert data == Record.create(data)
record = Record.create(data, format_checker=checker)
# test direct call to validate with valid data
assert record.validate(format_checker=checker) is None
# test commit with valid data
record.commit(format_checker=checker)
record["bar"] = "bar"
# test direct call to validate with invalid data
with pytest.raises(ValidationError) as excinfo:
record.validate(format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
# test commit with invalid data
with pytest.raises(ValidationError) as excinfo:
record.commit(format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
data["bar"] = "bar"
# test record creation with invalid data
with pytest.raises(ValidationError) as excinfo:
record = Record.create(data, format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
def test_it_can_register_checkers(self):
checker = FormatChecker()
checker.checks("new")(self.fn)
self.assertEqual(
checker.checkers,
dict(FormatChecker.checkers, new=(self.fn, ()))
)
def test_it_can_register_checkers(self):
checker = FormatChecker()
checker.checks("boom")(boom)
self.assertEqual(
checker.checkers,
dict(FormatChecker.checkers, boom=(boom, ()))
)
def test_it_can_register_checkers(self):
checker = FormatChecker()
checker.checks("boom")(boom)
self.assertEqual(
checker.checkers,
dict(FormatChecker.checkers, boom=(boom, ()))
)
def test_repr(self):
checker = FormatChecker(formats=())
checker.checks("foo")(lambda thing: True)
checker.checks("bar")(lambda thing: True)
checker.checks("baz")(lambda thing: True)
self.assertEqual(
repr(checker),
"<FormatChecker checkers=['bar', 'baz', 'foo']>",
)
def is_valid_json(data, schema):
checker = FormatChecker()
# add the "interval" format
checker.checks("interval")(parse_iso8601_interval)
validator = Draft4Validator(schema, format_checker=checker)
errors = []
for error in validator.iter_errors(data):
errors.append(error.message)
return errors
def is_valid_json(data, schema):
checker = FormatChecker();
# add the "interval" format
checker.checks("interval")(parse_iso8601_interval)
validator = Draft4Validator(schema, format_checker=checker)
errors = []
for error in validator.iter_errors(data):
errors.append(error.message)
return errors
def test_format_error_causes_become_validation_error_causes(self):
checker = FormatChecker()
checker.checks("boom", raises=ValueError)(boom)
validator = Draft4Validator({"format": "boom"}, format_checker=checker)
with self.assertRaises(ValidationError) as cm:
validator.validate("BOOM")
self.assertIs(cm.exception.cause, BOOM)
self.assertIs(cm.exception.__cause__, BOOM)
def test_format_error_causes_become_validation_error_causes(self):
checker = FormatChecker()
checker.checks("foo", raises=ValueError)(self.fn)
cause = self.fn.side_effect = ValueError()
validator = Draft4Validator({"format": "foo"}, format_checker=checker)
with self.assertRaises(ValidationError) as cm:
validator.validate("bar")
self.assertIs(cm.exception.__cause__, cause)
def test_format_error_causes_become_validation_error_causes(self):
checker = FormatChecker()
checker.checks("foo", raises=ValueError)(self.fn)
cause = self.fn.side_effect = ValueError()
validator = Draft4Validator({"format": "foo"}, format_checker=checker)
with self.assertRaises(ValidationError) as cm:
validator.validate("bar")
self.assertIs(cm.exception.__cause__, cause)
def test_format_error_causes_become_validation_error_causes(self):
checker = FormatChecker()
checker.checks("boom", raises=ValueError)(boom)
validator = Draft4Validator({"format": "boom"}, format_checker=checker)
with self.assertRaises(ValidationError) as cm:
validator.validate("BOOM")
self.assertIs(cm.exception.cause, BOOM)
self.assertIs(cm.exception.__cause__, BOOM)
def test_invalid_format_default_message(self):
checker = FormatChecker(formats=())
check_fn = mock.Mock(return_value=False)
checker.checks("thing")(check_fn)
schema = {"format" : "thing"}
message = self.message_for("bla", schema, format_checker=checker)
self.assertIn(repr("bla"), message)
self.assertIn(repr("thing"), message)
self.assertIn("is not a", message)
def test_invalid_format_default_message(self):
checker = FormatChecker(formats=())
check_fn = mock.Mock(return_value=False)
checker.checks(u"thing")(check_fn)
schema = {u"format": u"thing"}
message = self.message_for("bla", schema, format_checker=checker)
self.assertIn(repr("bla"), message)
self.assertIn(repr("thing"), message)
self.assertIn("is not a", message)
def test_it_catches_registered_errors(self):
checker = FormatChecker()
checker.checks("boom", raises=type(BOOM))(boom)
with self.assertRaises(FormatError) as cm:
checker.check(instance=12, format="boom")
self.assertIs(cm.exception.cause, BOOM)
self.assertIs(cm.exception.__cause__, BOOM)
# Unregistered errors should not be caught
with self.assertRaises(type(BANG)):
checker.check(instance="bang", format="boom")
def test_it_catches_registered_errors(self):
checker = FormatChecker()
checker.checks("boom", raises=type(BOOM))(boom)
with self.assertRaises(FormatError) as cm:
checker.check(instance=12, format="boom")
self.assertIs(cm.exception.cause, BOOM)
self.assertIs(cm.exception.__cause__, BOOM)
# Unregistered errors should not be caught
with self.assertRaises(type(BANG)):
checker.check(instance="bang", format="boom")
def test_invalid_format_default_message(self):
checker = FormatChecker(formats=())
checker.checks(u"thing")(lambda value: False)
schema = {u"format": u"thing"}
message = self.message_for(
instance="bla",
schema=schema,
format_checker=checker,
)
self.assertIn(repr("bla"), message)
self.assertIn(repr("thing"), message)
self.assertIn("is not a", message)
def test_it_catches_registered_errors(self):
checker = FormatChecker()
checker.checks("foo", raises=ValueError)(self.fn)
# Registered errors should be caught and turned into FormatErrors
cause = ValueError()
self.fn.side_effect = cause
with self.assertRaises(FormatError) as cm:
checker.check("bar", "foo")
# Original exception should be attached to cause attribute
self.assertIs(cm.exception.cause, cause)
# Unregistered errors should not be caught
self.fn.side_effect = AttributeError
with self.assertRaises(AttributeError):
checker.check("bar", "foo")
def test_it_catches_registered_errors(self):
checker = FormatChecker()
cause = self.fn.side_effect = ValueError()
checker.checks("foo", raises=ValueError)(self.fn)
with self.assertRaises(FormatError) as cm:
checker.check("bar", "foo")
self.assertIs(cm.exception.cause, cause)
self.assertIs(cm.exception.__cause__, cause)
# Unregistered errors should not be caught
self.fn.side_effect = AttributeError
with self.assertRaises(AttributeError):
checker.check("bar", "foo")
def test_it_catches_registered_errors(self):
checker = FormatChecker()
cause = self.fn.side_effect = ValueError()
checker.checks("foo", raises=ValueError)(self.fn)
with self.assertRaises(FormatError) as cm:
checker.check("bar", "foo")
self.assertIs(cm.exception.cause, cause)
self.assertIs(cm.exception.__cause__, cause)
# Unregistered errors should not be caught
self.fn.side_effect = AttributeError
with self.assertRaises(AttributeError):
checker.check("bar", "foo")
def handle(self):
components = urlparse(self.args.schema)
if components.scheme == 'file':
with open(self.args.schema[7:]) as f:
schema = json_load(f)
else:
schema = requests.get(self.args.schema).json()
format_checker = FormatChecker()
if self.args.check_urls:
def check_url(instance):
# See https://github.com/Julian/jsonschema/blob/master/jsonschema/_format.py
if not isinstance(instance, str_types):
return True
rfc3987.parse(instance, rule='URI') # raises ValueError
try:
response = requests.get(instance,
timeout=self.args.timeout)
result = response.status_code in (200, )
if not result:
print('HTTP {} on GET {}'.format(
response.status_code, instance))
return result
except requests.exceptions.Timeout:
print('Timedout on GET {}'.format(instance))
return False
format_checker.checks('uri', raises=(ValueError))(check_url)
for i, line in enumerate(self.buffer()):
try:
data = json_loads(line)
errors = False
for error in validator(
schema,
format_checker=format_checker).iter_errors(data):
print('item {}: {} ({})'.format(
i, error.message,
'/'.join(error.absolute_schema_path)))
errors = True
if not errors and self.args.verbose:
print('item {}: no errors'.format(i))
except json.decoder.JSONDecodeError as e:
raise CommandError('item {}: JSON error: {}'.format(i, e))
def test_default_format_checker(testapp):
"""Test a default format checker."""
checker = FormatChecker()
checker.checks('foo')(lambda el: el.startswith('foo'))
data = {
# The key 'bar' will fail validation if the format checker is used.
'bar': 'bar',
'$schema': {
'properties': {
'bar': {
'format': 'foo'
}
}
}
}
class CustomRecord(Record):
format_checker = checker
assert pytest.raises(ValidationError, CustomRecord(data).validate)
def test_validate_with_format(app, db):
"""Test that validation can accept custom format rules."""
with app.app_context():
checker = FormatChecker()
checker.checks('foo')(lambda el: el.startswith('foo'))
record = Record.create({
'bar': 'foo',
'$schema': {
'properties': {
'bar': {'format': 'foo'}
}
}
})
assert record.validate(format_checker=checker) is None
record['bar'] = 'bar'
with pytest.raises(ValidationError) as excinfo:
record.validate(format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
def test_validate_with_format(app, db):
"""Test that validation can accept custom format rules."""
with app.app_context():
checker = FormatChecker()
checker.checks('foo')(lambda el: el.startswith('foo'))
data = {
'bar': 'foo',
'$schema': {
'properties': {
'bar': {
'format': 'foo'
}
}
}
}
# test record creation with valid data
assert data == Record.create(data)
record = Record.create(data, format_checker=checker)
# test direct call to validate with valid data
assert record.validate(format_checker=checker) is None
# test commit with valid data
record.commit(format_checker=checker)
record['bar'] = 'bar'
# test direct call to validate with invalid data
with pytest.raises(ValidationError) as excinfo:
record.validate(format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
# test commit with invalid data
with pytest.raises(ValidationError) as excinfo:
record.commit(format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
data['bar'] = 'bar'
# test record creation with invalid data
with pytest.raises(ValidationError) as excinfo:
record = Record.create(data, format_checker=checker)
assert "'bar' is not a 'foo'" in str(excinfo.value)
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self, spec_dict, origin_url=None, http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(
base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=build_http_handlers(http_client),
)
self._validate_config()
if self.config['internally_dereference_refs']:
# If internally_dereference_refs is enabled we do NOT need to resolve references anymore
# it's useless to evaluate is_ref every time
self.deref = lambda ref_dict: ref_dict
else:
self.deref = self._force_deref
def _validate_config(self):
"""
Validates the correctness of the configurations injected and makes sure that:
- no extra config keys are available on the config dictionary
- dependent configs are checked
:return: True if the initial configs are valid, False otherwise
:rtype: bool
"""
are_config_changed = False
extraneous_keys = set(iterkeys(self.config)) - set(iterkeys(CONFIG_DEFAULTS))
if extraneous_keys:
are_config_changed = True
for key in extraneous_keys:
warnings.warn(
message='config {} is not a recognized config key'.format(key),
category=Warning,
)
if self.config['internally_dereference_refs'] and not self.config['validate_swagger_spec']:
are_config_changed = True
self.config['internally_dereference_refs'] = False
warnings.warn(
message='internally_dereference_refs config disabled because validate_swagger_spec has to be enabled',
category=Warning,
)
return not are_config_changed
@cached_property
def client_spec_dict(self):
"""Return a copy of spec_dict with x-scope metadata removed so that it
is suitable for consumption by Swagger clients.
You may be asking, "Why is there a difference between the Swagger spec
a client sees and the one used internally?". Well, as part of the
ingestion process, x-scope metadata is added to spec_dict so that
$refs can be de-reffed successfully during requset/response validation
and marshalling. This medatadata is specific to the context of the
server and contains files and paths that are not relevant to the
client. This is required so the client does not re-use (and in turn,
re-creates) the invalid x-scope metadata created by the server.
For example, a section of spec_dict that contains a ref would change
as folows.
Before:
'MON': {
'$ref': '#/definitions/DayHours',
'x-scope': [
'file:///happyhour/api_docs/swagger.json',
'file:///happyhour/api_docs/swagger.json#/definitions/WeekHours'
]
}
After:
'MON': {
'$ref': '#/definitions/DayHours'
}
"""
return strip_xscope(self.spec_dict)
@classmethod
def from_dict(cls, spec_dict, origin_url=None, http_client=None, config=None):
"""Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param: http_client: http client used to download remote $refs
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def _validate_spec(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
spec_dict=self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=build_http_handlers(self.http_client),
)
def build(self):
self._validate_spec()
post_process_spec(
self,
on_container_callbacks=[
functools.partial(
tag_models,
visited_models={},
swagger_spec=self,
),
functools.partial(
collect_models,
models=self.definitions,
swagger_spec=self,
),
],
)
for format in self.config['formats']:
self.register_format(format)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
@cached_property
def _internal_spec_dict(self):
if self.config['internally_dereference_refs']:
return self.deref_flattened_spec
else:
return self.spec_dict
def _force_deref(self, ref_dict):
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
_, target = self.resolver.resolve(ref_dict['$ref'])
return target
def deref(self, ref_dict):
# This method is actually set in __init__
pass
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(
name, raises=(SwaggerValidationError,))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn(
message='{0} format is not registered with bravado-core!'.format(name),
category=Warning,
)
return format
@cached_property
def security_definitions(self):
security_defs = {}
for security_name, security_def in iteritems(self.spec_dict.get('securityDefinitions', {})):
security_defs[security_name] = SecurityDefinition(self, security_def)
return security_defs
@cached_property
def flattened_spec(self):
"""
Representation of the current swagger specs that could be written to a single file.
NOTE: The representation strips out all the definitions that are not referenced
:return:
"""
if not self.config['validate_swagger_spec']:
raise RuntimeError('Swagger Specs have to be validated before flattening.')
# If resources are defined it means that Spec has been built and so swagger specs have been validated
if self.resources is None:
self._validate_spec()
return strip_xscope(
spec_dict=flattened_spec(
spec_dict=self.spec_dict,
spec_resolver=self.resolver,
spec_url=self.origin_url,
http_handlers=build_http_handlers(self.http_client),
spec_definitions=self.definitions,
),
)
@cached_property
def deref_flattened_spec(self):
deref_spec_dict = JsonRef.replace_refs(self.flattened_spec)
@memoize_by_id
def descend(obj):
# Inline modification of obj
# This method is needed because JsonRef could produce performance penalties in accessing
# the proxied attributes
if isinstance(obj, JsonRef):
# Extract the proxied value
# http://jsonref.readthedocs.io/en/latest/#jsonref.JsonRef.__subject__
return obj.__subject__
if is_dict_like(obj):
for key in list(iterkeys(obj)):
obj[key] = descend(obj[key])
elif is_list_like(obj):
# obj is list like object provided from flattened_spec specs.
# This guarantees that it cannot be a tuple instance and
# inline object modification are allowed
for index in range(len(obj)):
obj[index] = descend(obj[index])
return obj
try:
return descend(deref_spec_dict)
finally:
# Make sure that all memory allocated, for caching, could be released
descend.cache.clear()
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self, spec_dict, origin_url=None, http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = None
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
@classmethod
def from_dict(cls, spec_dict, origin_url=None, http_client=None,
config=None):
"""
Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
tag_models(spec_dict)
fix_malformed_model_refs(spec_dict)
spec_dict = jsonref.JsonRef.replace_refs(spec_dict,
base_uri=origin_url or '')
replace_jsonref_proxies(spec_dict)
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def build(self):
if self.config['validate_swagger_spec']:
validator20.validate_spec(self.spec_dict)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.definitions = build_models(self.spec_dict.get('definitions', {}))
self.resources = build_resources(self)
def get_op_for_request(self, http_method, path_pattern):
"""
Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(
name, raises=(SwaggerValidationError,))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn('{0} format is not registered with bravado-core!'
.format(name), Warning)
return format
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrieve the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(
self,
spec_dict,
origin_url=None,
http_client=None,
config=None,
):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
# spec dict used to build resources, in case internally_dereference_refs config is enabled
# it will be overridden by the dereferenced specs (by build method). More context in PR#263
self._internal_spec_dict = spec_dict
@cached_property
def resolver(self):
# type: () -> RefResolver
return RefResolver(
base_uri=self.origin_url or '',
referrer=self.spec_dict,
handlers=self.get_ref_handlers(),
)
def is_equal(self, other):
# type: (typing.Any) -> bool
"""
Compare self with `other`
NOTE: Not implemented as __eq__ otherwise we would need to implement __hash__ to preserve
hashability of the class and it would not necessarily be performance effective
WARNING: This method operates in "best-effort" mode in the sense that certain attributes are not implementing
any equality check and so we're might be ignoring checking them
:param other: instance to compare self against
:return: True if self and other are the same, False otherwise
"""
if id(self) == id(other):
return True
if not isinstance(other, self.__class__):
return False
# If self and other are of the same type but not pointing to the same memory location then we're going to inspect
# all the attributes.
for attr_name in set(
chain(iterkeys(self.__dict__), iterkeys(other.__dict__))):
# Some attributes do not define equality methods.
# As those attributes are defined internally only we do not expect that users of the library are modifying them.
if attr_name in {
'format_checker', # jsonschema.FormatChecker does not define an equality method
'resolver', # jsonschema.validators.RefResolver does not define an equality method
}:
continue
# In case of fully dereferenced specs _deref_flattened_spec (and consequently _internal_spec_dict) will contain
# recursive reference to objects. Python is not capable of comparing them (weird).
# As _internal_spec_dict and _deref_flattened_spec are private so we don't expect users modifying them.
if self.config['internally_dereference_refs'] and attr_name in {
'_internal_spec_dict',
'_deref_flattened_spec',
}:
continue
# It has recursive references to Spec and it is not straight-forward defining an equality check to ignore it
# As it is a private cached_property we can ignore it as users should not be "touching" it.
if attr_name == '_security_definitions':
continue
try:
self_attr = getattr(self, attr_name)
other_attr = getattr(other, attr_name)
except AttributeError:
return False
# Define some special exception handling for attributes that have recursive reference to self.
if attr_name == 'resources':
if not is_dict_like(self_attr) or not is_dict_like(other_attr):
return False
for key in set(chain(iterkeys(self_attr),
iterkeys(other_attr))):
try:
if not self_attr[key].is_equal(
other_attr[key], ignore_swagger_spec=True):
return False
except KeyError:
return False
elif attr_name == 'definitions':
if not is_dict_like(self_attr) or not is_dict_like(other_attr):
return False
for key in set(chain(iterkeys(self_attr),
iterkeys(other_attr))):
try:
self_definition = self_attr[key]
other_definition = other_attr[key]
if not issubclass(
self_definition, Model) or not issubclass(
other_definition, self_definition):
return False
except KeyError:
return False
elif self_attr != other_attr:
return False
return True
def __deepcopy__(self, memo=None):
if memo is None: # pragma: no cover # This should never happening, but better safe than sorry
memo = {}
copied_self = self.__class__(spec_dict=None)
memo[id(self)] = copied_self
# Copy the attributes that are built via Spec.build
for attr_name, attr_value in iteritems(self.__dict__):
setattr(copied_self, attr_name, deepcopy(attr_value, memo=memo))
return copied_self
def __getstate__(self):
state = {
k: v
for k, v in iteritems(self.__dict__) if k not in (
# Exclude resolver as it is not easily pickleable. As there are no real
# benefits on re-using the same Resolver respect to build a new one
# we're going to ignore the field and eventually re-create it if needed
# via cached_property
'resolver',
# Exclude definitions because it contain runtime defined type and those
# are not directly pickleable.
# Check bravado_core.model._to_pickleable_representation for details.
'definitions',
)
}
# A possible approach would be to re-execute model discovery on the newly Spec
# instance (in __setstate__) but it would be very slow.
# To avoid model discovery we store a pickleable representation of the Model types
# such that we can re-create them.
state['definitions'] = {
model_name: _to_pickleable_representation(model_name, model_type)
for model_name, model_type in iteritems(self.definitions)
}
# Store the bravado-core version used to create the Spec state
state['__bravado_core_version__'] = _version
return state
def __setstate__(self, state):
state_version = state.pop('__bravado_core_version__')
if state_version != _version:
warnings.warn(
'You are creating a Spec instance from a state created by a different '
'bravado-core version. We are not going to guarantee that the created '
'Spec instance will be correct. '
'State created by version {state_version}, current version {_version}'
.format(
state_version=state_version,
_version=_version,
),
category=UserWarning,
)
# Re-create Model types, avoiding model discovery
state['definitions'] = {
model_name:
_from_pickleable_representation(pickleable_representation)
for model_name, pickleable_representation in iteritems(
state['definitions'])
}
self.__dict__.clear()
self.__dict__.update(state)
@cached_property
def client_spec_dict(self):
"""Return a copy of spec_dict with x-scope metadata removed so that it
is suitable for consumption by Swagger clients.
You may be asking, "Why is there a difference between the Swagger spec
a client sees and the one used internally?". Well, as part of the
ingestion process, x-scope metadata is added to spec_dict so that
$refs can be de-reffed successfully during request/response validation
and marshalling. This metadata is specific to the context of the
server and contains files and paths that are not relevant to the
client. This is required so the client does not re-use (and in turn,
re-creates) the invalid x-scope metadata created by the server.
For example, a section of spec_dict that contains a ref would change
as follows.
Before:
'MON': {
'$ref': '#/definitions/DayHours',
'x-scope': [
'file:///happyhour/api_docs/swagger.json',
'file:///happyhour/api_docs/swagger.json#/definitions/WeekHours'
]
}
After:
'MON': {
'$ref': '#/definitions/DayHours'
}
"""
return strip_xscope(self.spec_dict)
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specification
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param http_client: http client used to download remote $refs
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def _validate_spec(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
spec_dict=self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=self.get_ref_handlers(),
)
def build(self):
self._validate_spec()
model_discovery(self)
if self.config['internally_dereference_refs']:
# Avoid to evaluate is_ref every time, no references are possible at this time
self.deref = _identity
self._internal_spec_dict = self.deref_flattened_spec
for user_defined_format in self.config['formats']:
self.register_format(user_defined_format)
self.resources = build_resources(self)
self.api_url = build_api_serving_url(
spec_dict=self.spec_dict,
origin_url=self.origin_url,
use_spec_url_for_base_path=self.
config['use_spec_url_for_base_path'],
)
def get_ref_handlers(self):
"""Get mapping from URI schemes to handlers that takes a URI.
The handlers (callables) are used by the RefResolver to retrieve
remote specification $refs.
:returns: dict like {'http': callable, 'https': callable}
:rtype: dict
"""
return build_http_handlers(self.http_client)
def _force_deref(self, ref_dict):
# type: (T) -> T
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
reference_value = ref_dict['$ref'] # type: ignore
_, target = self.resolver.resolve(reference_value)
return target
# NOTE: deref gets overridden, if internally_dereference_refs is enabled, after calling build
deref = _force_deref
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
# type: (typing.Text) -> SwaggerFormat
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatter.SwaggerFormat`
"""
user_defined_format = self.user_defined_formats.get(name)
if user_defined_format is None:
user_defined_format = formatter.DEFAULT_FORMATS.get(name)
if name == 'byte' and self.config['use_base64_for_byte_format']:
user_defined_format = formatter.BASE64_BYTE_FORMAT
if user_defined_format is None:
warnings.warn(
message='{0} format is not registered with bravado-core!'.
format(name),
category=Warning,
)
return user_defined_format
@cached_property
def _security_definitions(self):
# type: () -> typing.Dict[typing.Text, SecurityDefinition]
return {
security_name: SecurityDefinition(self, security_def)
for security_name, security_def in iteritems(
self.spec_dict.get('securityDefinitions', {}))
}
@property
def security_definitions(self):
# type: () -> typing.Dict[typing.Text, SecurityDefinition]
return self._security_definitions
@cached_property
def flattened_spec(self):
"""
Representation of the current swagger specs that could be written to a single file.
:rtype: dict
"""
if not self.config['validate_swagger_spec']:
log.warning(
'Flattening unvalidated specs could produce invalid specs. '
'Use it at your risk or enable `validate_swagger_specs`', )
return strip_xscope(spec_dict=flattened_spec(swagger_spec=self), )
@cached_property
def _deref_flattened_spec(self):
# type: () -> typing.Mapping[typing.Text, typing.Any]
deref_spec_dict = JsonRef.replace_refs(self.flattened_spec)
@memoize_by_id
def descend(obj):
# Inline modification of obj
# This method is needed because JsonRef could produce performance penalties in accessing
# the proxied attributes
if isinstance(obj, JsonRef):
# Extract the proxied value
# http://jsonref.readthedocs.io/en/latest/#jsonref.JsonRef.__subject__
return obj.__subject__
if is_dict_like(obj):
for key in list(iterkeys(obj)):
obj[key] = descend(obj=obj[key])
elif is_list_like(obj):
# obj is list like object provided from flattened_spec specs.
# This guarantees that it cannot be a tuple instance and
# inline object modification are allowed
for index in range(len(obj)):
obj[index] = descend(obj=obj[index])
return obj
try:
return descend(obj=deref_spec_dict)
finally:
# Make sure that all memory allocated, for caching, could be released
descend.cache.clear(
) # type: ignore # @memoize_by_id adds cache attribute to the decorated function
@property
def deref_flattened_spec(self):
# type: () -> typing.Mapping[typing.Text, typing.Any]
return self._deref_flattened_spec
def formatchecker_factory(**checkerdict):
"""Converts a dictionary of strings:checkers into a formatchecker object"""
fc = FormatChecker()
for format_name, checker in checkerdict.items():
fc.checks(format_name)(checker)
return fc
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self,
spec_dict,
origin_url=None,
http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(
base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=build_http_handlers(http_client),
)
self._validate_config()
if self.config['internally_dereference_refs']:
# If internally_dereference_refs is enabled we do NOT need to resolve references anymore
# it's useless to evaluate is_ref every time
self.deref = lambda ref_dict: ref_dict
else:
self.deref = self._force_deref
def _validate_config(self):
"""
Validates the correctness of the configurations injected and makes sure that:
- no extra config keys are available on the config dictionary
- dependent configs are checked
:return: True if the initial configs are valid, False otherwise
:rtype: bool
"""
are_config_changed = False
extraneous_keys = set(iterkeys(self.config)) - set(
iterkeys(CONFIG_DEFAULTS))
if extraneous_keys:
are_config_changed = True
for key in extraneous_keys:
warnings.warn(
message='config {} is not a recognized config key'.format(
key),
category=Warning,
)
if self.config['internally_dereference_refs'] and not self.config[
'validate_swagger_spec']:
are_config_changed = True
self.config['internally_dereference_refs'] = False
warnings.warn(
message=
'internally_dereference_refs config disabled because validate_swagger_spec has to be enabled',
category=Warning,
)
return not are_config_changed
@cached_property
def client_spec_dict(self):
"""Return a copy of spec_dict with x-scope metadata removed so that it
is suitable for consumption by Swagger clients.
You may be asking, "Why is there a difference between the Swagger spec
a client sees and the one used internally?". Well, as part of the
ingestion process, x-scope metadata is added to spec_dict so that
$refs can be de-reffed successfully during requset/response validation
and marshalling. This medatadata is specific to the context of the
server and contains files and paths that are not relevant to the
client. This is required so the client does not re-use (and in turn,
re-creates) the invalid x-scope metadata created by the server.
For example, a section of spec_dict that contains a ref would change
as folows.
Before:
'MON': {
'$ref': '#/definitions/DayHours',
'x-scope': [
'file:///happyhour/api_docs/swagger.json',
'file:///happyhour/api_docs/swagger.json#/definitions/WeekHours'
]
}
After:
'MON': {
'$ref': '#/definitions/DayHours'
}
"""
return strip_xscope(self.spec_dict)
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param: http_client: http client used to download remote $refs
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def _validate_spec(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
spec_dict=self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=build_http_handlers(self.http_client),
)
def build(self):
self._validate_spec()
post_process_spec(
self,
on_container_callbacks=[
functools.partial(
tag_models,
visited_models={},
swagger_spec=self,
),
functools.partial(
collect_models,
models=self.definitions,
swagger_spec=self,
),
],
)
for format in self.config['formats']:
self.register_format(format)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
@cached_property
def _internal_spec_dict(self):
if self.config['internally_dereference_refs']:
return self.deref_flattened_spec
else:
return self.spec_dict
def _force_deref(self, ref_dict):
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
_, target = self.resolver.resolve(ref_dict['$ref'])
return target
def deref(self, ref_dict):
# This method is actually set in __init__
pass
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn(
message='{0} format is not registered with bravado-core!'.
format(name),
category=Warning,
)
return format
@cached_property
def security_definitions(self):
security_defs = {}
for security_name, security_def in iteritems(
self.spec_dict.get('securityDefinitions', {})):
security_defs[security_name] = SecurityDefinition(
self, security_def)
return security_defs
@cached_property
def flattened_spec(self):
"""
Representation of the current swagger specs that could be written to a single file.
NOTE: The representation strips out all the definitions that are not referenced
:return:
"""
if not self.config['validate_swagger_spec']:
raise RuntimeError(
'Swagger Specs have to be validated before flattening.')
# If resources are defined it means that Spec has been built and so swagger specs have been validated
if self.resources is None:
self._validate_spec()
return strip_xscope(spec_dict=flattened_spec(
spec_dict=self.spec_dict,
spec_resolver=self.resolver,
spec_url=self.origin_url,
http_handlers=build_http_handlers(self.http_client),
spec_definitions=self.definitions,
), )
@cached_property
def deref_flattened_spec(self):
deref_spec_dict = JsonRef.replace_refs(self.flattened_spec)
@memoize_by_id
def descend(obj):
# Inline modification of obj
# This method is needed because JsonRef could produce performance penalties in accessing
# the proxied attributes
if isinstance(obj, JsonRef):
# Extract the proxied value
# http://jsonref.readthedocs.io/en/latest/#jsonref.JsonRef.__subject__
return obj.__subject__
if is_dict_like(obj):
for key in list(iterkeys(obj)):
obj[key] = descend(obj[key])
elif is_list_like(obj):
# obj is list like object provided from flattened_spec specs.
# This guarantees that it cannot be a tuple instance and
# inline object modification are allowed
for index in range(len(obj)):
obj[index] = descend(obj[index])
return obj
try:
return descend(deref_spec_dict)
finally:
# Make sure that all memory allocated, for caching, could be released
descend.cache.clear()
def formatchecker_factory(**checkerdict):
"""Converts a dictionary of strings:checkers into a formatchecker object"""
fc = FormatChecker()
for format_name, checker in checkerdict.items():
fc.checks(format_name)(checker)
return fc
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self,
spec_dict,
origin_url=None,
http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# Cached copy of spec_dict with x-scope metadata removed.
# See @property client_spec_dict().
self._client_spec_dict = None
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=build_http_handlers(http_client))
# generated by @property to avoid multiple swagger validations
self._security_definitions = None
@property
def client_spec_dict(self):
"""Return a copy of spec_dict with x-scope metadata removed so that it
is suitable for consumption by Swagger clients.
You may be asking, "Why is there a difference between the Swagger spec
a client sees and the one used internally?". Well, as part of the
ingestion process, x-scope metadata is added to spec_dict so that
$refs can be de-reffed successfully during requset/response validation
and marshalling. This medatadata is specific to the context of the
server and contains files and paths that are not relevant to the
client. This is required so the client does not re-use (and in turn,
re-creates) the invalid x-scope metadata created by the server.
For example, a section of spec_dict that contains a ref would change
as folows.
Before:
'MON': {
'$ref': '#/definitions/DayHours',
'x-scope': [
'file:///happyhour/api_docs/swagger.json',
'file:///happyhour/api_docs/swagger.json#/definitions/WeekHours'
]
}
After:
'MON': {
'$ref': '#/definitions/DayHours'
}
"""
if self._client_spec_dict is None:
self._client_spec_dict = strip_xscope(self.spec_dict)
return self._client_spec_dict
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param: http_client: http client used to download remote $refs
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def build(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=build_http_handlers(self.http_client))
post_process_spec(self,
on_container_callbacks=[
functools.partial(tag_models,
visited_models={},
swagger_spec=self),
functools.partial(collect_models,
models=self.definitions,
swagger_spec=self)
])
for format in self.config['formats']:
self.register_format(format)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
def deref(self, ref_dict):
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
log.debug('Resolving {0} with scope {1}: {2}'.format(
ref_dict['$ref'], len(self.resolver._scopes_stack),
self.resolver._scopes_stack))
_, target = self.resolver.resolve(ref_dict['$ref'])
return target
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn(
'{0} format is not registered with bravado-core!'.format(name),
Warning)
return format
@property
def security_definitions(self):
if self._security_definitions is None:
self._security_definitions = {}
for security_name, security_def in iteritems(
self.spec_dict.get('securityDefinitions', {})):
self._security_definitions[security_name] = SecurityDefinition(
self, security_def)
return self._security_definitions
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrieve the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(
self,
spec_dict,
origin_url=None,
http_client=None,
config=None,
):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(
base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=self.get_ref_handlers(),
)
# spec dict used to build resources, in case internally_dereference_refs config is enabled
# it will be overridden by the dereferenced specs (by build method). More context in PR#263
self._internal_spec_dict = spec_dict
def is_equal(self, other):
# Not implemented as __eq__ otherwise we would need to implement __hash__ to preserve
# hashability of the class and it would not necessarily be performance effective
if id(self) == id(other):
return True
if not isinstance(other, self.__class__):
return False
# If self and other are of the same type but not pointing to the same memory location then we're going to inspect
# all the attributes.
for attr_name in set(
chain(
iterkeys(self.__dict__),
iterkeys(other.__dict__),
), ):
# Few attributes have recursive references to Spec or do not define an equality method we're going to ignore them
if attr_name in {
'definitions', # Recursively point back to self (Spec instance). It is built via Spec.build so we're ignoring it
'format_checker', # jsonschema.FormatChecker does not define an equality method
'resolver', # jsonschema.validators.RefResolver does not define an equality method
'resources', # Recursively point back to self (Spec instance). It is built via Spec.build so we're ignoring it
'security_definitions', # Recursively point back to self (Spec instance). It is a cached property so ignore it
}:
continue
try:
if getattr(self, attr_name) != getattr(other, attr_name):
return False
except AttributeError:
return False
return True
def __deepcopy__(self, memo=None):
if memo is None:
memo = {}
copied_self = self.__class__(spec_dict=None)
memo[id(self)] = copied_self
# Copy the attributes that are built via Spec.build
for attr_name, attr_value in iteritems(self.__dict__):
setattr(copied_self, attr_name, deepcopy(attr_value, memo=memo))
return copied_self
@cached_property
def client_spec_dict(self):
"""Return a copy of spec_dict with x-scope metadata removed so that it
is suitable for consumption by Swagger clients.
You may be asking, "Why is there a difference between the Swagger spec
a client sees and the one used internally?". Well, as part of the
ingestion process, x-scope metadata is added to spec_dict so that
$refs can be de-reffed successfully during request/response validation
and marshalling. This metadata is specific to the context of the
server and contains files and paths that are not relevant to the
client. This is required so the client does not re-use (and in turn,
re-creates) the invalid x-scope metadata created by the server.
For example, a section of spec_dict that contains a ref would change
as follows.
Before:
'MON': {
'$ref': '#/definitions/DayHours',
'x-scope': [
'file:///happyhour/api_docs/swagger.json',
'file:///happyhour/api_docs/swagger.json#/definitions/WeekHours'
]
}
After:
'MON': {
'$ref': '#/definitions/DayHours'
}
"""
return strip_xscope(self.spec_dict)
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specification
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param http_client: http client used to download remote $refs
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def _validate_spec(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
spec_dict=self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=self.get_ref_handlers(),
)
def build(self):
self._validate_spec()
model_discovery(self)
if self.config['internally_dereference_refs']:
# Avoid to evaluate is_ref every time, no references are possible at this time
self.deref = lambda ref_dict: ref_dict
self._internal_spec_dict = self.deref_flattened_spec
for user_defined_format in self.config['formats']:
self.register_format(user_defined_format)
self.resources = build_resources(self)
self.api_url = build_api_serving_url(
spec_dict=self.spec_dict,
origin_url=self.origin_url,
use_spec_url_for_base_path=self.
config['use_spec_url_for_base_path'],
)
def get_ref_handlers(self):
"""Get mapping from URI schemes to handlers that takes a URI.
The handlers (callables) are used by the RefResolver to retrieve
remote specification $refs.
:returns: dict like {'http': callable, 'https': callable}
:rtype: dict
"""
return build_http_handlers(self.http_client)
def _force_deref(self, ref_dict):
# type: (T) -> T
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
reference_value = ref_dict['$ref'] # type: ignore
_, target = self.resolver.resolve(reference_value)
return target
# NOTE: deref gets overridden, if internally_dereference_refs is enabled, after calling build
deref = _force_deref
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
# type: (typing.Text) -> SwaggerFormat
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatter.SwaggerFormat`
"""
user_defined_format = self.user_defined_formats.get(name)
if user_defined_format is None:
user_defined_format = formatter.DEFAULT_FORMATS.get(name)
if name == 'byte' and self.config['use_base64_for_byte_format']:
user_defined_format = formatter.BASE64_BYTE_FORMAT
if user_defined_format is None:
warnings.warn(
message='{0} format is not registered with bravado-core!'.
format(name),
category=Warning,
)
return user_defined_format
@cached_property
def security_definitions(self):
security_defs = {}
for security_name, security_def in iteritems(
self.spec_dict.get('securityDefinitions', {})):
security_defs[security_name] = SecurityDefinition(
self, security_def)
return security_defs
@cached_property
def flattened_spec(self):
"""
Representation of the current swagger specs that could be written to a single file.
:rtype: dict
"""
if not self.config['validate_swagger_spec']:
log.warning(
'Flattening unvalidated specs could produce invalid specs. '
'Use it at your risk or enable `validate_swagger_specs`', )
return strip_xscope(spec_dict=flattened_spec(swagger_spec=self), )
@cached_property
def deref_flattened_spec(self):
deref_spec_dict = JsonRef.replace_refs(self.flattened_spec)
@memoize_by_id
def descend(obj):
# Inline modification of obj
# This method is needed because JsonRef could produce performance penalties in accessing
# the proxied attributes
if isinstance(obj, JsonRef):
# Extract the proxied value
# http://jsonref.readthedocs.io/en/latest/#jsonref.JsonRef.__subject__
return obj.__subject__
if is_dict_like(obj):
for key in list(iterkeys(obj)):
obj[key] = descend(obj=obj[key])
elif is_list_like(obj):
# obj is list like object provided from flattened_spec specs.
# This guarantees that it cannot be a tuple instance and
# inline object modification are allowed
for index in range(len(obj)):
obj[index] = descend(obj=obj[index])
return obj
try:
return descend(obj=deref_spec_dict)
finally:
# Make sure that all memory allocated, for caching, could be released
descend.cache.clear()
from jsonschema import Draft4Validator, FormatChecker, RefResolver
from aleph.core import get_config
resolver = RefResolver('core.json#', {})
SCHEMA_DIR = os.path.join(os.path.dirname(__file__), 'validation')
for (root, dirs, files) in os.walk(SCHEMA_DIR):
for schema_file in files:
with open(os.path.join(root, schema_file), 'r') as fh:
schema = json.load(fh)
resolver.store[schema['id']] = schema
format_checker = FormatChecker()
format_checker.checks('country-code')(is_country_code)
format_checker.checks('partial-date')(is_partial_date)
format_checker.checks('language-code')(is_language_code)
format_checker.checks('url')(is_url)
format_checker.checks('domain')(is_domain)
@format_checker.checks('collection-category')
def is_collection_category(cat):
categories = get_config('COLLECTION_CATEGORIES', {})
return cat in categories.keys()
def validate(data, schema):
_, schema = resolver.resolve(schema)
validator = Draft4Validator(schema, resolver=resolver,
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self, spec_dict, origin_url=None, http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(
base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=build_http_handlers(http_client))
@classmethod
def from_dict(cls, spec_dict, origin_url=None, http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def build(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
self.spec_dict, spec_url=self.origin_url or '',
http_handlers=build_http_handlers(self.http_client))
post_process_spec(
self,
on_container_callbacks=[
functools.partial(
tag_models, visited_models={}, swagger_spec=self),
functools.partial(
collect_models, models=self.definitions,
swagger_spec=self)
])
for format in self.config['formats']:
self.register_format(format)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
def deref(self, ref_dict):
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
log.debug('Resolving {0} with scope {1}: {2}'.format(
ref_dict['$ref'],
len(self.resolver._scopes_stack),
self.resolver._scopes_stack))
_, target = self.resolver.resolve(ref_dict['$ref'])
return target
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(
name, raises=(SwaggerValidationError,))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn('{0} format is not registered with bravado-core!'
.format(name), Warning)
return format
def checker(ontology):
modelname_checker = FormatChecker()
# Pass the ontology object as a closure
modelname_checker.checks("modelname", raises=ValidationError)(is_modelname(ontology))
# Returns the checker after configuring it
return modelname_checker
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self,
spec_dict,
origin_url=None,
http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = None
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""
Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
fix_malformed_model_refs(spec_dict)
spec_dict = jsonref.JsonRef.replace_refs(spec_dict,
base_uri=origin_url or '')
# Populated by post-processing callbacks below
models = {}
post_process_spec(spec_dict,
on_container_callbacks=(
annotate_with_xmodel_callback,
fix_models_with_no_type_callback,
functools.partial(create_reffed_models_callback,
models),
functools.partial(
create_dereffed_models_callback, models),
replace_jsonref_proxies_callback,
))
spec = cls(spec_dict, origin_url, http_client, config)
spec.definitions = models
spec.build()
return spec
def build(self):
if self.config['validate_swagger_spec']:
validator20.validate_spec(self.spec_dict)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
def get_op_for_request(self, http_method, path_pattern):
"""
Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn(
'{0} format is not registered with bravado-core!'.format(name),
Warning)
return format
class Spec(object):
"""Represents a Swagger Specification for a service.
:param spec_dict: Swagger API specification in json-like dict form
:param origin_url: URL from which the spec was retrieved.
:param http_client: Used to retrive the spec via http/https.
:type http_client: :class:`bravado.http_client.HTTPClient`
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
def __init__(self,
spec_dict,
origin_url=None,
http_client=None,
config=None):
self.spec_dict = spec_dict
self.origin_url = origin_url
self.http_client = http_client
self.api_url = None
self.config = dict(CONFIG_DEFAULTS, **(config or {}))
# (key, value) = (simple format def name, Model type)
# (key, value) = (#/ format def ref, Model type)
self.definitions = {}
# (key, value) = (simple resource name, Resource)
# (key, value) = (#/ format resource ref, Resource)
self.resources = None
# (key, value) = (simple ref name, param_spec in dict form)
# (key, value) = (#/ format ref name, param_spec in dict form)
self.params = None
# Built on-demand - see get_op_for_request(..)
self._request_to_op_map = None
# (key, value) = (format name, SwaggerFormat)
self.user_defined_formats = {}
self.format_checker = FormatChecker()
self.resolver = RefResolver(base_uri=origin_url or '',
referrer=self.spec_dict,
handlers=build_http_handlers(http_client))
@classmethod
def from_dict(cls,
spec_dict,
origin_url=None,
http_client=None,
config=None):
"""Build a :class:`Spec` from Swagger API Specificiation
:param spec_dict: swagger spec in json-like dict form.
:param origin_url: the url used to retrieve the spec, if any
:type origin_url: str
:param config: Configuration dict. See CONFIG_DEFAULTS.
"""
spec = cls(spec_dict, origin_url, http_client, config)
spec.build()
return spec
def build(self):
if self.config['validate_swagger_spec']:
self.resolver = validator20.validate_spec(
self.spec_dict,
spec_url=self.origin_url or '',
http_handlers=build_http_handlers(self.http_client))
post_process_spec(self,
on_container_callbacks=[
functools.partial(tag_models,
visited_models={},
swagger_spec=self),
functools.partial(collect_models,
models=self.definitions,
swagger_spec=self)
])
for format in self.config['formats']:
self.register_format(format)
self.api_url = build_api_serving_url(self.spec_dict, self.origin_url)
self.resources = build_resources(self)
def deref(self, ref_dict):
"""Dereference ref_dict (if it is indeed a ref) and return what the
ref points to.
:param ref_dict: {'$ref': '#/blah/blah'}
:return: dereferenced value of ref_dict
:rtype: scalar, list, dict
"""
if ref_dict is None or not is_ref(ref_dict):
return ref_dict
# Restore attached resolution scope before resolving since the
# resolver doesn't have a traversal history (accumulated scope_stack)
# when asked to resolve.
with in_scope(self.resolver, ref_dict):
log.debug('Resolving {0} with scope {1}: {2}'.format(
ref_dict['$ref'], len(self.resolver._scopes_stack),
self.resolver._scopes_stack))
_, target = self.resolver.resolve(ref_dict['$ref'])
return target
def get_op_for_request(self, http_method, path_pattern):
"""Return the Swagger operation for the passed in request http method
and path pattern. Makes it really easy for server-side implementations
to map incoming requests to the Swagger spec.
:param http_method: http method of the request
:param path_pattern: request path pattern. e.g. /foo/{bar}/baz/{id}
:returns: the matching operation or None if a match couldn't be found
:rtype: :class:`bravado_core.operation.Operation`
"""
if self._request_to_op_map is None:
# lazy initialization
self._request_to_op_map = {}
base_path = self.spec_dict.get('basePath', '').rstrip('/')
for resource in self.resources.values():
for op in resource.operations.values():
full_path = base_path + op.path_name
key = (op.http_method, full_path)
self._request_to_op_map[key] = op
key = (http_method.lower(), path_pattern)
return self._request_to_op_map.get(key)
def register_format(self, user_defined_format):
"""Registers a user-defined format to be used with this spec.
:type user_defined_format:
:class:`bravado_core.formatter.SwaggerFormat`
"""
name = user_defined_format.format
self.user_defined_formats[name] = user_defined_format
validate = return_true_wrapper(user_defined_format.validate)
self.format_checker.checks(name,
raises=(SwaggerValidationError, ))(validate)
def get_format(self, name):
"""
:param name: Name of the format to retrieve
:rtype: :class:`bravado_core.formatters.SwaggerFormat`
"""
if name in formatter.DEFAULT_FORMATS:
return formatter.DEFAULT_FORMATS[name]
format = self.user_defined_formats.get(name)
if format is None:
warnings.warn(
'{0} format is not registered with bravado-core!'.format(name),
Warning)
return format
