monai/transforms/compose.py (1)

40-51: Add Google-style docstring with Args/Returns.

Per coding guidelines, docstrings should describe parameters and return values.

📝 Proposed docstring

 def _inverse_one(
     t: InvertibleTransform,
     data: Any,
     map_items: bool | int,
     unpack_items: bool,
     log_stats: bool | str,
 ) -> Any:
-    """Invert a single transform, delegating directly to nested ``Compose`` objects."""
+    """Invert a single transform, delegating directly to nested ``Compose`` objects.
+
+    Args:
+        t: The invertible transform to invert.
+        data: Data to be inverted.
+        map_items: Whether to map over list/tuple items.
+        unpack_items: Whether to unpack data as parameters.
+        log_stats: Logger name or boolean for logging.
+
+    Returns:
+        The inverted data.
+    """
     if isinstance(t, Compose):
         return t.inverse(data)
     return apply_transform(t.inverse, data, map_items, unpack_items, lazy=False, log_stats=log_stats)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@monai/transforms/compose.py` around lines 40 - 51, Add a Google-style
docstring to the _inverse_one function describing its purpose, parameters and
return value: state that it inverts a single transform (delegating to
Compose.inverse when t is a Compose), document args t (InvertibleTransform),
data (Any), map_items (bool|int), unpack_items (bool), log_stats (bool|str), and
explain the return value (inverted data of type Any); also mention that
apply_transform is called for non-Compose transforms with lazy=False. Include
short notes on side effects (calls to Compose.inverse/apply_transform) if
relevant.

monai/transforms/compose.py (1)

354-361: flatten() doesn't preserve parent attributes (unlike OneOf.flatten()).

Line 361 returns Compose(new_transforms) with defaults. If someone calls flatten() expecting an equivalent executable pipeline, map_items, unpack_items, log_stats, lazy, and overrides are lost.

Current internal usage only reads .transforms, so no bug today.

Proposed fix

-        return Compose(new_transforms)
+        return Compose(new_transforms, self.map_items, self.unpack_items, self.log_stats, self.lazy, self.overrides)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@monai/transforms/compose.py` around lines 354 - 361, Compose.flatten()
currently builds and returns a new Compose instance with only new_transforms,
dropping parent attributes; update Compose.flatten to preserve and pass through
the parent's configuration (map_items, unpack_items, log_stats, lazy, overrides)
when constructing the returned Compose so the flattened pipeline is equivalent
to the original (mirroring OneOf.flatten behavior). Locate the Compose.flatten
implementation and change the return from Compose(new_transforms) to
Compose(new_transforms, map_items=self.map_items,
unpack_items=self.unpack_items, log_stats=self.log_stats, lazy=self.lazy,
overrides=self.overrides) or otherwise propagate those attributes from self into
the new Compose instance.

tests/transforms/compose/test_compose.py (1)

796-803: ⚡ Quick win

Some new regressions still bypass the map_items branch.

map_items only matters for list/tuple inputs. These cases use a tensor or scalar, so the pre-fix implementation would still pass. Please drive at least one inverse roundtrip and the three-level nesting case through list/tuple data, and add the same inverse coverage for RandomOrder / SomeOf, since those call sites changed too.

As per coding guidelines, "Ensure new or modified definitions will be covered by existing or new unit tests."

Also applies to: 880-900, 902-914

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/transforms/compose/test_compose.py` around lines 796 - 803, The test
currently uses tensor/scalar inputs so it misses the map_items branch; update
tests (e.g., test_inverse_respects_child_map_items and the other noted blocks)
to include at least one inverse roundtrip using list and tuple inputs (e.g.,
[tensor,...] and (tensor,...)) and a three-level nested Compose (Compose inside
Compose inside Compose) where the inner Compose has map_items=False to ensure
delegation to child Compose.inverse; additionally add equivalent inverse
roundtrip tests for RandomOrder and SomeOf compositions (with nested
map_items=False children) to exercise the changed call sites and ensure
list/tuple paths are covered.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes