Add typesys. Add OpenAPI, JSONSchema.

core-api · tomchristie · Jan 29, 2018 · Jan 30, 2018 · Jan 30, 2018 · Jan 30, 2018
commit bc6aa9eb4f59ce6f393730a4970200eb0f291270
diff --git a/coreapi/__init__.py b/coreapi/__init__.py
@@ -1,12 +1,12 @@
 # coding: utf-8
-from coreapi import auth, codecs, exceptions, transports, utils
+from coreapi import auth, codecs, exceptions, transports, typesys, utils
 from coreapi.client import Client
 from coreapi.document import Document, Link, Object, Error, Field
 
 
-__version__ = '2.3.3'
+__version__ = '3.0.0'
 __all__ = [
     'Document', 'Link', 'Object', 'Error', 'Field',
     'Client',
-    'auth', 'codecs', 'exceptions', 'transports', 'utils',
+    'auth', 'codecs', 'exceptions', 'transports', 'typesys', 'utils',
 ]
diff --git a/coreapi/codecs/__init__.py b/coreapi/codecs/__init__.py
@@ -4,11 +4,14 @@
 from coreapi.codecs.display import DisplayCodec
 from coreapi.codecs.download import DownloadCodec
 from coreapi.codecs.jsondata import JSONCodec
+from coreapi.codecs.jsonschema import JSONSchemaCodec
+from coreapi.codecs.openapi import OpenAPICodec
 from coreapi.codecs.python import PythonCodec
 from coreapi.codecs.text import TextCodec
 
 
 __all__ = [
-    'BaseCodec', 'CoreJSONCodec', 'DisplayCodec',
-    'JSONCodec', 'PythonCodec', 'TextCodec', 'DownloadCodec'
+    'BaseCodec', 'CoreJSONCodec', 'DisplayCodec', 'JSONCodec',
+    'JSONSchemaCodec', 'OpenAPICodec', 'PythonCodec', 'TextCodec',
+    'DownloadCodec'
 ]
diff --git a/coreapi/codecs/jsonschema.py b/coreapi/codecs/jsonschema.py
@@ -0,0 +1,166 @@
+from coreapi import typesys
+from coreapi.codecs.base import BaseCodec
+from coreapi.compat import COMPACT_SEPARATORS, VERBOSE_SEPARATORS, force_bytes
+from coreapi.exceptions import ParseError
+from coreapi.schemas import JSONSchema
+import collections
+import json
+
+
+class JSONSchemaCodec(BaseCodec):
+    media_type = 'application/schema+json'
+
+    def decode(self, bytestring, **options):
+        try:
+            data = json.loads(
+                bytestring.decode('utf-8'),
+                object_pairs_hook=collections.OrderedDict
+            )
+        except ValueError as exc:
+            raise ParseError('Malformed JSON. %s' % exc)
+        jsonschema = JSONSchema(data)
+        return self.decode_from_data_structure(jsonschema)
+
+    def decode_from_data_structure(self, struct):
+        attrs = {}
+
+        if '$ref' in struct:
+            if struct['$ref'] == '#':
+                return typesys.ref()
+            name = struct['$ref'].split('/')[-1]
+            return typesys.ref(name)
+
+        if struct['type'] == 'string':
+            if 'minLength' in struct:
+                attrs['min_length'] = struct['minLength']
+            if 'maxLength' in struct:
+                attrs['max_length'] = struct['maxLength']
+            if 'pattern' in struct:
+                attrs['pattern'] = struct['pattern']
+            if 'format' in struct:
+                attrs['format'] = struct['format']
+            return typesys.string(**attrs)
+
+        if struct['type'] in ['number', 'integer']:
+            if 'minimum' in struct:
+                attrs['minimum'] = struct['minimum']
+            if 'maximum' in struct:
+                attrs['maximum'] = struct['maximum']
+            if 'exclusiveMinimum' in struct:
+                attrs['exclusiveMinimum'] = struct['exclusiveMinimum']
+            if 'exclusiveMaximum' in struct:
+                attrs['exclusiveMaximum'] = struct['exclusiveMaximum']
+            if 'multipleOf' in struct:
+                attrs['multipleOf'] = struct['multipleOf']
+            if struct['type'] == 'integer':
+                return typesys.integer(**attrs)
+            return typesys.number(**attrs)
+
+        if struct['type'] == 'boolean':
+            return typesys.boolean()
+
+        if struct['type'] == 'object':
+            if 'properties' in struct:
+                attrs['properties'] = {
+                    key: self.decode_from_data_structure(value)
+                    for key, value in struct['properties'].items()
+                }
+            if 'required' in struct:
+                attrs['required'] = struct['required']
+            return typesys.obj(**attrs)
+
+        if struct['type'] == 'array':
+            if 'items' in struct:
+                attrs['items'] = self.decode_from_data_structure(struct['items'])
+            if 'additionalItems' in struct:
+                attrs['additional_items'] = struct['additionalItems']
+            if 'minItems' in struct:
+                attrs['min_items'] = struct['minItems']
+            if 'maxItems' in struct:
+                attrs['max_items'] = struct['maxItems']
+            if 'uniqueItems' in struct:
+                attrs['unique_items'] = struct['uniqueItems']
+            return typesys.array(**attrs)
+
+    def encode(self, cls, **options):
+        struct = self.encode_to_data_structure(cls)
+        indent = options.get('indent')
+        if indent:
+            kwargs = {
+                'ensure_ascii': False,
+                'indent': 4,
+                'separators': VERBOSE_SEPARATORS
+            }
+        else:
+            kwargs = {
+                'ensure_ascii': False,
+                'indent': None,
+                'separators': COMPACT_SEPARATORS
+            }
+        return force_bytes(json.dumps(struct, **kwargs))
+
+    def encode_to_data_structure(self, cls):
+        if issubclass(cls, typesys.String):
+            value = {'type': 'string'}
+            if cls.max_length is not None:
+                value['maxLength'] = cls.max_length
+            if cls.min_length is not None:
+                value['minLength'] = cls.min_length
+            if cls.pattern is not None:
+                value['pattern'] = cls.pattern
+            if cls.format is not None:
+                value['format'] = cls.format
+            return value
+
+        if issubclass(cls, typesys.NumericType):
+            if issubclass(cls, typesys.Integer):
+                value = {'type': 'integer'}
+            else:
+                value = {'type': 'number'}
+
+            if cls.minimum is not None:
+                value['minimum'] = cls.minimum
+            if cls.maximum is not None:
+                value['maximum'] = cls.maximum
+            if cls.exclusive_minimum:
+                value['exclusiveMinimum'] = cls.exclusive_minimum
+            if cls.exclusive_maximum:
+                value['exclusiveMaximum'] = cls.exclusive_maximum
+            if cls.multiple_of is not None:
+                value['multipleOf'] = cls.multiple_of
+            return value
+
+        if issubclass(cls, typesys.Boolean):
+            return {'type': 'boolean'}
+
+        if issubclass(cls, typesys.Object):
+            value = {'type': 'object'}
+            if cls.properties:
+                value['properties'] = {
+                    key: self.encode_to_data_structure(value)
+                    for key, value in cls.properties.items()
+                }
+            if cls.required:
+                value['required'] = cls.required
+            return value
+
+        if issubclass(cls, typesys.Array):
+            value = {'type': 'array'}
+            if cls.items is not None:
+                value['items'] = self.encode_to_data_structure(cls.items)
+            if cls.additional_items:
+                value['additionalItems'] = cls.additional_items
+            if cls.min_items is not None:
+                value['minItems'] = cls.min_items
+            if cls.max_items is not None:
+                value['maxItems'] = cls.max_items
+            if cls.unique_items is not None:
+                value['uniqueItems'] = cls.unique_items
+            return value
+
+        if issubclass(cls, typesys.Ref):
+            if not cls.to:
+                return {'$ref': '#'}
+            return {'$ref': '#/definitions/%s' % cls.to}
+
+        raise Exception('Cannot encode class %s' % cls)
diff --git a/coreapi/codecs/openapi.py b/coreapi/codecs/openapi.py
@@ -0,0 +1,94 @@
+from coreapi.codecs import BaseCodec, JSONSchemaCodec
+from coreapi.document import Document, Link, Field
+from coreapi.schemas import OpenAPI
+import yaml
+
+
+METHODS = [
+    'get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'
+]
+
+
+class OpenAPICodec(BaseCodec):
+    media_type = 'application/vnd.oai.openapi'
+    format = 'openapi'
+
+    def decode(self, bytestring, **options):
+        data = yaml.safe_load(bytestring)
+        openapi = OpenAPI(data)
+        title = openapi.lookup(['info', 'title'])
+        description = openapi.lookup(['info', 'description'])
+        url = openapi.lookup(['servers', 0, 'url'])
+        content = self.get_links(openapi)
+        return Document(title=title, description=description, url=url, content=content)
+
+    def get_links(self, openapi):
+        """
+        Return all the links in the document, layed out by tag and operationId.
+        """
+        content = {}
+
+        for path, path_info in openapi.get('paths', {}).items():
+            operations = {
+                key: path_info[key] for key in path_info
+                if key in METHODS
+            }
+            for operation, operation_info in operations.items():
+                operationId = operation_info.get('operationId')
+                tag = operation_info.lookup(['tags', 0])
+                if not operationId:
+                    continue
+
+                link = self.get_link(path, path_info, operation, operation_info)
+                if tag is None:
+                    content[operationId] = link
+                else:
+                    if tag in content:
+                        content[tag][operationId] = link
+                    else:
+                        content[tag] = {operationId: link}
+
+        return content
+
+    def get_link(self, path, path_info, operation, operation_info):
+        """
+        Return a single link in the document.
+        """
+        title = operation_info.get('summary')
+        description = operation_info.get('description')
+        parameters = path_info.get('parameters', [])
+        parameters += operation_info.get('parameters', [])
+
+        fields = [
+            self.get_field(parameter)
+            for parameter in parameters
+        ]
+
+        return Link(
+            url=path,
+            action=operation,
+            title=title,
+            description=description,
+            fields=fields
+        )
+
+    def get_field(self, parameter):
+        """
+        Return a single field in a link.
+        """
+        name = parameter.get('name')
+        location = parameter.get('in')
+        description = parameter.get('description')
+        required = parameter.get('required', False)
+        schema = parameter.get('schema')
+
+        if schema is not None:
+            schema = JSONSchemaCodec().decode_from_data_structure(schema)
+
+        return Field(
+            name=name,
+            location=location,
+            description=description,
+            required=required,
+            schema=schema
+        )
diff --git a/coreapi/document.py b/coreapi/document.py
@@ -1,6 +1,6 @@
 # coding: utf-8
 from __future__ import unicode_literals
-from collections import OrderedDict, namedtuple
+from collections import OrderedDict
 from coreapi.compat import string_types
 import itypes
 
@@ -40,14 +40,6 @@ def _key_sorting(item):
     return (0, key)
 
 
-# The field class, as used by Link objects:
-
-# NOTE: 'type', 'description' and 'example' are now deprecated,
-#       in favor of 'schema'.
-Field = namedtuple('Field', ['name', 'required', 'location', 'schema', 'description', 'type', 'example'])
-Field.__new__.__defaults__ = (False, '', None, None, None, None)
-
-
 # The Core API primitives:
 
 class Document(itypes.Dict):
@@ -238,6 +230,27 @@ def __str__(self):
         return _str(self)
 
 
+class Field(object):
+    def __init__(self, name, required=False, location='', schema=None, description=None, example=None):
+        self.name = name
+        self.required = required
+        self.location = location
+        self.schema = schema
+        self.description = description
+        self.example = example
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Field) and
+            self.name == other.name and
+            self.required == other.required and
+            self.location == other.location and
+            self.description == other.description and
+            self.schema.__class__ == other.schema.__class__ and
+            self.example == other.example
+        )
+
+
 class Error(itypes.Dict):
     def __init__(self, title=None, content=None):
         data = {} if (content is None) else content

diff --git a/coreapi/schemas/__init__.py b/coreapi/schemas/__init__.py
@@ -0,0 +1,5 @@
+from coreapi.schemas.jsonschema import JSONSchema
+from coreapi.schemas.openapi import OpenAPI
+
+
+__all__ = ['JSONSchema', 'OpenAPI']
diff --git a/coreapi/schemas/jsonschema.py b/coreapi/schemas/jsonschema.py
@@ -0,0 +1,32 @@
+from coreapi import typesys
+
+
+class JSONSchema(typesys.Object):
+    properties = {
+        '$ref': typesys.string(),
+        'type': typesys.string(),
+
+        # String
+        'minLength': typesys.integer(minimum=0, default=0),
+        'maxLength': typesys.integer(minimum=0),
+        'pattern': typesys.string(format='regex'),
+        'format': typesys.string(),
+
+        # Numeric
+        'minimum': typesys.number(),
+        'maximum': typesys.number(),
+        'exclusiveMinimum': typesys.boolean(default=False),
+        'exclusiveMaximum': typesys.boolean(default=False),
+        'multipleOf': typesys.number(minimum=0.0, exclusive_minimum=True),
+
+        # Object
+        'properties': typesys.obj(),  # TODO: typesys.ref('JSONSchema'),
+        'required': typesys.array(items=typesys.string(), min_items=1, unique=True),
+
+        # Array
+        'items': typesys.obj(),  # TODO: typesys.ref('JSONSchema'),
+        'additionalItems': typesys.boolean(),
+        'minItems': typesys.integer(minimum=0),
+        'maxItems': typesys.integer(minimum=0),
+        'uniqueItems': typesys.boolean(),
+    }