initial version

Author: p1c2u

MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include requirements_dev.txt

README.md

@@ -0,0 +1,24 @@
+openapi-core
+************
+
+Openapi-core is a Python library that adds client-side and server-side support
+for the `OpenAPI Specification v3.0.0 <github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md>`__.
+
+Installation
+============
+
+Recommended way (via pip):
+
+::
+
+    $ pip install openapi-core
+
+Alternatively you can download the code and install from the repository:
+
+.. code-block:: bash
+
+   $ pip install -e git+https://github.com/p1c2u/openapi-core.git#egg=openapi_core
+
+Related projects
+================
+* `openapi-spec-validator <https://github.com/p1c2u/openapi-spec-validator>`__

README.rst

@@ -0,0 +1,10 @@
+"""OpenAPI core module"""
+from openapi_core.shortcuts import create_spec
+
+__author__ = 'Artur Maciąg'
+__email__ = 'maciag.artur@gmail.com'
+__version__ = '0.0.1'
+__url__ = 'https://github.com/p1c2u/openapi-core'
+__license__ = 'BSD 3-Clause License'
+
+__all__ = ['create_spec', ]

openapi_core/__init__.py

@@ -0,0 +1,17 @@
+"""OpenAPI core exceptions module"""
+
+
+class OpenAPIError(Exception):
+    pass
+
+
+class OpenAPIMappingError(OpenAPIError):
+    pass
+
+
+class MissingParameterError(OpenAPIMappingError):
+    pass
+
+
+class InvalidContentTypeError(OpenAPIMappingError):
+    pass

openapi_core/exceptions.py

@@ -0,0 +1,37 @@
+"""OpenAPI core mediaTypes module"""
+from six import iteritems
+
+from openapi_core.schemas import SchemaFactory
+
+
+class MediaType(object):
+    """Represents an OpenAPI MediaType."""
+
+    def __init__(self, content_type, schema=None):
+        self.content_type = content_type
+        self.schema = schema
+
+    def unmarshal(self, value):
+        if not self.schema:
+            return value
+
+        return self.schema.unmarshal(value)
+
+
+class MediaTypeGenerator(object):
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def generate(self, content):
+        for content_type, media_type in iteritems(content):
+            schema_spec = media_type.get('schema')
+
+            schema = None
+            if schema_spec:
+                schema = self._create_schema(schema_spec)
+
+            yield content_type, MediaType(content_type, schema)
+
+    def _create_schema(self, schema_spec):
+        return SchemaFactory(self.dereferencer).create(schema_spec)

openapi_core/media_types.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""OpenAPI core operations module"""
+import logging
+
+from six import iteritems
+
+from openapi_core.parameters import ParametersGenerator
+from openapi_core.request_bodies import RequestBodyFactory
+
+log = logging.getLogger(__name__)
+
+
+class Operation(object):
+    """Represents an OpenAPI Operation."""
+
+    def __init__(
+            self, http_method, path_name, parameters, request_body=None,
+            deprecated=False, operation_id=None):
+        self.http_method = http_method
+        self.path_name = path_name
+        self.parameters = dict(parameters)
+        self.request_body = request_body
+        self.deprecated = deprecated
+        self.operation_id = operation_id
+
+    def __getitem__(self, name):
+        return self.parameters[name]
+
+
+class OperationsGenerator(object):
+    """Represents an OpenAPI Operation in a service."""
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def generate(self, path_name, path):
+        path_deref = self.dereferencer.dereference(path)
+        for http_method, operation in iteritems(path_deref):
+            if http_method.startswith('x-') or http_method == 'parameters':
+                continue
+
+            operation_deref = self.dereferencer.dereference(operation)
+            deprecated = operation_deref.get('deprecated', False)
+            parameters_list = operation_deref.get('parameters', [])
+            parameters = self._generate_parameters(parameters_list)
+
+            request_body = None
+            if 'requestBody' in operation_deref:
+                request_body_spec = operation_deref.get('requestBody')
+                request_body = self._create_request_body(request_body_spec)
+
+            yield (
+                http_method,
+                Operation(
+                    http_method, path_name, list(parameters),
+                    request_body=request_body, deprecated=deprecated,
+                ),
+            )
+
+    def _generate_parameters(self, parameters):
+        return ParametersGenerator(self.dereferencer).generate(parameters)
+
+    def _create_request_body(self, request_body_spec):
+        return RequestBodyFactory(self.dereferencer).create(request_body_spec)

openapi_core/operations.py

@@ -0,0 +1,59 @@
+"""OpenAPI core parameters module"""
+import logging
+
+from openapi_core.schemas import SchemaFactory
+
+log = logging.getLogger(__name__)
+
+
+class Parameter(object):
+    """Represents an OpenAPI operation Parameter."""
+
+    def __init__(
+            self, name, location, schema=None, default=None,
+            required=False, deprecated=False, allow_empty_value=False,
+            items=None, collection_format=None):
+        self.name = name
+        self.location = location
+        self.schema = schema
+        self.default = default
+        self.required = required
+        self.deprecated = deprecated
+        self.allow_empty_value = allow_empty_value
+        self.items = items
+        self.collection_format = collection_format
+
+    def unmarshal(self, value):
+        if not self.schema:
+            return value
+
+        return self.schema.unmarshal(value)
+
+
+class ParametersGenerator(object):
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def generate(self, paramters):
+        for parameter in paramters:
+            parameter_deref = self.dereferencer.dereference(parameter)
+
+            default = parameter_deref.get('default')
+            required = parameter_deref.get('required', False)
+
+            schema_spec = parameter_deref.get('schema', None)
+            schema = None
+            if schema_spec:
+                schema = self._create_schema(schema_spec)
+
+            yield (
+                parameter_deref['name'],
+                Parameter(
+                    parameter_deref['name'], parameter_deref['in'],
+                    schema=schema, default=default, required=required,
+                ),
+            )
+
+    def _create_schema(self, schema_spec):
+        return SchemaFactory(self.dereferencer).create(schema_spec)

openapi_core/parameters.py

@@ -0,0 +1,30 @@
+"""OpenAPI core paths module"""
+from six import iteritems
+
+from openapi_core.operations import OperationsGenerator
+
+
+class Path(object):
+    """Represents an OpenAPI Path."""
+
+    def __init__(self, name, operations):
+        self.name = name
+        self.operations = dict(operations)
+
+    def __getitem__(self, http_method):
+        return self.operations[http_method]
+
+
+class PathsGenerator(object):
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def generate(self, paths):
+        paths_deref = self.dereferencer.dereference(paths)
+        for path_name, path in iteritems(paths_deref):
+            operations = self._generate_operations(path_name, path)
+            yield path_name, Path(path_name, list(operations))
+
+    def _generate_operations(self, path_name, path):
+        return OperationsGenerator(self.dereferencer).generate(path_name, path)

openapi_core/paths.py

@@ -0,0 +1,30 @@
+"""OpenAPI core requestBodies module"""
+from openapi_core.media_types import MediaTypeGenerator
+
+
+class RequestBody(object):
+    """Represents an OpenAPI RequestBody."""
+
+    def __init__(self, content, required=False):
+        self.content = dict(content)
+        self.required = required
+
+    def __getitem__(self, content_type):
+        return self.content[content_type]
+
+
+class RequestBodyFactory(object):
+
+    def __init__(self, dereferencer):
+        self.dereferencer = dereferencer
+
+    def create(self, request_body_spec):
+        request_body_deref = self.dereferencer.dereference(
+            request_body_spec)
+        content = request_body_deref['content']
+        media_types = self._generate_media_types(content)
+        required = request_body_deref.get('required', False)
+        return RequestBody(media_types, required=required)
+
+    def _generate_media_types(self, content):
+        return MediaTypeGenerator(self.dereferencer).generate(content)