File size: 3,406 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
from __future__ import annotations
from collections.abc import Sequence
from typing import Any


def batch_image_data(media: Sequence[Any]) -> list[Any]:
    if all((item is None for item in media)):
        return list(media)
    return [item if item is not None else [] for item in media]


def _grid_identity(grid: Any) -> Any:
    if hasattr(grid, "tolist"):
        grid = grid.tolist()
    if isinstance(grid, (list, tuple)):
        return tuple((_grid_identity(value) for value in grid))
    if isinstance(grid, (str, int, float, bool, type(None))):
        return grid
    return ("opaque", id(grid))


def _media_identity(media: Any) -> tuple[Any, ...]:
    if media is None:
        return ("text",)
    if not isinstance(media, list) or not media:
        return ("opaque", id(media))
    identities = []
    for item in media:
        if (
            not isinstance(item, dict)
            or item.get("format") != "processor_output"
            or (not isinstance(item.get("clair_media_digest"), str))
            or (item.get("pixel_values") is None)
        ):
            return ("opaque", id(media))
        identities.append(
            (
                item["clair_media_digest"],
                id(item["pixel_values"]),
                _grid_identity(item.get("image_grid_thw")),
            )
        )
    return ("prepared", tuple(identities))


def _common_prefix(tasks: list[tuple[str, list[int], Any]]) -> list[int]:
    (first, last) = (min((task[1] for task in tasks)), max((task[1] for task in tasks)))
    length = next(
        (i for (i, (left, right)) in enumerate(zip(first, last)) if left != right),
        min(len(first), len(last)),
    )
    return list(first[:length])


def media_warmup_groups(
    tasks: list[tuple[str, list[int], Any]],
    *,
    default_salt: str,
    task_salts: dict[str, str] | None = None,
    annotations: dict[str, dict[str, Any]] | None = None,
    min_prefix_tokens: int = 128,
) -> list[dict[str, Any]]:
    (task_salts, annotations) = (task_salts or {}, annotations or {})
    partitions: dict[tuple[str, tuple[Any, ...]], dict[str, Any]] = {}
    for task in tasks:
        (name, _, media) = task
        salt = task_salts.get(name, default_salt)
        key = (salt, _media_identity(media))
        partitions.setdefault(key, {"media": media, "salt": salt, "tasks": []})[
            "tasks"
        ].append(task)
    records = []
    for partition in partitions.values():
        members = partition["tasks"]
        if len(members) < 2:
            continue
        prefix = _common_prefix(members)
        if len(prefix) < min_prefix_tokens:
            prefix = []
        parents: dict[str, list[tuple[str, list[int], Any]]] = {}
        for task in members:
            parent = annotations.get(task[0], {}).get("parent")
            if parent:
                parents.setdefault(parent, []).append(task)
        subgroups = [
            _common_prefix(group) for group in parents.values() if len(group) > 1
        ]
        subgroups = [group for group in subgroups if group and group != prefix]
        if prefix or subgroups:
            records.append(
                {
                    "prefix_ids": prefix,
                    "media": partition["media"],
                    "salt": partition["salt"],
                    "group_prefix_ids": subgroups,
                }
            )
    return records