File size: 3,515 Bytes
f65336d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
from __future__ import annotations
from collections.abc import Iterable
from typing import TYPE_CHECKING, Any, cast

if TYPE_CHECKING:
    from .api import ClairImage
    from .documents import ClairDocument
    from PIL import Image
    from .model import EncodedMedia
import copy
import hashlib
import uuid
from collections import OrderedDict
from dataclasses import dataclass


@dataclass(frozen=True)
class PreparedImages:
    images: list[Image.Image]
    media: EncodedMedia
    payload: list[dict[str, Any]]
    salt: str
    size: int
    source_images: list[Image.Image] | None = None


class ImageCache:
    _share_image_row_description: bool

    def __init__(
        self, max_bytes: int = 128 * 1024 * 1024, max_entries: int = 8
    ) -> None:
        (self.max_bytes, self.max_entries) = (max_bytes, max_entries)
        self.namespace = uuid.uuid4().hex
        self.entries: OrderedDict[str, PreparedImages] = OrderedDict()
        self.size = 0

    def clear(self) -> None:
        self.entries.clear()
        self.size = 0

    @staticmethod
    def key(images: Iterable[ClairImage | ClairDocument]) -> str:
        digest = hashlib.sha256()
        for image in images:
            content = image.base64.encode()
            digest.update(getattr(image, "content_type", "image").encode())
            digest.update(str(getattr(image, "rotation", 0)).encode())
            digest.update(bytes(["rotation" in getattr(image, "model_fields_set", ())]))
            digest.update(len(content).to_bytes(8, "big"))
            digest.update(content)
        return digest.hexdigest()

    def get(self, key: str) -> PreparedImages | None:
        entry = self.entries.get(key)
        if entry is not None:
            self.entries.move_to_end(key)
        return entry

    def put(
        self,
        key: str,
        images: list[Image.Image],
        media: EncodedMedia,
        payload: list[dict[str, Any]],
        *,
        source_images: list[Image.Image] | None = None,
    ) -> PreparedImages:
        tensors = {}
        for mapping in (cast(dict[str, Any], media.media), *payload):
            for value in mapping.values():
                if hasattr(value, "numel"):
                    tensors[id(value)] = value.numel() * value.element_size()
        source_images = images if source_images is None else source_images
        retained = {id(image): image for image in [*images, *source_images]}
        size = sum(tensors.values()) + sum(
            (image.width * image.height * 3 for image in retained.values())
        )
        if (
            media.media
            and len(payload) == 1
            and ("pixel_values" in media.media)
            and ("pixel_values" in payload[0])
        ):
            media = copy.copy(media)
            media.media = {
                **cast(dict[str, Any], media.media),
                "pixel_values": payload[0]["pixel_values"],
            }
        entry = PreparedImages(
            images, media, payload, uuid.uuid4().hex, size, source_images
        )
        if size > self.max_bytes:
            return entry
        old = self.entries.pop(key, None)
        if old is not None:
            self.size -= old.size
        while self.entries and (
            self.size + size > self.max_bytes or len(self.entries) >= self.max_entries
        ):
            (_, old) = self.entries.popitem(last=False)
            self.size -= old.size
        self.entries[key] = entry
        self.size += size
        return entry