plone.tiles 3.0.0__py3-none-any.whl

plone/tiles/data.py

@@ -0,0 +1,422 @@
+from persistent.dict import PersistentDict
+from plone.subrequest import ISubRequest
+from plone.tiles.directives import IGNORE_QUERYSTRING_KEY
+from plone.tiles.interfaces import IFieldTypeConverter
+from plone.tiles.interfaces import IPersistentTile
+from plone.tiles.interfaces import ITile
+from plone.tiles.interfaces import ITileDataContext
+from plone.tiles.interfaces import ITileDataManager
+from plone.tiles.interfaces import ITileDataStorage
+from plone.tiles.interfaces import ITileType
+from urllib import parse
+from zope.annotation.interfaces import IAnnotations
+from zope.component import adapter
+from zope.component import getMultiAdapter
+from zope.component import queryUtility
+from zope.interface import implementer
+from zope.interface import Interface
+from zope.interface.interfaces import ComponentLookupError
+from zope.schema import getFields
+from zope.schema import getFieldsInOrder
+from zope.schema.interfaces import ISequence
+
+import json
+import logging
+import pkg_resources
+
+
+try:
+    pkg_resources.get_distribution("plone.rfc822")
+except pkg_resources.DistributionNotFound:
+    HAS_RFC822 = False
+else:
+    from plone.rfc822.interfaces import IPrimaryField
+
+    HAS_RFC822 = True
+
+
+ANNOTATIONS_KEY_PREFIX = "plone.tiles.data"
+LOGGER = logging.getLogger("plone.tiles")
+
+
+@adapter(ITile)
+@implementer(ITileDataManager)
+def transientTileDataManagerFactory(tile):
+    if tile.request.get("X-Tile-Persistent"):
+        return PersistentTileDataManager(tile)
+    else:
+        return TransientTileDataManager(tile)
+
+
+class BaseTileDataManager:
+
+    def get_default_request_data(self):
+        """
+        from request form
+        """
+        # try to use a '_tiledata' parameter in the request
+        if "_tiledata" in self.tile.request.form:
+            data = json.loads(self.tile.request.form["_tiledata"])
+        elif self.tileType is None or self.tileType.schema is None:
+            data = self.tile.request.form.copy()
+        else:
+            # Try to decode the form data properly if we can
+            try:
+                data = decode(
+                    self.tile.request.form,
+                    self.tileType.schema,
+                    missing=True,
+                    primary=True,
+                )
+            except (
+                ValueError,
+                UnicodeDecodeError,
+            ):
+                LOGGER.exception("Could not convert form data to schema")
+                return self.data.copy()
+        # we're assuming this data is potentially unsafe so we need to check
+        # the ignore querystring field setting
+
+        # before we start, we allow it for sub-requests since in this case,
+        # the input is safe and we can trust it
+        if ISubRequest.providedBy(self.tile.request):
+            return data
+
+        # first off, we only care to filter if it is a GET request
+        if getattr(self.tile.request, "REQUEST_METHOD", "GET") != "GET":
+            return data
+
+        # now, pay attention to schema hints for form data
+        if self.tileType is not None and self.tileType.schema is not None:
+            for name in (
+                self.tileType.schema.queryTaggedValue(IGNORE_QUERYSTRING_KEY) or []
+            ):
+                if name in data:
+                    del data[name]
+
+        return data
+
+
+@adapter(ITile)
+@implementer(ITileDataManager)
+class TransientTileDataManager(BaseTileDataManager):
+    """A data manager for transient tile data, which reads data from the
+    request query string.
+    """
+
+    def __init__(self, tile):
+        self.tile = tile
+        self.tileType = queryUtility(ITileType, name=tile.__name__)
+
+        self.context = getMultiAdapter(
+            (tile.context, tile.request, tile), ITileDataContext
+        )
+        self.storage = getMultiAdapter(
+            (self.context, tile.request, tile), ITileDataStorage
+        )
+
+        if IAnnotations.providedBy(self.storage):
+            self.key = ".".join([ANNOTATIONS_KEY_PREFIX, str(tile.id)])
+        else:
+            self.key = str(tile.id)
+
+    @property
+    def annotations(self):  # BBB for < 0.7.0 support
+        return self.storage
+
+    def get(self):
+        # use explicitly set data (saved as annotation on the request)
+        if self.key in self.storage:
+            data = dict(self.storage[self.key])
+
+            if self.tileType is not None and self.tileType.schema is not None:
+                for name, field in getFields(self.tileType.schema).items():
+                    if name not in data:
+                        data[name] = field.missing_value
+        # fall back to the copy of request.form object itself
+        else:
+            data = self.get_default_request_data()
+
+        return data
+
+    def set(self, data):
+        self.storage[self.key] = data
+
+    def delete(self):
+        if self.key in self.storage:
+            self.storage[self.key] = {}
+
+
+@adapter(IPersistentTile)
+@implementer(ITileDataManager)
+class PersistentTileDataManager(BaseTileDataManager):
+    """A data reader for persistent tiles operating on annotatable contexts.
+    The data is retrieved from an annotation.
+    """
+
+    def __init__(self, tile):
+        self.tile = tile
+        self.tileType = queryUtility(ITileType, name=tile.__name__)
+
+        self.context = getMultiAdapter(
+            (tile.context, tile.request, tile), ITileDataContext
+        )
+        self.storage = getMultiAdapter(
+            (self.context, tile.request, tile), ITileDataStorage
+        )
+
+        if IAnnotations.providedBy(self.storage):
+            self.key = ".".join([ANNOTATIONS_KEY_PREFIX, str(tile.id)])
+        else:
+            self.key = str(tile.id)
+
+    @property
+    def annotations(self):  # BBB for < 0.7.0 support
+        return self.storage
+
+    def get(self):
+        data = self.get_default_request_data()
+        data.update(dict(self.storage.get(self.key, {})))
+        if self.tileType is not None and self.tileType.schema is not None:
+            for name, field in getFields(self.tileType.schema).items():
+                if name not in data:
+                    data[name] = field.missing_value
+        return data
+
+    def set(self, data):
+        self.storage[self.key] = PersistentDict(data)
+
+    def delete(self):
+        if self.key in self.storage:
+            del self.storage[self.key]
+
+
+@implementer(ITileDataContext)
+@adapter(Interface, Interface, ITile)
+def defaultTileDataContext(context, request, tile):
+    return tile.context
+
+
+@implementer(ITileDataStorage)
+@adapter(Interface, Interface, ITile)
+def defaultTileDataStorage(context, request, tile):
+    if tile.request.get("X-Tile-Persistent"):
+        return defaultPersistentTileDataStorage(context, request, tile)
+    else:
+        return IAnnotations(tile.request, tile.request.form)
+
+
+@implementer(ITileDataStorage)
+@adapter(Interface, Interface, IPersistentTile)
+def defaultPersistentTileDataStorage(context, request, tile):
+    return IAnnotations(context)
+
+
+# Encoding
+
+
+def map_to_pairs(encoded_name, value):
+    """Given an encoded basename, e.g. "foo:record" or "foo:record:list" and
+    a dictionary value, yields (encoded_name, value) pairs to be included
+    in the final encode.
+    """
+    prefix, postfix = encoded_name.split(":", 1)
+    postfix = postfix.replace("record:list", "records")
+
+    def guess_type(v):
+        if isinstance(v, str):
+            return ""
+        if isinstance(v, bool):
+            return ":boolean"
+        if isinstance(v, int):
+            return ":int"
+        if isinstance(v, float):
+            return ":float"
+        return ""
+
+    for item_name, item_value in value.items():
+        if isinstance(item_value, str):
+            item_value = item_value.encode("utf-8")
+
+        if isinstance(item_value, list) or isinstance(item_value, tuple):
+            for item_subvalue in item_value:
+                marshall_type = guess_type(item_subvalue)
+                if isinstance(item_subvalue, bool):
+                    item_subvalue = item_subvalue and "1" or ""
+                elif isinstance(item_subvalue, str):
+                    item_subvalue = item_subvalue.encode("utf-8")
+                encoded_name = "{}.{}{}:list:{}".format(
+                    prefix, item_name, marshall_type, postfix
+                )
+                yield encoded_name, item_subvalue
+        else:
+            marshall_type = guess_type(item_value)
+            if isinstance(item_value, bool):
+                item_value = item_value and "1" or ""
+            elif isinstance(item_value, str):
+                item_value = item_value.encode("utf-8")
+            encoded_name = "{:s}.{:s}{:s}:{:s}".format(
+                prefix, item_name, marshall_type, postfix
+            )
+            yield encoded_name, item_value
+
+
+def encode(data, schema, ignore=()):
+    """Given a data dictionary with key/value pairs and schema, return an
+    encoded query string. This is similar to urllib.urlencode(), but field
+    names will include the appropriate field type converters, e.g. an int
+    field will be encoded as fieldname:int=123. Fields not found in the data
+    dict will be ignored, and items in the dict not in the schema will also
+    be ignored. Additional fields to ignore can be passed with the 'ignore'
+    parameter. If any fields cannot be converted, a ComponentLookupError
+    will be raised.
+    """
+
+    encode = []
+
+    for name, field in getFieldsInOrder(schema):
+        if HAS_RFC822 and IPrimaryField.providedBy(field):
+            continue
+
+        if name in ignore or name not in data:
+            continue
+
+        converter = IFieldTypeConverter(field, None)
+        if converter is None:
+            raise ComponentLookupError(
+                f"Cannot URL encode {name} of type {field.__class__}"
+            )
+
+        encoded_name = name
+        if converter.token:
+            encoded_name = ":".join([name, converter.token])
+
+        value = data[name]
+        if value is None:
+            continue
+        elif isinstance(value, str):
+            value = value.encode("utf-8")
+
+        if ISequence.providedBy(field):
+            value_type_converter = IFieldTypeConverter(field.value_type, None)
+            if value_type_converter is None:
+                raise ComponentLookupError(
+                    "Cannot URL encode value type for {} of type "
+                    "{} : {}".format(name, field.__class__, field.value_type.__class__)
+                )
+
+            if value_type_converter.token:
+                encoded_name = ":".join(
+                    [name, value_type_converter.token, converter.token]
+                )
+
+            for item in value:
+
+                if isinstance(item, bool):
+                    item = item and "1" or ""
+                elif isinstance(item, str):
+                    item = item.encode("utf-8")
+
+                if isinstance(item, dict):
+                    encode.extend(map_to_pairs(encoded_name, item))
+                else:
+                    encode.append(
+                        (
+                            encoded_name,
+                            item,
+                        )
+                    )
+
+        else:
+            # The :bool converter just does bool() value, but urlencode() does
+            # str() on the object. The result is False => 'False' => True :(
+            if isinstance(value, bool):
+                value = value and "1" or ""
+
+            if isinstance(value, dict):
+                encode.extend(map_to_pairs(encoded_name, value))
+            else:
+                encode.append((encoded_name, value))
+
+    return parse.urlencode(encode)
+
+
+# Decoding
+
+
+def decode(data, schema, missing=True, primary=False):
+    """Decode a data dict according to a schema. The returned dictionary will
+    contain only keys matching schema names, and will force type values
+    appropriately.
+
+    This function is only necessary because the encoders used by encode()
+    are not sufficiently detailed to always return the exact type expected
+    by a field, e.g. resulting in ascii/unicode discrepancies.
+
+    If missing is True, fields that are in the schema but not in the data will
+    be set to field.missing_value. Otherwise, they are ignored.
+
+    If primary is True, also fields that are marged as primary fields are
+    decoded from the data. (Primary fields are not decoded by default,
+    because primary field are mainly used for rich text or binary fields
+    and data is usually parsed from query string with length limitations.)
+    """
+
+    decoded = {}
+
+    for name, field in getFields(schema).items():
+        if not primary and HAS_RFC822 and IPrimaryField.providedBy(field):
+            continue
+
+        if name not in data:
+            if missing:
+                decoded[name] = field.missing_value
+            continue
+
+        value = data[name]
+        if value is None:
+            continue
+
+        field_type = field._type
+        if isinstance(
+            field_type,
+            (
+                tuple,
+                list,
+            ),
+        ):
+            field_type = field_type[-1]
+
+        if ISequence.providedBy(field):
+            converted = []
+
+            value_type_field_type = field.value_type._type
+            if isinstance(
+                value_type_field_type,
+                (
+                    tuple,
+                    list,
+                ),
+            ):
+                value_type_field_type = value_type_field_type[-1]
+
+            for item in value:
+                if field.value_type._type and not isinstance(
+                    item, field.value_type._type
+                ):
+                    item = value_type_field_type(item)
+                converted.append(item)
+
+            value = converted
+        elif isinstance(value, (tuple, list)) and value:
+            value = value[0]
+
+        if isinstance(value, bytes):
+            value = value.decode("utf-8")
+
+        if field._type is not None and not isinstance(value, field._type):
+            value = field_type(value)
+
+        decoded[name] = value
+
+    return decoded

plone/tiles/data.rst

@@ -0,0 +1,179 @@
+======================
+Data encoding/decoding
+======================
+
+This test exercises the ``encode()`` and ``decode()`` methods in ``plone.tiles.data``.
+
+.. code-block:: python
+
+    >>> from zope.interface import Interface
+    >>> from zope import schema
+
+    >>> from plone.tiles.data import encode, decode
+
+Encoding
+--------
+
+First, we'll create a simple schema that exercises several field types:
+
+.. code-block:: python
+
+    >>> weekdays = [u'Monday', u'Tuesday', u'Wednesday', u'Thursday',
+    ...             u'Friday', u'Saturday', u'Sunday']
+    >>> class ISimple(Interface):
+    ...     text_line   = schema.TextLine(title=u'Text')
+    ...     ascii_line  = schema.ASCIILine(title=u'ASCII')
+    ...     text        = schema.Text(title=u'Text', missing_value=u'Missing')
+    ...     ascii       = schema.ASCII(title=u'ASCII')
+    ...     int         = schema.Int(title=u'Int')
+    ...     float       = schema.Float(title=u'Float')
+    ...     bool        = schema.Bool(title=u'Bool')
+    ...     weekday     = schema.Choice(title=u'Weekday', values=weekdays)
+    ...     list        = schema.List(value_type=schema.TextLine())
+    ...     listchoice  = schema.List(value_type=schema.Choice(vocabulary='foobar'))
+
+A simple encode produces a query string:
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line='B', text=u'C\nD', ascii='E\nF', int=3, float=1.2, bool=False, weekday=u'Saturday')
+    >>> encode(data, ISimple)
+    'text_line=A&ascii_line=B&text%3Atext=C%0AD&ascii%3Atext=E%0AF&int%3Along=3&float%3Afloat=1.2&bool%3Aboolean=&weekday=Saturday'
+
+Notice how a boolean is encoded as an empty value.
+If it were true, it'd be encoded as 1:
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line='B', text=u'C\nD', ascii='E\nF', int=3, float=1.2, bool=True, weekday=u'Saturday')
+    >>> encode(data, ISimple)
+    'text_line=A&ascii_line=B&text%3Atext=C%0AD&ascii%3Atext=E%0AF&int%3Along=3&float%3Afloat=1.2&bool%3Aboolean=1&weekday=Saturday'
+
+If the data dictionary has values not in the interface, they are ignored:
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line='B', text=u'C\nD', ascii='E\nF', int=3, float=1.2, bool=True, weekday=u'Saturday', foo=123)
+    >>> encode(data, ISimple)
+    'text_line=A&ascii_line=B&text%3Atext=C%0AD&ascii%3Atext=E%0AF&int%3Along=3&float%3Afloat=1.2&bool%3Aboolean=1&weekday=Saturday'
+
+If the data dictionary omits some fields, they are ignored.
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line='B', text=u'C\nD', ascii='E\nF', float=1.2, bool=True, foo=123)
+    >>> encode(data, ISimple)
+    'text_line=A&ascii_line=B&text%3Atext=C%0AD&ascii%3Atext=E%0AF&float%3Afloat=1.2&bool%3Aboolean=1'
+
+It is also possible to explicitly ignore some fields:
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line='B', text=u'C\nD', ascii='E\nF', float=1.2, bool=True, foo=123)
+    >>> encode(data, ISimple, ignore=('text_line', 'text',))
+    'ascii_line=B&ascii%3Atext=E%0AF&float%3Afloat=1.2&bool%3Aboolean=1'
+
+Lists and tuples may also be encoded. The value type will be encoded as well.
+
+.. code-block:: python
+
+    >>> class ISequences(Interface):
+    ...     list    = schema.List(title=u'List', value_type=schema.ASCIILine(title=u'Text'))
+    ...     tuple   = schema.Tuple(title=u'List', value_type=schema.Int(title=u'Int'))
+
+    >>> data = dict(list=['a', 'b'], tuple=(1,2,3))
+    >>> encode(data, ISequences)
+    'list%3Alist=a&list%3Alist=b&tuple%3Along%3Atuple=1&tuple%3Along%3Atuple=2&tuple%3Along%3Atuple=3'
+
+Even dictionaries may be encoded. And the value type will be encoded as well.
+
+.. code-block:: python
+
+    >>> class IRecords(Interface):
+    ...     record = schema.Dict(title=u'Record')
+    ...     records = schema.List(title=u'Records', value_type=schema.Dict())
+
+    >>> data = dict(record={'a': 'b', 'c': True}, records=[{'a': 'b', 'c': True}])
+    >>> encode(data, IRecords)
+    'record.a%3Arecord=b&record.c%3Aboolean%3Arecord=1&records.a%3Arecords=b&records.c%3Aboolean%3Arecords=1'
+
+Unsupported fields will raise a ComponentLookupError.
+This also applies to the value_type of a list or tuple:
+
+.. code-block:: python
+
+    >>> class IUnsupported(Interface):
+    ...     decimal     = schema.Decimal(title=u'Decimal')
+    ...     list        = schema.List(title=u'Set', value_type=schema.Decimal(title=u'Decimal'))
+    ...     bytes_line  = schema.BytesLine(title=u'Bytes line')
+
+    >>> from decimal import Decimal
+    >>> data = dict(decimal=Decimal(2), list=[Decimal(1), Decimal(2),], bytes_line='abc')
+    >>> encode(data, IUnsupported) # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    zope.interface.interfaces.ComponentLookupError: Cannot URL encode decimal of type <class 'zope.schema...Decimal'>
+
+    >>> encode(data, IUnsupported, ignore=('decimal',)) # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    zope.interface.interfaces.ComponentLookupError: Cannot URL encode value type for list of type <class 'zope.schema._field.List'> : <class 'zope.schema...Decimal'>
+
+    >>> encode(data, IUnsupported, ignore=('decimal', 'list',))
+    'bytes_line=abc'
+
+Decoding
+--------
+
+The decoder exists because the Zope form marshalers are not perfect:
+for instance, they cannot adequately deal with the differences between unicode and ASCII.
+``zope.schema`` is picky about that sort of thing.
+
+Let's use a data dictionary that may have come back from a query string like the first example above.
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line=u'B', text=u'C\nD', ascii=u'E\nF', int=3, float=1.2, bool=False, weekday=u'Saturday')
+    >>> sorted(decode(data, ISimple).items())
+    [('ascii', 'E\nF'), ('ascii_line', 'B'), ('bool', False), ('float', 1.2), ('int', 3), ('list', None), ('listchoice', None), ('text', 'C\nD'), ('text_line', 'A'), ('weekday', 'Saturday')]
+
+If any values are missing from the input dictionary,
+they will default to ``missing_value``.
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line=u'B', int=3, float=1.2, bool=False, weekday=u'Saturday')
+    >>> sorted(decode(data, ISimple).items())
+    [('ascii', None), ('ascii_line', 'B'), ('bool', False), ('float', 1.2), ('int', 3), ('list', None), ('listchoice', None), ('text', 'Missing'), ('text_line', 'A'), ('weekday', 'Saturday')]
+
+If you pass ``missing=False``, the values are ignored instead.
+
+.. code-block:: python
+
+    >>> data = dict(text_line=u'A', ascii_line=u'B', int=3, float=1.2, bool=False)
+    >>> sorted(decode(data, ISimple, missing=False).items())
+    [('ascii_line', 'B'), ('bool', False), ('float', 1.2), ('int', 3), ('text_line', 'A')]
+
+Decoding also works for lists and their value types:
+
+.. code-block:: python
+
+    >>> data = dict(list=[u'a', u'b'])
+    >>> sorted(decode(data, ISequences, missing=False).items())
+    [('list', ['a', 'b'])]
+
+Decoding should work with lists and the ISimple schema
+
+.. code-block:: python
+
+    >>> data = dict(list=['a', 'b'])
+    >>> sorted(decode(data, ISimple, missing=False).items())
+    [('list', ['a', 'b'])]
+
+And list choice fields
+
+.. code-block:: python
+
+    >>> data = dict(listchoice=['a', 'b'])
+    >>> sorted(decode(data, ISimple, missing=False).items())
+    [('listchoice', ['a', 'b'])]

plone/tiles/directives.py

@@ -0,0 +1,13 @@
+from plone.supermodel.directives import MetadataListDirective
+
+
+IGNORE_QUERYSTRING_KEY = "plone.tiles.ignore_querystring"
+
+
+class ignore_querystring(MetadataListDirective):
+    """Directive used to create fieldsets"""
+
+    key = IGNORE_QUERYSTRING_KEY
+
+    def factory(self, name):
+        return [name]