Merge pull request #12 from p1c2u/feature/serialized-parameters-support

Serialized parameters support

Author: p1c2u

openapi_core/enums.py

@@ -0,0 +1,48 @@
+from enum import Enum
+
+
+class ParameterLocation(Enum):
+
+    PATH = 'path'
+    QUERY = 'query'
+    HEADER = 'header'
+    COOKIE = 'cookie'
+
+    @classmethod
+    def has_value(cls, value):
+        return (any(value == item.value for item in cls))
+
+
+class ParameterStyle(Enum):
+
+    MATRIX = 'matrix'
+    LABEL = 'label'
+    FORM = 'form'
+    SIMPLE = 'simple'
+    SPACE_DELIMITED = 'spaceDelimited'
+    PIPE_DELIMITED = 'pipeDelimited'
+    DEEP_OBJECT = 'deepObject'
+
+
+class SchemaType(Enum):
+
+    INTEGER = 'integer'
+    NUMBER = 'number'
+    STRING = 'string'
+    BOOLEAN = 'boolean'
+    ARRAY = 'array'
+    OBJECT = 'object'
+
+
+class SchemaFormat(Enum):
+
+    NONE = None
+    INT32 = 'int32'
+    INT64 = 'int64'
+    FLOAT = 'float'
+    DOUBLE = 'double'
+    BYTE = 'byte'
+    BINARY = 'binary'
+    DATE = 'date'
+    DATETIME = 'date-time'
+    PASSWORD = 'password'

openapi_core/parameters.py

@@ -2,32 +2,73 @@
 import logging
 import warnings
 
+from functools import lru_cache
 from six import iteritems
 
+from openapi_core.enums import ParameterLocation, ParameterStyle, SchemaType
 from openapi_core.exceptions import (
     EmptyValue, InvalidValueType, InvalidParameterValue,
 )
 
 log = logging.getLogger(__name__)
 
+PARAMETER_STYLE_DESERIALIZERS = {
+    ParameterStyle.FORM: lambda x: x.split(','),
+    ParameterStyle.SIMPLE: lambda x: x.split(','),
+    ParameterStyle.SPACE_DELIMITED: lambda x: x.split(' '),
+    ParameterStyle.PIPE_DELIMITED: lambda x: x.split('|'),
+}
+
 
 class Parameter(object):
     """Represents an OpenAPI operation Parameter."""
 
     def __init__(
             self, name, location, schema=None, required=False,
             deprecated=False, allow_empty_value=False,
-            items=None, collection_format=None):
+            items=None, style=None, explode=None):
         self.name = name
-        self.location = location
+        self.location = ParameterLocation(location)
         self.schema = schema
-        self.required = True if self.location == "path" else required
+        self.required = (
+            True if self.location == ParameterLocation.PATH else required
+        )
         self.deprecated = deprecated
         self.allow_empty_value = (
-            allow_empty_value if self.location == "query" else False
+            allow_empty_value if self.location == ParameterLocation.QUERY
+            else False
         )
         self.items = items
-        self.collection_format = collection_format
+        self.style = ParameterStyle(style or self.default_style)
+        self.explode = self.default_explode if explode is None else explode
+
+    @property
+    def aslist(self):
+        return (
+            self.schema and
+            self.schema.type in [SchemaType.ARRAY, SchemaType.OBJECT]
+        )
+
+    @property
+    def default_style(self):
+        simple_locations = [ParameterLocation.PATH, ParameterLocation.HEADER]
+        return (
+            'simple' if self.location in simple_locations else "form"
+        )
+
+    @property
+    def default_explode(self):
+        return self.style == ParameterStyle.FORM
+
+    def get_dererializer(self):
+        return PARAMETER_STYLE_DESERIALIZERS[self.style]
+
+    def deserialize(self, value):
+        if not self.aslist or self.explode:
+            return value
+
+        deserializer = self.get_dererializer()
+        return deserializer(value)
 
     def unmarshal(self, value):
         if self.deprecated:
@@ -36,69 +77,73 @@ def unmarshal(self, value):
                 DeprecationWarning,
             )
 
-        if (self.location == "query" and value == "" and
+        if (self.location == ParameterLocation.QUERY and value == "" and
                 not self.allow_empty_value):
             raise EmptyValue(
                 "Value of {0} parameter cannot be empty".format(self.name))
 
         if not self.schema:
             return value
 
+        deserialized = self.deserialize(value)
+
         try:
-            return self.schema.unmarshal(value)
+            return self.schema.unmarshal(deserialized)
         except InvalidValueType as exc:
             raise InvalidParameterValue(str(exc))
 
 
+class ParameterFactory(object):
+
+    def __init__(self, dereferencer, schemas_registry):
+        self.dereferencer = dereferencer
+        self.schemas_registry = schemas_registry
+
+    def create(self, parameter_spec, parameter_name=None):
+        parameter_deref = self.dereferencer.dereference(parameter_spec)
+
+        parameter_name = parameter_name or parameter_deref['name']
+        parameter_in = parameter_deref.get('in', 'header')
+
+        allow_empty_value = parameter_deref.get('allowEmptyValue')
+        required = parameter_deref.get('required', False)
+
+        style = parameter_deref.get('style')
+        explode = parameter_deref.get('explode')
+
+        schema_spec = parameter_deref.get('schema', None)
+        schema = None
+        if schema_spec:
+            schema, _ = self.schemas_registry.get_or_create(schema_spec)
+
+        return Parameter(
+            parameter_name, parameter_in,
+            schema=schema, required=required,
+            allow_empty_value=allow_empty_value,
+            style=style, explode=explode,
+        )
+
+
 class ParametersGenerator(object):
 
     def __init__(self, dereferencer, schemas_registry):
         self.dereferencer = dereferencer
         self.schemas_registry = schemas_registry
 
     def generate(self, parameters):
-        for parameter_name, parameter in iteritems(parameters):
-            parameter_deref = self.dereferencer.dereference(parameter)
-
-            parameter_in = parameter_deref.get('in', 'header')
-
-            allow_empty_value = parameter_deref.get('allowEmptyValue')
-            required = parameter_deref.get('required', False)
-
-            schema_spec = parameter_deref.get('schema', None)
-            schema = None
-            if schema_spec:
-                schema, _ = self.schemas_registry.get_or_create(schema_spec)
-
-            yield (
-                parameter_name,
-                Parameter(
-                    parameter_name, parameter_in,
-                    schema=schema, required=required,
-                    allow_empty_value=allow_empty_value,
-                ),
-            )
+        for parameter_name, parameter_spec in iteritems(parameters):
+            parameter = self.parameter_factory.create(
+                parameter_spec, parameter_name=parameter_name)
+
+            yield (parameter_name, parameter)
 
     def generate_from_list(self, parameters_list):
-        for parameter in parameters_list:
-            parameter_deref = self.dereferencer.dereference(parameter)
-
-            parameter_name = parameter_deref['name']
-            parameter_in = parameter_deref.get('in', 'header')
-
-            allow_empty_value = parameter_deref.get('allowEmptyValue')
-            required = parameter_deref.get('required', False)
-
-            schema_spec = parameter_deref.get('schema', None)
-            schema = None
-            if schema_spec:
-                schema, _ = self.schemas_registry.get_or_create(schema_spec)
-
-            yield (
-                parameter_name,
-                Parameter(
-                    parameter_name, parameter_in,
-                    schema=schema, required=required,
-                    allow_empty_value=allow_empty_value,
-                ),
-            )
+        for parameter_spec in parameters_list:
+            parameter = self.parameter_factory.create(parameter_spec)
+
+            yield (parameter.name, parameter)
+
+    @property
+    @lru_cache()
+    def parameter_factory(self):
+        return ParameterFactory(self.dereferencer, self.schemas_registry)

openapi_core/schemas.py

@@ -9,6 +9,7 @@
 from json import loads
 from six import iteritems
 
+from openapi_core.enums import SchemaType, SchemaFormat
 from openapi_core.exceptions import (
     InvalidValueType, UndefinedSchemaProperty, MissingProperty, InvalidValue,
 )
@@ -17,9 +18,9 @@
 log = logging.getLogger(__name__)
 
 DEFAULT_CAST_CALLABLE_GETTER = {
-    'integer': int,
-    'number': float,
-    'boolean': lambda x: bool(strtobool(x)),
+    SchemaType.INTEGER: int,
+    SchemaType.NUMBER: float,
+    SchemaType.BOOLEAN: lambda x: bool(strtobool(x)),
 }
 
 
@@ -28,13 +29,13 @@ class Schema(object):
 
     def __init__(
             self, schema_type, model=None, properties=None, items=None,
-            spec_format=None, required=None, default=None, nullable=False,
+            schema_format=None, required=None, default=None, nullable=False,
             enum=None, deprecated=False, all_of=None):
-        self.type = schema_type
+        self.type = SchemaType(schema_type)
         self.model = model
         self.properties = properties and dict(properties) or {}
         self.items = items
-        self.format = spec_format
+        self.format = SchemaFormat(schema_format)
         self.required = required or []
         self.default = default
         self.nullable = nullable
@@ -57,8 +58,8 @@ def get_all_properties(self):
     def get_cast_mapping(self):
         mapping = DEFAULT_CAST_CALLABLE_GETTER.copy()
         mapping.update({
-            'array': self._unmarshal_collection,
-            'object': self._unmarshal_object,
+            SchemaType.ARRAY: self._unmarshal_collection,
+            SchemaType.OBJECT: self._unmarshal_object,
         })
 
         return defaultdict(lambda: lambda x: x, mapping)
@@ -159,6 +160,7 @@ def create(self, schema_spec):
         schema_deref = self.dereferencer.dereference(schema_spec)
 
         schema_type = schema_deref['type']
+        schema_format = schema_deref.get('format')
         model = schema_deref.get('x-model', None)
         required = schema_deref.get('required', False)
         default = schema_deref.get('default', None)
@@ -183,8 +185,8 @@ def create(self, schema_spec):
 
         return Schema(
             schema_type, model=model, properties=properties, items=items,
-            required=required, default=default, nullable=nullable, enum=enum,
-            deprecated=deprecated, all_of=all_of,
+            schema_format=schema_format, required=required, default=default,
+            nullable=nullable, enum=enum, deprecated=deprecated, all_of=all_of,
         )
 
     @property

openapi_core/validators.py

@@ -95,7 +95,7 @@ def validate(self, request):
             except OpenAPIMappingError as exc:
                 errors.append(exc)
             else:
-                parameters[param.location][param_name] = value
+                parameters[param.location.value][param_name] = value
 
         if operation.request_body is not None:
             try:
@@ -117,12 +117,19 @@ def validate(self, request):
         return RequestValidationResult(errors, body, parameters)
 
     def _get_raw_value(self, request, param):
+        location = request.parameters[param.location.value]
+
         try:
-            return request.parameters[param.location][param.name]
+            raw = request.parameters[param.location.value][param.name]
         except KeyError:
             raise MissingParameter(
                 "Missing required `{0}` parameter".format(param.name))
 
+        if param.aslist and param.explode:
+            return location.getlist(param.name)
+
+        return raw
+
     def _get_raw_body(self, request):
         if not request.body:
             raise MissingBody("Missing required request body")

openapi_core/wrappers.py

@@ -2,6 +2,7 @@
 import warnings
 
 from six.moves.urllib.parse import urljoin
+from werkzeug.datastructures import ImmutableMultiDict
 
 
 class BaseOpenAPIRequest(object):
@@ -54,9 +55,9 @@ def __init__(
 
         self.parameters = {
             'path': view_args or {},
-            'query': args or {},
-            'headers': headers or {},
-            'cookies': cookies or {},
+            'query': ImmutableMultiDict(args or []),
+            'header': headers or {},
+            'cookie': cookies or {},
         }
 
         self.body = data or ''