replace get_proc_class with get_proc

Author: FynnBe

README.md

@@ -275,6 +275,7 @@ functionality, but not any functionality depending on model prediction.
 To install additional deep learning libraries add `pytorch`, `onnxruntime`, `keras` or `tensorflow`.
 
 Deeplearning frameworks to consider installing alongside `bioimageio.core`:
+
 - [Pytorch/Torchscript](https://pytorch.org/get-started/locally/)
 - [TensorFlow](https://www.tensorflow.org/install)
 - [ONNXRuntime](https://onnxruntime.ai/docs/install/#python-installs)
@@ -297,13 +298,16 @@ These models are described by---and can be loaded with---the bioimageio.spec pac
 In addition bioimageio.core provides functionality to convert model weight formats.
 
 ### Documentation
+
 [Here you find the bioimageio.core documentation.](https://bioimage-io.github.io/core-bioimage-io-python/bioimageio/core.html)
 
 #### Presentations
+
 - [Create a model from scratch](https://bioimage-io.github.io/core-bioimage-io-python/presentations/create_ambitious_sloth.slides.html) ([source](https://github.com/bioimage-io/core-bioimage-io-python/tree/main/presentations))
 
 #### Examples
-<dl>    
+
+<dl>
   <dt>Notebooks that save and load resource descriptions and validate their format (using <a href="https://bioimage-io.github.io/core-bioimage-io-python/bioimageio/spec.html">bioimageio.spec</a>, a dependency of bioimageio.core)</dt>
   <dd><a href="https://github.com/bioimage-io/spec-bioimage-io/blob/main/example/load_model_and_create_your_own.ipynb">load_model_and_create_your_own.ipynb</a> <a target="_blank" href="https://colab.research.google.com/github/bioimage-io/spec-bioimage-io/blob/main/example/load_model_and_create_your_own.ipynb">
   <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
@@ -327,7 +331,6 @@ bioimageio
 
 For examples see [Get started](#get-started).
 
-
 ### CLI inputs from file
 
 For convenience the command line options (not arguments) may be given in a `bioimageio-cli.json`
@@ -342,7 +345,6 @@ blockwise: true
 stats: inputs/dataset_statistics.json
 ```
 
-
 ## Set up Development Environment
 
 To set up a development conda environment run the following commands:
@@ -355,13 +357,11 @@ pip install -e . --no-deps
 
 There are different environment files available that only install tensorflow or pytorch as dependencies, see [dev folder](https://github.com/bioimage-io/core-bioimage-io-python/tree/main/dev).
 
-
 ## Logging level
 
 `bioimageio.spec` and `bioimageio.core` use [loguru](https://github.com/Delgan/loguru) for logging, hence the logging level
 may be controlled with the `LOGURU_LEVEL` environment variable.
 
-
 ## Changelog
 
 ### 0.7.1 (to be released)
@@ -370,6 +370,7 @@ may be controlled with the `LOGURU_LEVEL` environment variable.
 - New feature: `bioimageio.core.test_description` accepts **runtime_env** and **run_command** to test a resource
   using the conda environment described by that resource (or another specified conda env)
 - new CLI command: `bioimageio add-weights` (and utility function: bioimageio.core.add_weights)
+- removed `bioimageio.core.proc_ops.get_proc_class` in favor of `bioimageio.core.proc_ops.get_proc`
 
 ### 0.7.0
 

bioimageio/core/proc_ops.py

@@ -16,8 +16,8 @@
 import xarray as xr
 from typing_extensions import Self, assert_never
 
+from bioimageio.core.digest_spec import get_member_id
 from bioimageio.spec.model import v0_4, v0_5
-from bioimageio.spec.model.v0_5 import TensorId
 from bioimageio.spec.model.v0_5 import (
     _convert_proc,  # pyright: ignore [reportPrivateUsage]
 )
@@ -672,144 +672,53 @@ def _apply(self, input: Tensor, stat: Stat) -> Tensor:
 ]
 
 
-def get_proc_class(proc_spec: ProcDescr):
-    if isinstance(proc_spec, (v0_4.BinarizeDescr, v0_5.BinarizeDescr)):
-        return Binarize
-    elif isinstance(proc_spec, (v0_4.ClipDescr, v0_5.ClipDescr)):
-        return Clip
-    elif isinstance(proc_spec, v0_5.EnsureDtypeDescr):
-        return EnsureDtype
-    elif isinstance(proc_spec, v0_5.FixedZeroMeanUnitVarianceDescr):
-        return FixedZeroMeanUnitVariance
-    elif isinstance(proc_spec, (v0_4.ScaleLinearDescr, v0_5.ScaleLinearDescr)):
-        return ScaleLinear
+def get_proc(
+    proc_descr: ProcDescr,
+    tensor_descr: Union[
+        v0_4.InputTensorDescr,
+        v0_4.OutputTensorDescr,
+        v0_5.InputTensorDescr,
+        v0_5.OutputTensorDescr,
+    ],
+) -> Processing:
+    member_id = get_member_id(tensor_descr)
+
+    if isinstance(proc_descr, (v0_4.BinarizeDescr, v0_5.BinarizeDescr)):
+        return Binarize.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, (v0_4.ClipDescr, v0_5.ClipDescr)):
+        return Clip.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, v0_5.EnsureDtypeDescr):
+        return EnsureDtype.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, v0_5.FixedZeroMeanUnitVarianceDescr):
+        return FixedZeroMeanUnitVariance.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, (v0_4.ScaleLinearDescr, v0_5.ScaleLinearDescr)):
+        return ScaleLinear.from_proc_descr(proc_descr, member_id)
     elif isinstance(
-        proc_spec, (v0_4.ScaleMeanVarianceDescr, v0_5.ScaleMeanVarianceDescr)
+        proc_descr, (v0_4.ScaleMeanVarianceDescr, v0_5.ScaleMeanVarianceDescr)
     ):
-        return ScaleMeanVariance
-    elif isinstance(proc_spec, (v0_4.ScaleRangeDescr, v0_5.ScaleRangeDescr)):
-        return ScaleRange
-    elif isinstance(proc_spec, (v0_4.SigmoidDescr, v0_5.SigmoidDescr)):
-        return Sigmoid
+        return ScaleMeanVariance.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, (v0_4.ScaleRangeDescr, v0_5.ScaleRangeDescr)):
+        return ScaleRange.from_proc_descr(proc_descr, member_id)
+    elif isinstance(proc_descr, (v0_4.SigmoidDescr, v0_5.SigmoidDescr)):
+        return Sigmoid.from_proc_descr(proc_descr, member_id)
     elif (
-        isinstance(proc_spec, v0_4.ZeroMeanUnitVarianceDescr)
-        and proc_spec.kwargs.mode == "fixed"
+        isinstance(proc_descr, v0_4.ZeroMeanUnitVarianceDescr)
+        and proc_descr.kwargs.mode == "fixed"
     ):
-        return FixedZeroMeanUnitVariance
+        if not isinstance(
+            tensor_descr, (v0_4.InputTensorDescr, v0_4.OutputTensorDescr)
+        ):
+            raise TypeError(
+                "Expected v0_4 tensor description for v0_4 processing description"
+            )
+
+        v5_proc_descr = _convert_proc(proc_descr, tensor_descr.axes)
+        assert isinstance(v5_proc_descr, v0_5.FixedZeroMeanUnitVarianceDescr)
+        return FixedZeroMeanUnitVariance.from_proc_descr(v5_proc_descr, member_id)
     elif isinstance(
-        proc_spec,
+        proc_descr,
         (v0_4.ZeroMeanUnitVarianceDescr, v0_5.ZeroMeanUnitVarianceDescr),
     ):
-        return ZeroMeanUnitVariance
-    else:
-        assert_never(proc_spec)
-
-
-def preproc_v4_to_processing(
-    inp: v0_4.InputTensorDescr,
-    proc_spec: v0_4.PreprocessingDescr,
-) -> Processing:
-    member_id = TensorId(str(inp.name))
-    if isinstance(proc_spec, v0_4.BinarizeDescr):
-        return Binarize.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ClipDescr):
-        return Clip.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ScaleLinearDescr):
-        return ScaleLinear.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ScaleRangeDescr):
-        return ScaleRange.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.SigmoidDescr):
-        return Sigmoid.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ZeroMeanUnitVarianceDescr):
-        if proc_spec.kwargs.mode == "fixed":
-            axes = inp.axes
-            v5_proc_spec = _convert_proc(proc_spec, axes)
-            assert isinstance(
-                v5_proc_spec, v0_5.FixedZeroMeanUnitVarianceDescr
-            )  # FIXME
-            return FixedZeroMeanUnitVariance.from_proc_descr(v5_proc_spec, member_id)
-        else:
-            return ZeroMeanUnitVariance.from_proc_descr(proc_spec, member_id)
-    else:
-        assert_never(proc_spec)
-
-
-def postproc_v4_to_processing(
-    inp: v0_4.OutputTensorDescr,
-    proc_spec: v0_4.PostprocessingDescr,
-) -> Processing:
-    member_id = TensorId(str(inp.name))
-    if isinstance(proc_spec, v0_4.BinarizeDescr):
-        return Binarize.from_proc_descr(proc_spec, member_id)
-    if isinstance(proc_spec, v0_4.ScaleMeanVarianceDescr):
-        return ScaleMeanVariance.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ClipDescr):
-        return Clip.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ScaleLinearDescr):
-        return ScaleLinear.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ScaleRangeDescr):
-        return ScaleRange.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.SigmoidDescr):
-        return Sigmoid.from_proc_descr(proc_spec, member_id)
-    elif isinstance(proc_spec, v0_4.ZeroMeanUnitVarianceDescr):
-        if proc_spec.kwargs.mode == "fixed":
-            axes = inp.axes
-            v5_proc_spec = _convert_proc(proc_spec, axes)
-            assert isinstance(
-                v5_proc_spec, v0_5.FixedZeroMeanUnitVarianceDescr
-            )  # FIXME
-            return FixedZeroMeanUnitVariance.from_proc_descr(v5_proc_spec, member_id)
-        else:
-            return ZeroMeanUnitVariance.from_proc_descr(proc_spec, member_id)
-    else:
-        assert_never(proc_spec)
-
-
-def preproc_v5_to_processing(
-    inp: v0_5.InputTensorDescr,
-    proc_spec: v0_5.PreprocessingDescr,
-) -> Processing:
-    if isinstance(proc_spec, v0_5.BinarizeDescr):
-        return Binarize.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ClipDescr):
-        return Clip.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ScaleLinearDescr):
-        return ScaleLinear.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ScaleRangeDescr):
-        return ScaleRange.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.SigmoidDescr):
-        return Sigmoid.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.EnsureDtypeDescr):
-        return EnsureDtype.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ZeroMeanUnitVarianceDescr):
-        return ZeroMeanUnitVariance.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.FixedZeroMeanUnitVarianceDescr):
-        return FixedZeroMeanUnitVariance.from_proc_descr(proc_spec, inp.id)
-    else:
-        assert_never(proc_spec)
-
-
-def postproc_v5_to_processing(
-    inp: v0_5.OutputTensorDescr,
-    proc_spec: v0_5.PostprocessingDescr,
-) -> Processing:
-    if isinstance(proc_spec, v0_5.BinarizeDescr):
-        return Binarize.from_proc_descr(proc_spec, inp.id)
-    if isinstance(proc_spec, v0_5.ScaleMeanVarianceDescr):
-        return ScaleMeanVariance.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ClipDescr):
-        return Clip.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ScaleLinearDescr):
-        return ScaleLinear.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ScaleRangeDescr):
-        return ScaleRange.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.SigmoidDescr):
-        return Sigmoid.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.EnsureDtypeDescr):
-        return EnsureDtype.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.ZeroMeanUnitVarianceDescr):
-        return ZeroMeanUnitVariance.from_proc_descr(proc_spec, inp.id)
-    elif isinstance(proc_spec, v0_5.FixedZeroMeanUnitVarianceDescr):
-        return FixedZeroMeanUnitVariance.from_proc_descr(proc_spec, inp.id)
+        return ZeroMeanUnitVariance.from_proc_descr(proc_descr, member_id)
     else:
-        assert_never(proc_spec)
+        assert_never(proc_descr)

bioimageio/core/proc_setup.py

@@ -12,18 +12,15 @@
 
 from typing_extensions import assert_never
 
+from bioimageio.core.digest_spec import get_member_id
 from bioimageio.spec.model import AnyModelDescr, v0_4, v0_5
-from bioimageio.spec.model.v0_5 import TensorId
 
 from .proc_ops import (
     AddKnownDatasetStats,
     EnsureDtype,
     Processing,
     UpdateStats,
-    postproc_v4_to_processing,
-    postproc_v5_to_processing,
-    preproc_v4_to_processing,
-    preproc_v5_to_processing,
+    get_proc,
 )
 from .sample import Sample
 from .stat_calculators import StatsCalculator
@@ -173,61 +170,50 @@ def get_requried_sample_measures(model: AnyModelDescr) -> RequiredSampleMeasures
     )
 
 
-def _prepare_v4_preprocs(
-    tensor_descrs: Sequence[v0_4.InputTensorDescr],
+def _prepare_procs(
+    tensor_descrs: Union[
+        Sequence[v0_4.InputTensorDescr],
+        Sequence[v0_5.InputTensorDescr],
+        Sequence[v0_4.OutputTensorDescr],
+        Sequence[v0_5.OutputTensorDescr],
+    ],
 ) -> List[Processing]:
     procs: List[Processing] = []
     for t_descr in tensor_descrs:
-        member_id = TensorId(str(t_descr.name))
-        procs.append(
-            EnsureDtype(input=member_id, output=member_id, dtype=t_descr.data_type)
-        )
-        for proc_d in t_descr.preprocessing:
-            procs.append(preproc_v4_to_processing(t_descr, proc_d))
-    return procs
-
-
-def _prepare_v4_postprocs(
-    tensor_descrs: Sequence[v0_4.OutputTensorDescr],
-) -> List[Processing]:
-    procs: List[Processing] = []
-    for t_descr in tensor_descrs:
-        member_id = TensorId(str(t_descr.name))
-        procs.append(
-            EnsureDtype(input=member_id, output=member_id, dtype=t_descr.data_type)
-        )
-        for proc_d in t_descr.postprocessing:
-            procs.append(postproc_v4_to_processing(t_descr, proc_d))
-    return procs
-
+        if isinstance(t_descr, (v0_4.InputTensorDescr, v0_4.OutputTensorDescr)):
+            member_id = get_member_id(t_descr)
+            procs.append(
+                EnsureDtype(input=member_id, output=member_id, dtype=t_descr.data_type)
+            )
+
+        if isinstance(t_descr, (v0_4.InputTensorDescr, v0_5.InputTensorDescr)):
+            for proc_d in t_descr.preprocessing:
+                procs.append(get_proc(proc_d, t_descr))
+        elif isinstance(t_descr, (v0_4.OutputTensorDescr, v0_5.OutputTensorDescr)):
+            for proc_d in t_descr.postprocessing:
+                procs.append(get_proc(proc_d, t_descr))
+        else:
+            assert_never(t_descr)
+
+        if isinstance(
+            t_descr,
+            (v0_4.InputTensorDescr, (v0_4.InputTensorDescr, v0_4.OutputTensorDescr)),
+        ) and not isinstance(procs[-1], EnsureDtype):
+            member_id = get_member_id(t_descr)
+            procs.append(
+                EnsureDtype(input=member_id, output=member_id, dtype=t_descr.data_type)
+            )
 
-def _prepare_v5_preprocs(
-    tensor_descrs: Sequence[v0_5.InputTensorDescr],
-) -> List[Processing]:
-    procs: List[Processing] = []
-    for t_descr in tensor_descrs:
-        for proc_d in t_descr.preprocessing:
-            procs.append(preproc_v5_to_processing(t_descr, proc_d))
-    return procs
-
-
-def _prepare_v5_postprocs(
-    tensor_descrs: Sequence[v0_5.OutputTensorDescr],
-) -> List[Processing]:
-    procs: List[Processing] = []
-    for t_descr in tensor_descrs:
-        for proc_d in t_descr.postprocessing:
-            procs.append(postproc_v5_to_processing(t_descr, proc_d))
     return procs
 
 
 def _prepare_setup_pre_and_postprocessing(model: AnyModelDescr) -> _SetupProcessing:
     if isinstance(model, v0_4.ModelDescr):
-        pre = _prepare_v4_preprocs(model.inputs)
-        post = _prepare_v4_postprocs(model.outputs)
+        pre = _prepare_procs(model.inputs)
+        post = _prepare_procs(model.outputs)
     elif isinstance(model, v0_5.ModelDescr):
-        pre = _prepare_v5_preprocs(model.inputs)
-        post = _prepare_v5_postprocs(model.outputs)
+        pre = _prepare_procs(model.inputs)
+        post = _prepare_procs(model.outputs)
     else:
         assert_never(model)