simo 1.7.20__py3-none-any.whl → 2.0.0__py3-none-any.whl

simo/core/drf_braces/forms/serializer_form.py

@@ -0,0 +1,156 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+
+import six
+from django import forms
+from django.forms.forms import DeclarativeFieldsMetaclass
+from rest_framework import serializers
+
+from .. import fields
+from ..utils import (
+    initialize_class_using_reference_object,
+    reduce_attr_dict_from_base_classes,
+)
+from .fields import ISO8601DateTimeField
+
+
+SERIALIZER_FORM_FIELD_MAPPING = {
+    fields.BooleanField: forms.BooleanField,
+    fields.CharField: forms.CharField,
+    fields.ChoiceField: forms.ChoiceField,
+    fields.DateTimeField: ISO8601DateTimeField,
+    fields.EmailField: forms.EmailField,
+    fields.IntegerField: forms.IntegerField,
+    fields.UUIDField: forms.UUIDField,
+    fields.URLField: forms.URLField,
+    fields.DateField: forms.DateField,
+    serializers.BooleanField: forms.BooleanField,
+    serializers.CharField: forms.CharField,
+    serializers.ChoiceField: forms.ChoiceField,
+    serializers.DateTimeField: ISO8601DateTimeField,
+    serializers.EmailField: forms.EmailField,
+    serializers.IntegerField: forms.IntegerField,
+    serializers.UUIDField: forms.UUIDField,
+    serializers.URLField: forms.URLField,
+    serializers.DateField: forms.DateField,
+}
+
+
+class SerializerFormOptions(object):
+    def __init__(self, options=None, name=None):
+        self.serializer = getattr(options, 'serializer', None)
+        self.fields = getattr(options, 'fields', [])
+        self.exclude = getattr(options, 'exclude', [])
+        self.field_mapping = getattr(options, 'field_mapping', {})
+
+        assert self.serializer is not None, (
+            '{}.Meta.serializer must be provided'
+            ''.format(name)
+        )
+        assert issubclass(self.serializer, serializers.BaseSerializer), (
+            '{}.Meta.serializer must be a subclass of DRF serializer'
+            ''.format(name)
+        )
+
+
+class SerializerFormMeta(DeclarativeFieldsMetaclass):
+    def __new__(cls, name, bases, attrs):
+        try:
+            parents = [b for b in bases if issubclass(b, SerializerForm)]
+        except NameError:
+            # We are defining SerializerForm itself
+            parents = None
+
+        meta = attrs.pop('Meta', None)
+
+        if not parents or attrs.pop('_is_base', False):
+            return super(SerializerFormMeta, cls).__new__(cls, name, bases, attrs)
+
+        attrs['_meta'] = options = SerializerFormOptions(meta, name=name)
+
+        new_attrs = cls.get_form_fields_from_serializer(bases, options)
+        # attrs should take priority in case a specific field is overwritten
+        new_attrs.update(attrs)
+
+        return super(SerializerFormMeta, cls).__new__(cls, name, bases, new_attrs)
+
+    @classmethod
+    def get_field_mapping(cls, bases, options):
+        mapping = reduce_attr_dict_from_base_classes(
+            bases,
+            lambda i: getattr(getattr(i, '_meta', None), 'field_mapping', {}),
+            SERIALIZER_FORM_FIELD_MAPPING
+        )
+        mapping.update(options.field_mapping)
+        return mapping
+
+    @classmethod
+    def get_form_fields_from_serializer(cls, bases, options):
+        fields = {}
+
+        mapping = cls.get_field_mapping(bases, options)
+
+        for name, field in options.serializer._declared_fields.items():
+            if field.read_only:
+                continue
+
+            if name not in options.fields or name in options.exclude:
+                continue
+
+            form_field_class = mapping.get(type(field))
+
+            if not form_field_class:
+                raise TypeError(
+                    '{} is not mapped to appropriate form field class. '
+                    'Please add it to the mapping via `field_mapping` '
+                    'Meta attribute.'
+                    ''.format(type(field))
+                )
+
+            fields[name] = initialize_class_using_reference_object(field, form_field_class)
+
+        return fields
+
+
+class SerializerFormBase(forms.Form):
+    def __init__(self, *args, **kwargs):
+        super(SerializerFormBase, self).__init__(*args, **kwargs)
+        # instantiated during validation
+        self.serializer = None
+
+    def get_serializer_context(self):
+        return {}
+
+    def get_serializer_data(self):
+        data = self.initial.copy()
+        data.update(self.cleaned_data or {})
+        return data
+
+    def get_serializer(self):
+        return self._meta.serializer(
+            data=self.get_serializer_data(),
+            context=self.get_serializer_context()
+        )
+
+    def _clean_form(self):
+        super(SerializerFormBase, self)._clean_form()
+
+        self.serializer = self.get_serializer()
+
+        if not self.serializer.is_valid():
+            self._errors.update(self.serializer.errors)
+        else:
+            self.cleaned_data.update(self.serializer.validated_data)
+
+
+class SerializerForm(six.with_metaclass(SerializerFormMeta, SerializerFormBase)):
+    _is_base = True
+
+
+def form_from_serializer(serializer, **kwargs):
+    assert inspect.isclass(serializer) and issubclass(serializer, serializers.BaseSerializer), (
+        'Can only create forms from DRF Serializers'
+    )
+    kwargs.update({'serializer': serializer})
+    meta = type(str('Meta'), (object,), kwargs)
+    return type(str('{}Form'.format(serializer.__name__)), (SerializerForm,), {'Meta': meta})

simo/core/drf_braces/mixins.py

@@ -0,0 +1,52 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+from .parsers import StrippingJSONParser
+
+
+class MultipleSerializersViewMixin(object):
+    def get_serializer(self, *args, **kwargs):
+        serializer_class = kwargs.pop('serializer_class', None)
+        if serializer_class is None:
+            serializer_class = self.get_serializer_class()
+
+        kwargs['context'] = self.get_serializer_context()
+
+        return serializer_class(*args, **kwargs)
+
+
+class MapDataViewMixin(object):
+    # Configuration for data mapper.
+    # Leave None if you don't require mapping
+    data_mapper_class = None
+
+    def get_mapper_context(self):
+        return self.get_serializer_context()
+
+    def get_data(self, mapper_class=None):
+        """
+        Get data for serialization.
+        """
+        if not mapper_class:
+            mapper_class = self.data_mapper_class
+
+        if mapper_class is not None:
+            return mapper_class(context=self.get_mapper_context())(self.request.data)
+
+        return self.request.data
+
+
+class StrippingJSONViewMixin(object):
+    parser_classes = (StrippingJSONParser,)
+
+    # Location of the root of the data for this api.
+    parser_root = None
+
+    def get_parser_context(self, http_request):
+        """
+        Add 'parser_root' to this view's parser's parse_context.
+        Since this view uses a DescendingJSONParser, it uses
+        this information to decide what to pull out.
+        """
+        context = super(StrippingJSONViewMixin, self).get_parser_context(http_request)
+        context.update({'parse_root': self.parser_root})
+        return context

simo/core/drf_braces/parsers.py

@@ -0,0 +1,72 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import json
+from collections import OrderedDict
+
+import six
+from django.conf import settings
+from rest_framework import parsers
+
+
+class SortedJSONParser(parsers.JSONParser):
+    """
+    Parses JSON-serialized data into OrderedDict.
+    """
+
+    def parse(self, stream, media_type=None, parser_context=None):
+        """
+        Parses the incoming bytestream as JSON and returns the resulting data.
+        """
+        parser_context = parser_context or {}
+        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
+
+        try:
+            data = stream.read().decode(encoding)
+            return json.loads(data, object_pairs_hook=OrderedDict)
+        except ValueError as exc:
+            raise parsers.ParseError('JSON parse error - %s' % six.text_type(exc))
+
+
+# TODO Create a Renderer that does the opposite of this parser.
+class StrippingJSONParser(parsers.JSONParser):
+    """
+    Strip the outer layer of JSON, returning only inner layer.
+
+    This is a convenience class, so that API creators do not need
+    to wrap their serializers in a "parent serializer" for the sole
+    purpose of stripping out the top-level node.
+
+    Place desired root into parser-context as 'parse-root'.
+    Only supports descending one level of nesting.
+
+    Caller is expected to add 'parse_root' to the parser's
+    context; a convenient place to do this is in a GenericApiView
+    subclass's `get_parser_context()` method.
+
+    Example, for parse_root of "dt_application"::
+
+        input json:
+            {
+                "dt_application": {
+                    "node1": 1234
+                }
+            }
+        output dictionary:
+            {
+                "node1": 1234
+            }
+    """
+
+    def parse(self, stream, media_type=None, parser_context=None):
+        data = super(StrippingJSONParser, self).parse(
+            stream, media_type=media_type, parser_context=parser_context
+        )
+
+        try:
+            root = parser_context.pop('parse_root')
+        except KeyError:
+            pass
+        else:
+            if root in data:
+                return data[root]
+
+        return data

simo/core/drf_braces/renderers.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+from collections import Mapping
+
+import six
+from rest_framework.renderers import JSONRenderer
+from rest_framework.utils.encoders import JSONEncoder
+
+
+class DoubleAsStrJsonEncoder(JSONEncoder):
+    def _encode(self, o):
+        if isinstance(o, Mapping):
+            return {k: self._encode(v) for k, v in o.items()}
+        elif isinstance(o, (list, tuple)):
+            return [self._encode(i) for i in o]
+        elif isinstance(o, six.integer_types):
+            int_str = six.text_type(o)
+            if len(int_str) >= 15:
+                o = int_str
+        return o
+
+    def encode(self, o):
+        return super(DoubleAsStrJsonEncoder, self).encode(self._encode(o))
+
+
+class DoubleAsStrJsonRenderer(JSONRenderer):
+    """
+    Regular Json renderer except big integers are converted to strings
+
+    Not all json clients support big integers (e.g. js) hence we need to convert
+    all big integers to strings for compatibility reasons.
+
+    For usage, custom ``Accept: application/json; double=str`` needs to be passed.
+    """
+    encoder_class = DoubleAsStrJsonEncoder
+    media_type = 'application/json; double=str'
+    format = 'json'

simo/core/drf_braces/serializers/enforce_validation_serializer.py

@@ -0,0 +1,214 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+
+from rest_framework import fields, serializers
+from rest_framework.fields import empty
+
+from ..utils import add_base_class_to_instance, get_class_name_with_new_suffix
+
+
+class EnforceValidationFieldMixin(object):
+    """
+    Custom DRF field mixin which allows to ignore validation error
+    if the field is not mandatory.
+
+    The field is mandatory when the parent serializer includes it
+    in the ``must_validate_fields`` list or ``must_validate_fields``
+    list is completely omitted. If the list is omitted, then all
+    fields in that serializer are mandatory and must validate.
+    """
+
+    def run_validation(self, data=empty):
+        try:
+            return super(EnforceValidationFieldMixin, self).run_validation(data)
+        except serializers.ValidationError as e:
+            must_validate_fields = getattr(self.parent, 'must_validate_fields', None)
+            field_name = getattr(self, 'field_name')
+
+            # only re-raise validation error when this field must be validated
+            # as defined by must_validate_fields list on the parent serializer
+            # or if must_validate_fields is not defined
+            if must_validate_fields is None or field_name in must_validate_fields:
+                raise
+            else:
+                self.capture_failed_field(field_name, data, e.detail)
+                raise fields.SkipField(
+                    'This field "{}" is being skipped as per enforce validation logic.'
+                    ''.format(field_name)
+                )
+
+    def capture_failed_field(self, field_name, field_data, error_msg):
+        """
+        Hook for capturing invalid fields. This is used to track which fields have been skipped.
+
+        Args:
+            field_name (str): the name of the field whose data failed to validate
+            field_data (object): the data of the field that failed validation
+            error_msg (str): validation error message
+
+        Returns:
+            Not meant to return anything.
+        """
+
+
+def _create_enforce_validation_serializer(serializer, strict_mode_by_default=True, validation_serializer_field_mixin_class=EnforceValidationFieldMixin):
+    """
+    Recursively creates a copy of a given serializer which enforces ``must_validate_fields``.
+
+    This function recursively copies serializers and replaces all fields
+    by adding ``EnforceValidationFieldMixin`` to their mro which then enforces validation
+    for fields defined in ``must_validate_fields`` and drops their data for all other fields.
+
+    Args:
+        serializer (Serializer): Serializer class or instance to be copied
+        strict_mode_by_default (bool): Whether serializer should use strict mode
+            when ``must_validate_fields`` is not defined.
+            If ``True``, then all fields must be validated by default
+            and if ``False``, then all fields can be dropped.
+        validation_serializer_field_mixin_class (type): the class used to validate serializer fields
+
+    Returns:
+        Recursive copy of the ``serializer`` which will enforce ``must_validate_fields``.
+    """
+    if inspect.isclass(serializer):
+        serializer = type(
+            get_class_name_with_new_suffix(
+                serializer,
+                'Serializer',
+                'EnforceValidationSerializer'
+            ),
+            (serializer,),
+            {}
+        )
+        fields = serializer._declared_fields
+        declared_fields = None
+
+    else:
+        # when serializer is instance, we still want to create a modified
+        # serializer class copy since if we only adjust the fields
+        # on the instance, that can complicate introspecting,
+        # especially when ``_create_enforce_validation_serializer``
+        # is used as decorator
+        serializer = add_base_class_to_instance(
+            serializer,
+            new_name=get_class_name_with_new_suffix(
+                serializer.__class__,
+                'Serializer',
+                'EnforceValidationSerializer'
+            )
+        )
+
+        if isinstance(serializer, serializers.ListSerializer):
+            serializer.child = _create_enforce_validation_serializer(
+                serializer.child,
+                strict_mode_by_default=strict_mode_by_default,
+                validation_serializer_field_mixin_class=validation_serializer_field_mixin_class,
+            )
+
+            # kwargs are used to take a deepcopy of the fields
+            # so we need to adjust the child kwargs not to loose
+            # reference to our custom child serializer
+            if 'child' in serializer._kwargs:
+                serializer._kwargs['child'] = serializer.child
+
+            return serializer
+
+        fields = serializer.fields
+        declared_fields = serializer._declared_fields
+
+    if not strict_mode_by_default and not hasattr(serializer, 'must_validate_fields'):
+        serializer.must_validate_fields = []
+
+        # this is necessary for deepcopy to work when
+        # root serializer is instantiated it does deepcopy
+        # on serializer._declared_fields which re-instantiates
+        # all child fields hence must_validate_fields will be lost
+        # adding it to the class makes it persistent
+        if not inspect.isclass(serializer):
+            serializer.__class__.must_validate_fields = []
+
+    # cant use .items() since we need to adjust dictionary
+    # within the loop so we cant be looping over the dict
+    # at the same time
+    # Python 3 even raises exception for this:
+    # RuntimeError: dictionary changed size during iteration
+    for name in list(fields.keys()):
+        field = fields[name]
+        replacement = None
+
+        if isinstance(field, serializers.BaseSerializer):
+            replacement = _create_enforce_validation_serializer(
+                field,
+                strict_mode_by_default=strict_mode_by_default,
+                validation_serializer_field_mixin_class=validation_serializer_field_mixin_class,
+            )
+
+        elif isinstance(field, serializers.Field):
+            replacement = add_base_class_to_instance(
+                field,
+                validation_serializer_field_mixin_class,
+                new_name=get_class_name_with_new_suffix(
+                    field.__class__,
+                    'Field',
+                    'EnforceValidationField'
+                )
+            )
+
+        if replacement is not None:
+            if declared_fields is not None:
+                declared_fields[name] = replacement
+
+            if replacement.source == name:
+                replacement.source = None
+
+            fields[name] = replacement
+
+    return serializer
+
+
+def create_enforce_validation_serializer(serializer=None, **kwargs):
+    """
+    Public function that creates a copy of a serializer which enforces ``must_validate_fields``.
+    The difference between this function and ``_create_enforce_validation_serializer``
+    is that this function can be used both as a direct decorator and decorator with
+    parameters.
+
+    For example::
+
+        @create_enforce_validation_serializer
+        class MySerializer(BaseSerializer): pass
+
+        # or
+
+        @create_enforce_validation_serializer(param=value)
+        class MySerializer(BaseSerializer): pass
+
+        # or
+
+        create_enforce_validation_serializer(
+            MySerializer,
+            param=value
+        )
+    """
+    # used as direct decorator so then simply return new serializer
+    # e.g.  @decorator
+    #       class MySerializer(...)
+    # or used as regular function
+    # e.g. function(Serializer, foo=bar)
+    if inspect.isclass(serializer) and issubclass(serializer, serializers.Serializer):
+        return _create_enforce_validation_serializer(serializer, **kwargs)
+
+    # used as decorator with parameters
+    # e.g.  @decorator(foo=bar)
+    #       class MySerializer(...)
+    elif serializer is None:
+        def inner(serializer):
+            return _create_enforce_validation_serializer(serializer, **kwargs)
+
+        return inner
+
+    else:
+        raise TypeError(
+            'create_enforce_validation_serializer can only be only on serializers. '
+            'It was called with "{}"'.format(type(serializer))
+        )