kinto 23.2.1__py3-none-any.whl

kinto/core/cornice/util.py

@@ -0,0 +1,138 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+import warnings
+
+
+__all__ = [
+    "is_string",
+    "to_list",
+    "match_accept_header",
+    "ContentTypePredicate",
+    "current_service",
+    "func_name",
+]
+
+
+def is_string(s):
+    return isinstance(s, str)
+
+
+def to_list(obj):
+    """Convert an object to a list if it is not already one"""
+    if not isinstance(obj, (list, tuple)):
+        obj = [
+            obj,
+        ]
+    return obj
+
+
+def match_accept_header(func, context, request):
+    """
+    Return True if the request ``Accept`` header match
+    the list returned by the callable specified in :param:func.
+
+    Also attach the total list of possible accepted
+    egress media types to the request.
+
+    Utility function for performing content negotiation.
+
+    :param func:
+        The callable returning the list of acceptable
+        internet media types for content negotiation.
+        It obtains the request object as single argument.
+    """
+    acceptable = to_list(func(request))
+    request.info["acceptable"] = acceptable
+    return len(request.accept.acceptable_offers(acceptable)) > 0
+
+
+def match_content_type_header(func, context, request):
+    """
+    Return True if the request ``Content-Type`` header match
+    the list returned by the callable specified in :param:func.
+
+    Also attach the total list of possible accepted
+    ingress media types to the request.
+
+    Utility function for performing request body
+    media type checks.
+
+    :param func:
+        The callable returning the list of acceptable
+        internet media types for request body
+        media type checks.
+        It obtains the request object as single argument.
+    """
+    supported_contenttypes = to_list(func(request))
+    request.info["supported_contenttypes"] = supported_contenttypes
+    return content_type_matches(request, supported_contenttypes)
+
+
+def extract_json_data(request):
+    warnings.warn("Use ``cornice.validators.extract_cstruct()`` instead", DeprecationWarning)
+    from kinto.core.cornice.validators import extract_cstruct
+
+    return extract_cstruct(request)["body"]
+
+
+def extract_form_urlencoded_data(request):
+    warnings.warn("Use ``cornice.validators.extract_cstruct()`` instead", DeprecationWarning)
+    return request.POST
+
+
+def content_type_matches(request, content_types):
+    """
+    Check whether ``request.content_type``
+    matches given list of content types.
+    """
+    return request.content_type in content_types
+
+
+class ContentTypePredicate(object):
+    """
+    Pyramid predicate for matching against ``Content-Type`` request header.
+    Should live in ``pyramid.config.predicates``.
+
+    .. seealso::
+      http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/hooks.html
+      #view-and-route-predicates
+    """
+
+    def __init__(self, val, config):
+        self.val = val
+
+    def text(self):
+        return "content_type = %s" % (self.val,)
+
+    phash = text
+
+    def __call__(self, context, request):
+        return request.content_type == self.val
+
+
+def func_name(f):
+    """Return the name of a function or class method."""
+    if isinstance(f, str):
+        return f
+    elif hasattr(f, "__qualname__"):  # pragma: no cover
+        return f.__qualname__  # Python 3
+    elif hasattr(f, "im_class"):  # pragma: no cover
+        return "{0}.{1}".format(f.im_class.__name__, f.__name__)  # Python 2
+    else:  # pragma: no cover
+        return f.__name__  # Python 2
+
+
+def current_service(request):
+    """Return the Cornice service matching the specified request.
+
+    :returns: the service or None if unmatched.
+    :rtype: kinto.core.cornice.Service
+    """
+    if request.matched_route:
+        services = request.registry.cornice_services
+        pattern = request.matched_route.pattern
+        name = request.matched_route.name
+        # try pattern first, then route name else return None
+        service = services.get(pattern, services.get("__cornice" + name))
+        return service

kinto/core/cornice/validators/__init__.py

@@ -0,0 +1,94 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+import re
+
+from webob.multidict import MultiDict
+
+from kinto.core.cornice.validators._colander import body_validator as colander_body_validator
+from kinto.core.cornice.validators._colander import headers_validator as colander_headers_validator
+from kinto.core.cornice.validators._colander import path_validator as colander_path_validator
+from kinto.core.cornice.validators._colander import (
+    querystring_validator as colander_querystring_validator,
+)
+from kinto.core.cornice.validators._colander import validator as colander_validator
+from kinto.core.cornice.validators._marshmallow import body_validator as marshmallow_body_validator
+from kinto.core.cornice.validators._marshmallow import (
+    headers_validator as marshmallow_headers_validator,
+)
+from kinto.core.cornice.validators._marshmallow import path_validator as marshmallow_path_validator
+from kinto.core.cornice.validators._marshmallow import (
+    querystring_validator as marshmallow_querystring_validator,
+)
+from kinto.core.cornice.validators._marshmallow import validator as marshmallow_validator
+
+
+__all__ = [
+    "colander_validator",
+    "colander_body_validator",
+    "colander_headers_validator",
+    "colander_path_validator",
+    "colander_querystring_validator",
+    "marshmallow_validator",
+    "marshmallow_body_validator",
+    "marshmallow_headers_validator",
+    "marshmallow_path_validator",
+    "marshmallow_querystring_validator",
+    "extract_cstruct",
+    "DEFAULT_VALIDATORS",
+    "DEFAULT_FILTERS",
+]
+
+
+DEFAULT_VALIDATORS = []
+DEFAULT_FILTERS = []
+
+
+def extract_cstruct(request):
+    """
+    Extract attributes from the specified `request` such as body, url, path,
+    method, querystring, headers, cookies, and returns them in a single dict
+    object.
+
+    :param request: Current request
+    :type request: :class:`~pyramid:pyramid.request.Request`
+
+    :returns: A mapping containing most request attributes.
+    :rtype: dict
+    """
+    is_json = re.match("^application/(.*?)json$", str(request.content_type))
+
+    if request.content_type in ("application/x-www-form-urlencoded", "multipart/form-data"):
+        body = request.POST.mixed()
+    elif request.content_type and not is_json:
+        body = request.body
+    else:
+        if request.body:
+            try:
+                body = request.json_body
+            except ValueError as e:
+                request.errors.add("body", "", "Invalid JSON: %s" % e)
+                return {}
+            else:
+                if not hasattr(body, "items") and not isinstance(body, list):
+                    request.errors.add("body", "", "Should be a JSON object or an array")
+                    return {}
+        else:
+            body = {}
+
+    cstruct = {
+        "method": request.method,
+        "url": request.url,
+        "path": request.matchdict,
+        "body": body,
+    }
+
+    for sub, attr in (("querystring", "GET"), ("header", "headers"), ("cookies", "cookies")):
+        data = getattr(request, attr)
+        if isinstance(data, MultiDict):
+            data = data.mixed()
+        else:
+            data = dict(data)
+        cstruct[sub] = data
+
+    return cstruct

kinto/core/cornice/validators/_colander.py

@@ -0,0 +1,142 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import inspect
+import warnings
+
+
+def _generate_colander_validator(location):
+    """
+    Generate a colander validator for data from the given location.
+
+    :param location: The location in the request to find the data to be
+        validated, such as "body" or "querystring".
+    :type location: str
+    :return: Returns a callable that will validate the request at the given
+        location.
+    :rtype: callable
+    """
+
+    def _validator(request, schema=None, deserializer=None, **kwargs):
+        """
+        Validate the location against the schema defined on the service.
+
+        The content of the location is deserialized, validated and stored in
+        the ``request.validated`` attribute.
+
+        .. note::
+
+            If no schema is defined, this validator does nothing.
+            Schema should be of type :class:`~colander:colander.MappingSchema`.
+
+        :param request: Current request
+        :type request: :class:`~pyramid:pyramid.request.Request`
+
+        :param schema: The Colander schema
+        :param deserializer: Optional deserializer, defaults to
+            :func:`cornice.validators.extract_cstruct`
+        """
+        import colander
+
+        if schema is None:
+            return
+
+        schema_instance = _ensure_instantiated(schema)
+
+        if not isinstance(schema_instance, colander.MappingSchema):
+            raise TypeError("Schema should inherit from colander.MappingSchema.")
+
+        class RequestSchemaMeta(colander._SchemaMeta):
+            """
+            A metaclass that will inject a location class attribute into
+            RequestSchema.
+            """
+
+            def __new__(cls, name, bases, class_attrs):
+                """
+                Instantiate the RequestSchema class.
+
+                :param name: The name of the class we are instantiating. Will
+                    be "RequestSchema".
+                :type name: str
+                :param bases: The class's superclasses.
+                :type bases: tuple
+                :param dct: The class's class attributes.
+                :type dct: dict
+                """
+                class_attrs[location] = schema_instance
+                return type(name, bases, class_attrs)
+
+        class RequestSchema(colander.MappingSchema, metaclass=RequestSchemaMeta):  # noqa
+            """A schema to validate the request's location attributes."""
+
+            pass
+
+        validator(request, RequestSchema(), deserializer, **kwargs)
+        validated_location = request.validated.get(location, {})
+        request.validated.update(validated_location)
+        if location not in validated_location:
+            request.validated.pop(location, None)
+
+    return _validator
+
+
+body_validator = _generate_colander_validator("body")
+headers_validator = _generate_colander_validator("headers")
+path_validator = _generate_colander_validator("path")
+querystring_validator = _generate_colander_validator("querystring")
+
+
+def validator(request, schema=None, deserializer=None, **kwargs):
+    """
+    Validate the full request against the schema defined on the service.
+
+    Each attribute of the request is deserialized, validated and stored in the
+    ``request.validated`` attribute
+    (eg. body in ``request.validated['body']``).
+
+    .. note::
+
+        If no schema is defined, this validator does nothing.
+
+    :param request: Current request
+    :type request: :class:`~pyramid:pyramid.request.Request`
+
+    :param schema: The Colander schema
+    :param deserializer: Optional deserializer, defaults to
+        :func:`cornice.validators.extract_cstruct`
+    """
+    import colander
+
+    from kinto.core.cornice.validators import extract_cstruct
+
+    if deserializer is None:
+        deserializer = extract_cstruct
+
+    if schema is None:
+        return
+
+    schema = _ensure_instantiated(schema)
+    cstruct = deserializer(request)
+    try:
+        deserialized = schema.deserialize(cstruct)
+    except colander.Invalid as e:
+        translate = request.localizer.translate
+        error_dict = e.asdict(translate=translate)
+        for name, msg in error_dict.items():
+            location, _, field = name.partition(".")
+            request.errors.add(location, field, msg)
+    else:
+        request.validated.update(deserialized)
+
+
+def _ensure_instantiated(schema):
+    if inspect.isclass(schema):
+        warnings.warn(
+            "Setting schema to a class is deprecated. Set schema to an instance instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        schema = schema()
+    return schema

kinto/core/cornice/validators/_marshmallow.py

@@ -0,0 +1,182 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import inspect
+
+
+def _generate_marshmallow_validator(location):
+    """
+    Generate a marshmallow validator for data from the given location.
+
+    :param location: The location in the request to find the data to be
+        validated, such as "body" or "querystring".
+    :type location: str
+    :return: Returns a callable that will validate the request at the given
+        location.
+    :rtype: callable
+    """
+
+    def _validator(request, schema=None, deserializer=None, **kwargs):
+        """
+        Validate the location against the schema defined on the service.
+
+        The content of the location is deserialized, validated and stored in
+        the ``request.validated`` attribute.
+
+        Keyword arguments to be included when initialising the marshmallow
+        schema can be passed as a dict in ``kwargs['schema_kwargs']`` variable.
+
+        .. note::
+
+            If no schema is defined, this validator does nothing.
+
+        :param request: Current request
+        :type request: :class:`~pyramid:pyramid.request.Request`
+
+        :param schema: The marshmallow schema
+        :param deserializer: Optional deserializer, defaults to
+            :func:`cornice.validators.extract_cstruct`
+        """
+        import marshmallow
+        import marshmallow.schema
+        from marshmallow.utils import EXCLUDE
+
+        if schema is None:
+            return
+
+        # see if the user wants to set any keyword arguments for their schema
+        schema_kwargs = kwargs.get("schema_kwargs", {})
+        schema = _instantiate_schema(schema, **schema_kwargs)
+
+        class ValidatedField(marshmallow.fields.Field):
+            def _deserialize(self, value, attr, data, **kwargs):
+                schema.context.setdefault("request", request)
+                deserialized = schema.load(value)
+                return deserialized
+
+        class Meta(object):
+            strict = True
+            ordered = True
+            unknown = EXCLUDE
+
+        class RequestSchemaMeta(marshmallow.schema.SchemaMeta):
+            """
+            A metaclass that will inject a location class attribute into
+            RequestSchema.
+            """
+
+            def __new__(cls, name, bases, class_attrs):
+                """
+                Instantiate the RequestSchema class.
+
+                :param name: The name of the class we are instantiating. Will
+                    be "RequestSchema".
+                :type name: str
+                :param bases: The class's superclasses.
+                :type bases: tuple
+                :param dct: The class's class attributes.
+                :type dct: dict
+                """
+
+                class_attrs[location] = ValidatedField(
+                    required=True, metadata={"load_from": location}
+                )
+                class_attrs["Meta"] = Meta
+                return type(name, bases, class_attrs)
+
+        class RequestSchema(marshmallow.Schema, metaclass=RequestSchemaMeta):  # noqa
+            """A schema to validate the request's location attributes."""
+
+            pass
+
+        validator(request, RequestSchema, deserializer, **kwargs)
+        request.validated = request.validated.get(location, {})
+
+    return _validator
+
+
+body_validator = _generate_marshmallow_validator("body")
+headers_validator = _generate_marshmallow_validator("header")
+path_validator = _generate_marshmallow_validator("path")
+querystring_validator = _generate_marshmallow_validator("querystring")
+
+
+def _message_normalizer(exc, no_field_name="_schema"):
+    """
+    Normally `normalize_messages` will exist on `ValidationError` but pre 2.10
+    versions don't have it
+    :param exc:
+    :param no_field_name:
+    :return:
+    """
+    if isinstance(exc.messages, dict):
+        return exc.messages
+    field_names = exc.kwargs.get("field_names", [])
+    if len(field_names) == 0:
+        return {no_field_name: exc.messages}
+    return dict((name, exc.messages) for name in field_names)
+
+
+def validator(request, schema=None, deserializer=None, **kwargs):
+    """
+    Validate the full request against the schema defined on the service.
+
+    Each attribute of the request is deserialized, validated and stored in the
+    ``request.validated`` attribute
+    (eg. body in ``request.validated['body']``).
+
+    .. note::
+
+        If no schema is defined, this validator does nothing.
+
+    :param request: Current request
+    :type request: :class:`~pyramid:pyramid.request.Request`
+
+    :param schema: The marshmallow schema
+    :param deserializer: Optional deserializer, defaults to
+        :func:`cornice.validators.extract_cstruct`
+    """
+    import marshmallow
+
+    from kinto.core.cornice.validators import extract_cstruct
+
+    if deserializer is None:
+        deserializer = extract_cstruct
+
+    if schema is None:
+        return
+
+    schema = _instantiate_schema(schema)
+    schema.context.setdefault("request", request)
+
+    cstruct = deserializer(request)
+    try:
+        deserialized = schema.load(cstruct)
+    except marshmallow.ValidationError as err:
+        # translate = request.localizer.translate
+        normalized_errors = _message_normalizer(err)
+        for location, details in normalized_errors.items():
+            location = location if location != "_schema" else ""
+            if hasattr(details, "items"):
+                for subfield, msg in details.items():
+                    request.errors.add(location, subfield, msg)
+            else:
+                request.errors.add(location, location, details)
+    else:
+        request.validated.update(deserialized)
+
+
+def _instantiate_schema(schema, **kwargs):
+    """
+    Returns an object of the given marshmallow schema.
+
+    :param schema: The marshmallow schema class with which the request should
+        be validated
+    :param kwargs: The keyword arguments that will be provided to the
+        marshmallow schema's constructor
+    :return: The object of the marshmallow schema
+    """
+    if not inspect.isclass(schema):
+        raise ValueError("You need to pass Marshmallow class instead of schema instance")
+    return schema(**kwargs)

kinto/core/cornice_swagger/__init__.py

@@ -0,0 +1,92 @@
+from pyramid.security import NO_PERMISSION_REQUIRED
+
+from kinto.core.cornice_swagger.swagger import CorniceSwagger
+
+
+__author__ = """Josip Delic"""
+__email__ = "delicj@delijati.net"
+__version__ = "0.3.0"
+
+
+__all__ = ["CorniceSwagger"]
+
+
+class CorniceSwaggerPredicate(object):
+    """Predicate to add simple information to Cornice Swagger."""
+
+    def __init__(self, schema, config):
+        self.schema = schema
+
+    def phash(self):
+        return str(self.schema)
+
+    def __call__(self, context, request):
+        return self.schema
+
+
+def includeme(config):
+    # Custom view parameters
+    config.add_view_predicate("response_schemas", CorniceSwaggerPredicate)
+    config.add_view_predicate("tags", CorniceSwaggerPredicate)
+    config.add_view_predicate("operation_id", CorniceSwaggerPredicate)
+    config.add_view_predicate("api_security", CorniceSwaggerPredicate)
+    config.add_directive("cornice_enable_openapi_view", cornice_enable_openapi_view)
+    config.add_directive("cornice_enable_openapi_explorer", cornice_enable_openapi_explorer)
+
+
+def cornice_enable_openapi_view(
+    config,
+    api_path="/api-explorer/swagger.json",
+    permission=NO_PERMISSION_REQUIRED,
+    route_factory=None,
+    **kwargs,
+):
+    """
+    :param config:
+        Pyramid configurator object
+    :param api_path:
+        where to expose swagger JSON definition view
+    :param permission:
+        pyramid permission for those views
+    :param route_factory:
+        factory for context object for those routes
+    :param kwargs:
+        kwargs that will be passed to CorniceSwagger's `generate()`
+
+    This registers and configures the view that serves api definitions
+    """
+    config.registry.settings["cornice_swagger.spec_kwargs"] = kwargs
+    config.add_route("cornice_swagger.open_api_path", api_path, factory=route_factory)
+    config.add_view(
+        "cornice_swagger.views.open_api_json_view",
+        renderer="json",
+        permission=permission,
+        route_name="cornice_swagger.open_api_path",
+    )
+
+
+def cornice_enable_openapi_explorer(
+    config,
+    api_explorer_path="/api-explorer",
+    permission=NO_PERMISSION_REQUIRED,
+    route_factory=None,
+    **kwargs,
+):
+    """
+    :param config:
+        Pyramid configurator object
+    :param api_explorer_path:
+        where to expose Swagger UI interface view
+    :param permission:
+        pyramid permission for those views
+    :param route_factory:
+        factory for context object for those routes
+
+    This registers and configures the view that serves api explorer
+    """
+    config.add_route("cornice_swagger.api_explorer_path", api_explorer_path, factory=route_factory)
+    config.add_view(
+        "cornice_swagger.views.swagger_ui_template_view",
+        permission=permission,
+        route_name="cornice_swagger.api_explorer_path",
+    )

kinto/core/cornice_swagger/converters/__init__.py

@@ -0,0 +1,21 @@
+"""
+This module handles the conversion between colander object schemas and swagger
+object schemas.
+"""
+
+from kinto.core.cornice_swagger.converters.parameters import ParameterConversionDispatcher
+from kinto.core.cornice_swagger.converters.schema import TypeConversionDispatcher
+
+
+def convert_schema(schema_node):
+    dispatcher = TypeConversionDispatcher()
+    converted = dispatcher(schema_node)
+
+    return converted
+
+
+def convert_parameter(location, schema_node, definition_handler=convert_schema):
+    dispatcher = ParameterConversionDispatcher(definition_handler)
+    converted = dispatcher(location, schema_node)
+
+    return converted

kinto/core/cornice_swagger/converters/exceptions.py

@@ -0,0 +1,6 @@
+class ConversionError(Exception):
+    pass
+
+
+class NoSuchConverter(ConversionError):
+    pass