modelscope-studio/backend/modelscope_studio/components/antd/image/__init__.py at 8a7c750f4ebfccf18ad16687e323a7c5f9a4bbad · modelscope/modelscope-studio · GitHub

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from __future__ import annotations

from pathlib import Path
from typing import Any, Union

from gradio import processing_utils
from gradio.data_classes import FileData, GradioRootModel
from gradio.events import EventListener

from ....utils.dev import ModelScopeDataLayoutComponent, resolve_frontend_dir
from .preview_group import AntdImagePreviewGroup


class AntdImageData(GradioRootModel):
    root: Union[FileData, str]


class AntdImage(ModelScopeDataLayoutComponent):
    """
    Ant Design: https://ant.design/components/image
    """
    PreviewGroup = AntdImagePreviewGroup

    EVENTS = [
        EventListener("error",
                      callback=lambda block: block._internal.update(
                          bind_error_event=True)),
        EventListener("preview_transform",
                      callback=lambda block: block._internal.update(
                          bind_preview_transform_event=True)),
        EventListener("preview_visible_change",
                      callback=lambda block: block._internal.update(
                          bind_preview_visibleChange_event=True))
    ]

    # supported slots
    SLOTS = [
        'placeholder',
        'preview.mask',
        'preview.closeIcon',
        'preview.toolbarRender',
        'preview.imageRender',
    ]

    def __init__(
            self,
            value: str | None = None,
            additional_props: dict | None = None,
            *,
            alt: str | None = None,
            fallback: str | None = None,
            mask: bool | dict | None = None,
            height: str | int | float | None = None,
            placeholder: bool | str | int | float | None = None,
            preview: bool | dict | None = None,
            focus_trap: bool | None = None,
            width: str | int | float | None = None,
            root_class_name: str | None = None,
            class_names: dict | str | None = None,
            styles: dict | str | None = None,
            as_item: str | None = None,
            _internal: None = None,
            # gradio properties
            visible: bool = True,
            elem_id: str | None = None,
            elem_classes: list[str] | str | None = None,
            elem_style: dict | None = None,
            render: bool = True,
            **kwargs):
        super().__init__(value=value,
                         visible=visible,
                         elem_id=elem_id,
                         elem_classes=elem_classes,
                         render=render,
                         as_item=as_item,
                         elem_style=elem_style,
                         **kwargs)
        self.class_names = class_names
        self.styles = styles
        self.additional_props = additional_props
        self.alt = alt
        self.fallback = fallback
        self.height = height
        self.mask = mask
        self.focus_trap = focus_trap
        self.placeholder = placeholder
        self.preview = preview
        self.width = width
        self.root_class_name = root_class_name

    FRONTEND_DIR = resolve_frontend_dir("image")

    data_model = AntdImageData

    @property
    def skip_api(self):
        return True

    def preprocess(
            self,
            payload: str | AntdImageData | None) -> str | AntdImageData | None:
        if isinstance(payload, AntdImageData):
            value = payload.root
            if isinstance(value, FileData):
                return value.path
            return value
        return payload

    def postprocess(self, value: str | None) -> str | None:
        if value is None:
            return None
        if value.startswith("http") or value.startswith("data"):
            return AntdImageData(root=value)
        file = processing_utils.move_resource_to_block_cache(value, self)
        return AntdImageData(root=FileData(path=file,
                                           orig_name=Path(file).name,
                                           size=Path(file).stat().st_size))

    def example_payload(self) -> Any:
        return None

    def example_value(self) -> Any:
        return None