1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

from uuid import uuid4
from zope.interface import Interface
from zope.interface import implements
from zope.annotation import IAnnotations
from UserDict import DictMixin


class IImageScaleStorage(Interface):
    """ adapter for image content and field which can store, retrieve and
        generate image scale data """

    def scale(create=True, **parameters):
        """ find or optionally create image scale data using the given
            parameters, which can be anything supported by `scaleImage` """

    def __getitem__(uid):
        """ find image scale data based on its uid """


class AbstractStorage(DictMixin):
    """ an abstract storage for image scales using annotations """
    implements(IImageScaleStorage)

    def __init__(self, context, field):
        self.context = context
        self.field = field

    @property
    def fieldname(self):
        return self.field.getName()

    @property
    def storage(self):
        return IAnnotations(self.context).setdefault('scales', {})

    def create(self, **parameters):
        raise NotImplemented

    def hash(self, **parameters):
        return tuple(sorted(parameters.items()))

    def scale(self, create=True, **parameters):
        key = self.hash(fieldname=self.fieldname, **parameters)
        storage = self.storage
        info = storage.get(key)
        if info is None and create:
            data, format, dimensions = self.create(**parameters)
            width, height = dimensions
            uid = str(uuid4())
            info = dict(id=uid, data=data, width=width, height=height,
                mimetype='image/%s' % format.lower(), key=key)
            storage[key] = storage[uid] = info
        return info

    def __getitem__(self, uid):
        return self.storage[uid]

    def __delitem__(self, uid):
        storage = self.storage
        info = storage[uid]
        del storage[info['key']]
        del storage[uid]

    def __iter__(self):
        return iter(self.storage)

    def keys(self):
        return self.storage.keys()

    def has_key(self, uid):
        return self.storage.has_key(uid)

    __contains__ = has_key