bioimageio.spec.common

768class FileDescr(Node):
769    source: ImportantFileSource
770    """∈📦 file source"""
771
772    sha256: Optional[Sha256] = None
773    """SHA256 checksum of the source file"""
774
775    @model_validator(mode="after")
776    def validate_sha256(self) -> Self:
777        context = validation_context_var.get()
778        if not context.perform_io_checks:
779            return self
780        elif (src_str := str(self.source)) in context.known_files:
781            actual_sha = context.known_files[src_str]
782        else:
783            local_source = download(self.source, sha256=self.sha256).path
784            actual_sha = get_sha256(local_source)
785            context.known_files[str(self.source)] = actual_sha
786
787        if self.sha256 is None:
788            self.sha256 = actual_sha
789        elif self.sha256 != actual_sha:
790            raise ValueError(
791                f"Sha256 mismatch for {self.source}. Expected {self.sha256}, got "
792                + f"{actual_sha}. Update expected `sha256` or point to the matching "
793                + "file."
794            )
795
796        return self
797
798    def download(self):
799
800        return download(self.source, sha256=self.sha256)

118class HttpUrl(RootHttpUrl):
119    """A URL with the HTTP or HTTPS scheme."""
120
121    root_model: ClassVar[Type[RootModel[Any]]] = RootModel[pydantic.HttpUrl]
122    _exists: Optional[bool] = None
123
124    def _after_validator(self):
125        self = super()._after_validator()
126        context = validation_context_var.get()
127        if (
128            context.perform_io_checks
129            and str(self._validated) not in context.known_files
130        ):
131            self._validated = _validate_url(self._validated)
132            self._exists = True
133
134        return self
135
136    def exists(self):
137        """True if URL is available"""
138        if self._exists is None:
139            try:
140                self._validated = _validate_url(self._validated)
141            except Exception as e:
142                logger.info(e)
143                self._exists = False
144            else:
145                self._exists = True
146
147        return self._exists

431class InvalidDescr(
432    ResourceDescrBase,
433    extra="allow",
434    title="An invalid resource description",
435):
436    """A representation of an invalid resource description"""
437
438    type: Any = "unknown"
439    format_version: Any = "unknown"
440    fields_to_set_explicitly: ClassVar[FrozenSet[LiteralString]] = frozenset()

186class RelativeFilePath(
187    RelativePathBase[Union[AbsoluteFilePath, HttpUrl, ZipPath]], frozen=True
188):
189    """A path relative to the `rdf.yaml` file (also if the RDF source is a URL)."""
190
191    def model_post_init(self, __context: Any) -> None:
192        """add validation @private"""
193        if not self.root.parts:  # an empty path can only be a directory
194            raise ValueError(f"{self.root} is not a valid file path.")
195
196        super().model_post_init(__context)
197
198    def get_absolute(
199        self, root: "RootHttpUrl | Path | AnyUrl | ZipFile"
200    ) -> "AbsoluteFilePath | HttpUrl | ZipPath":
201        absolute = self._get_absolute_impl(root)
202        if (
203            isinstance(absolute, Path)
204            and (context := validation_context_var.get()).perform_io_checks
205            and str(self.root) not in context.known_files
206            and not absolute.is_file()
207        ):
208            raise ValueError(f"{absolute} does not point to an existing file")
209
210        return absolute

13class RootHttpUrl(ValidatedString):
14    """A 'URL folder', possibly an invalid HTTP URL"""
15
16    root_model: ClassVar[Type[RootModel[Any]]] = RootModel[pydantic.HttpUrl]
17    _validated: pydantic.HttpUrl
18
19    def absolute(self):
20        """analog to `absolute` method of pathlib."""
21        return self
22
23    @property
24    def scheme(self) -> str:
25        return self._validated.scheme
26
27    @property
28    def host(self) -> Optional[str]:
29        return self._validated.host
30
31    @property
32    def path(self) -> Optional[str]:
33        return self._validated.path
34
35    @property
36    def parent(self) -> RootHttpUrl:
37        parsed = urlsplit(str(self))
38        path = list(parsed.path.split("/"))
39        if (
40            parsed.netloc == "zenodo.org"
41            and parsed.path.startswith("/api/records/")
42            and parsed.path.endswith("/content")
43        ):
44            path[-2:-1] = []
45        else:
46            path = path[:-1]
47
48        return RootHttpUrl(
49            urlunsplit(
50                (
51                    parsed.scheme,
52                    parsed.netloc,
53                    "/".join(path),
54                    parsed.query,
55                    parsed.fragment,
56                )
57            )
58        )

33class Sha256(ValidatedString):
34    """A SHA-256 hash value"""
35
36    root_model: ClassVar[Type[RootModel[Any]]] = RootModel[
37        Annotated[
38            str,
39            StringConstraints(
40                strip_whitespace=True, to_lower=True, min_length=64, max_length=64
41            ),
42        ]
43    ]