Fixes

Author: ericspod

monai/transforms/inverse.py

@@ -11,11 +11,11 @@
 
 from __future__ import annotations
 
+import threading
 import warnings
 from collections.abc import Hashable, Mapping
 from contextlib import contextmanager
 from typing import Any
-import threading
 
 import torch
 
@@ -76,7 +76,7 @@ def _init_trace_threadlocal(self):
         if not hasattr(self, "_tracing"):
             self._tracing = threading.local()
 
-        # This is True while the above initialising _tracing is False when this is 
+        # This is True while the above initialising _tracing is False when this is
         # called from a different thread than the one initialising _tracing.
         if not hasattr(self._tracing, "value"):
             self._tracing.value = MONAIEnvVars.trace_transform() != "0"
@@ -87,7 +87,7 @@ def tracing(self) -> bool:
         Returns the tracing state, which is thread-local and initialised to `MONAIEnvVars.trace_transform() != "0"`.
         """
         self._init_trace_threadlocal()
-        return self._tracing.value
+        return bool(self._tracing.value)
 
     @tracing.setter
     def tracing(self, val: bool):
@@ -338,18 +338,18 @@ def get_most_recent_transform(self, data, key: Hashable = None, check: bool = Tr
 
         # Find the last transform whose name matches that of this class, this allows Invertd to ignore applied
         # operations added by transforms it is not trying to invert, ie. those added in postprocessing.
-        idx=-1
+        idx = -1
         for i in reversed(range(len(all_transforms))):
             xform_name = all_transforms[i].get(TraceKeys.CLASS_NAME, "")
             if xform_name == self.__class__.__name__:
-                idx=i  # if nothing found, idx remains -1 so replicating previous behaviour
+                idx = i  # if nothing found, idx remains -1 so replicating previous behaviour
                 break
 
         if not all_transforms:
             raise ValueError(f"Item of type {type(data)} (key: {key}, pop: {pop}) has empty 'applied_operations'")
 
         if check:
-            if not (-len(all_transforms)<=idx<len(all_transforms)):
+            if not (-len(all_transforms) <= idx < len(all_transforms)):
                 raise IndexError(f"Index '{idx}' not valid for list of applied operations '{all_transforms}'")
 
             self.check_transforms_match(all_transforms[idx])

tests/transforms/inverse/test_inverse_dict.py

@@ -11,18 +11,17 @@
 
 from __future__ import annotations
 
-from itertools import product
 import unittest
+from itertools import product
 
 import torch
 from parameterized import parameterized
 
-from monai.data import MetaTensor, create_test_image_2d, Dataset, ThreadDataLoader, DataLoader
+from monai.data import DataLoader, Dataset, MetaTensor, ThreadDataLoader, create_test_image_2d
 from monai.engines.evaluator import SupervisedEvaluator
 from monai.transforms import Compose, EnsureChannelFirstd, Invertd, Spacingd
 from monai.transforms.utility.dictionary import Lambdad
 from monai.utils.enums import CommonKeys
-
 from tests.test_utils import TEST_DEVICES
 
 
@@ -48,12 +47,12 @@ def setUp(self):
     @parameterized.expand(TEST_DEVICES)
     def test_simple_processing(self, device):
         """
-        Tests postprocessing operations perform correctly, in particular that `Invertd` does inversion correctly. 
-        
-        This will apply the preprocessing sequence which resizes the result, then the postprocess sequence which 
-        returns it to the original shape using Invertd. This tests that the shape of the output is the same as the 
-        original image. This will also test that Invertd doesn't get confused if transforms in the postprocessing 
-        sequence are tracing and so adding information to `applied_operations`, this is what `Lambdad` is doing in 
+        Tests postprocessing operations perform correctly, in particular that `Invertd` does inversion correctly.
+
+        This will apply the preprocessing sequence which resizes the result, then the postprocess sequence which
+        returns it to the original shape using Invertd. This tests that the shape of the output is the same as the
+        original image. This will also test that Invertd doesn't get confused if transforms in the postprocessing
+        sequence are tracing and so adding information to `applied_operations`, this is what `Lambdad` is doing in
         `self.postprocessing`.
         """
 
@@ -77,8 +76,8 @@ def test_simple_processing(self, device):
     @parameterized.expand(product(sum(TEST_DEVICES, []), [True, False]))
     def test_workflow(self, device, use_threads):
         """
-        This tests the interaction between pre and postprocesing transform sequences being executed in parallel. 
-        
+        This tests the interaction between pre and postprocesing transform sequences being executed in parallel.
+
         When the `ThreadDataLoader` is used to load batches, this is done in parallel at times with the execution of
         the post-process transform sequence. Previously this encountered a race condition at times because the
         `TraceableTransform.tracing` variables of transforms was being toggled in different threads, so at times a