Skip to content

legacy_models

Pydantic models encapsulating the legacy-to-new reference normalization rules.

_ALLOWED_CONFIG_FILENAMES module-attribute 

_ALLOWED_CONFIG_FILENAMES = {
    "v2-inference-v.yaml",
    "v1-inference.yaml",
}

_BASELINE_NORMALIZATION_MAP module-attribute 

_BASELINE_NORMALIZATION_MAP = {
    "stable diffusion 1": "stable_diffusion_1",
    "stable diffusion 2": "stable_diffusion_2_768",
    "stable diffusion 2 512": "stable_diffusion_2_512",
    "stable_diffusion_xl": "stable_diffusion_xl",
    "stable_cascade": "stable_cascade",
}

LegacyRecordUnion module-attribute 

LegacyRecordUnion = (
    LegacyStableDiffusionRecord
    | LegacyTextGenerationRecord
    | LegacyBlipRecord
    | LegacyClipRecord
    | LegacyCodeformerRecord
    | LegacyControlnetRecord
    | LegacyEsrganRecord
    | LegacyGfpganRecord
    | LegacyGenericRecord
    | LegacySafetyCheckerRecord
    | LegacyMiscellaneousRecord
)

LegacyConfigFile

Bases: BaseModel

A single legacy config file entry.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class LegacyConfigFile(BaseModel):
    """A single legacy config file entry."""

    model_config = ConfigDict(extra="allow")

    path: str
    md5sum: str | None = None
    sha256sum: str | None = None
    file_type: str | None = None

    @model_validator(mode="after")
    def _ensure_sha256sum_for_model_files(self, info: ValidationInfo) -> LegacyConfigFile:
        if not self.path:
            _record_issue(info, "has a config file with no path.")
            return self
        if ".yaml" in self.path or ".json" in self.path:
            return self
        if ".ckpt" not in self.path:
            _record_issue(info, "has a config file with an invalid path.")
        if self.sha256sum is None:
            _record_issue(info, "has a config file with no sha256sum.")
        return self

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

path instance-attribute 

path: str

md5sum class-attribute instance-attribute 

md5sum: str | None = None

sha256sum class-attribute instance-attribute 

sha256sum: str | None = None

file_type class-attribute instance-attribute 

file_type: str | None = None

_ensure_sha256sum_for_model_files 

_ensure_sha256sum_for_model_files(
    info: ValidationInfo,
) -> LegacyConfigFile
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
59
60
61
62
63
64
65
66
67
68
69
70
@model_validator(mode="after")
def _ensure_sha256sum_for_model_files(self, info: ValidationInfo) -> LegacyConfigFile:
    if not self.path:
        _record_issue(info, "has a config file with no path.")
        return self
    if ".yaml" in self.path or ".json" in self.path:
        return self
    if ".ckpt" not in self.path:
        _record_issue(info, "has a config file with an invalid path.")
    if self.sha256sum is None:
        _record_issue(info, "has a config file with no sha256sum.")
    return self

LegacyConfigDownload

Bases: BaseModel

A single legacy config download entry.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
class LegacyConfigDownload(BaseModel):
    """A single legacy config download entry."""

    model_config = ConfigDict(extra="allow")

    file_name: str | None = None
    file_path: str | None = ""
    file_url: str | None = None

    @model_validator(mode="after")
    def _validate_download_fields(self, info: ValidationInfo) -> LegacyConfigDownload:
        if not self.file_name:
            _record_issue(info, "has a download with no file_name.")
        if not self.file_url:
            category = None
            if info.context is not None:
                category = info.context.get("category")
            if category != MODEL_REFERENCE_CATEGORY.clip:
                _record_issue(info, "has a download with no file_url.")
        return self

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

file_name class-attribute instance-attribute 

file_name: str | None = None

file_path class-attribute instance-attribute 

file_path: str | None = ''

file_url class-attribute instance-attribute 

file_url: str | None = None

_validate_download_fields 

_validate_download_fields(
    info: ValidationInfo,
) -> LegacyConfigDownload
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
82
83
84
85
86
87
88
89
90
91
92
@model_validator(mode="after")
def _validate_download_fields(self, info: ValidationInfo) -> LegacyConfigDownload:
    if not self.file_name:
        _record_issue(info, "has a download with no file_name.")
    if not self.file_url:
        category = None
        if info.context is not None:
            category = info.context.get("category")
        if category != MODEL_REFERENCE_CATEGORY.clip:
            _record_issue(info, "has a download with no file_url.")
    return self

LegacyConfig

Bases: BaseModel

Typed representation of the legacy config payload.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
 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
class LegacyConfig(BaseModel):
    """Typed representation of the legacy `config` payload."""

    model_config = ConfigDict(extra="ignore")

    files: list[LegacyConfigFile] = Field(default_factory=list)
    download: list[LegacyConfigDownload] = Field(default_factory=list)

    @model_validator(mode="before")
    @classmethod
    def _coerce_config_dict(cls, value: object, info: ValidationInfo) -> dict[str, Any]:
        if value is None:
            return {}
        if not isinstance(value, dict):
            raise TypeError("config entries must be provided as a mapping")
        raw_dict: dict[str, object] = {str(k): v for k, v in value.items()}
        if len(raw_dict) > 2:
            _record_issue(info, "has more than 2 config entries.")
        coerced: dict[str, Any] = {}
        for key in ("files", "download"):
            entries = raw_dict.get(key) or []
            if not isinstance(entries, Iterable):
                raise TypeError(f"config[{key!s}] must be iterable")
            coerced[key] = list(entries)
        return coerced

    @model_validator(mode="after")
    def _normalize_entries(self, info: ValidationInfo) -> LegacyConfig:
        sha_lookup: dict[str, str] = {}

        for file_entry in self.files:
            if not file_entry.path:
                _record_issue(info, "has a config file with no path.")
                continue
            path_obj = Path(file_entry.path)
            if path_obj.suffix == ".yaml":
                if path_obj.name not in _ALLOWED_CONFIG_FILENAMES:
                    _record_issue(info, "has a non-standard config file.")
                continue
            if ".ckpt" not in file_entry.path:
                _record_issue(info, "has a config file with an invalid path.")
            if not file_entry.sha256sum:
                _record_issue(info, "has a config file with no sha256sum.")
            else:
                if len(file_entry.sha256sum) != 64:
                    _record_issue(info, "has a config file with an invalid sha256sum.")
                sha_lookup[file_entry.path] = file_entry.sha256sum

        for download_entry in self.download:
            if download_entry.file_path is None:
                _record_issue(info, "has a download with a file_path.")
                download_entry.file_path = ""
            elif download_entry.file_path != "":
                _record_issue(info, "has a download with a file_path.")
            if not download_entry.file_url:
                continue
            try:
                parsed_url = urllib.parse.urlparse(download_entry.file_url)
            except Exception:
                _record_issue(info, "has a download with an invalid file_url.")
                raise ValueError("invalid download url") from None
            _increment_host_counter(info, parsed_url.netloc)

        return self

    def is_empty(self) -> bool:
        """Return True when no download entries survive normalization.

        Note: files are always cleared during normalization (new format doesn't use them).
        """
        return len(self.download) == 0

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='ignore')

files class-attribute instance-attribute 

files: list[LegacyConfigFile] = Field(default_factory=list)

download class-attribute instance-attribute 

download: list[LegacyConfigDownload] = Field(
    default_factory=list
)

_coerce_config_dict classmethod 

_coerce_config_dict(
    value: object, info: ValidationInfo
) -> dict[str, Any]
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
@model_validator(mode="before")
@classmethod
def _coerce_config_dict(cls, value: object, info: ValidationInfo) -> dict[str, Any]:
    if value is None:
        return {}
    if not isinstance(value, dict):
        raise TypeError("config entries must be provided as a mapping")
    raw_dict: dict[str, object] = {str(k): v for k, v in value.items()}
    if len(raw_dict) > 2:
        _record_issue(info, "has more than 2 config entries.")
    coerced: dict[str, Any] = {}
    for key in ("files", "download"):
        entries = raw_dict.get(key) or []
        if not isinstance(entries, Iterable):
            raise TypeError(f"config[{key!s}] must be iterable")
        coerced[key] = list(entries)
    return coerced

_normalize_entries 

_normalize_entries(info: ValidationInfo) -> LegacyConfig
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
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
@model_validator(mode="after")
def _normalize_entries(self, info: ValidationInfo) -> LegacyConfig:
    sha_lookup: dict[str, str] = {}

    for file_entry in self.files:
        if not file_entry.path:
            _record_issue(info, "has a config file with no path.")
            continue
        path_obj = Path(file_entry.path)
        if path_obj.suffix == ".yaml":
            if path_obj.name not in _ALLOWED_CONFIG_FILENAMES:
                _record_issue(info, "has a non-standard config file.")
            continue
        if ".ckpt" not in file_entry.path:
            _record_issue(info, "has a config file with an invalid path.")
        if not file_entry.sha256sum:
            _record_issue(info, "has a config file with no sha256sum.")
        else:
            if len(file_entry.sha256sum) != 64:
                _record_issue(info, "has a config file with an invalid sha256sum.")
            sha_lookup[file_entry.path] = file_entry.sha256sum

    for download_entry in self.download:
        if download_entry.file_path is None:
            _record_issue(info, "has a download with a file_path.")
            download_entry.file_path = ""
        elif download_entry.file_path != "":
            _record_issue(info, "has a download with a file_path.")
        if not download_entry.file_url:
            continue
        try:
            parsed_url = urllib.parse.urlparse(download_entry.file_url)
        except Exception:
            _record_issue(info, "has a download with an invalid file_url.")
            raise ValueError("invalid download url") from None
        _increment_host_counter(info, parsed_url.netloc)

    return self

is_empty 

is_empty() -> bool

Return True when no download entries survive normalization.

Note: files are always cleared during normalization (new format doesn't use them).

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
160
161
162
163
164
165
def is_empty(self) -> bool:
    """Return True when no download entries survive normalization.

    Note: files are always cleared during normalization (new format doesn't use them).
    """
    return len(self.download) == 0

LegacyGenericRecord

Bases: BaseModel

Base legacy record representation with shared validation rules.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
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
class LegacyGenericRecord(BaseModel):
    """Base legacy record representation with shared validation rules."""

    model_config = ConfigDict(extra="allow")

    name: str
    type: str | None = None
    description: str | None = None
    version: str | None = None
    style: str | None = None
    nsfw: bool | None = None
    download_all: bool | None = None
    config: LegacyConfig = Field(default_factory=LegacyConfig)
    available: bool | None = None
    features_not_supported: list[str] | None = None

    @model_validator(mode="after")
    def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
        model_key = None
        debug_mode = False
        if info.context is not None:
            model_key = info.context.get("model_key")
            debug_mode = bool(info.context.get("debug_mode"))
        if model_key and self.name != model_key:
            _record_issue(info, "name mismatch.")
        if self.available:
            _record_issue(info, "is flagged 'available'.")
        if self.download_all and debug_mode:
            _record_issue(info, "has download_all set.")
        if self.config.is_empty():
            _record_issue(info, "has no config.")
        if self.description is None:
            _record_issue(info, "has no description.")
        if self.style == "":
            _record_issue(info, "has no style.")
        return self

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

type class-attribute instance-attribute 

type: str | None = None

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyStableDiffusionRecord

Bases: LegacyGenericRecord

Stable Diffusion legacy record with category-specific validation.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
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
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
class LegacyStableDiffusionRecord(LegacyGenericRecord):
    """Stable Diffusion legacy record with category-specific validation."""

    type: Literal["ckpt"] = "ckpt"
    inpainting: bool = False
    baseline: str
    tags: list[str] | None = None
    showcases: list[str] | None = None
    min_bridge_version: int | None = None
    trigger: list[str] | None = None
    homepage: str | None = None
    size_on_disk_bytes: int | None = None
    optimization: str | None = None
    requirements: dict[str, int | float | str | list[int] | list[float] | list[str] | bool] | None = None

    @model_validator(mode="after")
    def _validate_stable_diffusion_rules(self, info: ValidationInfo) -> LegacyStableDiffusionRecord:
        if self.type != "ckpt":
            _record_issue(info, "is not a ckpt!")
        if self.baseline in _BASELINE_NORMALIZATION_MAP:
            self.baseline = _BASELINE_NORMALIZATION_MAP[self.baseline]
        model_key = self.name
        existing_showcases: dict[str, list[str]] = {}
        if info.context is not None:
            model_key = info.context.get("model_key", self.name)
            existing_showcases = info.context.get("existing_showcase_files", {})
        expected_showcase_foldername = model_name_to_showcase_folder_name(model_key)
        on_disk_showcases = existing_showcases.get(expected_showcase_foldername)
        if self.showcases:
            if on_disk_showcases is None:
                _record_issue(
                    info,
                    f"is expected to have a showcase folder named {expected_showcase_foldername}",
                )
                # Don't raise, just record the issue and continue
            elif len(on_disk_showcases) == 0:
                _record_issue(info, "has no showcases defined on disk.")
            elif len(self.showcases) != len(on_disk_showcases):
                _record_issue(
                    info,
                    "has a mismatch between defined showcases and the files present on disk.",
                )
            if any("huggingface" in showcase for showcase in self.showcases):
                _record_issue(info, "has a huggingface showcase.")
        return self

    @model_serializer(when_used="always")
    def sort_model_fields(self) -> dict[str, Any]:
        """Sort fields for consistent JSON output."""
        field_order = [
            "name",
            "baseline",
            "optimization",
            "type",
            "inpainting",
            "description",
            "tags",
            "showcases",
            "version",
            "style",
            "trigger",
            "homepage",
            "nsfw",
            "download_all",
            "requirements",
            "config",
            "available",
            "features_not_supported",
            "size_on_disk_bytes",
        ]

        return_dict = {
            field: getattr(self, field)
            for field in field_order
            if hasattr(self, field) and getattr(self, field) is not None
        }

        # translate _BASELINE_NORMALIZATION_MAP keys back to their original values for output
        if "baseline" in return_dict:
            for original, normalized in _BASELINE_NORMALIZATION_MAP.items():
                if return_dict["baseline"] == normalized:
                    return_dict["baseline"] = original
                    break

        return return_dict

type class-attribute instance-attribute 

type: Literal['ckpt'] = 'ckpt'

inpainting class-attribute instance-attribute 

inpainting: bool = False

baseline instance-attribute 

baseline: str

tags class-attribute instance-attribute 

tags: list[str] | None = None

showcases class-attribute instance-attribute 

showcases: list[str] | None = None

min_bridge_version class-attribute instance-attribute 

min_bridge_version: int | None = None

trigger class-attribute instance-attribute 

trigger: list[str] | None = None

homepage class-attribute instance-attribute 

homepage: str | None = None

size_on_disk_bytes class-attribute instance-attribute 

size_on_disk_bytes: int | None = None

optimization class-attribute instance-attribute 

optimization: str | None = None

requirements class-attribute instance-attribute 

requirements: (
    dict[
        str,
        int
        | float
        | str
        | list[int]
        | list[float]
        | list[str]
        | bool,
    ]
    | None
) = None

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_stable_diffusion_rules 

_validate_stable_diffusion_rules(
    info: ValidationInfo,
) -> LegacyStableDiffusionRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
@model_validator(mode="after")
def _validate_stable_diffusion_rules(self, info: ValidationInfo) -> LegacyStableDiffusionRecord:
    if self.type != "ckpt":
        _record_issue(info, "is not a ckpt!")
    if self.baseline in _BASELINE_NORMALIZATION_MAP:
        self.baseline = _BASELINE_NORMALIZATION_MAP[self.baseline]
    model_key = self.name
    existing_showcases: dict[str, list[str]] = {}
    if info.context is not None:
        model_key = info.context.get("model_key", self.name)
        existing_showcases = info.context.get("existing_showcase_files", {})
    expected_showcase_foldername = model_name_to_showcase_folder_name(model_key)
    on_disk_showcases = existing_showcases.get(expected_showcase_foldername)
    if self.showcases:
        if on_disk_showcases is None:
            _record_issue(
                info,
                f"is expected to have a showcase folder named {expected_showcase_foldername}",
            )
            # Don't raise, just record the issue and continue
        elif len(on_disk_showcases) == 0:
            _record_issue(info, "has no showcases defined on disk.")
        elif len(self.showcases) != len(on_disk_showcases):
            _record_issue(
                info,
                "has a mismatch between defined showcases and the files present on disk.",
            )
        if any("huggingface" in showcase for showcase in self.showcases):
            _record_issue(info, "has a huggingface showcase.")
    return self

sort_model_fields 

sort_model_fields() -> dict[str, Any]

Sort fields for consistent JSON output.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
@model_serializer(when_used="always")
def sort_model_fields(self) -> dict[str, Any]:
    """Sort fields for consistent JSON output."""
    field_order = [
        "name",
        "baseline",
        "optimization",
        "type",
        "inpainting",
        "description",
        "tags",
        "showcases",
        "version",
        "style",
        "trigger",
        "homepage",
        "nsfw",
        "download_all",
        "requirements",
        "config",
        "available",
        "features_not_supported",
        "size_on_disk_bytes",
    ]

    return_dict = {
        field: getattr(self, field)
        for field in field_order
        if hasattr(self, field) and getattr(self, field) is not None
    }

    # translate _BASELINE_NORMALIZATION_MAP keys back to their original values for output
    if "baseline" in return_dict:
        for original, normalized in _BASELINE_NORMALIZATION_MAP.items():
            if return_dict["baseline"] == normalized:
                return_dict["baseline"] = original
                break

    return return_dict

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyTextGenerationRecord

Bases: LegacyGenericRecord

Text generation legacy record with category-specific validation.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
class LegacyTextGenerationRecord(LegacyGenericRecord):
    """Text generation legacy record with category-specific validation."""

    model_name: str | None = None
    baseline: str | None = None
    parameters: int | None = None
    display_name: str | None = None
    url: str | None = None
    tags: list[str] | None = None
    instruct_format: str | None = None
    settings: dict[str, int | float | str | list[int] | list[float] | list[str] | bool] | None = None

    @model_validator(mode="after")
    def _validate_text_generation_rules(self, info: ValidationInfo) -> LegacyTextGenerationRecord:
        """Validate text generation specific rules."""
        if self.parameters is None:
            _record_issue(info, "has no parameters count.")
        return self

model_name class-attribute instance-attribute 

model_name: str | None = None

baseline class-attribute instance-attribute 

baseline: str | None = None

parameters class-attribute instance-attribute 

parameters: int | None = None

display_name class-attribute instance-attribute 

display_name: str | None = None

url class-attribute instance-attribute 

url: str | None = None

tags class-attribute instance-attribute 

tags: list[str] | None = None

instruct_format class-attribute instance-attribute 

instruct_format: str | None = None

settings class-attribute instance-attribute 

settings: (
    dict[
        str,
        int
        | float
        | str
        | list[int]
        | list[float]
        | list[str]
        | bool,
    ]
    | None
) = None

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

type class-attribute instance-attribute 

type: str | None = None

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_text_generation_rules 

_validate_text_generation_rules(
    info: ValidationInfo,
) -> LegacyTextGenerationRecord

Validate text generation specific rules.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
305
306
307
308
309
310
@model_validator(mode="after")
def _validate_text_generation_rules(self, info: ValidationInfo) -> LegacyTextGenerationRecord:
    """Validate text generation specific rules."""
    if self.parameters is None:
        _record_issue(info, "has no parameters count.")
    return self

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyBlipRecord

Bases: LegacyGenericRecord

BLIP legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
313
314
315
316
class LegacyBlipRecord(LegacyGenericRecord):
    """BLIP legacy record with category-specific normalization."""

    type: Literal["blip"] = "blip"

type class-attribute instance-attribute 

type: Literal['blip'] = 'blip'

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyClipRecord

Bases: LegacyGenericRecord

CLIP legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
319
320
321
322
323
class LegacyClipRecord(LegacyGenericRecord):
    """CLIP legacy record with category-specific normalization."""

    type: Literal["clip", "coca"] = "clip"
    pretrained_name: str | None = None

type class-attribute instance-attribute 

type: Literal['clip', 'coca'] = 'clip'

pretrained_name class-attribute instance-attribute 

pretrained_name: str | None = None

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyCodeformerRecord

Bases: LegacyGenericRecord

Codeformers legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
326
327
328
329
class LegacyCodeformerRecord(LegacyGenericRecord):
    """Codeformers legacy record with category-specific normalization."""

    type: Literal["CodeFormers"] = "CodeFormers"

type class-attribute instance-attribute 

type: Literal['CodeFormers'] = 'CodeFormers'

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyEsrganRecord

Bases: LegacyGenericRecord

ESRGAN legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
332
333
334
335
class LegacyEsrganRecord(LegacyGenericRecord):
    """ESRGAN legacy record with category-specific normalization."""

    type: Literal["realesrgan"] = "realesrgan"

type class-attribute instance-attribute 

type: Literal['realesrgan'] = 'realesrgan'

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyGfpganRecord

Bases: LegacyGenericRecord

GFPGAN legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
338
339
340
341
class LegacyGfpganRecord(LegacyGenericRecord):
    """GFPGAN legacy record with category-specific normalization."""

    type: Literal["gfpgan"] = "gfpgan"

type class-attribute instance-attribute 

type: Literal['gfpgan'] = 'gfpgan'

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacySafetyCheckerRecord

Bases: LegacyGenericRecord

Safety Checker legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
344
345
346
347
class LegacySafetyCheckerRecord(LegacyGenericRecord):
    """Safety Checker legacy record with category-specific normalization."""

    type: Literal["safety_checker"] = "safety_checker"

type class-attribute instance-attribute 

type: Literal['safety_checker'] = 'safety_checker'

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyMiscellaneousRecord

Bases: LegacyGenericRecord

Miscellaneous legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
350
351
352
353
class LegacyMiscellaneousRecord(LegacyGenericRecord):
    """Miscellaneous legacy record with category-specific normalization."""

    type: Literal["layer_diffuse"]

type instance-attribute 

type: Literal['layer_diffuse']

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

LegacyControlnetRecord

Bases: LegacyGenericRecord

ControlNet legacy record with category-specific normalization.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
class LegacyControlnetRecord(LegacyGenericRecord):
    """ControlNet legacy record with category-specific normalization."""

    type: Literal[
        "control_canny",
        "control_depth",
        "control_hed",
        "control_mlsd",
        "control_normal",
        "control_openpose",
        "control_fakescribbles",
        "control_scribble",
        "control_seg",
        "control_qr",
        "control_qr_xl",
    ]

type instance-attribute 

type: Literal[
    "control_canny",
    "control_depth",
    "control_hed",
    "control_mlsd",
    "control_normal",
    "control_openpose",
    "control_fakescribbles",
    "control_scribble",
    "control_seg",
    "control_qr",
    "control_qr_xl",
]

model_config class-attribute instance-attribute 

model_config = ConfigDict(extra='allow')

name instance-attribute 

name: str

description class-attribute instance-attribute 

description: str | None = None

version class-attribute instance-attribute 

version: str | None = None

style class-attribute instance-attribute 

style: str | None = None

nsfw class-attribute instance-attribute 

nsfw: bool | None = None

download_all class-attribute instance-attribute 

download_all: bool | None = None

config class-attribute instance-attribute 

config: LegacyConfig = Field(default_factory=LegacyConfig)

available class-attribute instance-attribute 

available: bool | None = None

features_not_supported class-attribute instance-attribute 

features_not_supported: list[str] | None = None

_validate_common_rules 

_validate_common_rules(
    info: ValidationInfo,
) -> LegacyGenericRecord
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
@model_validator(mode="after")
def _validate_common_rules(self, info: ValidationInfo) -> LegacyGenericRecord:
    model_key = None
    debug_mode = False
    if info.context is not None:
        model_key = info.context.get("model_key")
        debug_mode = bool(info.context.get("debug_mode"))
    if model_key and self.name != model_key:
        _record_issue(info, "name mismatch.")
    if self.available:
        _record_issue(info, "is flagged 'available'.")
    if self.download_all and debug_mode:
        _record_issue(info, "has download_all set.")
    if self.config.is_empty():
        _record_issue(info, "has no config.")
    if self.description is None:
        _record_issue(info, "has no description.")
    if self.style == "":
        _record_issue(info, "has no style.")
    return self

_record_issue 

_record_issue(info: ValidationInfo, message: str) -> None

Append a validation issue message to the shared conversion context.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def _record_issue(info: ValidationInfo, message: str) -> None:
    """Append a validation issue message to the shared conversion context."""
    issues: list[str] | None = None
    if info.context is not None:
        issues = info.context.get("issues")
    if issues is None:
        return
    model_key = None
    if info.context is not None:
        model_key = info.context.get("model_key")
    if model_key:
        issues.append(f"{model_key} {message}")
    else:
        issues.append(message)

_increment_host_counter 

_increment_host_counter(
    info: ValidationInfo, host: str
) -> None
Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
41
42
43
44
45
46
def _increment_host_counter(info: ValidationInfo, host: str) -> None:
    if info.context is None:
        return
    host_counter = info.context.get("host_counter")
    if isinstance(host_counter, dict):
        host_counter[host] = host_counter.get(host, 0) + 1

get_legacy_model_type 

get_legacy_model_type(
    category: MODEL_REFERENCE_CATEGORY,
) -> type[LegacyRecordUnion]

Get the appropriate Pydantic model class for a given category.

Source code in src/horde_model_reference/legacy/classes/legacy_models.py 
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
def get_legacy_model_type(category: MODEL_REFERENCE_CATEGORY) -> type[LegacyRecordUnion]:
    """Get the appropriate Pydantic model class for a given category."""
    category_model_map: dict[MODEL_REFERENCE_CATEGORY, type[LegacyRecordUnion]] = {
        MODEL_REFERENCE_CATEGORY.image_generation: LegacyStableDiffusionRecord,
        MODEL_REFERENCE_CATEGORY.text_generation: LegacyTextGenerationRecord,
        MODEL_REFERENCE_CATEGORY.blip: LegacyBlipRecord,
        MODEL_REFERENCE_CATEGORY.clip: LegacyClipRecord,
        MODEL_REFERENCE_CATEGORY.codeformer: LegacyCodeformerRecord,
        MODEL_REFERENCE_CATEGORY.controlnet: LegacyControlnetRecord,
        MODEL_REFERENCE_CATEGORY.esrgan: LegacyEsrganRecord,
        MODEL_REFERENCE_CATEGORY.gfpgan: LegacyGfpganRecord,
        MODEL_REFERENCE_CATEGORY.safety_checker: LegacySafetyCheckerRecord,
        MODEL_REFERENCE_CATEGORY.miscellaneous: LegacyMiscellaneousRecord,
    }
    return category_model_map.get(category, LegacyGenericRecord)