def parameters(self):
"""
Combined path-level and operation-level parameters.
Any $refs are resolved here.
Note that this implementation differs from the spec in that we only use
the _name_ of a parameter to consider its uniqueness, not the name and location.
This is because we end up passing parameters to the handler by name anyway,
so any duplicate names, even if they had different locations, would be horribly mangled.
:rtype: list[dict]
"""
parameters = OrderedDict()
for source in (
self.path.mapping.get('parameters', ()),
self.data.get('parameters', {}),
):
source = maybe_resolve(source, self.router.resolve_reference)
for parameter in source:
parameter = maybe_resolve(parameter,
self.router.resolve_reference)
parameters[parameter['name']] = parameter
return list(parameters.values())
def _get_regular_parameters(self):
for source in (
self.path.mapping.get('parameters', ()),
self.data.get('parameters', {}),
):
source = maybe_resolve(source, self.api.resolve_reference)
for parameter in source:
parameter_data = maybe_resolve(parameter,
self.api.resolve_reference)
parameter = self.parameter_class(data=parameter_data,
operation=self,
api=self.api)
yield parameter
def cast_parameter_value(api_info, parameter, value):
if parameter.get('type') == 'array':
if not isinstance(value, list): # could be a list already if collection format was multi
splitter = COLLECTION_FORMAT_SPLITTERS.get(parameter.get('collectionFormat', 'csv'))
if not splitter:
raise NotImplementedError('unsupported collection format in %r' % parameter)
value = splitter(value)
items = parameter['items']
value = [cast_parameter_value(api_info, items, item) for item in value]
if 'schema' in parameter:
schema = maybe_resolve(parameter['schema'], api_info.router.resolve_reference)
jsonschema.validate(value, schema, resolver=api_info.router.resolver)
if 'discriminator' in schema: # Swagger Polymorphism support
type = value[schema['discriminator']]
actual_type = '#/definitions/%s' % type
schema = api_info.router.resolve_reference(actual_type)
jsonschema.validate(value, schema, resolver=api_info.router.resolver)
return value
value = cast_primitive_value(parameter, value)
jsonschema_validation_object = {
key: parameter[key]
for key in parameter
if key in OPENAPI_JSONSCHEMA_VALIDATION_KEYS
}
if jsonschema_validation_object:
jsonschema.validate(value, jsonschema_validation_object)
return value
def validate_schema(schema, api, value):
schema = maybe_resolve(schema, resolve=api.resolve_reference)
jsonschema.validate(
value,
schema,
cls=LepoDraft4Validator,
resolver=api.resolver,
)
if 'discriminator' in schema: # Swagger/OpenAPI 3 Polymorphism support
discriminator = schema['discriminator']
if isinstance(discriminator, dict): # OpenAPI 3
type = value[discriminator['propertyName']]
if 'mapping' in discriminator:
actual_type = discriminator['mapping'][type]
else:
actual_type = '#/components/schemas/%s' % type
else:
type = value[discriminator]
actual_type = '#/definitions/%s' % type
schema = api.resolve_reference(actual_type)
jsonschema.validate(
value,
schema,
cls=LepoDraft4Validator,
resolver=api.resolver,
)
return value
def get_path(self, path):
"""
Construct a Path object from a path string.
The Path string must be declared in the API.
:type path: str
:rtype: lepo.path.Path
"""
mapping = maybe_resolve(self.api['paths'][path],
self.resolve_reference)
return self.path_class(router=self, path=path, mapping=mapping)
def _get_body_parameter(self):
for source in (
self.path.mapping.get('requestBody'),
self.data.get('requestBody'),
):
if source:
source = maybe_resolve(source, self.api.resolve_reference)
body_parameter = self.body_parameter_class(data=source,
operation=self,
api=self.api)
# TODO: Document x-lepo-body-name
body_parameter.name = self.data.get('x-lepo-body-name',
body_parameter.name)
return body_parameter
def get_path_mapping(self, path):
return maybe_resolve(self.doc['paths'][path], self.resolve_reference)
def validate_schema(self, api, value):
schema = maybe_resolve(self.schema, resolve=api.resolve_reference)
return validate_schema(schema, api, value)
def schema(self):
schema = self.data['schema']
schema = maybe_resolve(
schema, resolve=(self.api.resolve_reference if self.api else None))
return OpenAPI3Schema(schema)
