Skip to content

object_models

SDKParameterSetTypeVar module-attribute 

SDKParameterSetTypeVar = TypeVar(
    "SDKParameterSetTypeVar", bound=CompositeParametersBase
)

BackendSamplersTypeVar module-attribute 

BackendSamplersTypeVar = TypeVar(
    "BackendSamplersTypeVar", bound=StrEnum
)

BackendSchedulersTypeVar module-attribute 

BackendSchedulersTypeVar = TypeVar(
    "BackendSchedulersTypeVar", bound=StrEnum
)

BackendControlnetsTypeVar module-attribute 

BackendControlnetsTypeVar = TypeVar(
    "BackendControlnetsTypeVar", bound=StrEnum
)

MappingOutputTypeVar module-attribute 

MappingOutputTypeVar = TypeVar(
    "MappingOutputTypeVar", bound=StrEnum
)

BackendValuesMapper

Bases: ABC

Base class for all backend values mappers.

Value mappers provide a way to convert between the backend representations and the SDK representations of certain values. For example, a backend may use a different name for a sampler than the SDK, even though they are referring to the same thing.

Source code in horde_sdk/backend_parsing/object_models.py 
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
class BackendValuesMapper[SDKParameterSetTypeVar: CompositeParametersBase](ABC):
    """Base class for all backend values mappers.

    Value mappers provide a way to convert between the backend representations and the SDK representations of
    certain values. For example, a backend may use a different name for a sampler than the SDK, even though they are
    referring to the same thing.
    """

    _worker_type: WORKER_TYPE
    _inference_backend: KNOWN_INFERENCE_BACKEND

    def _map_value(
        self,
        value: str,
        mapping: dict[str, MappingOutputTypeVar],
        known_input_type: type[StrEnum],
        known_target_type: type[MappingOutputTypeVar],
    ) -> MappingOutputTypeVar:
        if len(mapping) == 0:
            return known_target_type(value)

        if isinstance(value, known_input_type):
            if value in mapping:
                return mapping[value]

            return known_target_type[value.name]

        if isinstance(value, str):
            if value in mapping:
                return mapping[value]
            if value in known_target_type.__members__:
                return known_target_type[value]
            if value in known_target_type.__members__.values():
                return known_target_type(value)

        raise TypeError(
            f"Invalid type for value: {type(value)}, {value}",
        )

    def _is_valid_value(
        self,
        value: str,
        known_type: type[StrEnum],
    ) -> bool:
        """Check if a value is valid for a given known type."""
        if isinstance(value, known_type):
            return True

        if isinstance(value, str):
            if value in known_type.__members__:
                return True
            if value in known_type.__members__.values():
                return True

        return False

ImageBackendValuesMapper

Bases: BackendValuesMapper[ImageGenerationParametersTemplate]

Base class for all image backend values mappers.

Image backends often refer to samplers and schedulers in different ways in addition to the SDK having its own representation of these values.

See :class:BackendValuesMapper for more information.

Source code in horde_sdk/backend_parsing/object_models.py 
 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
class ImageBackendValuesMapper[
    BackendSamplersTypeVar: StrEnum,
    BackendSchedulersTypeVar: StrEnum,
    BackendControlnetsTypeVar: StrEnum,
](
    BackendValuesMapper[ImageGenerationParametersTemplate],
):
    """Base class for all image backend values mappers.

    Image backends often refer to samplers and schedulers in different ways in addition to the SDK having its own
    representation of these values.

    See :class:`BackendValuesMapper` for more information.
    """

    _backend_samplers_type: type[BackendSamplersTypeVar]
    _backend_schedulers_type: type[BackendSchedulersTypeVar]
    _backend_controlnets_type: type[BackendControlnetsTypeVar]

    _to_sdk_sampler_map: dict[BackendSamplersTypeVar | str, KNOWN_IMAGE_SAMPLERS]
    _to_sdk_scheduler_map: dict[BackendSchedulersTypeVar | str, KNOWN_IMAGE_SCHEDULERS]
    _to_sdk_controlnet_map: dict[BackendControlnetsTypeVar | str, KNOWN_IMAGE_CONTROLNETS]

    _to_backend_sampler_map: dict[KNOWN_IMAGE_SAMPLERS | str, BackendSamplersTypeVar]
    _to_backend_scheduler_map: dict[KNOWN_IMAGE_SCHEDULERS | str, BackendSchedulersTypeVar]
    _to_backend_controlnet_map: dict[KNOWN_IMAGE_CONTROLNETS | str, BackendControlnetsTypeVar]

    def __init__(
        self,
        *,
        backend_samplers_type: type[BackendSamplersTypeVar],
        backend_schedulers_type: type[BackendSchedulersTypeVar],
        backend_controlnets_type: type[BackendControlnetsTypeVar],
        sdk_samplers_map: dict[BackendSamplersTypeVar | str, KNOWN_IMAGE_SAMPLERS],
        sdk_schedulers_map: dict[BackendSchedulersTypeVar | str, KNOWN_IMAGE_SCHEDULERS],
        sdk_controlnets_map: dict[BackendControlnetsTypeVar | str, KNOWN_IMAGE_CONTROLNETS],
    ) -> None:
        """Initialize the image backend values mapper.

        Args:
            backend_samplers_type: The backend samplers type.
            backend_schedulers_type: The backend schedulers type.
            backend_controlnets_type: The backend controlnets type.
            sdk_samplers_map: The SDK samplers mapping.
            sdk_schedulers_map: The SDK schedulers mapping.
            sdk_controlnets_map: The SDK controlnets mapping.
        """
        self._backend_samplers_type = backend_samplers_type
        self._backend_schedulers_type = backend_schedulers_type
        self._backend_controlnets = backend_controlnets_type

        self._to_sdk_sampler_map = sdk_samplers_map
        self._to_sdk_scheduler_map = sdk_schedulers_map
        self._to_sdk_controlnet_map = sdk_controlnets_map

        self._to_backend_sampler_map = {v: backend_samplers_type(k) for k, v in sdk_samplers_map.items()}
        self._to_backend_scheduler_map = {v: backend_schedulers_type(k) for k, v in sdk_schedulers_map.items()}
        self._to_backend_controlnet_map = {v: backend_controlnets_type(k) for k, v in sdk_controlnets_map.items()}

    def map_to_sdk_sampler(
        self,
        backend_sampler: BackendSamplersTypeVar | str,
    ) -> KNOWN_IMAGE_SAMPLERS:
        """Map a backend sampler to a SDK sampler."""
        return self._map_value(
            value=backend_sampler,
            mapping=self._to_sdk_sampler_map,
            known_input_type=self._backend_samplers_type,
            known_target_type=KNOWN_IMAGE_SAMPLERS,
        )

    def map_to_backend_sampler(
        self,
        sdk_sampler: KNOWN_IMAGE_SAMPLERS | str,
    ) -> BackendSamplersTypeVar | str:
        """Map a SDK sampler to a backend sampler."""
        return self._map_value(
            value=sdk_sampler,
            mapping=self._to_backend_sampler_map,
            known_input_type=KNOWN_IMAGE_SAMPLERS,
            known_target_type=self._backend_samplers_type,
        )

    def is_valid_backend_sampler(
        self,
        backend_sampler: BackendSamplersTypeVar | str,
    ) -> bool:
        """Check if a backend sampler is valid."""
        return self._is_valid_value(
            value=backend_sampler,
            known_type=self._backend_samplers_type,
        )

    def map_to_sdk_scheduler(
        self,
        backend_scheduler: BackendSchedulersTypeVar | str,
    ) -> KNOWN_IMAGE_SCHEDULERS:
        """Map a backend scheduler to a SDK scheduler."""
        return self._map_value(
            value=backend_scheduler,
            mapping=self._to_sdk_scheduler_map,
            known_input_type=self._backend_schedulers_type,
            known_target_type=KNOWN_IMAGE_SCHEDULERS,
        )

    def map_to_backend_scheduler(
        self,
        sdk_scheduler: KNOWN_IMAGE_SCHEDULERS | str,
    ) -> BackendSchedulersTypeVar | str:
        """Map a SDK scheduler to a backend scheduler."""
        return self._map_value(
            value=sdk_scheduler,
            mapping=self._to_backend_scheduler_map,
            known_input_type=KNOWN_IMAGE_SCHEDULERS,
            known_target_type=self._backend_schedulers_type,
        )

    def is_valid_backend_scheduler(
        self,
        backend_scheduler: BackendSchedulersTypeVar | str,
    ) -> bool:
        """Check if a backend scheduler is valid."""
        return self._is_valid_value(
            value=backend_scheduler,
            known_type=self._backend_schedulers_type,
        )

    def map_to_sdk_controlnet(
        self,
        backend_controlnet: BackendControlnetsTypeVar | str,
    ) -> KNOWN_IMAGE_CONTROLNETS:
        """Map a backend controlnet to a SDK controlnet."""
        return self._map_value(
            value=backend_controlnet,
            mapping=self._to_sdk_controlnet_map,
            known_input_type=self._backend_controlnets,
            known_target_type=KNOWN_IMAGE_CONTROLNETS,
        )

    def map_to_backend_controlnet(
        self,
        sdk_controlnet: KNOWN_IMAGE_CONTROLNETS | str,
    ) -> BackendControlnetsTypeVar | str:
        """Map a SDK controlnet to a backend controlnet."""
        return self._map_value(
            value=sdk_controlnet,
            mapping=self._to_backend_controlnet_map,
            known_input_type=KNOWN_IMAGE_CONTROLNETS,
            known_target_type=self._backend_controlnets,
        )

    def is_valid_backend_controlnet(
        self,
        backend_controlnet: BackendControlnetsTypeVar | str,
    ) -> bool:
        """Check if a backend controlnet is valid."""
        return self._is_valid_value(
            value=backend_controlnet,
            known_type=self._backend_controlnets,
        )

__init__ 

__init__(
    *,
    backend_samplers_type: type[BackendSamplersTypeVar],
    backend_schedulers_type: type[BackendSchedulersTypeVar],
    backend_controlnets_type: type[
        BackendControlnetsTypeVar
    ],
    sdk_samplers_map: dict[
        BackendSamplersTypeVar | str, KNOWN_IMAGE_SAMPLERS
    ],
    sdk_schedulers_map: dict[
        BackendSchedulersTypeVar | str,
        KNOWN_IMAGE_SCHEDULERS,
    ],
    sdk_controlnets_map: dict[
        BackendControlnetsTypeVar | str,
        KNOWN_IMAGE_CONTROLNETS,
    ]
) -> None

Initialize the image backend values mapper.

Parameters:

  • backend_samplers_type (type[BackendSamplersTypeVar]) –

    The backend samplers type.

  • backend_schedulers_type (type[BackendSchedulersTypeVar]) –

    The backend schedulers type.

  • backend_controlnets_type (type[BackendControlnetsTypeVar]) –

    The backend controlnets type.

  • sdk_samplers_map (dict[BackendSamplersTypeVar | str, KNOWN_IMAGE_SAMPLERS]) –

    The SDK samplers mapping.

  • sdk_schedulers_map (dict[BackendSchedulersTypeVar | str, KNOWN_IMAGE_SCHEDULERS]) –

    The SDK schedulers mapping.

  • sdk_controlnets_map (dict[BackendControlnetsTypeVar | str, KNOWN_IMAGE_CONTROLNETS]) –

    The SDK controlnets mapping.

Source code in horde_sdk/backend_parsing/object_models.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def __init__(
    self,
    *,
    backend_samplers_type: type[BackendSamplersTypeVar],
    backend_schedulers_type: type[BackendSchedulersTypeVar],
    backend_controlnets_type: type[BackendControlnetsTypeVar],
    sdk_samplers_map: dict[BackendSamplersTypeVar | str, KNOWN_IMAGE_SAMPLERS],
    sdk_schedulers_map: dict[BackendSchedulersTypeVar | str, KNOWN_IMAGE_SCHEDULERS],
    sdk_controlnets_map: dict[BackendControlnetsTypeVar | str, KNOWN_IMAGE_CONTROLNETS],
) -> None:
    """Initialize the image backend values mapper.

    Args:
        backend_samplers_type: The backend samplers type.
        backend_schedulers_type: The backend schedulers type.
        backend_controlnets_type: The backend controlnets type.
        sdk_samplers_map: The SDK samplers mapping.
        sdk_schedulers_map: The SDK schedulers mapping.
        sdk_controlnets_map: The SDK controlnets mapping.
    """
    self._backend_samplers_type = backend_samplers_type
    self._backend_schedulers_type = backend_schedulers_type
    self._backend_controlnets = backend_controlnets_type

    self._to_sdk_sampler_map = sdk_samplers_map
    self._to_sdk_scheduler_map = sdk_schedulers_map
    self._to_sdk_controlnet_map = sdk_controlnets_map

    self._to_backend_sampler_map = {v: backend_samplers_type(k) for k, v in sdk_samplers_map.items()}
    self._to_backend_scheduler_map = {v: backend_schedulers_type(k) for k, v in sdk_schedulers_map.items()}
    self._to_backend_controlnet_map = {v: backend_controlnets_type(k) for k, v in sdk_controlnets_map.items()}

map_to_sdk_sampler 

map_to_sdk_sampler(
    backend_sampler: BackendSamplersTypeVar | str,
) -> KNOWN_IMAGE_SAMPLERS

Map a backend sampler to a SDK sampler.

Source code in horde_sdk/backend_parsing/object_models.py 
141
142
143
144
145
146
147
148
149
150
151
def map_to_sdk_sampler(
    self,
    backend_sampler: BackendSamplersTypeVar | str,
) -> KNOWN_IMAGE_SAMPLERS:
    """Map a backend sampler to a SDK sampler."""
    return self._map_value(
        value=backend_sampler,
        mapping=self._to_sdk_sampler_map,
        known_input_type=self._backend_samplers_type,
        known_target_type=KNOWN_IMAGE_SAMPLERS,
    )

map_to_backend_sampler 

map_to_backend_sampler(
    sdk_sampler: KNOWN_IMAGE_SAMPLERS | str,
) -> BackendSamplersTypeVar | str

Map a SDK sampler to a backend sampler.

Source code in horde_sdk/backend_parsing/object_models.py 
153
154
155
156
157
158
159
160
161
162
163
def map_to_backend_sampler(
    self,
    sdk_sampler: KNOWN_IMAGE_SAMPLERS | str,
) -> BackendSamplersTypeVar | str:
    """Map a SDK sampler to a backend sampler."""
    return self._map_value(
        value=sdk_sampler,
        mapping=self._to_backend_sampler_map,
        known_input_type=KNOWN_IMAGE_SAMPLERS,
        known_target_type=self._backend_samplers_type,
    )

is_valid_backend_sampler 

is_valid_backend_sampler(
    backend_sampler: BackendSamplersTypeVar | str,
) -> bool

Check if a backend sampler is valid.

Source code in horde_sdk/backend_parsing/object_models.py 
165
166
167
168
169
170
171
172
173
def is_valid_backend_sampler(
    self,
    backend_sampler: BackendSamplersTypeVar | str,
) -> bool:
    """Check if a backend sampler is valid."""
    return self._is_valid_value(
        value=backend_sampler,
        known_type=self._backend_samplers_type,
    )

map_to_sdk_scheduler 

map_to_sdk_scheduler(
    backend_scheduler: BackendSchedulersTypeVar | str,
) -> KNOWN_IMAGE_SCHEDULERS

Map a backend scheduler to a SDK scheduler.

Source code in horde_sdk/backend_parsing/object_models.py 
175
176
177
178
179
180
181
182
183
184
185
def map_to_sdk_scheduler(
    self,
    backend_scheduler: BackendSchedulersTypeVar | str,
) -> KNOWN_IMAGE_SCHEDULERS:
    """Map a backend scheduler to a SDK scheduler."""
    return self._map_value(
        value=backend_scheduler,
        mapping=self._to_sdk_scheduler_map,
        known_input_type=self._backend_schedulers_type,
        known_target_type=KNOWN_IMAGE_SCHEDULERS,
    )

map_to_backend_scheduler 

map_to_backend_scheduler(
    sdk_scheduler: KNOWN_IMAGE_SCHEDULERS | str,
) -> BackendSchedulersTypeVar | str

Map a SDK scheduler to a backend scheduler.

Source code in horde_sdk/backend_parsing/object_models.py 
187
188
189
190
191
192
193
194
195
196
197
def map_to_backend_scheduler(
    self,
    sdk_scheduler: KNOWN_IMAGE_SCHEDULERS | str,
) -> BackendSchedulersTypeVar | str:
    """Map a SDK scheduler to a backend scheduler."""
    return self._map_value(
        value=sdk_scheduler,
        mapping=self._to_backend_scheduler_map,
        known_input_type=KNOWN_IMAGE_SCHEDULERS,
        known_target_type=self._backend_schedulers_type,
    )

is_valid_backend_scheduler 

is_valid_backend_scheduler(
    backend_scheduler: BackendSchedulersTypeVar | str,
) -> bool

Check if a backend scheduler is valid.

Source code in horde_sdk/backend_parsing/object_models.py 
199
200
201
202
203
204
205
206
207
def is_valid_backend_scheduler(
    self,
    backend_scheduler: BackendSchedulersTypeVar | str,
) -> bool:
    """Check if a backend scheduler is valid."""
    return self._is_valid_value(
        value=backend_scheduler,
        known_type=self._backend_schedulers_type,
    )

map_to_sdk_controlnet 

map_to_sdk_controlnet(
    backend_controlnet: BackendControlnetsTypeVar | str,
) -> KNOWN_IMAGE_CONTROLNETS

Map a backend controlnet to a SDK controlnet.

Source code in horde_sdk/backend_parsing/object_models.py 
209
210
211
212
213
214
215
216
217
218
219
def map_to_sdk_controlnet(
    self,
    backend_controlnet: BackendControlnetsTypeVar | str,
) -> KNOWN_IMAGE_CONTROLNETS:
    """Map a backend controlnet to a SDK controlnet."""
    return self._map_value(
        value=backend_controlnet,
        mapping=self._to_sdk_controlnet_map,
        known_input_type=self._backend_controlnets,
        known_target_type=KNOWN_IMAGE_CONTROLNETS,
    )

map_to_backend_controlnet 

map_to_backend_controlnet(
    sdk_controlnet: KNOWN_IMAGE_CONTROLNETS | str,
) -> BackendControlnetsTypeVar | str

Map a SDK controlnet to a backend controlnet.

Source code in horde_sdk/backend_parsing/object_models.py 
221
222
223
224
225
226
227
228
229
230
231
def map_to_backend_controlnet(
    self,
    sdk_controlnet: KNOWN_IMAGE_CONTROLNETS | str,
) -> BackendControlnetsTypeVar | str:
    """Map a SDK controlnet to a backend controlnet."""
    return self._map_value(
        value=sdk_controlnet,
        mapping=self._to_backend_controlnet_map,
        known_input_type=KNOWN_IMAGE_CONTROLNETS,
        known_target_type=self._backend_controlnets,
    )

is_valid_backend_controlnet 

is_valid_backend_controlnet(
    backend_controlnet: BackendControlnetsTypeVar | str,
) -> bool

Check if a backend controlnet is valid.

Source code in horde_sdk/backend_parsing/object_models.py 
233
234
235
236
237
238
239
240
241
def is_valid_backend_controlnet(
    self,
    backend_controlnet: BackendControlnetsTypeVar | str,
) -> bool:
    """Check if a backend controlnet is valid."""
    return self._is_valid_value(
        value=backend_controlnet,
        known_type=self._backend_controlnets,
    )