Coverage for bioimageio/spec/generic/v0_3.py: 91%

1from __future__ import annotations 

2 

3import string 

4from functools import partial 

5from typing import ( 

6 TYPE_CHECKING, 

7 Any, 

8 Callable, 

9 ClassVar, 

10 Dict, 

11 List, 

12 Literal, 

13 Optional, 

14 Sequence, 

15 Type, 

16 TypeVar, 

17 Union, 

18 cast, 

19) 

20 

21import annotated_types 

22from annotated_types import Len, LowerCase, MaxLen, MinLen 

23from pydantic import Field, RootModel, ValidationInfo, field_validator, model_validator 

24from typing_extensions import Annotated 

25 

26from bioimageio.spec._internal.type_guards import is_dict 

27 

28from .._internal.common_nodes import Node, ResourceDescrBase 

29from .._internal.constants import TAG_CATEGORIES 

30from .._internal.field_validation import validate_github_user 

31from .._internal.field_warning import as_warning, warn 

32from .._internal.io import ( 

33 BioimageioYamlContent, 

34 FileDescr, 

35 WithSuffix, 

36 is_yaml_value, 

37) 

38from .._internal.io_basics import Sha256 

39from .._internal.io_packaging import FileDescr_ 

40from .._internal.license_id import DeprecatedLicenseId, LicenseId 

41from .._internal.node_converter import Converter 

42from .._internal.types import FileSource_, NotEmpty, RelativeFilePath 

43from .._internal.url import HttpUrl 

44from .._internal.validated_string import ValidatedString 

45from .._internal.validator_annotations import ( 

46 Predicate, 

47 RestrictCharacters, 

48) 

49from .._internal.version_type import Version 

50from .._internal.warning_levels import ALERT, INFO 

51from ._v0_3_converter import convert_from_older_format 

52from .v0_2 import Author as _Author_v0_2 

53from .v0_2 import BadgeDescr, Doi, FileSource_cover, OrcidId, Uploader 

54from .v0_2 import Maintainer as _Maintainer_v0_2 

55 

56__all__ = [ 

57 "Author", 

58 "BadgeDescr", 

59 "CiteEntry", 

60 "DeprecatedLicenseId", 

61 "Doi", 

62 "FileDescr", 

63 "GenericDescr", 

64 "HttpUrl", 

65 "KNOWN_SPECIFIC_RESOURCE_TYPES", 

66 "LicenseId", 

67 "LinkedResource", 

68 "Maintainer", 

69 "OrcidId", 

70 "RelativeFilePath", 

71 "ResourceId", 

72 "Sha256", 

73 "Uploader", 

74 "VALID_COVER_IMAGE_EXTENSIONS", 

75 "Version", 

76] 

77 

78KNOWN_SPECIFIC_RESOURCE_TYPES = ( 

79 "application", 

80 "collection", 

81 "dataset", 

82 "model", 

83 "notebook", 

84) 

85VALID_COVER_IMAGE_EXTENSIONS = ( 

86 ".gif", 

87 ".jpeg", 

88 ".jpg", 

89 ".png", 

90 ".svg", 

91) 

92 

93 

94class ResourceId(ValidatedString): 

95 root_model: ClassVar[Type[RootModel[Any]]] = RootModel[ 

96 Annotated[ 

97 NotEmpty[str], 

98 RestrictCharacters(string.ascii_lowercase + string.digits + "_-/."), 

99 annotated_types.Predicate( 

100 lambda s: not (s.startswith("/") or s.endswith("/")) 

101 ), 

102 ] 

103 ] 

104 

105 

106def _has_no_slash(s: str) -> bool: 

107 return "/" not in s and "\\" not in s 

108 

109 

110class Author(_Author_v0_2): 

111 name: Annotated[str, Predicate(_has_no_slash)] 

112 github_user: Optional[str] = None 

113 

114 @field_validator("github_user", mode="after") 

115 def _validate_github_user(cls, value: Optional[str]): 

116 if value is None: 

117 return None 

118 else: 

119 return validate_github_user(value) 

120 

121 

122class _AuthorConv(Converter[_Author_v0_2, Author]): 

123 def _convert( 

124 self, src: _Author_v0_2, tgt: "type[Author] | type[dict[str, Any]]" 

125 ) -> "Author | dict[str, Any]": 

126 return tgt( 

127 name=src.name, 

128 github_user=src.github_user, 

129 affiliation=src.affiliation, 

130 email=src.email, 

131 orcid=src.orcid, 

132 ) 

133 

134 

135_author_conv = _AuthorConv(_Author_v0_2, Author) 

136 

137 

138class Maintainer(_Maintainer_v0_2): 

139 name: Optional[Annotated[str, Predicate(_has_no_slash)]] = None 

140 github_user: str 

141 

142 @field_validator("github_user", mode="after") 

143 def validate_github_user(cls, value: str): 

144 return validate_github_user(value) 

145 

146 

147class _MaintainerConv(Converter[_Maintainer_v0_2, Maintainer]): 

148 def _convert( 

149 self, src: _Maintainer_v0_2, tgt: "type[Maintainer | dict[str, Any]]" 

150 ) -> "Maintainer | dict[str, Any]": 

151 return tgt( 

152 name=src.name, 

153 github_user=src.github_user, 

154 affiliation=src.affiliation, 

155 email=src.email, 

156 orcid=src.orcid, 

157 ) 

158 

159 

160_maintainer_conv = _MaintainerConv(_Maintainer_v0_2, Maintainer) 

161 

162 

163class CiteEntry(Node): 

164 """A citation that should be referenced in work using this resource.""" 

165 

166 text: str 

167 """free text description""" 

168 

169 doi: Optional[Doi] = None 

170 """A digital object identifier (DOI) is the prefered citation reference. 

171 See https://www.doi.org/ for details. 

172 Note: 

173 Either **doi** or **url** have to be specified. 

174 """ 

175 

176 url: Optional[HttpUrl] = None 

177 """URL to cite (preferably specify a **doi** instead/also). 

178 Note: 

179 Either **doi** or **url** have to be specified. 

180 """ 

181 

182 @model_validator(mode="after") 

183 def _check_doi_or_url(self): 

184 if not self.doi and not self.url: 

185 raise ValueError("Either 'doi' or 'url' is required") 

186 

187 return self 

188 

189 

190class LinkedResourceBase(Node): 

191 

192 @model_validator(mode="before") 

193 def _remove_version_number(cls, value: Any): 

194 if is_dict(value): 

195 vn = value.pop("version_number", None) 

196 if vn is not None and value.get("version") is None: 

197 value["version"] = vn 

198 

199 return value 

200 

201 version: Optional[Version] = None 

202 """The version of the linked resource following SemVer 2.0.""" 

203 

204 

205class LinkedResource(LinkedResourceBase): 

206 """Reference to a bioimage.io resource""" 

207 

208 id: ResourceId 

209 """A valid resource `id` from the official bioimage.io collection.""" 

210 

211 

212class BioimageioConfig(Node, extra="allow"): 

213 """bioimage.io internal metadata.""" 

214 

215 

216class Config(Node, extra="allow"): 

217 """A place to store additional metadata (often tool specific). 

218 

219 Such additional metadata is typically set programmatically by the respective tool 

220 or by people with specific insights into the tool. 

221 If you want to store additional metadata that does not match any of the other 

222 fields, think of a key unlikely to collide with anyone elses use-case/tool and save 

223 it here. 

224 

225 Please consider creating [an issue in the bioimageio.spec repository](https://github.com/bioimage-io/spec-bioimage-io/issues/new?template=Blank+issue) 

226 if you are not sure if an existing field could cover your use case 

227 or if you think such a field should exist. 

228 """ 

229 

230 bioimageio: BioimageioConfig = Field(default_factory=BioimageioConfig) 

231 """bioimage.io internal metadata.""" 

232 

233 @model_validator(mode="after") 

234 def _validate_extra_fields(self): 

235 if self.model_extra: 

236 for k, v in self.model_extra.items(): 

237 if not isinstance(v, Node) and not is_yaml_value(v): 

238 raise ValueError( 

239 f"config.{k} is not a valid YAML value or `Node` instance" 

240 ) 

241 

242 return self 

243 

244 def __getitem__(self, key: str) -> Any: 

245 """Allows to access the config as a dictionary.""" 

246 return getattr(self, key) 

247 

248 def __setitem__(self, key: str, value: Any) -> None: 

249 """Allows to set the config as a dictionary.""" 

250 setattr(self, key, value) 

251 

252 

253class GenericModelDescrBase(ResourceDescrBase): 

254 """Base for all resource descriptions including of model descriptions""" 

255 

256 name: Annotated[ 

257 Annotated[ 

258 str, RestrictCharacters(string.ascii_letters + string.digits + "_+- ()") 

259 ], 

260 MinLen(5), 

261 MaxLen(128), 

262 warn(MaxLen(64), "Name longer than 64 characters.", INFO), 

263 ] 

264 name: Annotated[NotEmpty[str], MaxLen(128)] 

265 """A human-friendly name of the resource description. 

266 May only contains letters, digits, underscore, minus, parentheses and spaces.""" 

267 

268 description: Annotated[ 

269 str, MaxLen(1024), warn(MaxLen(512), "Description longer than 512 characters.") 

270 ] 

271 """A string containing a brief description.""" 

272 

273 covers: List[FileSource_cover] = Field( 

274 default_factory=cast(Callable[[], List[FileSource_cover]], list), 

275 description=( 

276 "Cover images. Please use an image smaller than 500KB and an aspect" 

277 " ratio width to height of 2:1 or 1:1.\nThe supported image formats" 

278 f" are: {VALID_COVER_IMAGE_EXTENSIONS}" 

279 ), 

280 examples=[["cover.png"]], 

281 ) 

282 """Cover images.""" 

283 

284 id_emoji: Optional[ 

285 Annotated[str, Len(min_length=1, max_length=2), Field(examples=["🦈", "🦥"])] 

286 ] = None 

287 """UTF-8 emoji for display alongside the `id`.""" 

288 

289 authors: NotEmpty[List[Author]] 

290 """The authors are the creators of this resource description and the primary points of contact.""" 

291 

292 attachments: List[FileDescr_] = Field( 

293 default_factory=cast(Callable[[], List[FileDescr_]], list) 

294 ) 

295 """file attachments""" 

296 

297 cite: NotEmpty[List[CiteEntry]] 

298 """citations""" 

299 

300 license: Annotated[ 

301 Annotated[ 

302 Union[LicenseId, DeprecatedLicenseId], Field(union_mode="left_to_right") 

303 ], 

304 warn( 

305 LicenseId, 

306 "{value} is deprecated, see https://spdx.org/licenses/{value}.html", 

307 ), 

308 Field(examples=["CC0-1.0", "MIT", "BSD-2-Clause"]), 

309 ] 

310 """A [SPDX license identifier](https://spdx.org/licenses/). 

311 We do not support custom license beyond the SPDX license list, if you need that please 

312 [open a GitHub issue](https://github.com/bioimage-io/spec-bioimage-io/issues/new/choose) 

313 to discuss your intentions with the community.""" 

314 

315 git_repo: Annotated[ 

316 Optional[HttpUrl], 

317 Field( 

318 examples=[ 

319 "https://github.com/bioimage-io/spec-bioimage-io/tree/main/example_descriptions/models/unet2d_nuclei_broad" 

320 ], 

321 ), 

322 ] = None 

323 """A URL to the Git repository where the resource is being developed.""" 

324 

325 icon: Union[Annotated[str, Len(min_length=1, max_length=2)], FileSource_, None] = ( 

326 None 

327 ) 

328 """An icon for illustration, e.g. on bioimage.io""" 

329 

330 links: Annotated[ 

331 List[str], 

332 Field( 

333 examples=[ 

334 ( 

335 "ilastik/ilastik", 

336 "deepimagej/deepimagej", 

337 "zero/notebook_u-net_3d_zerocostdl4mic", 

338 ) 

339 ], 

340 ), 

341 ] = Field(default_factory=list) 

342 """IDs of other bioimage.io resources""" 

343 

344 uploader: Optional[Uploader] = None 

345 """The person who uploaded the model (e.g. to bioimage.io)""" 

346 

347 maintainers: List[Maintainer] = Field( # pyright: ignore[reportUnknownVariableType] 

348 default_factory=list 

349 ) 

350 """Maintainers of this resource. 

351 If not specified, `authors` are maintainers and at least some of them has to specify their `github_user` name""" 

352 

353 @partial(as_warning, severity=ALERT) 

354 @field_validator("maintainers", mode="after") 

355 @classmethod 

356 def check_maintainers_exist( 

357 cls, maintainers: List[Maintainer], info: ValidationInfo 

358 ) -> List[Maintainer]: 

359 if not maintainers and "authors" in info.data: 

360 authors: List[Author] = info.data["authors"] 

361 if all(a.github_user is None for a in authors): 

362 raise ValueError( 

363 "Missing `maintainers` or any author in `authors` with a specified" 

364 + " `github_user` name." 

365 ) 

366 

367 return maintainers 

368 

369 tags: Annotated[ 

370 List[str], 

371 Field(examples=[("unet2d", "pytorch", "nucleus", "segmentation", "dsb2018")]), 

372 ] = Field(default_factory=list) 

373 """Associated tags""" 

374 

375 @as_warning 

376 @field_validator("tags") 

377 @classmethod 

378 def warn_about_tag_categories( 

379 cls, value: List[str], info: ValidationInfo 

380 ) -> List[str]: 

381 categories = TAG_CATEGORIES.get(info.data["type"], {}) 

382 missing_categories: List[Dict[str, Sequence[str]]] = [] 

383 for cat, entries in categories.items(): 

384 if not any(e in value for e in entries): 

385 missing_categories.append({cat: entries}) 

386 

387 if missing_categories: 

388 raise ValueError( 

389 f"Missing tags from bioimage.io categories: {missing_categories}" 

390 ) 

391 

392 return value 

393 

394 version: Optional[Version] = None 

395 """The version of the resource following SemVer 2.0.""" 

396 

397 @model_validator(mode="before") 

398 def _remove_version_number(cls, value: Any): 

399 if is_dict(value): 

400 vn = value.pop("version_number", None) 

401 if vn is not None and value.get("version") is None: 

402 value["version"] = vn 

403 

404 return value 

405 

406 

407FileSource_documentation = Annotated[ 

408 FileSource_, 

409 WithSuffix(".md", case_sensitive=True), 

410 Field( 

411 examples=[ 

412 "https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/example_descriptions/models/unet2d_nuclei_broad/README.md", 

413 "README.md", 

414 ], 

415 ), 

416] 

417 

418 

419class GenericDescrBase(GenericModelDescrBase): 

420 """Base for all resource descriptions except for the model descriptions""" 

421 

422 implemented_format_version: ClassVar[Literal["0.3.0"]] = "0.3.0" 

423 if TYPE_CHECKING: 

424 format_version: Literal["0.3.0"] = "0.3.0" 

425 else: 

426 format_version: Literal["0.3.0"] 

427 """The **format** version of this resource specification""" 

428 

429 @model_validator(mode="before") 

430 @classmethod 

431 def _convert_from_older_format( 

432 cls, data: BioimageioYamlContent, / 

433 ) -> BioimageioYamlContent: 

434 cls.convert_from_old_format_wo_validation(data) 

435 return data 

436 

437 @classmethod 

438 def convert_from_old_format_wo_validation(cls, data: BioimageioYamlContent) -> None: 

439 """Convert metadata following an older format version to this classes' format 

440 without validating the result. 

441 """ 

442 convert_from_older_format(data) 

443 

444 documentation: Optional[FileSource_documentation] = None 

445 """URL or relative path to a markdown file encoded in UTF-8 with additional documentation. 

446 The recommended documentation file name is `README.md`. An `.md` suffix is mandatory.""" 

447 

448 badges: List[BadgeDescr] = Field( # pyright: ignore[reportUnknownVariableType] 

449 default_factory=list 

450 ) 

451 """badges associated with this resource""" 

452 

453 config: Config = Field(default_factory=Config) 

454 """A field for custom configuration that can contain any keys not present in the RDF spec. 

455 This means you should not store, for example, a GitHub repo URL in `config` since there is a `git_repo` field. 

456 Keys in `config` may be very specific to a tool or consumer software. To avoid conflicting definitions, 

457 it is recommended to wrap added configuration into a sub-field named with the specific domain or tool name, 

458 for example: 

459 ```yaml 

460 config: 

461 giraffe_neckometer: # here is the domain name 

462 length: 3837283 

463 address: 

464 home: zoo 

465 imagej: # config specific to ImageJ 

466 macro_dir: path/to/macro/file 

467 ``` 

468 If possible, please use [`snake_case`](https://en.wikipedia.org/wiki/Snake_case) for keys in `config`. 

469 You may want to list linked files additionally under `attachments` to include them when packaging a resource. 

470 (Packaging a resource means downloading/copying important linked files and creating a ZIP archive that contains 

471 an altered rdf.yaml file with local references to the downloaded files.)""" 

472 

473 

474ResourceDescrType = TypeVar("ResourceDescrType", bound=GenericDescrBase) 

475 

476 

477class GenericDescr(GenericDescrBase, extra="ignore"): 

478 """Specification of the fields used in a generic bioimage.io-compliant resource description file (RDF). 

479 

480 An RDF is a YAML file that describes a resource such as a model, a dataset, or a notebook. 

481 Note that those resources are described with a type-specific RDF. 

482 Use this generic resource description, if none of the known specific types matches your resource. 

483 """ 

484 

485 implemented_type: ClassVar[Literal["generic"]] = "generic" 

486 if TYPE_CHECKING: 

487 type: Annotated[str, LowerCase] = "generic" 

488 """The resource type assigns a broad category to the resource.""" 

489 else: 

490 type: Annotated[str, LowerCase] 

491 """The resource type assigns a broad category to the resource.""" 

492 

493 id: Optional[ 

494 Annotated[ResourceId, Field(examples=["affable-shark", "ambitious-sloth"])] 

495 ] = None 

496 """bioimage.io-wide unique resource identifier 

497 assigned by bioimage.io; version **un**specific.""" 

498 

499 parent: Optional[ResourceId] = None 

500 """The description from which this one is derived""" 

501 

502 source: Optional[HttpUrl] = None 

503 """The primary source of the resource""" 

504 

505 @field_validator("type", mode="after") 

506 @classmethod 

507 def check_specific_types(cls, value: str) -> str: 

508 if value in KNOWN_SPECIFIC_RESOURCE_TYPES: 

509 raise ValueError( 

510 f"Use the {value} description instead of this generic description for" 

511 + f" your '{value}' resource." 

512 ) 

513 

514 return value